dwarf2out.c revision 146895
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 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, 59 Temple Place - Suite 330, Boston, MA 2302111-1307, 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 "flags.h" 43#include "real.h" 44#include "rtl.h" 45#include "hard-reg-set.h" 46#include "regs.h" 47#include "insn-config.h" 48#include "reload.h" 49#include "function.h" 50#include "output.h" 51#include "expr.h" 52#include "libfuncs.h" 53#include "except.h" 54#include "dwarf2.h" 55#include "dwarf2out.h" 56#include "dwarf2asm.h" 57#include "toplev.h" 58#include "varray.h" 59#include "ggc.h" 60#include "md5.h" 61#include "tm_p.h" 62#include "diagnostic.h" 63#include "debug.h" 64#include "target.h" 65#include "langhooks.h" 66#include "hashtab.h" 67#include "cgraph.h" 68 69#ifdef DWARF2_DEBUGGING_INFO 70static void dwarf2out_source_line (unsigned int, const char *); 71#endif 72 73/* DWARF2 Abbreviation Glossary: 74 CFA = Canonical Frame Address 75 a fixed address on the stack which identifies a call frame. 76 We define it to be the value of SP just before the call insn. 77 The CFA register and offset, which may change during the course 78 of the function, are used to calculate its value at runtime. 79 CFI = Call Frame Instruction 80 an instruction for the DWARF2 abstract machine 81 CIE = Common Information Entry 82 information describing information common to one or more FDEs 83 DIE = Debugging Information Entry 84 FDE = Frame Description Entry 85 information describing the stack call frame, in particular, 86 how to restore registers 87 88 DW_CFA_... = DWARF2 CFA call frame instruction 89 DW_TAG_... = DWARF2 DIE tag */ 90 91/* Decide whether we want to emit frame unwind information for the current 92 translation unit. */ 93 94int 95dwarf2out_do_frame (void) 96{ 97 return (write_symbols == DWARF2_DEBUG 98 || write_symbols == VMS_AND_DWARF2_DEBUG 99#ifdef DWARF2_FRAME_INFO 100 || DWARF2_FRAME_INFO 101#endif 102#ifdef DWARF2_UNWIND_INFO 103 || flag_unwind_tables 104 || (flag_exceptions && ! USING_SJLJ_EXCEPTIONS) 105#endif 106 ); 107} 108 109/* The size of the target's pointer type. */ 110#ifndef PTR_SIZE 111#define PTR_SIZE (POINTER_SIZE / BITS_PER_UNIT) 112#endif 113 114/* Various versions of targetm.eh_frame_section. Note these must appear 115 outside the DWARF2_DEBUGGING_INFO || DWARF2_UNWIND_INFO macro guards. */ 116 117/* Version of targetm.eh_frame_section for systems with named sections. */ 118void 119named_section_eh_frame_section (void) 120{ 121#ifdef EH_FRAME_SECTION_NAME 122#ifdef HAVE_LD_RO_RW_SECTION_MIXING 123 int fde_encoding = ASM_PREFERRED_EH_DATA_FORMAT (/*code=*/1, /*global=*/0); 124 int per_encoding = ASM_PREFERRED_EH_DATA_FORMAT (/*code=*/2, /*global=*/1); 125 int lsda_encoding = ASM_PREFERRED_EH_DATA_FORMAT (/*code=*/0, /*global=*/0); 126 int flags; 127 128 flags = (! flag_pic 129 || ((fde_encoding & 0x70) != DW_EH_PE_absptr 130 && (fde_encoding & 0x70) != DW_EH_PE_aligned 131 && (per_encoding & 0x70) != DW_EH_PE_absptr 132 && (per_encoding & 0x70) != DW_EH_PE_aligned 133 && (lsda_encoding & 0x70) != DW_EH_PE_absptr 134 && (lsda_encoding & 0x70) != DW_EH_PE_aligned)) 135 ? 0 : SECTION_WRITE; 136 named_section_flags (EH_FRAME_SECTION_NAME, flags); 137#else 138 named_section_flags (EH_FRAME_SECTION_NAME, SECTION_WRITE); 139#endif 140#endif 141} 142 143/* Version of targetm.eh_frame_section for systems using collect2. */ 144void 145collect2_eh_frame_section (void) 146{ 147 tree label = get_file_function_name ('F'); 148 149 data_section (); 150 ASM_OUTPUT_ALIGN (asm_out_file, floor_log2 (PTR_SIZE)); 151 (*targetm.asm_out.globalize_label) (asm_out_file, IDENTIFIER_POINTER (label)); 152 ASM_OUTPUT_LABEL (asm_out_file, IDENTIFIER_POINTER (label)); 153} 154 155/* Default version of targetm.eh_frame_section. */ 156void 157default_eh_frame_section (void) 158{ 159#ifdef EH_FRAME_SECTION_NAME 160 named_section_eh_frame_section (); 161#else 162 collect2_eh_frame_section (); 163#endif 164} 165 166/* Array of RTXes referenced by the debugging information, which therefore 167 must be kept around forever. */ 168static GTY(()) varray_type used_rtx_varray; 169 170/* A pointer to the base of a list of incomplete types which might be 171 completed at some later time. incomplete_types_list needs to be a VARRAY 172 because we want to tell the garbage collector about it. */ 173static GTY(()) varray_type incomplete_types; 174 175/* A pointer to the base of a table of references to declaration 176 scopes. This table is a display which tracks the nesting 177 of declaration scopes at the current scope and containing 178 scopes. This table is used to find the proper place to 179 define type declaration DIE's. */ 180static GTY(()) varray_type decl_scope_table; 181 182/* How to start an assembler comment. */ 183#ifndef ASM_COMMENT_START 184#define ASM_COMMENT_START ";#" 185#endif 186 187typedef struct dw_cfi_struct *dw_cfi_ref; 188typedef struct dw_fde_struct *dw_fde_ref; 189typedef union dw_cfi_oprnd_struct *dw_cfi_oprnd_ref; 190 191/* Call frames are described using a sequence of Call Frame 192 Information instructions. The register number, offset 193 and address fields are provided as possible operands; 194 their use is selected by the opcode field. */ 195 196enum dw_cfi_oprnd_type { 197 dw_cfi_oprnd_unused, 198 dw_cfi_oprnd_reg_num, 199 dw_cfi_oprnd_offset, 200 dw_cfi_oprnd_addr, 201 dw_cfi_oprnd_loc 202}; 203 204typedef union dw_cfi_oprnd_struct GTY(()) 205{ 206 unsigned long GTY ((tag ("dw_cfi_oprnd_reg_num"))) dw_cfi_reg_num; 207 HOST_WIDE_INT GTY ((tag ("dw_cfi_oprnd_offset"))) dw_cfi_offset; 208 const char * GTY ((tag ("dw_cfi_oprnd_addr"))) dw_cfi_addr; 209 struct dw_loc_descr_struct * GTY ((tag ("dw_cfi_oprnd_loc"))) dw_cfi_loc; 210} 211dw_cfi_oprnd; 212 213typedef struct dw_cfi_struct GTY(()) 214{ 215 dw_cfi_ref dw_cfi_next; 216 enum dwarf_call_frame_info dw_cfi_opc; 217 dw_cfi_oprnd GTY ((desc ("dw_cfi_oprnd1_desc (%1.dw_cfi_opc)"))) 218 dw_cfi_oprnd1; 219 dw_cfi_oprnd GTY ((desc ("dw_cfi_oprnd2_desc (%1.dw_cfi_opc)"))) 220 dw_cfi_oprnd2; 221} 222dw_cfi_node; 223 224/* This is how we define the location of the CFA. We use to handle it 225 as REG + OFFSET all the time, but now it can be more complex. 226 It can now be either REG + CFA_OFFSET or *(REG + BASE_OFFSET) + CFA_OFFSET. 227 Instead of passing around REG and OFFSET, we pass a copy 228 of this structure. */ 229typedef struct cfa_loc GTY(()) 230{ 231 unsigned long reg; 232 HOST_WIDE_INT offset; 233 HOST_WIDE_INT base_offset; 234 int indirect; /* 1 if CFA is accessed via a dereference. */ 235} dw_cfa_location; 236 237/* All call frame descriptions (FDE's) in the GCC generated DWARF 238 refer to a single Common Information Entry (CIE), defined at 239 the beginning of the .debug_frame section. This use of a single 240 CIE obviates the need to keep track of multiple CIE's 241 in the DWARF generation routines below. */ 242 243typedef struct dw_fde_struct GTY(()) 244{ 245 const char *dw_fde_begin; 246 const char *dw_fde_current_label; 247 const char *dw_fde_end; 248 dw_cfi_ref dw_fde_cfi; 249 unsigned funcdef_number; 250 unsigned all_throwers_are_sibcalls : 1; 251 unsigned nothrow : 1; 252 unsigned uses_eh_lsda : 1; 253} 254dw_fde_node; 255 256/* Maximum size (in bytes) of an artificially generated label. */ 257#define MAX_ARTIFICIAL_LABEL_BYTES 30 258 259/* The size of addresses as they appear in the Dwarf 2 data. 260 Some architectures use word addresses to refer to code locations, 261 but Dwarf 2 info always uses byte addresses. On such machines, 262 Dwarf 2 addresses need to be larger than the architecture's 263 pointers. */ 264#ifndef DWARF2_ADDR_SIZE 265#define DWARF2_ADDR_SIZE (POINTER_SIZE / BITS_PER_UNIT) 266#endif 267 268/* The size in bytes of a DWARF field indicating an offset or length 269 relative to a debug info section, specified to be 4 bytes in the 270 DWARF-2 specification. The SGI/MIPS ABI defines it to be the same 271 as PTR_SIZE. */ 272 273#ifndef DWARF_OFFSET_SIZE 274#define DWARF_OFFSET_SIZE 4 275#endif 276 277/* According to the (draft) DWARF 3 specification, the initial length 278 should either be 4 or 12 bytes. When it's 12 bytes, the first 4 279 bytes are 0xffffffff, followed by the length stored in the next 8 280 bytes. 281 282 However, the SGI/MIPS ABI uses an initial length which is equal to 283 DWARF_OFFSET_SIZE. It is defined (elsewhere) accordingly. */ 284 285#ifndef DWARF_INITIAL_LENGTH_SIZE 286#define DWARF_INITIAL_LENGTH_SIZE (DWARF_OFFSET_SIZE == 4 ? 4 : 12) 287#endif 288 289#define DWARF_VERSION 2 290 291/* Round SIZE up to the nearest BOUNDARY. */ 292#define DWARF_ROUND(SIZE,BOUNDARY) \ 293 ((((SIZE) + (BOUNDARY) - 1) / (BOUNDARY)) * (BOUNDARY)) 294 295/* Offsets recorded in opcodes are a multiple of this alignment factor. */ 296#ifndef DWARF_CIE_DATA_ALIGNMENT 297#ifdef STACK_GROWS_DOWNWARD 298#define DWARF_CIE_DATA_ALIGNMENT (-((int) UNITS_PER_WORD)) 299#else 300#define DWARF_CIE_DATA_ALIGNMENT ((int) UNITS_PER_WORD) 301#endif 302#endif 303 304/* A pointer to the base of a table that contains frame description 305 information for each routine. */ 306static GTY((length ("fde_table_allocated"))) dw_fde_ref fde_table; 307 308/* Number of elements currently allocated for fde_table. */ 309static GTY(()) unsigned fde_table_allocated; 310 311/* Number of elements in fde_table currently in use. */ 312static GTY(()) unsigned fde_table_in_use; 313 314/* Size (in elements) of increments by which we may expand the 315 fde_table. */ 316#define FDE_TABLE_INCREMENT 256 317 318/* A list of call frame insns for the CIE. */ 319static GTY(()) dw_cfi_ref cie_cfi_head; 320 321#if defined (DWARF2_DEBUGGING_INFO) || defined (DWARF2_UNWIND_INFO) 322/* Some DWARF extensions (e.g., MIPS/SGI) implement a subprogram 323 attribute that accelerates the lookup of the FDE associated 324 with the subprogram. This variable holds the table index of the FDE 325 associated with the current function (body) definition. */ 326static unsigned current_funcdef_fde; 327#endif 328 329struct indirect_string_node GTY(()) 330{ 331 const char *str; 332 unsigned int refcount; 333 unsigned int form; 334 char *label; 335}; 336 337static GTY ((param_is (struct indirect_string_node))) htab_t debug_str_hash; 338 339static GTY(()) int dw2_string_counter; 340static GTY(()) unsigned long dwarf2out_cfi_label_num; 341 342#if defined (DWARF2_DEBUGGING_INFO) || defined (DWARF2_UNWIND_INFO) 343 344/* Forward declarations for functions defined in this file. */ 345 346static char *stripattributes (const char *); 347static const char *dwarf_cfi_name (unsigned); 348static dw_cfi_ref new_cfi (void); 349static void add_cfi (dw_cfi_ref *, dw_cfi_ref); 350static void add_fde_cfi (const char *, dw_cfi_ref); 351static void lookup_cfa_1 (dw_cfi_ref, dw_cfa_location *); 352static void lookup_cfa (dw_cfa_location *); 353static void reg_save (const char *, unsigned, unsigned, HOST_WIDE_INT); 354static void initial_return_save (rtx); 355static HOST_WIDE_INT stack_adjust_offset (rtx); 356static void output_cfi (dw_cfi_ref, dw_fde_ref, int); 357static void output_call_frame_info (int); 358static void dwarf2out_stack_adjust (rtx); 359static void queue_reg_save (const char *, rtx, HOST_WIDE_INT); 360static void flush_queued_reg_saves (void); 361static bool clobbers_queued_reg_save (rtx); 362static void dwarf2out_frame_debug_expr (rtx, const char *); 363 364/* Support for complex CFA locations. */ 365static void output_cfa_loc (dw_cfi_ref); 366static void get_cfa_from_loc_descr (dw_cfa_location *, 367 struct dw_loc_descr_struct *); 368static struct dw_loc_descr_struct *build_cfa_loc 369 (dw_cfa_location *); 370static void def_cfa_1 (const char *, dw_cfa_location *); 371 372/* How to start an assembler comment. */ 373#ifndef ASM_COMMENT_START 374#define ASM_COMMENT_START ";#" 375#endif 376 377/* Data and reference forms for relocatable data. */ 378#define DW_FORM_data (DWARF_OFFSET_SIZE == 8 ? DW_FORM_data8 : DW_FORM_data4) 379#define DW_FORM_ref (DWARF_OFFSET_SIZE == 8 ? DW_FORM_ref8 : DW_FORM_ref4) 380 381#ifndef DEBUG_FRAME_SECTION 382#define DEBUG_FRAME_SECTION ".debug_frame" 383#endif 384 385#ifndef FUNC_BEGIN_LABEL 386#define FUNC_BEGIN_LABEL "LFB" 387#endif 388 389#ifndef FUNC_END_LABEL 390#define FUNC_END_LABEL "LFE" 391#endif 392 393#define FRAME_BEGIN_LABEL "Lframe" 394#define CIE_AFTER_SIZE_LABEL "LSCIE" 395#define CIE_END_LABEL "LECIE" 396#define FDE_LABEL "LSFDE" 397#define FDE_AFTER_SIZE_LABEL "LASFDE" 398#define FDE_END_LABEL "LEFDE" 399#define LINE_NUMBER_BEGIN_LABEL "LSLT" 400#define LINE_NUMBER_END_LABEL "LELT" 401#define LN_PROLOG_AS_LABEL "LASLTP" 402#define LN_PROLOG_END_LABEL "LELTP" 403#define DIE_LABEL_PREFIX "DW" 404 405/* The DWARF 2 CFA column which tracks the return address. Normally this 406 is the column for PC, or the first column after all of the hard 407 registers. */ 408#ifndef DWARF_FRAME_RETURN_COLUMN 409#ifdef PC_REGNUM 410#define DWARF_FRAME_RETURN_COLUMN DWARF_FRAME_REGNUM (PC_REGNUM) 411#else 412#define DWARF_FRAME_RETURN_COLUMN DWARF_FRAME_REGISTERS 413#endif 414#endif 415 416/* The mapping from gcc register number to DWARF 2 CFA column number. By 417 default, we just provide columns for all registers. */ 418#ifndef DWARF_FRAME_REGNUM 419#define DWARF_FRAME_REGNUM(REG) DBX_REGISTER_NUMBER (REG) 420#endif 421 422/* The offset from the incoming value of %sp to the top of the stack frame 423 for the current function. */ 424#ifndef INCOMING_FRAME_SP_OFFSET 425#define INCOMING_FRAME_SP_OFFSET 0 426#endif 427 428/* Hook used by __throw. */ 429 430rtx 431expand_builtin_dwarf_sp_column (void) 432{ 433 return GEN_INT (DWARF_FRAME_REGNUM (STACK_POINTER_REGNUM)); 434} 435 436/* Return a pointer to a copy of the section string name S with all 437 attributes stripped off, and an asterisk prepended (for assemble_name). */ 438 439static inline char * 440stripattributes (const char *s) 441{ 442 char *stripped = xmalloc (strlen (s) + 2); 443 char *p = stripped; 444 445 *p++ = '*'; 446 447 while (*s && *s != ',') 448 *p++ = *s++; 449 450 *p = '\0'; 451 return stripped; 452} 453 454/* Generate code to initialize the register size table. */ 455 456void 457expand_builtin_init_dwarf_reg_sizes (tree address) 458{ 459 int i; 460 enum machine_mode mode = TYPE_MODE (char_type_node); 461 rtx addr = expand_expr (address, NULL_RTX, VOIDmode, 0); 462 rtx mem = gen_rtx_MEM (BLKmode, addr); 463 bool wrote_return_column = false; 464 465 for (i = 0; i < FIRST_PSEUDO_REGISTER; i++) 466 if (DWARF_FRAME_REGNUM (i) < DWARF_FRAME_REGISTERS) 467 { 468 HOST_WIDE_INT offset = DWARF_FRAME_REGNUM (i) * GET_MODE_SIZE (mode); 469 enum machine_mode save_mode = reg_raw_mode[i]; 470 HOST_WIDE_INT size; 471 472 if (HARD_REGNO_CALL_PART_CLOBBERED (i, save_mode)) 473 save_mode = choose_hard_reg_mode (i, 1, true); 474 if (DWARF_FRAME_REGNUM (i) == DWARF_FRAME_RETURN_COLUMN) 475 { 476 if (save_mode == VOIDmode) 477 continue; 478 wrote_return_column = true; 479 } 480 size = GET_MODE_SIZE (save_mode); 481 if (offset < 0) 482 continue; 483 484 emit_move_insn (adjust_address (mem, mode, offset), GEN_INT (size)); 485 } 486 487#ifdef DWARF_ALT_FRAME_RETURN_COLUMN 488 if (! wrote_return_column) 489 abort (); 490 i = DWARF_ALT_FRAME_RETURN_COLUMN; 491 wrote_return_column = false; 492#else 493 i = DWARF_FRAME_RETURN_COLUMN; 494#endif 495 496 if (! wrote_return_column) 497 { 498 enum machine_mode save_mode = Pmode; 499 HOST_WIDE_INT offset = i * GET_MODE_SIZE (mode); 500 HOST_WIDE_INT size = GET_MODE_SIZE (save_mode); 501 emit_move_insn (adjust_address (mem, mode, offset), GEN_INT (size)); 502 } 503} 504 505/* Convert a DWARF call frame info. operation to its string name */ 506 507static const char * 508dwarf_cfi_name (unsigned int cfi_opc) 509{ 510 switch (cfi_opc) 511 { 512 case DW_CFA_advance_loc: 513 return "DW_CFA_advance_loc"; 514 case DW_CFA_offset: 515 return "DW_CFA_offset"; 516 case DW_CFA_restore: 517 return "DW_CFA_restore"; 518 case DW_CFA_nop: 519 return "DW_CFA_nop"; 520 case DW_CFA_set_loc: 521 return "DW_CFA_set_loc"; 522 case DW_CFA_advance_loc1: 523 return "DW_CFA_advance_loc1"; 524 case DW_CFA_advance_loc2: 525 return "DW_CFA_advance_loc2"; 526 case DW_CFA_advance_loc4: 527 return "DW_CFA_advance_loc4"; 528 case DW_CFA_offset_extended: 529 return "DW_CFA_offset_extended"; 530 case DW_CFA_restore_extended: 531 return "DW_CFA_restore_extended"; 532 case DW_CFA_undefined: 533 return "DW_CFA_undefined"; 534 case DW_CFA_same_value: 535 return "DW_CFA_same_value"; 536 case DW_CFA_register: 537 return "DW_CFA_register"; 538 case DW_CFA_remember_state: 539 return "DW_CFA_remember_state"; 540 case DW_CFA_restore_state: 541 return "DW_CFA_restore_state"; 542 case DW_CFA_def_cfa: 543 return "DW_CFA_def_cfa"; 544 case DW_CFA_def_cfa_register: 545 return "DW_CFA_def_cfa_register"; 546 case DW_CFA_def_cfa_offset: 547 return "DW_CFA_def_cfa_offset"; 548 549 /* DWARF 3 */ 550 case DW_CFA_def_cfa_expression: 551 return "DW_CFA_def_cfa_expression"; 552 case DW_CFA_expression: 553 return "DW_CFA_expression"; 554 case DW_CFA_offset_extended_sf: 555 return "DW_CFA_offset_extended_sf"; 556 case DW_CFA_def_cfa_sf: 557 return "DW_CFA_def_cfa_sf"; 558 case DW_CFA_def_cfa_offset_sf: 559 return "DW_CFA_def_cfa_offset_sf"; 560 561 /* SGI/MIPS specific */ 562 case DW_CFA_MIPS_advance_loc8: 563 return "DW_CFA_MIPS_advance_loc8"; 564 565 /* GNU extensions */ 566 case DW_CFA_GNU_window_save: 567 return "DW_CFA_GNU_window_save"; 568 case DW_CFA_GNU_args_size: 569 return "DW_CFA_GNU_args_size"; 570 case DW_CFA_GNU_negative_offset_extended: 571 return "DW_CFA_GNU_negative_offset_extended"; 572 573 default: 574 return "DW_CFA_<unknown>"; 575 } 576} 577 578/* Return a pointer to a newly allocated Call Frame Instruction. */ 579 580static inline dw_cfi_ref 581new_cfi (void) 582{ 583 dw_cfi_ref cfi = ggc_alloc (sizeof (dw_cfi_node)); 584 585 cfi->dw_cfi_next = NULL; 586 cfi->dw_cfi_oprnd1.dw_cfi_reg_num = 0; 587 cfi->dw_cfi_oprnd2.dw_cfi_reg_num = 0; 588 589 return cfi; 590} 591 592/* Add a Call Frame Instruction to list of instructions. */ 593 594static inline void 595add_cfi (dw_cfi_ref *list_head, dw_cfi_ref cfi) 596{ 597 dw_cfi_ref *p; 598 599 /* Find the end of the chain. */ 600 for (p = list_head; (*p) != NULL; p = &(*p)->dw_cfi_next) 601 ; 602 603 *p = cfi; 604} 605 606/* Generate a new label for the CFI info to refer to. */ 607 608char * 609dwarf2out_cfi_label (void) 610{ 611 static char label[20]; 612 613 ASM_GENERATE_INTERNAL_LABEL (label, "LCFI", dwarf2out_cfi_label_num++); 614 ASM_OUTPUT_LABEL (asm_out_file, label); 615 return label; 616} 617 618/* Add CFI to the current fde at the PC value indicated by LABEL if specified, 619 or to the CIE if LABEL is NULL. */ 620 621static void 622add_fde_cfi (const char *label, dw_cfi_ref cfi) 623{ 624 if (label) 625 { 626 dw_fde_ref fde = &fde_table[fde_table_in_use - 1]; 627 628 if (*label == 0) 629 label = dwarf2out_cfi_label (); 630 631 if (fde->dw_fde_current_label == NULL 632 || strcmp (label, fde->dw_fde_current_label) != 0) 633 { 634 dw_cfi_ref xcfi; 635 636 fde->dw_fde_current_label = label = xstrdup (label); 637 638 /* Set the location counter to the new label. */ 639 xcfi = new_cfi (); 640 xcfi->dw_cfi_opc = DW_CFA_advance_loc4; 641 xcfi->dw_cfi_oprnd1.dw_cfi_addr = label; 642 add_cfi (&fde->dw_fde_cfi, xcfi); 643 } 644 645 add_cfi (&fde->dw_fde_cfi, cfi); 646 } 647 648 else 649 add_cfi (&cie_cfi_head, cfi); 650} 651 652/* Subroutine of lookup_cfa. */ 653 654static inline void 655lookup_cfa_1 (dw_cfi_ref cfi, dw_cfa_location *loc) 656{ 657 switch (cfi->dw_cfi_opc) 658 { 659 case DW_CFA_def_cfa_offset: 660 loc->offset = cfi->dw_cfi_oprnd1.dw_cfi_offset; 661 break; 662 case DW_CFA_def_cfa_register: 663 loc->reg = cfi->dw_cfi_oprnd1.dw_cfi_reg_num; 664 break; 665 case DW_CFA_def_cfa: 666 loc->reg = cfi->dw_cfi_oprnd1.dw_cfi_reg_num; 667 loc->offset = cfi->dw_cfi_oprnd2.dw_cfi_offset; 668 break; 669 case DW_CFA_def_cfa_expression: 670 get_cfa_from_loc_descr (loc, cfi->dw_cfi_oprnd1.dw_cfi_loc); 671 break; 672 default: 673 break; 674 } 675} 676 677/* Find the previous value for the CFA. */ 678 679static void 680lookup_cfa (dw_cfa_location *loc) 681{ 682 dw_cfi_ref cfi; 683 684 loc->reg = (unsigned long) -1; 685 loc->offset = 0; 686 loc->indirect = 0; 687 loc->base_offset = 0; 688 689 for (cfi = cie_cfi_head; cfi; cfi = cfi->dw_cfi_next) 690 lookup_cfa_1 (cfi, loc); 691 692 if (fde_table_in_use) 693 { 694 dw_fde_ref fde = &fde_table[fde_table_in_use - 1]; 695 for (cfi = fde->dw_fde_cfi; cfi; cfi = cfi->dw_cfi_next) 696 lookup_cfa_1 (cfi, loc); 697 } 698} 699 700/* The current rule for calculating the DWARF2 canonical frame address. */ 701static dw_cfa_location cfa; 702 703/* The register used for saving registers to the stack, and its offset 704 from the CFA. */ 705static dw_cfa_location cfa_store; 706 707/* The running total of the size of arguments pushed onto the stack. */ 708static HOST_WIDE_INT args_size; 709 710/* The last args_size we actually output. */ 711static HOST_WIDE_INT old_args_size; 712 713/* Entry point to update the canonical frame address (CFA). 714 LABEL is passed to add_fde_cfi. The value of CFA is now to be 715 calculated from REG+OFFSET. */ 716 717void 718dwarf2out_def_cfa (const char *label, unsigned int reg, HOST_WIDE_INT offset) 719{ 720 dw_cfa_location loc; 721 loc.indirect = 0; 722 loc.base_offset = 0; 723 loc.reg = reg; 724 loc.offset = offset; 725 def_cfa_1 (label, &loc); 726} 727 728/* This routine does the actual work. The CFA is now calculated from 729 the dw_cfa_location structure. */ 730 731static void 732def_cfa_1 (const char *label, dw_cfa_location *loc_p) 733{ 734 dw_cfi_ref cfi; 735 dw_cfa_location old_cfa, loc; 736 737 cfa = *loc_p; 738 loc = *loc_p; 739 740 if (cfa_store.reg == loc.reg && loc.indirect == 0) 741 cfa_store.offset = loc.offset; 742 743 loc.reg = DWARF_FRAME_REGNUM (loc.reg); 744 lookup_cfa (&old_cfa); 745 746 /* If nothing changed, no need to issue any call frame instructions. */ 747 if (loc.reg == old_cfa.reg && loc.offset == old_cfa.offset 748 && loc.indirect == old_cfa.indirect 749 && (loc.indirect == 0 || loc.base_offset == old_cfa.base_offset)) 750 return; 751 752 cfi = new_cfi (); 753 754 if (loc.reg == old_cfa.reg && !loc.indirect) 755 { 756 /* Construct a "DW_CFA_def_cfa_offset <offset>" instruction, 757 indicating the CFA register did not change but the offset 758 did. */ 759 cfi->dw_cfi_opc = DW_CFA_def_cfa_offset; 760 cfi->dw_cfi_oprnd1.dw_cfi_offset = loc.offset; 761 } 762 763#ifndef MIPS_DEBUGGING_INFO /* SGI dbx thinks this means no offset. */ 764 else if (loc.offset == old_cfa.offset && old_cfa.reg != (unsigned long) -1 765 && !loc.indirect) 766 { 767 /* Construct a "DW_CFA_def_cfa_register <register>" instruction, 768 indicating the CFA register has changed to <register> but the 769 offset has not changed. */ 770 cfi->dw_cfi_opc = DW_CFA_def_cfa_register; 771 cfi->dw_cfi_oprnd1.dw_cfi_reg_num = loc.reg; 772 } 773#endif 774 775 else if (loc.indirect == 0) 776 { 777 /* Construct a "DW_CFA_def_cfa <register> <offset>" instruction, 778 indicating the CFA register has changed to <register> with 779 the specified offset. */ 780 cfi->dw_cfi_opc = DW_CFA_def_cfa; 781 cfi->dw_cfi_oprnd1.dw_cfi_reg_num = loc.reg; 782 cfi->dw_cfi_oprnd2.dw_cfi_offset = loc.offset; 783 } 784 else 785 { 786 /* Construct a DW_CFA_def_cfa_expression instruction to 787 calculate the CFA using a full location expression since no 788 register-offset pair is available. */ 789 struct dw_loc_descr_struct *loc_list; 790 791 cfi->dw_cfi_opc = DW_CFA_def_cfa_expression; 792 loc_list = build_cfa_loc (&loc); 793 cfi->dw_cfi_oprnd1.dw_cfi_loc = loc_list; 794 } 795 796 add_fde_cfi (label, cfi); 797} 798 799/* Add the CFI for saving a register. REG is the CFA column number. 800 LABEL is passed to add_fde_cfi. 801 If SREG is -1, the register is saved at OFFSET from the CFA; 802 otherwise it is saved in SREG. */ 803 804static void 805reg_save (const char *label, unsigned int reg, unsigned int sreg, HOST_WIDE_INT offset) 806{ 807 dw_cfi_ref cfi = new_cfi (); 808 809 cfi->dw_cfi_oprnd1.dw_cfi_reg_num = reg; 810 811 /* The following comparison is correct. -1 is used to indicate that 812 the value isn't a register number. */ 813 if (sreg == (unsigned int) -1) 814 { 815 if (reg & ~0x3f) 816 /* The register number won't fit in 6 bits, so we have to use 817 the long form. */ 818 cfi->dw_cfi_opc = DW_CFA_offset_extended; 819 else 820 cfi->dw_cfi_opc = DW_CFA_offset; 821 822#ifdef ENABLE_CHECKING 823 { 824 /* If we get an offset that is not a multiple of 825 DWARF_CIE_DATA_ALIGNMENT, there is either a bug in the 826 definition of DWARF_CIE_DATA_ALIGNMENT, or a bug in the machine 827 description. */ 828 HOST_WIDE_INT check_offset = offset / DWARF_CIE_DATA_ALIGNMENT; 829 830 if (check_offset * DWARF_CIE_DATA_ALIGNMENT != offset) 831 abort (); 832 } 833#endif 834 offset /= DWARF_CIE_DATA_ALIGNMENT; 835 if (offset < 0) 836 cfi->dw_cfi_opc = DW_CFA_offset_extended_sf; 837 838 cfi->dw_cfi_oprnd2.dw_cfi_offset = offset; 839 } 840 else if (sreg == reg) 841 /* We could emit a DW_CFA_same_value in this case, but don't bother. */ 842 return; 843 else 844 { 845 cfi->dw_cfi_opc = DW_CFA_register; 846 cfi->dw_cfi_oprnd2.dw_cfi_reg_num = sreg; 847 } 848 849 add_fde_cfi (label, cfi); 850} 851 852/* Add the CFI for saving a register window. LABEL is passed to reg_save. 853 This CFI tells the unwinder that it needs to restore the window registers 854 from the previous frame's window save area. 855 856 ??? Perhaps we should note in the CIE where windows are saved (instead of 857 assuming 0(cfa)) and what registers are in the window. */ 858 859void 860dwarf2out_window_save (const char *label) 861{ 862 dw_cfi_ref cfi = new_cfi (); 863 864 cfi->dw_cfi_opc = DW_CFA_GNU_window_save; 865 add_fde_cfi (label, cfi); 866} 867 868/* Add a CFI to update the running total of the size of arguments 869 pushed onto the stack. */ 870 871void 872dwarf2out_args_size (const char *label, HOST_WIDE_INT size) 873{ 874 dw_cfi_ref cfi; 875 876 if (size == old_args_size) 877 return; 878 879 old_args_size = size; 880 881 cfi = new_cfi (); 882 cfi->dw_cfi_opc = DW_CFA_GNU_args_size; 883 cfi->dw_cfi_oprnd1.dw_cfi_offset = size; 884 add_fde_cfi (label, cfi); 885} 886 887/* Entry point for saving a register to the stack. REG is the GCC register 888 number. LABEL and OFFSET are passed to reg_save. */ 889 890void 891dwarf2out_reg_save (const char *label, unsigned int reg, HOST_WIDE_INT offset) 892{ 893 reg_save (label, DWARF_FRAME_REGNUM (reg), -1, offset); 894} 895 896/* Entry point for saving the return address in the stack. 897 LABEL and OFFSET are passed to reg_save. */ 898 899void 900dwarf2out_return_save (const char *label, HOST_WIDE_INT offset) 901{ 902 reg_save (label, DWARF_FRAME_RETURN_COLUMN, -1, offset); 903} 904 905/* Entry point for saving the return address in a register. 906 LABEL and SREG are passed to reg_save. */ 907 908void 909dwarf2out_return_reg (const char *label, unsigned int sreg) 910{ 911 reg_save (label, DWARF_FRAME_RETURN_COLUMN, sreg, 0); 912} 913 914/* Record the initial position of the return address. RTL is 915 INCOMING_RETURN_ADDR_RTX. */ 916 917static void 918initial_return_save (rtx rtl) 919{ 920 unsigned int reg = (unsigned int) -1; 921 HOST_WIDE_INT offset = 0; 922 923 switch (GET_CODE (rtl)) 924 { 925 case REG: 926 /* RA is in a register. */ 927 reg = DWARF_FRAME_REGNUM (REGNO (rtl)); 928 break; 929 930 case MEM: 931 /* RA is on the stack. */ 932 rtl = XEXP (rtl, 0); 933 switch (GET_CODE (rtl)) 934 { 935 case REG: 936 if (REGNO (rtl) != STACK_POINTER_REGNUM) 937 abort (); 938 offset = 0; 939 break; 940 941 case PLUS: 942 if (REGNO (XEXP (rtl, 0)) != STACK_POINTER_REGNUM) 943 abort (); 944 offset = INTVAL (XEXP (rtl, 1)); 945 break; 946 947 case MINUS: 948 if (REGNO (XEXP (rtl, 0)) != STACK_POINTER_REGNUM) 949 abort (); 950 offset = -INTVAL (XEXP (rtl, 1)); 951 break; 952 953 default: 954 abort (); 955 } 956 957 break; 958 959 case PLUS: 960 /* The return address is at some offset from any value we can 961 actually load. For instance, on the SPARC it is in %i7+8. Just 962 ignore the offset for now; it doesn't matter for unwinding frames. */ 963 if (GET_CODE (XEXP (rtl, 1)) != CONST_INT) 964 abort (); 965 initial_return_save (XEXP (rtl, 0)); 966 return; 967 968 default: 969 abort (); 970 } 971 972 reg_save (NULL, DWARF_FRAME_RETURN_COLUMN, reg, offset - cfa.offset); 973} 974 975/* Given a SET, calculate the amount of stack adjustment it 976 contains. */ 977 978static HOST_WIDE_INT 979stack_adjust_offset (rtx pattern) 980{ 981 rtx src = SET_SRC (pattern); 982 rtx dest = SET_DEST (pattern); 983 HOST_WIDE_INT offset = 0; 984 enum rtx_code code; 985 986 if (dest == stack_pointer_rtx) 987 { 988 /* (set (reg sp) (plus (reg sp) (const_int))) */ 989 code = GET_CODE (src); 990 if (! (code == PLUS || code == MINUS) 991 || XEXP (src, 0) != stack_pointer_rtx 992 || GET_CODE (XEXP (src, 1)) != CONST_INT) 993 return 0; 994 995 offset = INTVAL (XEXP (src, 1)); 996 if (code == PLUS) 997 offset = -offset; 998 } 999 else if (GET_CODE (dest) == MEM) 1000 { 1001 /* (set (mem (pre_dec (reg sp))) (foo)) */ 1002 src = XEXP (dest, 0); 1003 code = GET_CODE (src); 1004 1005 switch (code) 1006 { 1007 case PRE_MODIFY: 1008 case POST_MODIFY: 1009 if (XEXP (src, 0) == stack_pointer_rtx) 1010 { 1011 rtx val = XEXP (XEXP (src, 1), 1); 1012 /* We handle only adjustments by constant amount. */ 1013 if (GET_CODE (XEXP (src, 1)) != PLUS || 1014 GET_CODE (val) != CONST_INT) 1015 abort (); 1016 offset = -INTVAL (val); 1017 break; 1018 } 1019 return 0; 1020 1021 case PRE_DEC: 1022 case POST_DEC: 1023 if (XEXP (src, 0) == stack_pointer_rtx) 1024 { 1025 offset = GET_MODE_SIZE (GET_MODE (dest)); 1026 break; 1027 } 1028 return 0; 1029 1030 case PRE_INC: 1031 case POST_INC: 1032 if (XEXP (src, 0) == stack_pointer_rtx) 1033 { 1034 offset = -GET_MODE_SIZE (GET_MODE (dest)); 1035 break; 1036 } 1037 return 0; 1038 1039 default: 1040 return 0; 1041 } 1042 } 1043 else 1044 return 0; 1045 1046 return offset; 1047} 1048 1049/* Check INSN to see if it looks like a push or a stack adjustment, and 1050 make a note of it if it does. EH uses this information to find out how 1051 much extra space it needs to pop off the stack. */ 1052 1053static void 1054dwarf2out_stack_adjust (rtx insn) 1055{ 1056 HOST_WIDE_INT offset; 1057 const char *label; 1058 int i; 1059 1060 /* Don't handle epilogues at all. Certainly it would be wrong to do so 1061 with this function. Proper support would require all frame-related 1062 insns to be marked, and to be able to handle saving state around 1063 epilogues textually in the middle of the function. */ 1064 if (prologue_epilogue_contains (insn) || sibcall_epilogue_contains (insn)) 1065 return; 1066 1067 if (!flag_asynchronous_unwind_tables && GET_CODE (insn) == CALL_INSN) 1068 { 1069 /* Extract the size of the args from the CALL rtx itself. */ 1070 insn = PATTERN (insn); 1071 if (GET_CODE (insn) == PARALLEL) 1072 insn = XVECEXP (insn, 0, 0); 1073 if (GET_CODE (insn) == SET) 1074 insn = SET_SRC (insn); 1075 if (GET_CODE (insn) != CALL) 1076 abort (); 1077 1078 dwarf2out_args_size ("", INTVAL (XEXP (insn, 1))); 1079 return; 1080 } 1081 1082 /* If only calls can throw, and we have a frame pointer, 1083 save up adjustments until we see the CALL_INSN. */ 1084 else if (!flag_asynchronous_unwind_tables && cfa.reg != STACK_POINTER_REGNUM) 1085 return; 1086 1087 if (GET_CODE (insn) == BARRIER) 1088 { 1089 /* When we see a BARRIER, we know to reset args_size to 0. Usually 1090 the compiler will have already emitted a stack adjustment, but 1091 doesn't bother for calls to noreturn functions. */ 1092#ifdef STACK_GROWS_DOWNWARD 1093 offset = -args_size; 1094#else 1095 offset = args_size; 1096#endif 1097 } 1098 else if (GET_CODE (PATTERN (insn)) == SET) 1099 offset = stack_adjust_offset (PATTERN (insn)); 1100 else if (GET_CODE (PATTERN (insn)) == PARALLEL 1101 || GET_CODE (PATTERN (insn)) == SEQUENCE) 1102 { 1103 /* There may be stack adjustments inside compound insns. Search 1104 for them. */ 1105 for (offset = 0, i = XVECLEN (PATTERN (insn), 0) - 1; i >= 0; i--) 1106 if (GET_CODE (XVECEXP (PATTERN (insn), 0, i)) == SET) 1107 offset += stack_adjust_offset (XVECEXP (PATTERN (insn), 0, i)); 1108 } 1109 else 1110 return; 1111 1112 if (offset == 0) 1113 return; 1114 1115 if (cfa.reg == STACK_POINTER_REGNUM) 1116 cfa.offset += offset; 1117 1118#ifndef STACK_GROWS_DOWNWARD 1119 offset = -offset; 1120#endif 1121 1122 args_size += offset; 1123 if (args_size < 0) 1124 args_size = 0; 1125 1126 label = dwarf2out_cfi_label (); 1127 def_cfa_1 (label, &cfa); 1128 dwarf2out_args_size (label, args_size); 1129} 1130 1131#endif 1132 1133/* We delay emitting a register save until either (a) we reach the end 1134 of the prologue or (b) the register is clobbered. This clusters 1135 register saves so that there are fewer pc advances. */ 1136 1137struct queued_reg_save GTY(()) 1138{ 1139 struct queued_reg_save *next; 1140 rtx reg; 1141 HOST_WIDE_INT cfa_offset; 1142}; 1143 1144static GTY(()) struct queued_reg_save *queued_reg_saves; 1145 1146#if defined (DWARF2_DEBUGGING_INFO) || defined (DWARF2_UNWIND_INFO) 1147static const char *last_reg_save_label; 1148 1149static void 1150queue_reg_save (const char *label, rtx reg, HOST_WIDE_INT offset) 1151{ 1152 struct queued_reg_save *q = ggc_alloc (sizeof (*q)); 1153 1154 q->next = queued_reg_saves; 1155 q->reg = reg; 1156 q->cfa_offset = offset; 1157 queued_reg_saves = q; 1158 1159 last_reg_save_label = label; 1160} 1161 1162static void 1163flush_queued_reg_saves (void) 1164{ 1165 struct queued_reg_save *q, *next; 1166 1167 for (q = queued_reg_saves; q; q = next) 1168 { 1169 dwarf2out_reg_save (last_reg_save_label, REGNO (q->reg), q->cfa_offset); 1170 next = q->next; 1171 } 1172 1173 queued_reg_saves = NULL; 1174 last_reg_save_label = NULL; 1175} 1176 1177static bool 1178clobbers_queued_reg_save (rtx insn) 1179{ 1180 struct queued_reg_save *q; 1181 1182 for (q = queued_reg_saves; q; q = q->next) 1183 if (modified_in_p (q->reg, insn)) 1184 return true; 1185 1186 return false; 1187} 1188 1189 1190/* A temporary register holding an integral value used in adjusting SP 1191 or setting up the store_reg. The "offset" field holds the integer 1192 value, not an offset. */ 1193static dw_cfa_location cfa_temp; 1194 1195/* Record call frame debugging information for an expression EXPR, 1196 which either sets SP or FP (adjusting how we calculate the frame 1197 address) or saves a register to the stack. LABEL indicates the 1198 address of EXPR. 1199 1200 This function encodes a state machine mapping rtxes to actions on 1201 cfa, cfa_store, and cfa_temp.reg. We describe these rules so 1202 users need not read the source code. 1203 1204 The High-Level Picture 1205 1206 Changes in the register we use to calculate the CFA: Currently we 1207 assume that if you copy the CFA register into another register, we 1208 should take the other one as the new CFA register; this seems to 1209 work pretty well. If it's wrong for some target, it's simple 1210 enough not to set RTX_FRAME_RELATED_P on the insn in question. 1211 1212 Changes in the register we use for saving registers to the stack: 1213 This is usually SP, but not always. Again, we deduce that if you 1214 copy SP into another register (and SP is not the CFA register), 1215 then the new register is the one we will be using for register 1216 saves. This also seems to work. 1217 1218 Register saves: There's not much guesswork about this one; if 1219 RTX_FRAME_RELATED_P is set on an insn which modifies memory, it's a 1220 register save, and the register used to calculate the destination 1221 had better be the one we think we're using for this purpose. 1222 1223 Except: If the register being saved is the CFA register, and the 1224 offset is nonzero, we are saving the CFA, so we assume we have to 1225 use DW_CFA_def_cfa_expression. If the offset is 0, we assume that 1226 the intent is to save the value of SP from the previous frame. 1227 1228 Invariants / Summaries of Rules 1229 1230 cfa current rule for calculating the CFA. It usually 1231 consists of a register and an offset. 1232 cfa_store register used by prologue code to save things to the stack 1233 cfa_store.offset is the offset from the value of 1234 cfa_store.reg to the actual CFA 1235 cfa_temp register holding an integral value. cfa_temp.offset 1236 stores the value, which will be used to adjust the 1237 stack pointer. cfa_temp is also used like cfa_store, 1238 to track stores to the stack via fp or a temp reg. 1239 1240 Rules 1- 4: Setting a register's value to cfa.reg or an expression 1241 with cfa.reg as the first operand changes the cfa.reg and its 1242 cfa.offset. Rule 1 and 4 also set cfa_temp.reg and 1243 cfa_temp.offset. 1244 1245 Rules 6- 9: Set a non-cfa.reg register value to a constant or an 1246 expression yielding a constant. This sets cfa_temp.reg 1247 and cfa_temp.offset. 1248 1249 Rule 5: Create a new register cfa_store used to save items to the 1250 stack. 1251 1252 Rules 10-14: Save a register to the stack. Define offset as the 1253 difference of the original location and cfa_store's 1254 location (or cfa_temp's location if cfa_temp is used). 1255 1256 The Rules 1257 1258 "{a,b}" indicates a choice of a xor b. 1259 "<reg>:cfa.reg" indicates that <reg> must equal cfa.reg. 1260 1261 Rule 1: 1262 (set <reg1> <reg2>:cfa.reg) 1263 effects: cfa.reg = <reg1> 1264 cfa.offset unchanged 1265 cfa_temp.reg = <reg1> 1266 cfa_temp.offset = cfa.offset 1267 1268 Rule 2: 1269 (set sp ({minus,plus,losum} {sp,fp}:cfa.reg 1270 {<const_int>,<reg>:cfa_temp.reg})) 1271 effects: cfa.reg = sp if fp used 1272 cfa.offset += {+/- <const_int>, cfa_temp.offset} if cfa.reg==sp 1273 cfa_store.offset += {+/- <const_int>, cfa_temp.offset} 1274 if cfa_store.reg==sp 1275 1276 Rule 3: 1277 (set fp ({minus,plus,losum} <reg>:cfa.reg <const_int>)) 1278 effects: cfa.reg = fp 1279 cfa_offset += +/- <const_int> 1280 1281 Rule 4: 1282 (set <reg1> ({plus,losum} <reg2>:cfa.reg <const_int>)) 1283 constraints: <reg1> != fp 1284 <reg1> != sp 1285 effects: cfa.reg = <reg1> 1286 cfa_temp.reg = <reg1> 1287 cfa_temp.offset = cfa.offset 1288 1289 Rule 5: 1290 (set <reg1> (plus <reg2>:cfa_temp.reg sp:cfa.reg)) 1291 constraints: <reg1> != fp 1292 <reg1> != sp 1293 effects: cfa_store.reg = <reg1> 1294 cfa_store.offset = cfa.offset - cfa_temp.offset 1295 1296 Rule 6: 1297 (set <reg> <const_int>) 1298 effects: cfa_temp.reg = <reg> 1299 cfa_temp.offset = <const_int> 1300 1301 Rule 7: 1302 (set <reg1>:cfa_temp.reg (ior <reg2>:cfa_temp.reg <const_int>)) 1303 effects: cfa_temp.reg = <reg1> 1304 cfa_temp.offset |= <const_int> 1305 1306 Rule 8: 1307 (set <reg> (high <exp>)) 1308 effects: none 1309 1310 Rule 9: 1311 (set <reg> (lo_sum <exp> <const_int>)) 1312 effects: cfa_temp.reg = <reg> 1313 cfa_temp.offset = <const_int> 1314 1315 Rule 10: 1316 (set (mem (pre_modify sp:cfa_store (???? <reg1> <const_int>))) <reg2>) 1317 effects: cfa_store.offset -= <const_int> 1318 cfa.offset = cfa_store.offset if cfa.reg == sp 1319 cfa.reg = sp 1320 cfa.base_offset = -cfa_store.offset 1321 1322 Rule 11: 1323 (set (mem ({pre_inc,pre_dec} sp:cfa_store.reg)) <reg>) 1324 effects: cfa_store.offset += -/+ mode_size(mem) 1325 cfa.offset = cfa_store.offset if cfa.reg == sp 1326 cfa.reg = sp 1327 cfa.base_offset = -cfa_store.offset 1328 1329 Rule 12: 1330 (set (mem ({minus,plus,losum} <reg1>:{cfa_store,cfa_temp} <const_int>)) 1331 1332 <reg2>) 1333 effects: cfa.reg = <reg1> 1334 cfa.base_offset = -/+ <const_int> - {cfa_store,cfa_temp}.offset 1335 1336 Rule 13: 1337 (set (mem <reg1>:{cfa_store,cfa_temp}) <reg2>) 1338 effects: cfa.reg = <reg1> 1339 cfa.base_offset = -{cfa_store,cfa_temp}.offset 1340 1341 Rule 14: 1342 (set (mem (postinc <reg1>:cfa_temp <const_int>)) <reg2>) 1343 effects: cfa.reg = <reg1> 1344 cfa.base_offset = -cfa_temp.offset 1345 cfa_temp.offset -= mode_size(mem) */ 1346 1347static void 1348dwarf2out_frame_debug_expr (rtx expr, const char *label) 1349{ 1350 rtx src, dest; 1351 HOST_WIDE_INT offset; 1352 1353 /* If RTX_FRAME_RELATED_P is set on a PARALLEL, process each member of 1354 the PARALLEL independently. The first element is always processed if 1355 it is a SET. This is for backward compatibility. Other elements 1356 are processed only if they are SETs and the RTX_FRAME_RELATED_P 1357 flag is set in them. */ 1358 if (GET_CODE (expr) == PARALLEL || GET_CODE (expr) == SEQUENCE) 1359 { 1360 int par_index; 1361 int limit = XVECLEN (expr, 0); 1362 1363 for (par_index = 0; par_index < limit; par_index++) 1364 if (GET_CODE (XVECEXP (expr, 0, par_index)) == SET 1365 && (RTX_FRAME_RELATED_P (XVECEXP (expr, 0, par_index)) 1366 || par_index == 0)) 1367 dwarf2out_frame_debug_expr (XVECEXP (expr, 0, par_index), label); 1368 1369 return; 1370 } 1371 1372 if (GET_CODE (expr) != SET) 1373 abort (); 1374 1375 src = SET_SRC (expr); 1376 dest = SET_DEST (expr); 1377 1378 switch (GET_CODE (dest)) 1379 { 1380 case REG: 1381 /* Rule 1 */ 1382 /* Update the CFA rule wrt SP or FP. Make sure src is 1383 relative to the current CFA register. */ 1384 switch (GET_CODE (src)) 1385 { 1386 /* Setting FP from SP. */ 1387 case REG: 1388 if (cfa.reg == (unsigned) REGNO (src)) 1389 /* OK. */ 1390 ; 1391 else 1392 abort (); 1393 1394 /* We used to require that dest be either SP or FP, but the 1395 ARM copies SP to a temporary register, and from there to 1396 FP. So we just rely on the backends to only set 1397 RTX_FRAME_RELATED_P on appropriate insns. */ 1398 cfa.reg = REGNO (dest); 1399 cfa_temp.reg = cfa.reg; 1400 cfa_temp.offset = cfa.offset; 1401 break; 1402 1403 case PLUS: 1404 case MINUS: 1405 case LO_SUM: 1406 if (dest == stack_pointer_rtx) 1407 { 1408 /* Rule 2 */ 1409 /* Adjusting SP. */ 1410 switch (GET_CODE (XEXP (src, 1))) 1411 { 1412 case CONST_INT: 1413 offset = INTVAL (XEXP (src, 1)); 1414 break; 1415 case REG: 1416 if ((unsigned) REGNO (XEXP (src, 1)) != cfa_temp.reg) 1417 abort (); 1418 offset = cfa_temp.offset; 1419 break; 1420 default: 1421 abort (); 1422 } 1423 1424 if (XEXP (src, 0) == hard_frame_pointer_rtx) 1425 { 1426 /* Restoring SP from FP in the epilogue. */ 1427 if (cfa.reg != (unsigned) HARD_FRAME_POINTER_REGNUM) 1428 abort (); 1429 cfa.reg = STACK_POINTER_REGNUM; 1430 } 1431 else if (GET_CODE (src) == LO_SUM) 1432 /* Assume we've set the source reg of the LO_SUM from sp. */ 1433 ; 1434 else if (XEXP (src, 0) != stack_pointer_rtx) 1435 abort (); 1436 1437 if (GET_CODE (src) != MINUS) 1438 offset = -offset; 1439 if (cfa.reg == STACK_POINTER_REGNUM) 1440 cfa.offset += offset; 1441 if (cfa_store.reg == STACK_POINTER_REGNUM) 1442 cfa_store.offset += offset; 1443 } 1444 else if (dest == hard_frame_pointer_rtx) 1445 { 1446 /* Rule 3 */ 1447 /* Either setting the FP from an offset of the SP, 1448 or adjusting the FP */ 1449 if (! frame_pointer_needed) 1450 abort (); 1451 1452 if (GET_CODE (XEXP (src, 0)) == REG 1453 && (unsigned) REGNO (XEXP (src, 0)) == cfa.reg 1454 && GET_CODE (XEXP (src, 1)) == CONST_INT) 1455 { 1456 offset = INTVAL (XEXP (src, 1)); 1457 if (GET_CODE (src) != MINUS) 1458 offset = -offset; 1459 cfa.offset += offset; 1460 cfa.reg = HARD_FRAME_POINTER_REGNUM; 1461 } 1462 else 1463 abort (); 1464 } 1465 else 1466 { 1467 if (GET_CODE (src) == MINUS) 1468 abort (); 1469 1470 /* Rule 4 */ 1471 if (GET_CODE (XEXP (src, 0)) == REG 1472 && REGNO (XEXP (src, 0)) == cfa.reg 1473 && GET_CODE (XEXP (src, 1)) == CONST_INT) 1474 { 1475 /* Setting a temporary CFA register that will be copied 1476 into the FP later on. */ 1477 offset = - INTVAL (XEXP (src, 1)); 1478 cfa.offset += offset; 1479 cfa.reg = REGNO (dest); 1480 /* Or used to save regs to the stack. */ 1481 cfa_temp.reg = cfa.reg; 1482 cfa_temp.offset = cfa.offset; 1483 } 1484 1485 /* Rule 5 */ 1486 else if (GET_CODE (XEXP (src, 0)) == REG 1487 && REGNO (XEXP (src, 0)) == cfa_temp.reg 1488 && XEXP (src, 1) == stack_pointer_rtx) 1489 { 1490 /* Setting a scratch register that we will use instead 1491 of SP for saving registers to the stack. */ 1492 if (cfa.reg != STACK_POINTER_REGNUM) 1493 abort (); 1494 cfa_store.reg = REGNO (dest); 1495 cfa_store.offset = cfa.offset - cfa_temp.offset; 1496 } 1497 1498 /* Rule 9 */ 1499 else if (GET_CODE (src) == LO_SUM 1500 && GET_CODE (XEXP (src, 1)) == CONST_INT) 1501 { 1502 cfa_temp.reg = REGNO (dest); 1503 cfa_temp.offset = INTVAL (XEXP (src, 1)); 1504 } 1505 else 1506 abort (); 1507 } 1508 break; 1509 1510 /* Rule 6 */ 1511 case CONST_INT: 1512 cfa_temp.reg = REGNO (dest); 1513 cfa_temp.offset = INTVAL (src); 1514 break; 1515 1516 /* Rule 7 */ 1517 case IOR: 1518 if (GET_CODE (XEXP (src, 0)) != REG 1519 || (unsigned) REGNO (XEXP (src, 0)) != cfa_temp.reg 1520 || GET_CODE (XEXP (src, 1)) != CONST_INT) 1521 abort (); 1522 1523 if ((unsigned) REGNO (dest) != cfa_temp.reg) 1524 cfa_temp.reg = REGNO (dest); 1525 cfa_temp.offset |= INTVAL (XEXP (src, 1)); 1526 break; 1527 1528 /* Skip over HIGH, assuming it will be followed by a LO_SUM, 1529 which will fill in all of the bits. */ 1530 /* Rule 8 */ 1531 case HIGH: 1532 break; 1533 1534 default: 1535 abort (); 1536 } 1537 1538 def_cfa_1 (label, &cfa); 1539 break; 1540 1541 case MEM: 1542 if (GET_CODE (src) != REG) 1543 abort (); 1544 1545 /* Saving a register to the stack. Make sure dest is relative to the 1546 CFA register. */ 1547 switch (GET_CODE (XEXP (dest, 0))) 1548 { 1549 /* Rule 10 */ 1550 /* With a push. */ 1551 case PRE_MODIFY: 1552 /* We can't handle variable size modifications. */ 1553 if (GET_CODE (XEXP (XEXP (XEXP (dest, 0), 1), 1)) != CONST_INT) 1554 abort (); 1555 offset = -INTVAL (XEXP (XEXP (XEXP (dest, 0), 1), 1)); 1556 1557 if (REGNO (XEXP (XEXP (dest, 0), 0)) != STACK_POINTER_REGNUM 1558 || cfa_store.reg != STACK_POINTER_REGNUM) 1559 abort (); 1560 1561 cfa_store.offset += offset; 1562 if (cfa.reg == STACK_POINTER_REGNUM) 1563 cfa.offset = cfa_store.offset; 1564 1565 offset = -cfa_store.offset; 1566 break; 1567 1568 /* Rule 11 */ 1569 case PRE_INC: 1570 case PRE_DEC: 1571 offset = GET_MODE_SIZE (GET_MODE (dest)); 1572 if (GET_CODE (XEXP (dest, 0)) == PRE_INC) 1573 offset = -offset; 1574 1575 if (REGNO (XEXP (XEXP (dest, 0), 0)) != STACK_POINTER_REGNUM 1576 || cfa_store.reg != STACK_POINTER_REGNUM) 1577 abort (); 1578 1579 cfa_store.offset += offset; 1580 if (cfa.reg == STACK_POINTER_REGNUM) 1581 cfa.offset = cfa_store.offset; 1582 1583 offset = -cfa_store.offset; 1584 break; 1585 1586 /* Rule 12 */ 1587 /* With an offset. */ 1588 case PLUS: 1589 case MINUS: 1590 case LO_SUM: 1591 if (GET_CODE (XEXP (XEXP (dest, 0), 1)) != CONST_INT) 1592 abort (); 1593 offset = INTVAL (XEXP (XEXP (dest, 0), 1)); 1594 if (GET_CODE (XEXP (dest, 0)) == MINUS) 1595 offset = -offset; 1596 1597 if (cfa_store.reg == (unsigned) REGNO (XEXP (XEXP (dest, 0), 0))) 1598 offset -= cfa_store.offset; 1599 else if (cfa_temp.reg == (unsigned) REGNO (XEXP (XEXP (dest, 0), 0))) 1600 offset -= cfa_temp.offset; 1601 else 1602 abort (); 1603 break; 1604 1605 /* Rule 13 */ 1606 /* Without an offset. */ 1607 case REG: 1608 if (cfa_store.reg == (unsigned) REGNO (XEXP (dest, 0))) 1609 offset = -cfa_store.offset; 1610 else if (cfa_temp.reg == (unsigned) REGNO (XEXP (dest, 0))) 1611 offset = -cfa_temp.offset; 1612 else 1613 abort (); 1614 break; 1615 1616 /* Rule 14 */ 1617 case POST_INC: 1618 if (cfa_temp.reg != (unsigned) REGNO (XEXP (XEXP (dest, 0), 0))) 1619 abort (); 1620 offset = -cfa_temp.offset; 1621 cfa_temp.offset -= GET_MODE_SIZE (GET_MODE (dest)); 1622 break; 1623 1624 default: 1625 abort (); 1626 } 1627 1628 if (REGNO (src) != STACK_POINTER_REGNUM 1629 && REGNO (src) != HARD_FRAME_POINTER_REGNUM 1630 && (unsigned) REGNO (src) == cfa.reg) 1631 { 1632 /* We're storing the current CFA reg into the stack. */ 1633 1634 if (cfa.offset == 0) 1635 { 1636 /* If the source register is exactly the CFA, assume 1637 we're saving SP like any other register; this happens 1638 on the ARM. */ 1639 def_cfa_1 (label, &cfa); 1640 queue_reg_save (label, stack_pointer_rtx, offset); 1641 break; 1642 } 1643 else 1644 { 1645 /* Otherwise, we'll need to look in the stack to 1646 calculate the CFA. */ 1647 rtx x = XEXP (dest, 0); 1648 1649 if (GET_CODE (x) != REG) 1650 x = XEXP (x, 0); 1651 if (GET_CODE (x) != REG) 1652 abort (); 1653 1654 cfa.reg = REGNO (x); 1655 cfa.base_offset = offset; 1656 cfa.indirect = 1; 1657 def_cfa_1 (label, &cfa); 1658 break; 1659 } 1660 } 1661 1662 def_cfa_1 (label, &cfa); 1663 queue_reg_save (label, src, offset); 1664 break; 1665 1666 default: 1667 abort (); 1668 } 1669} 1670 1671/* Record call frame debugging information for INSN, which either 1672 sets SP or FP (adjusting how we calculate the frame address) or saves a 1673 register to the stack. If INSN is NULL_RTX, initialize our state. */ 1674 1675void 1676dwarf2out_frame_debug (rtx insn) 1677{ 1678 const char *label; 1679 rtx src; 1680 1681 if (insn == NULL_RTX) 1682 { 1683 /* Flush any queued register saves. */ 1684 flush_queued_reg_saves (); 1685 1686 /* Set up state for generating call frame debug info. */ 1687 lookup_cfa (&cfa); 1688 if (cfa.reg != (unsigned long) DWARF_FRAME_REGNUM (STACK_POINTER_REGNUM)) 1689 abort (); 1690 1691 cfa.reg = STACK_POINTER_REGNUM; 1692 cfa_store = cfa; 1693 cfa_temp.reg = -1; 1694 cfa_temp.offset = 0; 1695 return; 1696 } 1697 1698 if (GET_CODE (insn) != INSN || clobbers_queued_reg_save (insn)) 1699 flush_queued_reg_saves (); 1700 1701 if (! RTX_FRAME_RELATED_P (insn)) 1702 { 1703 if (!ACCUMULATE_OUTGOING_ARGS) 1704 dwarf2out_stack_adjust (insn); 1705 1706 return; 1707 } 1708 1709 label = dwarf2out_cfi_label (); 1710 src = find_reg_note (insn, REG_FRAME_RELATED_EXPR, NULL_RTX); 1711 if (src) 1712 insn = XEXP (src, 0); 1713 else 1714 insn = PATTERN (insn); 1715 1716 dwarf2out_frame_debug_expr (insn, label); 1717} 1718 1719#endif 1720 1721/* Describe for the GTY machinery what parts of dw_cfi_oprnd1 are used. */ 1722static enum dw_cfi_oprnd_type dw_cfi_oprnd1_desc 1723 (enum dwarf_call_frame_info cfi); 1724 1725static enum dw_cfi_oprnd_type 1726dw_cfi_oprnd1_desc (enum dwarf_call_frame_info cfi) 1727{ 1728 switch (cfi) 1729 { 1730 case DW_CFA_nop: 1731 case DW_CFA_GNU_window_save: 1732 return dw_cfi_oprnd_unused; 1733 1734 case DW_CFA_set_loc: 1735 case DW_CFA_advance_loc1: 1736 case DW_CFA_advance_loc2: 1737 case DW_CFA_advance_loc4: 1738 case DW_CFA_MIPS_advance_loc8: 1739 return dw_cfi_oprnd_addr; 1740 1741 case DW_CFA_offset: 1742 case DW_CFA_offset_extended: 1743 case DW_CFA_def_cfa: 1744 case DW_CFA_offset_extended_sf: 1745 case DW_CFA_def_cfa_sf: 1746 case DW_CFA_restore_extended: 1747 case DW_CFA_undefined: 1748 case DW_CFA_same_value: 1749 case DW_CFA_def_cfa_register: 1750 case DW_CFA_register: 1751 return dw_cfi_oprnd_reg_num; 1752 1753 case DW_CFA_def_cfa_offset: 1754 case DW_CFA_GNU_args_size: 1755 case DW_CFA_def_cfa_offset_sf: 1756 return dw_cfi_oprnd_offset; 1757 1758 case DW_CFA_def_cfa_expression: 1759 case DW_CFA_expression: 1760 return dw_cfi_oprnd_loc; 1761 1762 default: 1763 abort (); 1764 } 1765} 1766 1767/* Describe for the GTY machinery what parts of dw_cfi_oprnd2 are used. */ 1768static enum dw_cfi_oprnd_type dw_cfi_oprnd2_desc 1769 (enum dwarf_call_frame_info cfi); 1770 1771static enum dw_cfi_oprnd_type 1772dw_cfi_oprnd2_desc (enum dwarf_call_frame_info cfi) 1773{ 1774 switch (cfi) 1775 { 1776 case DW_CFA_def_cfa: 1777 case DW_CFA_def_cfa_sf: 1778 case DW_CFA_offset: 1779 case DW_CFA_offset_extended_sf: 1780 case DW_CFA_offset_extended: 1781 return dw_cfi_oprnd_offset; 1782 1783 case DW_CFA_register: 1784 return dw_cfi_oprnd_reg_num; 1785 1786 default: 1787 return dw_cfi_oprnd_unused; 1788 } 1789} 1790 1791#if defined (DWARF2_DEBUGGING_INFO) || defined (DWARF2_UNWIND_INFO) 1792 1793/* Map register numbers held in the call frame info that gcc has 1794 collected using DWARF_FRAME_REGNUM to those that should be output in 1795 .debug_frame and .eh_frame. */ 1796#ifndef DWARF2_FRAME_REG_OUT 1797#define DWARF2_FRAME_REG_OUT(REGNO, FOR_EH) (REGNO) 1798#endif 1799 1800/* Output a Call Frame Information opcode and its operand(s). */ 1801 1802static void 1803output_cfi (dw_cfi_ref cfi, dw_fde_ref fde, int for_eh) 1804{ 1805 unsigned long r; 1806 if (cfi->dw_cfi_opc == DW_CFA_advance_loc) 1807 dw2_asm_output_data (1, (cfi->dw_cfi_opc 1808 | (cfi->dw_cfi_oprnd1.dw_cfi_offset & 0x3f)), 1809 "DW_CFA_advance_loc " HOST_WIDE_INT_PRINT_HEX, 1810 cfi->dw_cfi_oprnd1.dw_cfi_offset); 1811 else if (cfi->dw_cfi_opc == DW_CFA_offset) 1812 { 1813 r = DWARF2_FRAME_REG_OUT (cfi->dw_cfi_oprnd1.dw_cfi_reg_num, for_eh); 1814 dw2_asm_output_data (1, (cfi->dw_cfi_opc | (r & 0x3f)), 1815 "DW_CFA_offset, column 0x%lx", r); 1816 dw2_asm_output_data_uleb128 (cfi->dw_cfi_oprnd2.dw_cfi_offset, NULL); 1817 } 1818 else if (cfi->dw_cfi_opc == DW_CFA_restore) 1819 { 1820 r = DWARF2_FRAME_REG_OUT (cfi->dw_cfi_oprnd1.dw_cfi_reg_num, for_eh); 1821 dw2_asm_output_data (1, (cfi->dw_cfi_opc | (r & 0x3f)), 1822 "DW_CFA_restore, column 0x%lx", r); 1823 } 1824 else 1825 { 1826 dw2_asm_output_data (1, cfi->dw_cfi_opc, 1827 "%s", dwarf_cfi_name (cfi->dw_cfi_opc)); 1828 1829 switch (cfi->dw_cfi_opc) 1830 { 1831 case DW_CFA_set_loc: 1832 if (for_eh) 1833 dw2_asm_output_encoded_addr_rtx ( 1834 ASM_PREFERRED_EH_DATA_FORMAT (/*code=*/1, /*global=*/0), 1835 gen_rtx_SYMBOL_REF (Pmode, cfi->dw_cfi_oprnd1.dw_cfi_addr), 1836 NULL); 1837 else 1838 dw2_asm_output_addr (DWARF2_ADDR_SIZE, 1839 cfi->dw_cfi_oprnd1.dw_cfi_addr, NULL); 1840 break; 1841 1842 case DW_CFA_advance_loc1: 1843 dw2_asm_output_delta (1, cfi->dw_cfi_oprnd1.dw_cfi_addr, 1844 fde->dw_fde_current_label, NULL); 1845 fde->dw_fde_current_label = cfi->dw_cfi_oprnd1.dw_cfi_addr; 1846 break; 1847 1848 case DW_CFA_advance_loc2: 1849 dw2_asm_output_delta (2, cfi->dw_cfi_oprnd1.dw_cfi_addr, 1850 fde->dw_fde_current_label, NULL); 1851 fde->dw_fde_current_label = cfi->dw_cfi_oprnd1.dw_cfi_addr; 1852 break; 1853 1854 case DW_CFA_advance_loc4: 1855 dw2_asm_output_delta (4, cfi->dw_cfi_oprnd1.dw_cfi_addr, 1856 fde->dw_fde_current_label, NULL); 1857 fde->dw_fde_current_label = cfi->dw_cfi_oprnd1.dw_cfi_addr; 1858 break; 1859 1860 case DW_CFA_MIPS_advance_loc8: 1861 dw2_asm_output_delta (8, cfi->dw_cfi_oprnd1.dw_cfi_addr, 1862 fde->dw_fde_current_label, NULL); 1863 fde->dw_fde_current_label = cfi->dw_cfi_oprnd1.dw_cfi_addr; 1864 break; 1865 1866 case DW_CFA_offset_extended: 1867 case DW_CFA_def_cfa: 1868 r = DWARF2_FRAME_REG_OUT (cfi->dw_cfi_oprnd1.dw_cfi_reg_num, for_eh); 1869 dw2_asm_output_data_uleb128 (r, NULL); 1870 dw2_asm_output_data_uleb128 (cfi->dw_cfi_oprnd2.dw_cfi_offset, NULL); 1871 break; 1872 1873 case DW_CFA_offset_extended_sf: 1874 case DW_CFA_def_cfa_sf: 1875 r = DWARF2_FRAME_REG_OUT (cfi->dw_cfi_oprnd1.dw_cfi_reg_num, for_eh); 1876 dw2_asm_output_data_uleb128 (r, NULL); 1877 dw2_asm_output_data_sleb128 (cfi->dw_cfi_oprnd2.dw_cfi_offset, NULL); 1878 break; 1879 1880 case DW_CFA_restore_extended: 1881 case DW_CFA_undefined: 1882 case DW_CFA_same_value: 1883 case DW_CFA_def_cfa_register: 1884 r = DWARF2_FRAME_REG_OUT (cfi->dw_cfi_oprnd1.dw_cfi_reg_num, for_eh); 1885 dw2_asm_output_data_uleb128 (r, NULL); 1886 break; 1887 1888 case DW_CFA_register: 1889 r = DWARF2_FRAME_REG_OUT (cfi->dw_cfi_oprnd1.dw_cfi_reg_num, for_eh); 1890 dw2_asm_output_data_uleb128 (r, NULL); 1891 r = DWARF2_FRAME_REG_OUT (cfi->dw_cfi_oprnd2.dw_cfi_reg_num, for_eh); 1892 dw2_asm_output_data_uleb128 (r, NULL); 1893 break; 1894 1895 case DW_CFA_def_cfa_offset: 1896 case DW_CFA_GNU_args_size: 1897 dw2_asm_output_data_uleb128 (cfi->dw_cfi_oprnd1.dw_cfi_offset, NULL); 1898 break; 1899 1900 case DW_CFA_def_cfa_offset_sf: 1901 dw2_asm_output_data_sleb128 (cfi->dw_cfi_oprnd1.dw_cfi_offset, NULL); 1902 break; 1903 1904 case DW_CFA_GNU_window_save: 1905 break; 1906 1907 case DW_CFA_def_cfa_expression: 1908 case DW_CFA_expression: 1909 output_cfa_loc (cfi); 1910 break; 1911 1912 case DW_CFA_GNU_negative_offset_extended: 1913 /* Obsoleted by DW_CFA_offset_extended_sf. */ 1914 abort (); 1915 1916 default: 1917 break; 1918 } 1919 } 1920} 1921 1922/* Output the call frame information used to record information 1923 that relates to calculating the frame pointer, and records the 1924 location of saved registers. */ 1925 1926static void 1927output_call_frame_info (int for_eh) 1928{ 1929 unsigned int i; 1930 dw_fde_ref fde; 1931 dw_cfi_ref cfi; 1932 char l1[20], l2[20], section_start_label[20]; 1933 bool any_lsda_needed = false; 1934 char augmentation[6]; 1935 int augmentation_size; 1936 int fde_encoding = DW_EH_PE_absptr; 1937 int per_encoding = DW_EH_PE_absptr; 1938 int lsda_encoding = DW_EH_PE_absptr; 1939 1940 /* Don't emit a CIE if there won't be any FDEs. */ 1941 if (fde_table_in_use == 0) 1942 return; 1943 1944 /* If we don't have any functions we'll want to unwind out of, don't 1945 emit any EH unwind information. Note that if exceptions aren't 1946 enabled, we won't have collected nothrow information, and if we 1947 asked for asynchronous tables, we always want this info. */ 1948 if (for_eh) 1949 { 1950 bool any_eh_needed = !flag_exceptions || flag_asynchronous_unwind_tables; 1951 1952 for (i = 0; i < fde_table_in_use; i++) 1953 if (fde_table[i].uses_eh_lsda) 1954 any_eh_needed = any_lsda_needed = true; 1955 else if (! fde_table[i].nothrow 1956 && ! fde_table[i].all_throwers_are_sibcalls) 1957 any_eh_needed = true; 1958 1959 if (! any_eh_needed) 1960 return; 1961 } 1962 1963 /* We're going to be generating comments, so turn on app. */ 1964 if (flag_debug_asm) 1965 app_enable (); 1966 1967 if (for_eh) 1968 (*targetm.asm_out.eh_frame_section) (); 1969 else 1970 named_section_flags (DEBUG_FRAME_SECTION, SECTION_DEBUG); 1971 1972 ASM_GENERATE_INTERNAL_LABEL (section_start_label, FRAME_BEGIN_LABEL, for_eh); 1973 ASM_OUTPUT_LABEL (asm_out_file, section_start_label); 1974 1975 /* Output the CIE. */ 1976 ASM_GENERATE_INTERNAL_LABEL (l1, CIE_AFTER_SIZE_LABEL, for_eh); 1977 ASM_GENERATE_INTERNAL_LABEL (l2, CIE_END_LABEL, for_eh); 1978 dw2_asm_output_delta (for_eh ? 4 : DWARF_OFFSET_SIZE, l2, l1, 1979 "Length of Common Information Entry"); 1980 ASM_OUTPUT_LABEL (asm_out_file, l1); 1981 1982 /* Now that the CIE pointer is PC-relative for EH, 1983 use 0 to identify the CIE. */ 1984 dw2_asm_output_data ((for_eh ? 4 : DWARF_OFFSET_SIZE), 1985 (for_eh ? 0 : DW_CIE_ID), 1986 "CIE Identifier Tag"); 1987 1988 dw2_asm_output_data (1, DW_CIE_VERSION, "CIE Version"); 1989 1990 augmentation[0] = 0; 1991 augmentation_size = 0; 1992 if (for_eh) 1993 { 1994 char *p; 1995 1996 /* Augmentation: 1997 z Indicates that a uleb128 is present to size the 1998 augmentation section. 1999 L Indicates the encoding (and thus presence) of 2000 an LSDA pointer in the FDE augmentation. 2001 R Indicates a non-default pointer encoding for 2002 FDE code pointers. 2003 P Indicates the presence of an encoding + language 2004 personality routine in the CIE augmentation. */ 2005 2006 fde_encoding = ASM_PREFERRED_EH_DATA_FORMAT (/*code=*/1, /*global=*/0); 2007 per_encoding = ASM_PREFERRED_EH_DATA_FORMAT (/*code=*/2, /*global=*/1); 2008 lsda_encoding = ASM_PREFERRED_EH_DATA_FORMAT (/*code=*/0, /*global=*/0); 2009 2010 p = augmentation + 1; 2011 if (eh_personality_libfunc) 2012 { 2013 *p++ = 'P'; 2014 augmentation_size += 1 + size_of_encoded_value (per_encoding); 2015 } 2016 if (any_lsda_needed) 2017 { 2018 *p++ = 'L'; 2019 augmentation_size += 1; 2020 } 2021 if (fde_encoding != DW_EH_PE_absptr) 2022 { 2023 *p++ = 'R'; 2024 augmentation_size += 1; 2025 } 2026 if (p > augmentation + 1) 2027 { 2028 augmentation[0] = 'z'; 2029 *p = '\0'; 2030 } 2031 2032 /* Ug. Some platforms can't do unaligned dynamic relocations at all. */ 2033 if (eh_personality_libfunc && per_encoding == DW_EH_PE_aligned) 2034 { 2035 int offset = ( 4 /* Length */ 2036 + 4 /* CIE Id */ 2037 + 1 /* CIE version */ 2038 + strlen (augmentation) + 1 /* Augmentation */ 2039 + size_of_uleb128 (1) /* Code alignment */ 2040 + size_of_sleb128 (DWARF_CIE_DATA_ALIGNMENT) 2041 + 1 /* RA column */ 2042 + 1 /* Augmentation size */ 2043 + 1 /* Personality encoding */ ); 2044 int pad = -offset & (PTR_SIZE - 1); 2045 2046 augmentation_size += pad; 2047 2048 /* Augmentations should be small, so there's scarce need to 2049 iterate for a solution. Die if we exceed one uleb128 byte. */ 2050 if (size_of_uleb128 (augmentation_size) != 1) 2051 abort (); 2052 } 2053 } 2054 2055 dw2_asm_output_nstring (augmentation, -1, "CIE Augmentation"); 2056 dw2_asm_output_data_uleb128 (1, "CIE Code Alignment Factor"); 2057 dw2_asm_output_data_sleb128 (DWARF_CIE_DATA_ALIGNMENT, 2058 "CIE Data Alignment Factor"); 2059 dw2_asm_output_data (1, DWARF_FRAME_RETURN_COLUMN, "CIE RA Column"); 2060 2061 if (augmentation[0]) 2062 { 2063 dw2_asm_output_data_uleb128 (augmentation_size, "Augmentation size"); 2064 if (eh_personality_libfunc) 2065 { 2066 dw2_asm_output_data (1, per_encoding, "Personality (%s)", 2067 eh_data_format_name (per_encoding)); 2068 dw2_asm_output_encoded_addr_rtx (per_encoding, 2069 eh_personality_libfunc, NULL); 2070 } 2071 2072 if (any_lsda_needed) 2073 dw2_asm_output_data (1, lsda_encoding, "LSDA Encoding (%s)", 2074 eh_data_format_name (lsda_encoding)); 2075 2076 if (fde_encoding != DW_EH_PE_absptr) 2077 dw2_asm_output_data (1, fde_encoding, "FDE Encoding (%s)", 2078 eh_data_format_name (fde_encoding)); 2079 } 2080 2081 for (cfi = cie_cfi_head; cfi != NULL; cfi = cfi->dw_cfi_next) 2082 output_cfi (cfi, NULL, for_eh); 2083 2084 /* Pad the CIE out to an address sized boundary. */ 2085 ASM_OUTPUT_ALIGN (asm_out_file, 2086 floor_log2 (for_eh ? PTR_SIZE : DWARF2_ADDR_SIZE)); 2087 ASM_OUTPUT_LABEL (asm_out_file, l2); 2088 2089 /* Loop through all of the FDE's. */ 2090 for (i = 0; i < fde_table_in_use; i++) 2091 { 2092 fde = &fde_table[i]; 2093 2094 /* Don't emit EH unwind info for leaf functions that don't need it. */ 2095 if (for_eh && !flag_asynchronous_unwind_tables && flag_exceptions 2096 && (fde->nothrow || fde->all_throwers_are_sibcalls) 2097 && !fde->uses_eh_lsda) 2098 continue; 2099 2100 (*targetm.asm_out.internal_label) (asm_out_file, FDE_LABEL, for_eh + i * 2); 2101 ASM_GENERATE_INTERNAL_LABEL (l1, FDE_AFTER_SIZE_LABEL, for_eh + i * 2); 2102 ASM_GENERATE_INTERNAL_LABEL (l2, FDE_END_LABEL, for_eh + i * 2); 2103 dw2_asm_output_delta (for_eh ? 4 : DWARF_OFFSET_SIZE, l2, l1, 2104 "FDE Length"); 2105 ASM_OUTPUT_LABEL (asm_out_file, l1); 2106 2107 if (for_eh) 2108 dw2_asm_output_delta (4, l1, section_start_label, "FDE CIE offset"); 2109 else 2110 dw2_asm_output_offset (DWARF_OFFSET_SIZE, section_start_label, 2111 "FDE CIE offset"); 2112 2113 if (for_eh) 2114 { 2115 dw2_asm_output_encoded_addr_rtx (fde_encoding, 2116 gen_rtx_SYMBOL_REF (Pmode, fde->dw_fde_begin), 2117 "FDE initial location"); 2118 dw2_asm_output_delta (size_of_encoded_value (fde_encoding), 2119 fde->dw_fde_end, fde->dw_fde_begin, 2120 "FDE address range"); 2121 } 2122 else 2123 { 2124 dw2_asm_output_addr (DWARF2_ADDR_SIZE, fde->dw_fde_begin, 2125 "FDE initial location"); 2126 dw2_asm_output_delta (DWARF2_ADDR_SIZE, 2127 fde->dw_fde_end, fde->dw_fde_begin, 2128 "FDE address range"); 2129 } 2130 2131 if (augmentation[0]) 2132 { 2133 if (any_lsda_needed) 2134 { 2135 int size = size_of_encoded_value (lsda_encoding); 2136 2137 if (lsda_encoding == DW_EH_PE_aligned) 2138 { 2139 int offset = ( 4 /* Length */ 2140 + 4 /* CIE offset */ 2141 + 2 * size_of_encoded_value (fde_encoding) 2142 + 1 /* Augmentation size */ ); 2143 int pad = -offset & (PTR_SIZE - 1); 2144 2145 size += pad; 2146 if (size_of_uleb128 (size) != 1) 2147 abort (); 2148 } 2149 2150 dw2_asm_output_data_uleb128 (size, "Augmentation size"); 2151 2152 if (fde->uses_eh_lsda) 2153 { 2154 ASM_GENERATE_INTERNAL_LABEL (l1, "LLSDA", 2155 fde->funcdef_number); 2156 dw2_asm_output_encoded_addr_rtx ( 2157 lsda_encoding, gen_rtx_SYMBOL_REF (Pmode, l1), 2158 "Language Specific Data Area"); 2159 } 2160 else 2161 { 2162 if (lsda_encoding == DW_EH_PE_aligned) 2163 ASM_OUTPUT_ALIGN (asm_out_file, floor_log2 (PTR_SIZE)); 2164 dw2_asm_output_data 2165 (size_of_encoded_value (lsda_encoding), 0, 2166 "Language Specific Data Area (none)"); 2167 } 2168 } 2169 else 2170 dw2_asm_output_data_uleb128 (0, "Augmentation size"); 2171 } 2172 2173 /* Loop through the Call Frame Instructions associated with 2174 this FDE. */ 2175 fde->dw_fde_current_label = fde->dw_fde_begin; 2176 for (cfi = fde->dw_fde_cfi; cfi != NULL; cfi = cfi->dw_cfi_next) 2177 output_cfi (cfi, fde, for_eh); 2178 2179 /* Pad the FDE out to an address sized boundary. */ 2180 ASM_OUTPUT_ALIGN (asm_out_file, 2181 floor_log2 ((for_eh ? PTR_SIZE : DWARF2_ADDR_SIZE))); 2182 ASM_OUTPUT_LABEL (asm_out_file, l2); 2183 } 2184 2185 if (for_eh && targetm.terminate_dw2_eh_frame_info) 2186 dw2_asm_output_data (4, 0, "End of Table"); 2187#ifdef MIPS_DEBUGGING_INFO 2188 /* Work around Irix 6 assembler bug whereby labels at the end of a section 2189 get a value of 0. Putting .align 0 after the label fixes it. */ 2190 ASM_OUTPUT_ALIGN (asm_out_file, 0); 2191#endif 2192 2193 /* Turn off app to make assembly quicker. */ 2194 if (flag_debug_asm) 2195 app_disable (); 2196} 2197 2198/* Output a marker (i.e. a label) for the beginning of a function, before 2199 the prologue. */ 2200 2201void 2202dwarf2out_begin_prologue (unsigned int line ATTRIBUTE_UNUSED, 2203 const char *file ATTRIBUTE_UNUSED) 2204{ 2205 char label[MAX_ARTIFICIAL_LABEL_BYTES]; 2206 dw_fde_ref fde; 2207 2208 current_function_func_begin_label = 0; 2209 2210#ifdef IA64_UNWIND_INFO 2211 /* ??? current_function_func_begin_label is also used by except.c 2212 for call-site information. We must emit this label if it might 2213 be used. */ 2214 if ((! flag_exceptions || USING_SJLJ_EXCEPTIONS) 2215 && ! dwarf2out_do_frame ()) 2216 return; 2217#else 2218 if (! dwarf2out_do_frame ()) 2219 return; 2220#endif 2221 2222 function_section (current_function_decl); 2223 ASM_GENERATE_INTERNAL_LABEL (label, FUNC_BEGIN_LABEL, 2224 current_function_funcdef_no); 2225 ASM_OUTPUT_DEBUG_LABEL (asm_out_file, FUNC_BEGIN_LABEL, 2226 current_function_funcdef_no); 2227 current_function_func_begin_label = get_identifier (label); 2228 2229#ifdef IA64_UNWIND_INFO 2230 /* We can elide the fde allocation if we're not emitting debug info. */ 2231 if (! dwarf2out_do_frame ()) 2232 return; 2233#endif 2234 2235 /* Expand the fde table if necessary. */ 2236 if (fde_table_in_use == fde_table_allocated) 2237 { 2238 fde_table_allocated += FDE_TABLE_INCREMENT; 2239 fde_table = ggc_realloc (fde_table, 2240 fde_table_allocated * sizeof (dw_fde_node)); 2241 memset (fde_table + fde_table_in_use, 0, 2242 FDE_TABLE_INCREMENT * sizeof (dw_fde_node)); 2243 } 2244 2245 /* Record the FDE associated with this function. */ 2246 current_funcdef_fde = fde_table_in_use; 2247 2248 /* Add the new FDE at the end of the fde_table. */ 2249 fde = &fde_table[fde_table_in_use++]; 2250 fde->dw_fde_begin = xstrdup (label); 2251 fde->dw_fde_current_label = NULL; 2252 fde->dw_fde_end = NULL; 2253 fde->dw_fde_cfi = NULL; 2254 fde->funcdef_number = current_function_funcdef_no; 2255 fde->nothrow = current_function_nothrow; 2256 fde->uses_eh_lsda = cfun->uses_eh_lsda; 2257 fde->all_throwers_are_sibcalls = cfun->all_throwers_are_sibcalls; 2258 2259 args_size = old_args_size = 0; 2260 2261 /* We only want to output line number information for the genuine dwarf2 2262 prologue case, not the eh frame case. */ 2263#ifdef DWARF2_DEBUGGING_INFO 2264 if (file) 2265 dwarf2out_source_line (line, file); 2266#endif 2267} 2268 2269/* Output a marker (i.e. a label) for the absolute end of the generated code 2270 for a function definition. This gets called *after* the epilogue code has 2271 been generated. */ 2272 2273void 2274dwarf2out_end_epilogue (unsigned int line ATTRIBUTE_UNUSED, 2275 const char *file ATTRIBUTE_UNUSED) 2276{ 2277 dw_fde_ref fde; 2278 char label[MAX_ARTIFICIAL_LABEL_BYTES]; 2279 2280 /* Output a label to mark the endpoint of the code generated for this 2281 function. */ 2282 ASM_GENERATE_INTERNAL_LABEL (label, FUNC_END_LABEL, 2283 current_function_funcdef_no); 2284 ASM_OUTPUT_LABEL (asm_out_file, label); 2285 fde = &fde_table[fde_table_in_use - 1]; 2286 fde->dw_fde_end = xstrdup (label); 2287} 2288 2289void 2290dwarf2out_frame_init (void) 2291{ 2292 /* Allocate the initial hunk of the fde_table. */ 2293 fde_table = ggc_alloc_cleared (FDE_TABLE_INCREMENT * sizeof (dw_fde_node)); 2294 fde_table_allocated = FDE_TABLE_INCREMENT; 2295 fde_table_in_use = 0; 2296 2297 /* Generate the CFA instructions common to all FDE's. Do it now for the 2298 sake of lookup_cfa. */ 2299 2300#ifdef DWARF2_UNWIND_INFO 2301 /* On entry, the Canonical Frame Address is at SP. */ 2302 dwarf2out_def_cfa (NULL, STACK_POINTER_REGNUM, INCOMING_FRAME_SP_OFFSET); 2303 initial_return_save (INCOMING_RETURN_ADDR_RTX); 2304#endif 2305} 2306 2307void 2308dwarf2out_frame_finish (void) 2309{ 2310 /* Output call frame information. */ 2311 if (write_symbols == DWARF2_DEBUG || write_symbols == VMS_AND_DWARF2_DEBUG) 2312 output_call_frame_info (0); 2313 2314 if (! USING_SJLJ_EXCEPTIONS && (flag_unwind_tables || flag_exceptions)) 2315 output_call_frame_info (1); 2316} 2317#endif 2318 2319/* And now, the subset of the debugging information support code necessary 2320 for emitting location expressions. */ 2321 2322/* We need some way to distinguish DW_OP_addr with a direct symbol 2323 relocation from DW_OP_addr with a dtp-relative symbol relocation. */ 2324#define INTERNAL_DW_OP_tls_addr (0x100 + DW_OP_addr) 2325 2326 2327typedef struct dw_val_struct *dw_val_ref; 2328typedef struct die_struct *dw_die_ref; 2329typedef struct dw_loc_descr_struct *dw_loc_descr_ref; 2330typedef struct dw_loc_list_struct *dw_loc_list_ref; 2331 2332/* Each DIE may have a series of attribute/value pairs. Values 2333 can take on several forms. The forms that are used in this 2334 implementation are listed below. */ 2335 2336enum dw_val_class 2337{ 2338 dw_val_class_addr, 2339 dw_val_class_offset, 2340 dw_val_class_loc, 2341 dw_val_class_loc_list, 2342 dw_val_class_range_list, 2343 dw_val_class_const, 2344 dw_val_class_unsigned_const, 2345 dw_val_class_long_long, 2346 dw_val_class_vec, 2347 dw_val_class_flag, 2348 dw_val_class_die_ref, 2349 dw_val_class_fde_ref, 2350 dw_val_class_lbl_id, 2351 dw_val_class_lbl_offset, 2352 dw_val_class_str 2353}; 2354 2355/* Describe a double word constant value. */ 2356/* ??? Every instance of long_long in the code really means CONST_DOUBLE. */ 2357 2358typedef struct dw_long_long_struct GTY(()) 2359{ 2360 unsigned long hi; 2361 unsigned long low; 2362} 2363dw_long_long_const; 2364 2365/* Describe a floating point constant value, or a vector constant value. */ 2366 2367typedef struct dw_vec_struct GTY(()) 2368{ 2369 unsigned char * GTY((length ("%h.length"))) array; 2370 unsigned length; 2371 unsigned elt_size; 2372} 2373dw_vec_const; 2374 2375/* The dw_val_node describes an attribute's value, as it is 2376 represented internally. */ 2377 2378typedef struct dw_val_struct GTY(()) 2379{ 2380 enum dw_val_class val_class; 2381 union dw_val_struct_union 2382 { 2383 rtx GTY ((tag ("dw_val_class_addr"))) val_addr; 2384 unsigned HOST_WIDE_INT GTY ((tag ("dw_val_class_offset"))) val_offset; 2385 dw_loc_list_ref GTY ((tag ("dw_val_class_loc_list"))) val_loc_list; 2386 dw_loc_descr_ref GTY ((tag ("dw_val_class_loc"))) val_loc; 2387 HOST_WIDE_INT GTY ((default (""))) val_int; 2388 unsigned HOST_WIDE_INT GTY ((tag ("dw_val_class_unsigned_const"))) val_unsigned; 2389 dw_long_long_const GTY ((tag ("dw_val_class_long_long"))) val_long_long; 2390 dw_vec_const GTY ((tag ("dw_val_class_vec"))) val_vec; 2391 struct dw_val_die_union 2392 { 2393 dw_die_ref die; 2394 int external; 2395 } GTY ((tag ("dw_val_class_die_ref"))) val_die_ref; 2396 unsigned GTY ((tag ("dw_val_class_fde_ref"))) val_fde_index; 2397 struct indirect_string_node * GTY ((tag ("dw_val_class_str"))) val_str; 2398 char * GTY ((tag ("dw_val_class_lbl_id"))) val_lbl_id; 2399 unsigned char GTY ((tag ("dw_val_class_flag"))) val_flag; 2400 } 2401 GTY ((desc ("%1.val_class"))) v; 2402} 2403dw_val_node; 2404 2405/* Locations in memory are described using a sequence of stack machine 2406 operations. */ 2407 2408typedef struct dw_loc_descr_struct GTY(()) 2409{ 2410 dw_loc_descr_ref dw_loc_next; 2411 enum dwarf_location_atom dw_loc_opc; 2412 dw_val_node dw_loc_oprnd1; 2413 dw_val_node dw_loc_oprnd2; 2414 int dw_loc_addr; 2415} 2416dw_loc_descr_node; 2417 2418/* Location lists are ranges + location descriptions for that range, 2419 so you can track variables that are in different places over 2420 their entire life. */ 2421typedef struct dw_loc_list_struct GTY(()) 2422{ 2423 dw_loc_list_ref dw_loc_next; 2424 const char *begin; /* Label for begin address of range */ 2425 const char *end; /* Label for end address of range */ 2426 char *ll_symbol; /* Label for beginning of location list. 2427 Only on head of list */ 2428 const char *section; /* Section this loclist is relative to */ 2429 dw_loc_descr_ref expr; 2430} dw_loc_list_node; 2431 2432#if defined (DWARF2_DEBUGGING_INFO) || defined (DWARF2_UNWIND_INFO) 2433 2434static const char *dwarf_stack_op_name (unsigned); 2435static dw_loc_descr_ref new_loc_descr (enum dwarf_location_atom, 2436 unsigned HOST_WIDE_INT, unsigned HOST_WIDE_INT); 2437static void add_loc_descr (dw_loc_descr_ref *, dw_loc_descr_ref); 2438static unsigned long size_of_loc_descr (dw_loc_descr_ref); 2439static unsigned long size_of_locs (dw_loc_descr_ref); 2440static void output_loc_operands (dw_loc_descr_ref); 2441static void output_loc_sequence (dw_loc_descr_ref); 2442 2443/* Convert a DWARF stack opcode into its string name. */ 2444 2445static const char * 2446dwarf_stack_op_name (unsigned int op) 2447{ 2448 switch (op) 2449 { 2450 case DW_OP_addr: 2451 case INTERNAL_DW_OP_tls_addr: 2452 return "DW_OP_addr"; 2453 case DW_OP_deref: 2454 return "DW_OP_deref"; 2455 case DW_OP_const1u: 2456 return "DW_OP_const1u"; 2457 case DW_OP_const1s: 2458 return "DW_OP_const1s"; 2459 case DW_OP_const2u: 2460 return "DW_OP_const2u"; 2461 case DW_OP_const2s: 2462 return "DW_OP_const2s"; 2463 case DW_OP_const4u: 2464 return "DW_OP_const4u"; 2465 case DW_OP_const4s: 2466 return "DW_OP_const4s"; 2467 case DW_OP_const8u: 2468 return "DW_OP_const8u"; 2469 case DW_OP_const8s: 2470 return "DW_OP_const8s"; 2471 case DW_OP_constu: 2472 return "DW_OP_constu"; 2473 case DW_OP_consts: 2474 return "DW_OP_consts"; 2475 case DW_OP_dup: 2476 return "DW_OP_dup"; 2477 case DW_OP_drop: 2478 return "DW_OP_drop"; 2479 case DW_OP_over: 2480 return "DW_OP_over"; 2481 case DW_OP_pick: 2482 return "DW_OP_pick"; 2483 case DW_OP_swap: 2484 return "DW_OP_swap"; 2485 case DW_OP_rot: 2486 return "DW_OP_rot"; 2487 case DW_OP_xderef: 2488 return "DW_OP_xderef"; 2489 case DW_OP_abs: 2490 return "DW_OP_abs"; 2491 case DW_OP_and: 2492 return "DW_OP_and"; 2493 case DW_OP_div: 2494 return "DW_OP_div"; 2495 case DW_OP_minus: 2496 return "DW_OP_minus"; 2497 case DW_OP_mod: 2498 return "DW_OP_mod"; 2499 case DW_OP_mul: 2500 return "DW_OP_mul"; 2501 case DW_OP_neg: 2502 return "DW_OP_neg"; 2503 case DW_OP_not: 2504 return "DW_OP_not"; 2505 case DW_OP_or: 2506 return "DW_OP_or"; 2507 case DW_OP_plus: 2508 return "DW_OP_plus"; 2509 case DW_OP_plus_uconst: 2510 return "DW_OP_plus_uconst"; 2511 case DW_OP_shl: 2512 return "DW_OP_shl"; 2513 case DW_OP_shr: 2514 return "DW_OP_shr"; 2515 case DW_OP_shra: 2516 return "DW_OP_shra"; 2517 case DW_OP_xor: 2518 return "DW_OP_xor"; 2519 case DW_OP_bra: 2520 return "DW_OP_bra"; 2521 case DW_OP_eq: 2522 return "DW_OP_eq"; 2523 case DW_OP_ge: 2524 return "DW_OP_ge"; 2525 case DW_OP_gt: 2526 return "DW_OP_gt"; 2527 case DW_OP_le: 2528 return "DW_OP_le"; 2529 case DW_OP_lt: 2530 return "DW_OP_lt"; 2531 case DW_OP_ne: 2532 return "DW_OP_ne"; 2533 case DW_OP_skip: 2534 return "DW_OP_skip"; 2535 case DW_OP_lit0: 2536 return "DW_OP_lit0"; 2537 case DW_OP_lit1: 2538 return "DW_OP_lit1"; 2539 case DW_OP_lit2: 2540 return "DW_OP_lit2"; 2541 case DW_OP_lit3: 2542 return "DW_OP_lit3"; 2543 case DW_OP_lit4: 2544 return "DW_OP_lit4"; 2545 case DW_OP_lit5: 2546 return "DW_OP_lit5"; 2547 case DW_OP_lit6: 2548 return "DW_OP_lit6"; 2549 case DW_OP_lit7: 2550 return "DW_OP_lit7"; 2551 case DW_OP_lit8: 2552 return "DW_OP_lit8"; 2553 case DW_OP_lit9: 2554 return "DW_OP_lit9"; 2555 case DW_OP_lit10: 2556 return "DW_OP_lit10"; 2557 case DW_OP_lit11: 2558 return "DW_OP_lit11"; 2559 case DW_OP_lit12: 2560 return "DW_OP_lit12"; 2561 case DW_OP_lit13: 2562 return "DW_OP_lit13"; 2563 case DW_OP_lit14: 2564 return "DW_OP_lit14"; 2565 case DW_OP_lit15: 2566 return "DW_OP_lit15"; 2567 case DW_OP_lit16: 2568 return "DW_OP_lit16"; 2569 case DW_OP_lit17: 2570 return "DW_OP_lit17"; 2571 case DW_OP_lit18: 2572 return "DW_OP_lit18"; 2573 case DW_OP_lit19: 2574 return "DW_OP_lit19"; 2575 case DW_OP_lit20: 2576 return "DW_OP_lit20"; 2577 case DW_OP_lit21: 2578 return "DW_OP_lit21"; 2579 case DW_OP_lit22: 2580 return "DW_OP_lit22"; 2581 case DW_OP_lit23: 2582 return "DW_OP_lit23"; 2583 case DW_OP_lit24: 2584 return "DW_OP_lit24"; 2585 case DW_OP_lit25: 2586 return "DW_OP_lit25"; 2587 case DW_OP_lit26: 2588 return "DW_OP_lit26"; 2589 case DW_OP_lit27: 2590 return "DW_OP_lit27"; 2591 case DW_OP_lit28: 2592 return "DW_OP_lit28"; 2593 case DW_OP_lit29: 2594 return "DW_OP_lit29"; 2595 case DW_OP_lit30: 2596 return "DW_OP_lit30"; 2597 case DW_OP_lit31: 2598 return "DW_OP_lit31"; 2599 case DW_OP_reg0: 2600 return "DW_OP_reg0"; 2601 case DW_OP_reg1: 2602 return "DW_OP_reg1"; 2603 case DW_OP_reg2: 2604 return "DW_OP_reg2"; 2605 case DW_OP_reg3: 2606 return "DW_OP_reg3"; 2607 case DW_OP_reg4: 2608 return "DW_OP_reg4"; 2609 case DW_OP_reg5: 2610 return "DW_OP_reg5"; 2611 case DW_OP_reg6: 2612 return "DW_OP_reg6"; 2613 case DW_OP_reg7: 2614 return "DW_OP_reg7"; 2615 case DW_OP_reg8: 2616 return "DW_OP_reg8"; 2617 case DW_OP_reg9: 2618 return "DW_OP_reg9"; 2619 case DW_OP_reg10: 2620 return "DW_OP_reg10"; 2621 case DW_OP_reg11: 2622 return "DW_OP_reg11"; 2623 case DW_OP_reg12: 2624 return "DW_OP_reg12"; 2625 case DW_OP_reg13: 2626 return "DW_OP_reg13"; 2627 case DW_OP_reg14: 2628 return "DW_OP_reg14"; 2629 case DW_OP_reg15: 2630 return "DW_OP_reg15"; 2631 case DW_OP_reg16: 2632 return "DW_OP_reg16"; 2633 case DW_OP_reg17: 2634 return "DW_OP_reg17"; 2635 case DW_OP_reg18: 2636 return "DW_OP_reg18"; 2637 case DW_OP_reg19: 2638 return "DW_OP_reg19"; 2639 case DW_OP_reg20: 2640 return "DW_OP_reg20"; 2641 case DW_OP_reg21: 2642 return "DW_OP_reg21"; 2643 case DW_OP_reg22: 2644 return "DW_OP_reg22"; 2645 case DW_OP_reg23: 2646 return "DW_OP_reg23"; 2647 case DW_OP_reg24: 2648 return "DW_OP_reg24"; 2649 case DW_OP_reg25: 2650 return "DW_OP_reg25"; 2651 case DW_OP_reg26: 2652 return "DW_OP_reg26"; 2653 case DW_OP_reg27: 2654 return "DW_OP_reg27"; 2655 case DW_OP_reg28: 2656 return "DW_OP_reg28"; 2657 case DW_OP_reg29: 2658 return "DW_OP_reg29"; 2659 case DW_OP_reg30: 2660 return "DW_OP_reg30"; 2661 case DW_OP_reg31: 2662 return "DW_OP_reg31"; 2663 case DW_OP_breg0: 2664 return "DW_OP_breg0"; 2665 case DW_OP_breg1: 2666 return "DW_OP_breg1"; 2667 case DW_OP_breg2: 2668 return "DW_OP_breg2"; 2669 case DW_OP_breg3: 2670 return "DW_OP_breg3"; 2671 case DW_OP_breg4: 2672 return "DW_OP_breg4"; 2673 case DW_OP_breg5: 2674 return "DW_OP_breg5"; 2675 case DW_OP_breg6: 2676 return "DW_OP_breg6"; 2677 case DW_OP_breg7: 2678 return "DW_OP_breg7"; 2679 case DW_OP_breg8: 2680 return "DW_OP_breg8"; 2681 case DW_OP_breg9: 2682 return "DW_OP_breg9"; 2683 case DW_OP_breg10: 2684 return "DW_OP_breg10"; 2685 case DW_OP_breg11: 2686 return "DW_OP_breg11"; 2687 case DW_OP_breg12: 2688 return "DW_OP_breg12"; 2689 case DW_OP_breg13: 2690 return "DW_OP_breg13"; 2691 case DW_OP_breg14: 2692 return "DW_OP_breg14"; 2693 case DW_OP_breg15: 2694 return "DW_OP_breg15"; 2695 case DW_OP_breg16: 2696 return "DW_OP_breg16"; 2697 case DW_OP_breg17: 2698 return "DW_OP_breg17"; 2699 case DW_OP_breg18: 2700 return "DW_OP_breg18"; 2701 case DW_OP_breg19: 2702 return "DW_OP_breg19"; 2703 case DW_OP_breg20: 2704 return "DW_OP_breg20"; 2705 case DW_OP_breg21: 2706 return "DW_OP_breg21"; 2707 case DW_OP_breg22: 2708 return "DW_OP_breg22"; 2709 case DW_OP_breg23: 2710 return "DW_OP_breg23"; 2711 case DW_OP_breg24: 2712 return "DW_OP_breg24"; 2713 case DW_OP_breg25: 2714 return "DW_OP_breg25"; 2715 case DW_OP_breg26: 2716 return "DW_OP_breg26"; 2717 case DW_OP_breg27: 2718 return "DW_OP_breg27"; 2719 case DW_OP_breg28: 2720 return "DW_OP_breg28"; 2721 case DW_OP_breg29: 2722 return "DW_OP_breg29"; 2723 case DW_OP_breg30: 2724 return "DW_OP_breg30"; 2725 case DW_OP_breg31: 2726 return "DW_OP_breg31"; 2727 case DW_OP_regx: 2728 return "DW_OP_regx"; 2729 case DW_OP_fbreg: 2730 return "DW_OP_fbreg"; 2731 case DW_OP_bregx: 2732 return "DW_OP_bregx"; 2733 case DW_OP_piece: 2734 return "DW_OP_piece"; 2735 case DW_OP_deref_size: 2736 return "DW_OP_deref_size"; 2737 case DW_OP_xderef_size: 2738 return "DW_OP_xderef_size"; 2739 case DW_OP_nop: 2740 return "DW_OP_nop"; 2741 case DW_OP_push_object_address: 2742 return "DW_OP_push_object_address"; 2743 case DW_OP_call2: 2744 return "DW_OP_call2"; 2745 case DW_OP_call4: 2746 return "DW_OP_call4"; 2747 case DW_OP_call_ref: 2748 return "DW_OP_call_ref"; 2749 case DW_OP_GNU_push_tls_address: 2750 return "DW_OP_GNU_push_tls_address"; 2751 default: 2752 return "OP_<unknown>"; 2753 } 2754} 2755 2756/* Return a pointer to a newly allocated location description. Location 2757 descriptions are simple expression terms that can be strung 2758 together to form more complicated location (address) descriptions. */ 2759 2760static inline dw_loc_descr_ref 2761new_loc_descr (enum dwarf_location_atom op, unsigned HOST_WIDE_INT oprnd1, 2762 unsigned HOST_WIDE_INT oprnd2) 2763{ 2764 dw_loc_descr_ref descr = ggc_alloc_cleared (sizeof (dw_loc_descr_node)); 2765 2766 descr->dw_loc_opc = op; 2767 descr->dw_loc_oprnd1.val_class = dw_val_class_unsigned_const; 2768 descr->dw_loc_oprnd1.v.val_unsigned = oprnd1; 2769 descr->dw_loc_oprnd2.val_class = dw_val_class_unsigned_const; 2770 descr->dw_loc_oprnd2.v.val_unsigned = oprnd2; 2771 2772 return descr; 2773} 2774 2775 2776/* Add a location description term to a location description expression. */ 2777 2778static inline void 2779add_loc_descr (dw_loc_descr_ref *list_head, dw_loc_descr_ref descr) 2780{ 2781 dw_loc_descr_ref *d; 2782 2783 /* Find the end of the chain. */ 2784 for (d = list_head; (*d) != NULL; d = &(*d)->dw_loc_next) 2785 ; 2786 2787 *d = descr; 2788} 2789 2790/* Return the size of a location descriptor. */ 2791 2792static unsigned long 2793size_of_loc_descr (dw_loc_descr_ref loc) 2794{ 2795 unsigned long size = 1; 2796 2797 switch (loc->dw_loc_opc) 2798 { 2799 case DW_OP_addr: 2800 case INTERNAL_DW_OP_tls_addr: 2801 size += DWARF2_ADDR_SIZE; 2802 break; 2803 case DW_OP_const1u: 2804 case DW_OP_const1s: 2805 size += 1; 2806 break; 2807 case DW_OP_const2u: 2808 case DW_OP_const2s: 2809 size += 2; 2810 break; 2811 case DW_OP_const4u: 2812 case DW_OP_const4s: 2813 size += 4; 2814 break; 2815 case DW_OP_const8u: 2816 case DW_OP_const8s: 2817 size += 8; 2818 break; 2819 case DW_OP_constu: 2820 size += size_of_uleb128 (loc->dw_loc_oprnd1.v.val_unsigned); 2821 break; 2822 case DW_OP_consts: 2823 size += size_of_sleb128 (loc->dw_loc_oprnd1.v.val_int); 2824 break; 2825 case DW_OP_pick: 2826 size += 1; 2827 break; 2828 case DW_OP_plus_uconst: 2829 size += size_of_uleb128 (loc->dw_loc_oprnd1.v.val_unsigned); 2830 break; 2831 case DW_OP_skip: 2832 case DW_OP_bra: 2833 size += 2; 2834 break; 2835 case DW_OP_breg0: 2836 case DW_OP_breg1: 2837 case DW_OP_breg2: 2838 case DW_OP_breg3: 2839 case DW_OP_breg4: 2840 case DW_OP_breg5: 2841 case DW_OP_breg6: 2842 case DW_OP_breg7: 2843 case DW_OP_breg8: 2844 case DW_OP_breg9: 2845 case DW_OP_breg10: 2846 case DW_OP_breg11: 2847 case DW_OP_breg12: 2848 case DW_OP_breg13: 2849 case DW_OP_breg14: 2850 case DW_OP_breg15: 2851 case DW_OP_breg16: 2852 case DW_OP_breg17: 2853 case DW_OP_breg18: 2854 case DW_OP_breg19: 2855 case DW_OP_breg20: 2856 case DW_OP_breg21: 2857 case DW_OP_breg22: 2858 case DW_OP_breg23: 2859 case DW_OP_breg24: 2860 case DW_OP_breg25: 2861 case DW_OP_breg26: 2862 case DW_OP_breg27: 2863 case DW_OP_breg28: 2864 case DW_OP_breg29: 2865 case DW_OP_breg30: 2866 case DW_OP_breg31: 2867 size += size_of_sleb128 (loc->dw_loc_oprnd1.v.val_int); 2868 break; 2869 case DW_OP_regx: 2870 size += size_of_uleb128 (loc->dw_loc_oprnd1.v.val_unsigned); 2871 break; 2872 case DW_OP_fbreg: 2873 size += size_of_sleb128 (loc->dw_loc_oprnd1.v.val_int); 2874 break; 2875 case DW_OP_bregx: 2876 size += size_of_uleb128 (loc->dw_loc_oprnd1.v.val_unsigned); 2877 size += size_of_sleb128 (loc->dw_loc_oprnd2.v.val_int); 2878 break; 2879 case DW_OP_piece: 2880 size += size_of_uleb128 (loc->dw_loc_oprnd1.v.val_unsigned); 2881 break; 2882 case DW_OP_deref_size: 2883 case DW_OP_xderef_size: 2884 size += 1; 2885 break; 2886 case DW_OP_call2: 2887 size += 2; 2888 break; 2889 case DW_OP_call4: 2890 size += 4; 2891 break; 2892 case DW_OP_call_ref: 2893 size += DWARF2_ADDR_SIZE; 2894 break; 2895 default: 2896 break; 2897 } 2898 2899 return size; 2900} 2901 2902/* Return the size of a series of location descriptors. */ 2903 2904static unsigned long 2905size_of_locs (dw_loc_descr_ref loc) 2906{ 2907 unsigned long size; 2908 2909 for (size = 0; loc != NULL; loc = loc->dw_loc_next) 2910 { 2911 loc->dw_loc_addr = size; 2912 size += size_of_loc_descr (loc); 2913 } 2914 2915 return size; 2916} 2917 2918/* Output location description stack opcode's operands (if any). */ 2919 2920static void 2921output_loc_operands (dw_loc_descr_ref loc) 2922{ 2923 dw_val_ref val1 = &loc->dw_loc_oprnd1; 2924 dw_val_ref val2 = &loc->dw_loc_oprnd2; 2925 2926 switch (loc->dw_loc_opc) 2927 { 2928#ifdef DWARF2_DEBUGGING_INFO 2929 case DW_OP_addr: 2930 dw2_asm_output_addr_rtx (DWARF2_ADDR_SIZE, val1->v.val_addr, NULL); 2931 break; 2932 case DW_OP_const2u: 2933 case DW_OP_const2s: 2934 dw2_asm_output_data (2, val1->v.val_int, NULL); 2935 break; 2936 case DW_OP_const4u: 2937 case DW_OP_const4s: 2938 dw2_asm_output_data (4, val1->v.val_int, NULL); 2939 break; 2940 case DW_OP_const8u: 2941 case DW_OP_const8s: 2942 if (HOST_BITS_PER_LONG < 64) 2943 abort (); 2944 dw2_asm_output_data (8, val1->v.val_int, NULL); 2945 break; 2946 case DW_OP_skip: 2947 case DW_OP_bra: 2948 { 2949 int offset; 2950 2951 if (val1->val_class == dw_val_class_loc) 2952 offset = val1->v.val_loc->dw_loc_addr - (loc->dw_loc_addr + 3); 2953 else 2954 abort (); 2955 2956 dw2_asm_output_data (2, offset, NULL); 2957 } 2958 break; 2959#else 2960 case DW_OP_addr: 2961 case DW_OP_const2u: 2962 case DW_OP_const2s: 2963 case DW_OP_const4u: 2964 case DW_OP_const4s: 2965 case DW_OP_const8u: 2966 case DW_OP_const8s: 2967 case DW_OP_skip: 2968 case DW_OP_bra: 2969 /* We currently don't make any attempt to make sure these are 2970 aligned properly like we do for the main unwind info, so 2971 don't support emitting things larger than a byte if we're 2972 only doing unwinding. */ 2973 abort (); 2974#endif 2975 case DW_OP_const1u: 2976 case DW_OP_const1s: 2977 dw2_asm_output_data (1, val1->v.val_int, NULL); 2978 break; 2979 case DW_OP_constu: 2980 dw2_asm_output_data_uleb128 (val1->v.val_unsigned, NULL); 2981 break; 2982 case DW_OP_consts: 2983 dw2_asm_output_data_sleb128 (val1->v.val_int, NULL); 2984 break; 2985 case DW_OP_pick: 2986 dw2_asm_output_data (1, val1->v.val_int, NULL); 2987 break; 2988 case DW_OP_plus_uconst: 2989 dw2_asm_output_data_uleb128 (val1->v.val_unsigned, NULL); 2990 break; 2991 case DW_OP_breg0: 2992 case DW_OP_breg1: 2993 case DW_OP_breg2: 2994 case DW_OP_breg3: 2995 case DW_OP_breg4: 2996 case DW_OP_breg5: 2997 case DW_OP_breg6: 2998 case DW_OP_breg7: 2999 case DW_OP_breg8: 3000 case DW_OP_breg9: 3001 case DW_OP_breg10: 3002 case DW_OP_breg11: 3003 case DW_OP_breg12: 3004 case DW_OP_breg13: 3005 case DW_OP_breg14: 3006 case DW_OP_breg15: 3007 case DW_OP_breg16: 3008 case DW_OP_breg17: 3009 case DW_OP_breg18: 3010 case DW_OP_breg19: 3011 case DW_OP_breg20: 3012 case DW_OP_breg21: 3013 case DW_OP_breg22: 3014 case DW_OP_breg23: 3015 case DW_OP_breg24: 3016 case DW_OP_breg25: 3017 case DW_OP_breg26: 3018 case DW_OP_breg27: 3019 case DW_OP_breg28: 3020 case DW_OP_breg29: 3021 case DW_OP_breg30: 3022 case DW_OP_breg31: 3023 dw2_asm_output_data_sleb128 (val1->v.val_int, NULL); 3024 break; 3025 case DW_OP_regx: 3026 dw2_asm_output_data_uleb128 (val1->v.val_unsigned, NULL); 3027 break; 3028 case DW_OP_fbreg: 3029 dw2_asm_output_data_sleb128 (val1->v.val_int, NULL); 3030 break; 3031 case DW_OP_bregx: 3032 dw2_asm_output_data_uleb128 (val1->v.val_unsigned, NULL); 3033 dw2_asm_output_data_sleb128 (val2->v.val_int, NULL); 3034 break; 3035 case DW_OP_piece: 3036 dw2_asm_output_data_uleb128 (val1->v.val_unsigned, NULL); 3037 break; 3038 case DW_OP_deref_size: 3039 case DW_OP_xderef_size: 3040 dw2_asm_output_data (1, val1->v.val_int, NULL); 3041 break; 3042 3043 case INTERNAL_DW_OP_tls_addr: 3044#ifdef ASM_OUTPUT_DWARF_DTPREL 3045 ASM_OUTPUT_DWARF_DTPREL (asm_out_file, DWARF2_ADDR_SIZE, 3046 val1->v.val_addr); 3047 fputc ('\n', asm_out_file); 3048#else 3049 abort (); 3050#endif 3051 break; 3052 3053 default: 3054 /* Other codes have no operands. */ 3055 break; 3056 } 3057} 3058 3059/* Output a sequence of location operations. */ 3060 3061static void 3062output_loc_sequence (dw_loc_descr_ref loc) 3063{ 3064 for (; loc != NULL; loc = loc->dw_loc_next) 3065 { 3066 /* Output the opcode. */ 3067 dw2_asm_output_data (1, loc->dw_loc_opc, 3068 "%s", dwarf_stack_op_name (loc->dw_loc_opc)); 3069 3070 /* Output the operand(s) (if any). */ 3071 output_loc_operands (loc); 3072 } 3073} 3074 3075/* This routine will generate the correct assembly data for a location 3076 description based on a cfi entry with a complex address. */ 3077 3078static void 3079output_cfa_loc (dw_cfi_ref cfi) 3080{ 3081 dw_loc_descr_ref loc; 3082 unsigned long size; 3083 3084 /* Output the size of the block. */ 3085 loc = cfi->dw_cfi_oprnd1.dw_cfi_loc; 3086 size = size_of_locs (loc); 3087 dw2_asm_output_data_uleb128 (size, NULL); 3088 3089 /* Now output the operations themselves. */ 3090 output_loc_sequence (loc); 3091} 3092 3093/* This function builds a dwarf location descriptor sequence from 3094 a dw_cfa_location. */ 3095 3096static struct dw_loc_descr_struct * 3097build_cfa_loc (dw_cfa_location *cfa) 3098{ 3099 struct dw_loc_descr_struct *head, *tmp; 3100 3101 if (cfa->indirect == 0) 3102 abort (); 3103 3104 if (cfa->base_offset) 3105 { 3106 if (cfa->reg <= 31) 3107 head = new_loc_descr (DW_OP_breg0 + cfa->reg, cfa->base_offset, 0); 3108 else 3109 head = new_loc_descr (DW_OP_bregx, cfa->reg, cfa->base_offset); 3110 } 3111 else if (cfa->reg <= 31) 3112 head = new_loc_descr (DW_OP_reg0 + cfa->reg, 0, 0); 3113 else 3114 head = new_loc_descr (DW_OP_regx, cfa->reg, 0); 3115 3116 head->dw_loc_oprnd1.val_class = dw_val_class_const; 3117 tmp = new_loc_descr (DW_OP_deref, 0, 0); 3118 add_loc_descr (&head, tmp); 3119 if (cfa->offset != 0) 3120 { 3121 tmp = new_loc_descr (DW_OP_plus_uconst, cfa->offset, 0); 3122 add_loc_descr (&head, tmp); 3123 } 3124 3125 return head; 3126} 3127 3128/* This function fills in aa dw_cfa_location structure from a dwarf location 3129 descriptor sequence. */ 3130 3131static void 3132get_cfa_from_loc_descr (dw_cfa_location *cfa, struct dw_loc_descr_struct *loc) 3133{ 3134 struct dw_loc_descr_struct *ptr; 3135 cfa->offset = 0; 3136 cfa->base_offset = 0; 3137 cfa->indirect = 0; 3138 cfa->reg = -1; 3139 3140 for (ptr = loc; ptr != NULL; ptr = ptr->dw_loc_next) 3141 { 3142 enum dwarf_location_atom op = ptr->dw_loc_opc; 3143 3144 switch (op) 3145 { 3146 case DW_OP_reg0: 3147 case DW_OP_reg1: 3148 case DW_OP_reg2: 3149 case DW_OP_reg3: 3150 case DW_OP_reg4: 3151 case DW_OP_reg5: 3152 case DW_OP_reg6: 3153 case DW_OP_reg7: 3154 case DW_OP_reg8: 3155 case DW_OP_reg9: 3156 case DW_OP_reg10: 3157 case DW_OP_reg11: 3158 case DW_OP_reg12: 3159 case DW_OP_reg13: 3160 case DW_OP_reg14: 3161 case DW_OP_reg15: 3162 case DW_OP_reg16: 3163 case DW_OP_reg17: 3164 case DW_OP_reg18: 3165 case DW_OP_reg19: 3166 case DW_OP_reg20: 3167 case DW_OP_reg21: 3168 case DW_OP_reg22: 3169 case DW_OP_reg23: 3170 case DW_OP_reg24: 3171 case DW_OP_reg25: 3172 case DW_OP_reg26: 3173 case DW_OP_reg27: 3174 case DW_OP_reg28: 3175 case DW_OP_reg29: 3176 case DW_OP_reg30: 3177 case DW_OP_reg31: 3178 cfa->reg = op - DW_OP_reg0; 3179 break; 3180 case DW_OP_regx: 3181 cfa->reg = ptr->dw_loc_oprnd1.v.val_int; 3182 break; 3183 case DW_OP_breg0: 3184 case DW_OP_breg1: 3185 case DW_OP_breg2: 3186 case DW_OP_breg3: 3187 case DW_OP_breg4: 3188 case DW_OP_breg5: 3189 case DW_OP_breg6: 3190 case DW_OP_breg7: 3191 case DW_OP_breg8: 3192 case DW_OP_breg9: 3193 case DW_OP_breg10: 3194 case DW_OP_breg11: 3195 case DW_OP_breg12: 3196 case DW_OP_breg13: 3197 case DW_OP_breg14: 3198 case DW_OP_breg15: 3199 case DW_OP_breg16: 3200 case DW_OP_breg17: 3201 case DW_OP_breg18: 3202 case DW_OP_breg19: 3203 case DW_OP_breg20: 3204 case DW_OP_breg21: 3205 case DW_OP_breg22: 3206 case DW_OP_breg23: 3207 case DW_OP_breg24: 3208 case DW_OP_breg25: 3209 case DW_OP_breg26: 3210 case DW_OP_breg27: 3211 case DW_OP_breg28: 3212 case DW_OP_breg29: 3213 case DW_OP_breg30: 3214 case DW_OP_breg31: 3215 cfa->reg = op - DW_OP_breg0; 3216 cfa->base_offset = ptr->dw_loc_oprnd1.v.val_int; 3217 break; 3218 case DW_OP_bregx: 3219 cfa->reg = ptr->dw_loc_oprnd1.v.val_int; 3220 cfa->base_offset = ptr->dw_loc_oprnd2.v.val_int; 3221 break; 3222 case DW_OP_deref: 3223 cfa->indirect = 1; 3224 break; 3225 case DW_OP_plus_uconst: 3226 cfa->offset = ptr->dw_loc_oprnd1.v.val_unsigned; 3227 break; 3228 default: 3229 internal_error ("DW_LOC_OP %s not implemented\n", 3230 dwarf_stack_op_name (ptr->dw_loc_opc)); 3231 } 3232 } 3233} 3234#endif /* .debug_frame support */ 3235 3236/* And now, the support for symbolic debugging information. */ 3237#ifdef DWARF2_DEBUGGING_INFO 3238 3239/* .debug_str support. */ 3240static int output_indirect_string (void **, void *); 3241 3242static void dwarf2out_init (const char *); 3243static void dwarf2out_finish (const char *); 3244static void dwarf2out_define (unsigned int, const char *); 3245static void dwarf2out_undef (unsigned int, const char *); 3246static void dwarf2out_start_source_file (unsigned, const char *); 3247static void dwarf2out_end_source_file (unsigned); 3248static void dwarf2out_begin_block (unsigned, unsigned); 3249static void dwarf2out_end_block (unsigned, unsigned); 3250static bool dwarf2out_ignore_block (tree); 3251static void dwarf2out_global_decl (tree); 3252static void dwarf2out_abstract_function (tree); 3253 3254/* The debug hooks structure. */ 3255 3256const struct gcc_debug_hooks dwarf2_debug_hooks = 3257{ 3258 dwarf2out_init, 3259 dwarf2out_finish, 3260 dwarf2out_define, 3261 dwarf2out_undef, 3262 dwarf2out_start_source_file, 3263 dwarf2out_end_source_file, 3264 dwarf2out_begin_block, 3265 dwarf2out_end_block, 3266 dwarf2out_ignore_block, 3267 dwarf2out_source_line, 3268 dwarf2out_begin_prologue, 3269 debug_nothing_int_charstar, /* end_prologue */ 3270 dwarf2out_end_epilogue, 3271 debug_nothing_tree, /* begin_function */ 3272 debug_nothing_int, /* end_function */ 3273 dwarf2out_decl, /* function_decl */ 3274 dwarf2out_global_decl, 3275 debug_nothing_tree, /* deferred_inline_function */ 3276 /* The DWARF 2 backend tries to reduce debugging bloat by not 3277 emitting the abstract description of inline functions until 3278 something tries to reference them. */ 3279 dwarf2out_abstract_function, /* outlining_inline_function */ 3280 debug_nothing_rtx, /* label */ 3281 debug_nothing_int /* handle_pch */ 3282}; 3283#endif 3284 3285/* NOTE: In the comments in this file, many references are made to 3286 "Debugging Information Entries". This term is abbreviated as `DIE' 3287 throughout the remainder of this file. */ 3288 3289/* An internal representation of the DWARF output is built, and then 3290 walked to generate the DWARF debugging info. The walk of the internal 3291 representation is done after the entire program has been compiled. 3292 The types below are used to describe the internal representation. */ 3293 3294/* Various DIE's use offsets relative to the beginning of the 3295 .debug_info section to refer to each other. */ 3296 3297typedef long int dw_offset; 3298 3299/* Define typedefs here to avoid circular dependencies. */ 3300 3301typedef struct dw_attr_struct *dw_attr_ref; 3302typedef struct dw_line_info_struct *dw_line_info_ref; 3303typedef struct dw_separate_line_info_struct *dw_separate_line_info_ref; 3304typedef struct pubname_struct *pubname_ref; 3305typedef struct dw_ranges_struct *dw_ranges_ref; 3306 3307/* Each entry in the line_info_table maintains the file and 3308 line number associated with the label generated for that 3309 entry. The label gives the PC value associated with 3310 the line number entry. */ 3311 3312typedef struct dw_line_info_struct GTY(()) 3313{ 3314 unsigned long dw_file_num; 3315 unsigned long dw_line_num; 3316} 3317dw_line_info_entry; 3318 3319/* Line information for functions in separate sections; each one gets its 3320 own sequence. */ 3321typedef struct dw_separate_line_info_struct GTY(()) 3322{ 3323 unsigned long dw_file_num; 3324 unsigned long dw_line_num; 3325 unsigned long function; 3326} 3327dw_separate_line_info_entry; 3328 3329/* Each DIE attribute has a field specifying the attribute kind, 3330 a link to the next attribute in the chain, and an attribute value. 3331 Attributes are typically linked below the DIE they modify. */ 3332 3333typedef struct dw_attr_struct GTY(()) 3334{ 3335 enum dwarf_attribute dw_attr; 3336 dw_attr_ref dw_attr_next; 3337 dw_val_node dw_attr_val; 3338} 3339dw_attr_node; 3340 3341/* The Debugging Information Entry (DIE) structure */ 3342 3343typedef struct die_struct GTY(()) 3344{ 3345 enum dwarf_tag die_tag; 3346 char *die_symbol; 3347 dw_attr_ref die_attr; 3348 dw_die_ref die_parent; 3349 dw_die_ref die_child; 3350 dw_die_ref die_sib; 3351 dw_die_ref die_definition; /* ref from a specification to its definition */ 3352 dw_offset die_offset; 3353 unsigned long die_abbrev; 3354 int die_mark; 3355} 3356die_node; 3357 3358/* The pubname structure */ 3359 3360typedef struct pubname_struct GTY(()) 3361{ 3362 dw_die_ref die; 3363 char *name; 3364} 3365pubname_entry; 3366 3367struct dw_ranges_struct GTY(()) 3368{ 3369 int block_num; 3370}; 3371 3372/* The limbo die list structure. */ 3373typedef struct limbo_die_struct GTY(()) 3374{ 3375 dw_die_ref die; 3376 tree created_for; 3377 struct limbo_die_struct *next; 3378} 3379limbo_die_node; 3380 3381/* How to start an assembler comment. */ 3382#ifndef ASM_COMMENT_START 3383#define ASM_COMMENT_START ";#" 3384#endif 3385 3386/* Define a macro which returns nonzero for a TYPE_DECL which was 3387 implicitly generated for a tagged type. 3388 3389 Note that unlike the gcc front end (which generates a NULL named 3390 TYPE_DECL node for each complete tagged type, each array type, and 3391 each function type node created) the g++ front end generates a 3392 _named_ TYPE_DECL node for each tagged type node created. 3393 These TYPE_DECLs have DECL_ARTIFICIAL set, so we know not to 3394 generate a DW_TAG_typedef DIE for them. */ 3395 3396#define TYPE_DECL_IS_STUB(decl) \ 3397 (DECL_NAME (decl) == NULL_TREE \ 3398 || (DECL_ARTIFICIAL (decl) \ 3399 && is_tagged_type (TREE_TYPE (decl)) \ 3400 && ((decl == TYPE_STUB_DECL (TREE_TYPE (decl))) \ 3401 /* This is necessary for stub decls that \ 3402 appear in nested inline functions. */ \ 3403 || (DECL_ABSTRACT_ORIGIN (decl) != NULL_TREE \ 3404 && (decl_ultimate_origin (decl) \ 3405 == TYPE_STUB_DECL (TREE_TYPE (decl))))))) 3406 3407/* Information concerning the compilation unit's programming 3408 language, and compiler version. */ 3409 3410/* Fixed size portion of the DWARF compilation unit header. */ 3411#define DWARF_COMPILE_UNIT_HEADER_SIZE \ 3412 (DWARF_INITIAL_LENGTH_SIZE + DWARF_OFFSET_SIZE + 3) 3413 3414/* Fixed size portion of public names info. */ 3415#define DWARF_PUBNAMES_HEADER_SIZE (2 * DWARF_OFFSET_SIZE + 2) 3416 3417/* Fixed size portion of the address range info. */ 3418#define DWARF_ARANGES_HEADER_SIZE \ 3419 (DWARF_ROUND (DWARF_INITIAL_LENGTH_SIZE + DWARF_OFFSET_SIZE + 4, \ 3420 DWARF2_ADDR_SIZE * 2) \ 3421 - DWARF_INITIAL_LENGTH_SIZE) 3422 3423/* Size of padding portion in the address range info. It must be 3424 aligned to twice the pointer size. */ 3425#define DWARF_ARANGES_PAD_SIZE \ 3426 (DWARF_ROUND (DWARF_INITIAL_LENGTH_SIZE + DWARF_OFFSET_SIZE + 4, \ 3427 DWARF2_ADDR_SIZE * 2) \ 3428 - (DWARF_INITIAL_LENGTH_SIZE + DWARF_OFFSET_SIZE + 4)) 3429 3430/* Use assembler line directives if available. */ 3431#ifndef DWARF2_ASM_LINE_DEBUG_INFO 3432#ifdef HAVE_AS_DWARF2_DEBUG_LINE 3433#define DWARF2_ASM_LINE_DEBUG_INFO 1 3434#else 3435#define DWARF2_ASM_LINE_DEBUG_INFO 0 3436#endif 3437#endif 3438 3439/* Minimum line offset in a special line info. opcode. 3440 This value was chosen to give a reasonable range of values. */ 3441#define DWARF_LINE_BASE -10 3442 3443/* First special line opcode - leave room for the standard opcodes. */ 3444#define DWARF_LINE_OPCODE_BASE 10 3445 3446/* Range of line offsets in a special line info. opcode. */ 3447#define DWARF_LINE_RANGE (254-DWARF_LINE_OPCODE_BASE+1) 3448 3449/* Flag that indicates the initial value of the is_stmt_start flag. 3450 In the present implementation, we do not mark any lines as 3451 the beginning of a source statement, because that information 3452 is not made available by the GCC front-end. */ 3453#define DWARF_LINE_DEFAULT_IS_STMT_START 1 3454 3455#ifdef DWARF2_DEBUGGING_INFO 3456/* This location is used by calc_die_sizes() to keep track 3457 the offset of each DIE within the .debug_info section. */ 3458static unsigned long next_die_offset; 3459#endif 3460 3461/* Record the root of the DIE's built for the current compilation unit. */ 3462static GTY(()) dw_die_ref comp_unit_die; 3463 3464/* A list of DIEs with a NULL parent waiting to be relocated. */ 3465static GTY(()) limbo_die_node *limbo_die_list; 3466 3467/* Filenames referenced by this compilation unit. */ 3468static GTY(()) varray_type file_table; 3469static GTY(()) varray_type file_table_emitted; 3470static GTY(()) size_t file_table_last_lookup_index; 3471 3472/* A pointer to the base of a table of references to DIE's that describe 3473 declarations. The table is indexed by DECL_UID() which is a unique 3474 number identifying each decl. */ 3475static GTY((length ("decl_die_table_allocated"))) dw_die_ref *decl_die_table; 3476 3477/* Number of elements currently allocated for the decl_die_table. */ 3478static GTY(()) unsigned decl_die_table_allocated; 3479 3480/* Number of elements in decl_die_table currently in use. */ 3481static GTY(()) unsigned decl_die_table_in_use; 3482 3483/* Size (in elements) of increments by which we may expand the 3484 decl_die_table. */ 3485#define DECL_DIE_TABLE_INCREMENT 256 3486 3487/* A pointer to the base of a list of references to DIE's that 3488 are uniquely identified by their tag, presence/absence of 3489 children DIE's, and list of attribute/value pairs. */ 3490static GTY((length ("abbrev_die_table_allocated"))) 3491 dw_die_ref *abbrev_die_table; 3492 3493/* Number of elements currently allocated for abbrev_die_table. */ 3494static GTY(()) unsigned abbrev_die_table_allocated; 3495 3496/* Number of elements in type_die_table currently in use. */ 3497static GTY(()) unsigned abbrev_die_table_in_use; 3498 3499/* Size (in elements) of increments by which we may expand the 3500 abbrev_die_table. */ 3501#define ABBREV_DIE_TABLE_INCREMENT 256 3502 3503/* A pointer to the base of a table that contains line information 3504 for each source code line in .text in the compilation unit. */ 3505static GTY((length ("line_info_table_allocated"))) 3506 dw_line_info_ref line_info_table; 3507 3508/* Number of elements currently allocated for line_info_table. */ 3509static GTY(()) unsigned line_info_table_allocated; 3510 3511/* Number of elements in line_info_table currently in use. */ 3512static GTY(()) unsigned line_info_table_in_use; 3513 3514/* A pointer to the base of a table that contains line information 3515 for each source code line outside of .text in the compilation unit. */ 3516static GTY ((length ("separate_line_info_table_allocated"))) 3517 dw_separate_line_info_ref separate_line_info_table; 3518 3519/* Number of elements currently allocated for separate_line_info_table. */ 3520static GTY(()) unsigned separate_line_info_table_allocated; 3521 3522/* Number of elements in separate_line_info_table currently in use. */ 3523static GTY(()) unsigned separate_line_info_table_in_use; 3524 3525/* Size (in elements) of increments by which we may expand the 3526 line_info_table. */ 3527#define LINE_INFO_TABLE_INCREMENT 1024 3528 3529/* A pointer to the base of a table that contains a list of publicly 3530 accessible names. */ 3531static GTY ((length ("pubname_table_allocated"))) pubname_ref pubname_table; 3532 3533/* Number of elements currently allocated for pubname_table. */ 3534static GTY(()) unsigned pubname_table_allocated; 3535 3536/* Number of elements in pubname_table currently in use. */ 3537static GTY(()) unsigned pubname_table_in_use; 3538 3539/* Size (in elements) of increments by which we may expand the 3540 pubname_table. */ 3541#define PUBNAME_TABLE_INCREMENT 64 3542 3543/* Array of dies for which we should generate .debug_arange info. */ 3544static GTY((length ("arange_table_allocated"))) dw_die_ref *arange_table; 3545 3546/* Number of elements currently allocated for arange_table. */ 3547static GTY(()) unsigned arange_table_allocated; 3548 3549/* Number of elements in arange_table currently in use. */ 3550static GTY(()) unsigned arange_table_in_use; 3551 3552/* Size (in elements) of increments by which we may expand the 3553 arange_table. */ 3554#define ARANGE_TABLE_INCREMENT 64 3555 3556/* Array of dies for which we should generate .debug_ranges info. */ 3557static GTY ((length ("ranges_table_allocated"))) dw_ranges_ref ranges_table; 3558 3559/* Number of elements currently allocated for ranges_table. */ 3560static GTY(()) unsigned ranges_table_allocated; 3561 3562/* Number of elements in ranges_table currently in use. */ 3563static GTY(()) unsigned ranges_table_in_use; 3564 3565/* Size (in elements) of increments by which we may expand the 3566 ranges_table. */ 3567#define RANGES_TABLE_INCREMENT 64 3568 3569/* Whether we have location lists that need outputting */ 3570static GTY(()) unsigned have_location_lists; 3571 3572#ifdef DWARF2_DEBUGGING_INFO 3573/* Record whether the function being analyzed contains inlined functions. */ 3574static int current_function_has_inlines; 3575#endif 3576#if 0 && defined (MIPS_DEBUGGING_INFO) 3577static int comp_unit_has_inlines; 3578#endif 3579 3580/* Number of file tables emitted in maybe_emit_file(). */ 3581static GTY(()) int emitcount = 0; 3582 3583/* Number of internal labels generated by gen_internal_sym(). */ 3584static GTY(()) int label_num; 3585 3586#ifdef DWARF2_DEBUGGING_INFO 3587 3588/* Forward declarations for functions defined in this file. */ 3589 3590static int is_pseudo_reg (rtx); 3591static tree type_main_variant (tree); 3592static int is_tagged_type (tree); 3593static const char *dwarf_tag_name (unsigned); 3594static const char *dwarf_attr_name (unsigned); 3595static const char *dwarf_form_name (unsigned); 3596#if 0 3597static const char *dwarf_type_encoding_name (unsigned); 3598#endif 3599static tree decl_ultimate_origin (tree); 3600static tree block_ultimate_origin (tree); 3601static tree decl_class_context (tree); 3602static void add_dwarf_attr (dw_die_ref, dw_attr_ref); 3603static inline enum dw_val_class AT_class (dw_attr_ref); 3604static void add_AT_flag (dw_die_ref, enum dwarf_attribute, unsigned); 3605static inline unsigned AT_flag (dw_attr_ref); 3606static void add_AT_int (dw_die_ref, enum dwarf_attribute, HOST_WIDE_INT); 3607static inline HOST_WIDE_INT AT_int (dw_attr_ref); 3608static void add_AT_unsigned (dw_die_ref, enum dwarf_attribute, unsigned HOST_WIDE_INT); 3609static inline unsigned HOST_WIDE_INT AT_unsigned (dw_attr_ref); 3610static void add_AT_long_long (dw_die_ref, enum dwarf_attribute, unsigned long, 3611 unsigned long); 3612static inline void add_AT_vec (dw_die_ref, enum dwarf_attribute, unsigned int, 3613 unsigned int, unsigned char *); 3614static hashval_t debug_str_do_hash (const void *); 3615static int debug_str_eq (const void *, const void *); 3616static void add_AT_string (dw_die_ref, enum dwarf_attribute, const char *); 3617static inline const char *AT_string (dw_attr_ref); 3618static int AT_string_form (dw_attr_ref); 3619static void add_AT_die_ref (dw_die_ref, enum dwarf_attribute, dw_die_ref); 3620static void add_AT_specification (dw_die_ref, dw_die_ref); 3621static inline dw_die_ref AT_ref (dw_attr_ref); 3622static inline int AT_ref_external (dw_attr_ref); 3623static inline void set_AT_ref_external (dw_attr_ref, int); 3624static void add_AT_fde_ref (dw_die_ref, enum dwarf_attribute, unsigned); 3625static void add_AT_loc (dw_die_ref, enum dwarf_attribute, dw_loc_descr_ref); 3626static inline dw_loc_descr_ref AT_loc (dw_attr_ref); 3627static void add_AT_loc_list (dw_die_ref, enum dwarf_attribute, 3628 dw_loc_list_ref); 3629static inline dw_loc_list_ref AT_loc_list (dw_attr_ref); 3630static void add_AT_addr (dw_die_ref, enum dwarf_attribute, rtx); 3631static inline rtx AT_addr (dw_attr_ref); 3632static void add_AT_lbl_id (dw_die_ref, enum dwarf_attribute, const char *); 3633static void add_AT_lbl_offset (dw_die_ref, enum dwarf_attribute, const char *); 3634static void add_AT_offset (dw_die_ref, enum dwarf_attribute, 3635 unsigned HOST_WIDE_INT); 3636static void add_AT_range_list (dw_die_ref, enum dwarf_attribute, 3637 unsigned long); 3638static inline const char *AT_lbl (dw_attr_ref); 3639static dw_attr_ref get_AT (dw_die_ref, enum dwarf_attribute); 3640static const char *get_AT_low_pc (dw_die_ref); 3641static const char *get_AT_hi_pc (dw_die_ref); 3642static const char *get_AT_string (dw_die_ref, enum dwarf_attribute); 3643static int get_AT_flag (dw_die_ref, enum dwarf_attribute); 3644static unsigned get_AT_unsigned (dw_die_ref, enum dwarf_attribute); 3645static inline dw_die_ref get_AT_ref (dw_die_ref, enum dwarf_attribute); 3646static bool is_c_family (void); 3647static bool is_cxx (void); 3648static bool is_java (void); 3649static bool is_fortran (void); 3650static bool is_ada (void); 3651static void remove_AT (dw_die_ref, enum dwarf_attribute); 3652static void remove_child_TAG (dw_die_ref, enum dwarf_tag); 3653static inline void free_die (dw_die_ref); 3654static void remove_children (dw_die_ref); 3655static void add_child_die (dw_die_ref, dw_die_ref); 3656static dw_die_ref new_die (enum dwarf_tag, dw_die_ref, tree); 3657static dw_die_ref lookup_type_die (tree); 3658static void equate_type_number_to_die (tree, dw_die_ref); 3659static dw_die_ref lookup_decl_die (tree); 3660static void equate_decl_number_to_die (tree, dw_die_ref); 3661static void print_spaces (FILE *); 3662static void print_die (dw_die_ref, FILE *); 3663static void print_dwarf_line_table (FILE *); 3664static void reverse_die_lists (dw_die_ref); 3665static void reverse_all_dies (dw_die_ref); 3666static dw_die_ref push_new_compile_unit (dw_die_ref, dw_die_ref); 3667static dw_die_ref pop_compile_unit (dw_die_ref); 3668static void loc_checksum (dw_loc_descr_ref, struct md5_ctx *); 3669static void attr_checksum (dw_attr_ref, struct md5_ctx *, int *); 3670static void die_checksum (dw_die_ref, struct md5_ctx *, int *); 3671static int same_loc_p (dw_loc_descr_ref, dw_loc_descr_ref, int *); 3672static int same_dw_val_p (dw_val_node *, dw_val_node *, int *); 3673static int same_attr_p (dw_attr_ref, dw_attr_ref, int *); 3674static int same_die_p (dw_die_ref, dw_die_ref, int *); 3675static int same_die_p_wrap (dw_die_ref, dw_die_ref); 3676static void compute_section_prefix (dw_die_ref); 3677static int is_type_die (dw_die_ref); 3678static int is_comdat_die (dw_die_ref); 3679static int is_symbol_die (dw_die_ref); 3680static void assign_symbol_names (dw_die_ref); 3681static void break_out_includes (dw_die_ref); 3682static hashval_t htab_cu_hash (const void *); 3683static int htab_cu_eq (const void *, const void *); 3684static void htab_cu_del (void *); 3685static int check_duplicate_cu (dw_die_ref, htab_t, unsigned *); 3686static void record_comdat_symbol_number (dw_die_ref, htab_t, unsigned); 3687static void add_sibling_attributes (dw_die_ref); 3688static void build_abbrev_table (dw_die_ref); 3689static void output_location_lists (dw_die_ref); 3690static int constant_size (long unsigned); 3691static unsigned long size_of_die (dw_die_ref); 3692static void calc_die_sizes (dw_die_ref); 3693static void mark_dies (dw_die_ref); 3694static void unmark_dies (dw_die_ref); 3695static void unmark_all_dies (dw_die_ref); 3696static unsigned long size_of_pubnames (void); 3697static unsigned long size_of_aranges (void); 3698static enum dwarf_form value_format (dw_attr_ref); 3699static void output_value_format (dw_attr_ref); 3700static void output_abbrev_section (void); 3701static void output_die_symbol (dw_die_ref); 3702static void output_die (dw_die_ref); 3703static void output_compilation_unit_header (void); 3704static void output_comp_unit (dw_die_ref, int); 3705static const char *dwarf2_name (tree, int); 3706static void add_pubname (tree, dw_die_ref); 3707static void output_pubnames (void); 3708static void add_arange (tree, dw_die_ref); 3709static void output_aranges (void); 3710static unsigned int add_ranges (tree); 3711static void output_ranges (void); 3712static void output_line_info (void); 3713static void output_file_names (void); 3714static dw_die_ref base_type_die (tree); 3715static tree root_type (tree); 3716static int is_base_type (tree); 3717static bool is_subrange_type (tree); 3718static dw_die_ref subrange_type_die (tree, dw_die_ref); 3719static dw_die_ref modified_type_die (tree, int, int, dw_die_ref); 3720static int type_is_enum (tree); 3721static unsigned int dbx_reg_number (rtx); 3722static dw_loc_descr_ref reg_loc_descriptor (rtx); 3723static dw_loc_descr_ref one_reg_loc_descriptor (unsigned int); 3724static dw_loc_descr_ref multiple_reg_loc_descriptor (rtx, rtx); 3725static dw_loc_descr_ref int_loc_descriptor (HOST_WIDE_INT); 3726static dw_loc_descr_ref based_loc_descr (unsigned, HOST_WIDE_INT); 3727static int is_based_loc (rtx); 3728static dw_loc_descr_ref mem_loc_descriptor (rtx, enum machine_mode mode); 3729static dw_loc_descr_ref concat_loc_descriptor (rtx, rtx); 3730static dw_loc_descr_ref loc_descriptor (rtx); 3731static dw_loc_descr_ref loc_descriptor_from_tree (tree, int); 3732static HOST_WIDE_INT ceiling (HOST_WIDE_INT, unsigned int); 3733static tree field_type (tree); 3734static unsigned int simple_type_align_in_bits (tree); 3735static unsigned int simple_decl_align_in_bits (tree); 3736static unsigned HOST_WIDE_INT simple_type_size_in_bits (tree); 3737static HOST_WIDE_INT field_byte_offset (tree); 3738static void add_AT_location_description (dw_die_ref, enum dwarf_attribute, 3739 dw_loc_descr_ref); 3740static void add_data_member_location_attribute (dw_die_ref, tree); 3741static void add_const_value_attribute (dw_die_ref, rtx); 3742static void insert_int (HOST_WIDE_INT, unsigned, unsigned char *); 3743static HOST_WIDE_INT extract_int (const unsigned char *, unsigned); 3744static void insert_float (rtx, unsigned char *); 3745static rtx rtl_for_decl_location (tree); 3746static void add_location_or_const_value_attribute (dw_die_ref, tree); 3747static void tree_add_const_value_attribute (dw_die_ref, tree); 3748static void add_name_attribute (dw_die_ref, const char *); 3749static void add_comp_dir_attribute (dw_die_ref); 3750static void add_bound_info (dw_die_ref, enum dwarf_attribute, tree); 3751static void add_subscript_info (dw_die_ref, tree); 3752static void add_byte_size_attribute (dw_die_ref, tree); 3753static void add_bit_offset_attribute (dw_die_ref, tree); 3754static void add_bit_size_attribute (dw_die_ref, tree); 3755static void add_prototyped_attribute (dw_die_ref, tree); 3756static void add_abstract_origin_attribute (dw_die_ref, tree); 3757static void add_pure_or_virtual_attribute (dw_die_ref, tree); 3758static void add_src_coords_attributes (dw_die_ref, tree); 3759static void add_name_and_src_coords_attributes (dw_die_ref, tree); 3760static void push_decl_scope (tree); 3761static void pop_decl_scope (void); 3762static dw_die_ref scope_die_for (tree, dw_die_ref); 3763static inline int local_scope_p (dw_die_ref); 3764static inline int class_or_namespace_scope_p (dw_die_ref); 3765static void add_type_attribute (dw_die_ref, tree, int, int, dw_die_ref); 3766static const char *type_tag (tree); 3767static tree member_declared_type (tree); 3768#if 0 3769static const char *decl_start_label (tree); 3770#endif 3771static void gen_array_type_die (tree, dw_die_ref); 3772static void gen_set_type_die (tree, dw_die_ref); 3773#if 0 3774static void gen_entry_point_die (tree, dw_die_ref); 3775#endif 3776static void gen_inlined_enumeration_type_die (tree, dw_die_ref); 3777static void gen_inlined_structure_type_die (tree, dw_die_ref); 3778static void gen_inlined_union_type_die (tree, dw_die_ref); 3779static dw_die_ref gen_enumeration_type_die (tree, dw_die_ref); 3780static dw_die_ref gen_formal_parameter_die (tree, dw_die_ref); 3781static void gen_unspecified_parameters_die (tree, dw_die_ref); 3782static void gen_formal_types_die (tree, dw_die_ref); 3783static void gen_subprogram_die (tree, dw_die_ref); 3784static void gen_variable_die (tree, dw_die_ref); 3785static void gen_label_die (tree, dw_die_ref); 3786static void gen_lexical_block_die (tree, dw_die_ref, int); 3787static void gen_inlined_subroutine_die (tree, dw_die_ref, int); 3788static void gen_field_die (tree, dw_die_ref); 3789static void gen_ptr_to_mbr_type_die (tree, dw_die_ref); 3790static dw_die_ref gen_compile_unit_die (const char *); 3791static void gen_string_type_die (tree, dw_die_ref); 3792static void gen_inheritance_die (tree, tree, dw_die_ref); 3793static void gen_member_die (tree, dw_die_ref); 3794static void gen_struct_or_union_type_die (tree, dw_die_ref); 3795static void gen_subroutine_type_die (tree, dw_die_ref); 3796static void gen_typedef_die (tree, dw_die_ref); 3797static void gen_type_die (tree, dw_die_ref); 3798static void gen_tagged_type_instantiation_die (tree, dw_die_ref); 3799static void gen_block_die (tree, dw_die_ref, int); 3800static void decls_for_scope (tree, dw_die_ref, int); 3801static int is_redundant_typedef (tree); 3802static void gen_namespace_die (tree); 3803static void gen_decl_die (tree, dw_die_ref); 3804static dw_die_ref force_namespace_die (tree); 3805static dw_die_ref setup_namespace_context (tree, dw_die_ref); 3806static void declare_in_namespace (tree, dw_die_ref); 3807static unsigned lookup_filename (const char *); 3808static void init_file_table (void); 3809static void retry_incomplete_types (void); 3810static void gen_type_die_for_member (tree, tree, dw_die_ref); 3811static void splice_child_die (dw_die_ref, dw_die_ref); 3812static int file_info_cmp (const void *, const void *); 3813static dw_loc_list_ref new_loc_list (dw_loc_descr_ref, const char *, 3814 const char *, const char *, unsigned); 3815static void add_loc_descr_to_loc_list (dw_loc_list_ref *, dw_loc_descr_ref, 3816 const char *, const char *, 3817 const char *); 3818static void output_loc_list (dw_loc_list_ref); 3819static char *gen_internal_sym (const char *); 3820 3821static void prune_unmark_dies (dw_die_ref); 3822static void prune_unused_types_mark (dw_die_ref, int); 3823static void prune_unused_types_walk (dw_die_ref); 3824static void prune_unused_types_walk_attribs (dw_die_ref); 3825static void prune_unused_types_prune (dw_die_ref); 3826static void prune_unused_types (void); 3827static int maybe_emit_file (int); 3828 3829/* Section names used to hold DWARF debugging information. */ 3830#ifndef DEBUG_INFO_SECTION 3831#define DEBUG_INFO_SECTION ".debug_info" 3832#endif 3833#ifndef DEBUG_ABBREV_SECTION 3834#define DEBUG_ABBREV_SECTION ".debug_abbrev" 3835#endif 3836#ifndef DEBUG_ARANGES_SECTION 3837#define DEBUG_ARANGES_SECTION ".debug_aranges" 3838#endif 3839#ifndef DEBUG_MACINFO_SECTION 3840#define DEBUG_MACINFO_SECTION ".debug_macinfo" 3841#endif 3842#ifndef DEBUG_LINE_SECTION 3843#define DEBUG_LINE_SECTION ".debug_line" 3844#endif 3845#ifndef DEBUG_LOC_SECTION 3846#define DEBUG_LOC_SECTION ".debug_loc" 3847#endif 3848#ifndef DEBUG_PUBNAMES_SECTION 3849#define DEBUG_PUBNAMES_SECTION ".debug_pubnames" 3850#endif 3851#ifndef DEBUG_STR_SECTION 3852#define DEBUG_STR_SECTION ".debug_str" 3853#endif 3854#ifndef DEBUG_RANGES_SECTION 3855#define DEBUG_RANGES_SECTION ".debug_ranges" 3856#endif 3857 3858/* Standard ELF section names for compiled code and data. */ 3859#ifndef TEXT_SECTION_NAME 3860#define TEXT_SECTION_NAME ".text" 3861#endif 3862 3863/* Section flags for .debug_str section. */ 3864#define DEBUG_STR_SECTION_FLAGS \ 3865 (HAVE_GAS_SHF_MERGE && flag_merge_constants \ 3866 ? SECTION_DEBUG | SECTION_MERGE | SECTION_STRINGS | 1 \ 3867 : SECTION_DEBUG) 3868 3869/* Labels we insert at beginning sections we can reference instead of 3870 the section names themselves. */ 3871 3872#ifndef TEXT_SECTION_LABEL 3873#define TEXT_SECTION_LABEL "Ltext" 3874#endif 3875#ifndef DEBUG_LINE_SECTION_LABEL 3876#define DEBUG_LINE_SECTION_LABEL "Ldebug_line" 3877#endif 3878#ifndef DEBUG_INFO_SECTION_LABEL 3879#define DEBUG_INFO_SECTION_LABEL "Ldebug_info" 3880#endif 3881#ifndef DEBUG_ABBREV_SECTION_LABEL 3882#define DEBUG_ABBREV_SECTION_LABEL "Ldebug_abbrev" 3883#endif 3884#ifndef DEBUG_LOC_SECTION_LABEL 3885#define DEBUG_LOC_SECTION_LABEL "Ldebug_loc" 3886#endif 3887#ifndef DEBUG_RANGES_SECTION_LABEL 3888#define DEBUG_RANGES_SECTION_LABEL "Ldebug_ranges" 3889#endif 3890#ifndef DEBUG_MACINFO_SECTION_LABEL 3891#define DEBUG_MACINFO_SECTION_LABEL "Ldebug_macinfo" 3892#endif 3893 3894/* Definitions of defaults for formats and names of various special 3895 (artificial) labels which may be generated within this file (when the -g 3896 options is used and DWARF2_DEBUGGING_INFO is in effect. 3897 If necessary, these may be overridden from within the tm.h file, but 3898 typically, overriding these defaults is unnecessary. */ 3899 3900static char text_end_label[MAX_ARTIFICIAL_LABEL_BYTES]; 3901static char text_section_label[MAX_ARTIFICIAL_LABEL_BYTES]; 3902static char abbrev_section_label[MAX_ARTIFICIAL_LABEL_BYTES]; 3903static char debug_info_section_label[MAX_ARTIFICIAL_LABEL_BYTES]; 3904static char debug_line_section_label[MAX_ARTIFICIAL_LABEL_BYTES]; 3905static char macinfo_section_label[MAX_ARTIFICIAL_LABEL_BYTES]; 3906static char loc_section_label[MAX_ARTIFICIAL_LABEL_BYTES]; 3907static char ranges_section_label[2 * MAX_ARTIFICIAL_LABEL_BYTES]; 3908 3909#ifndef TEXT_END_LABEL 3910#define TEXT_END_LABEL "Letext" 3911#endif 3912#ifndef BLOCK_BEGIN_LABEL 3913#define BLOCK_BEGIN_LABEL "LBB" 3914#endif 3915#ifndef BLOCK_END_LABEL 3916#define BLOCK_END_LABEL "LBE" 3917#endif 3918#ifndef LINE_CODE_LABEL 3919#define LINE_CODE_LABEL "LM" 3920#endif 3921#ifndef SEPARATE_LINE_CODE_LABEL 3922#define SEPARATE_LINE_CODE_LABEL "LSM" 3923#endif 3924 3925/* We allow a language front-end to designate a function that is to be 3926 called to "demangle" any name before it it put into a DIE. */ 3927 3928static const char *(*demangle_name_func) (const char *); 3929 3930void 3931dwarf2out_set_demangle_name_func (const char *(*func) (const char *)) 3932{ 3933 demangle_name_func = func; 3934} 3935 3936/* Test if rtl node points to a pseudo register. */ 3937 3938static inline int 3939is_pseudo_reg (rtx rtl) 3940{ 3941 return ((GET_CODE (rtl) == REG && REGNO (rtl) >= FIRST_PSEUDO_REGISTER) 3942 || (GET_CODE (rtl) == SUBREG 3943 && REGNO (SUBREG_REG (rtl)) >= FIRST_PSEUDO_REGISTER)); 3944} 3945 3946/* Return a reference to a type, with its const and volatile qualifiers 3947 removed. */ 3948 3949static inline tree 3950type_main_variant (tree type) 3951{ 3952 type = TYPE_MAIN_VARIANT (type); 3953 3954 /* ??? There really should be only one main variant among any group of 3955 variants of a given type (and all of the MAIN_VARIANT values for all 3956 members of the group should point to that one type) but sometimes the C 3957 front-end messes this up for array types, so we work around that bug 3958 here. */ 3959 if (TREE_CODE (type) == ARRAY_TYPE) 3960 while (type != TYPE_MAIN_VARIANT (type)) 3961 type = TYPE_MAIN_VARIANT (type); 3962 3963 return type; 3964} 3965 3966/* Return nonzero if the given type node represents a tagged type. */ 3967 3968static inline int 3969is_tagged_type (tree type) 3970{ 3971 enum tree_code code = TREE_CODE (type); 3972 3973 return (code == RECORD_TYPE || code == UNION_TYPE 3974 || code == QUAL_UNION_TYPE || code == ENUMERAL_TYPE); 3975} 3976 3977/* Convert a DIE tag into its string name. */ 3978 3979static const char * 3980dwarf_tag_name (unsigned int tag) 3981{ 3982 switch (tag) 3983 { 3984 case DW_TAG_padding: 3985 return "DW_TAG_padding"; 3986 case DW_TAG_array_type: 3987 return "DW_TAG_array_type"; 3988 case DW_TAG_class_type: 3989 return "DW_TAG_class_type"; 3990 case DW_TAG_entry_point: 3991 return "DW_TAG_entry_point"; 3992 case DW_TAG_enumeration_type: 3993 return "DW_TAG_enumeration_type"; 3994 case DW_TAG_formal_parameter: 3995 return "DW_TAG_formal_parameter"; 3996 case DW_TAG_imported_declaration: 3997 return "DW_TAG_imported_declaration"; 3998 case DW_TAG_label: 3999 return "DW_TAG_label"; 4000 case DW_TAG_lexical_block: 4001 return "DW_TAG_lexical_block"; 4002 case DW_TAG_member: 4003 return "DW_TAG_member"; 4004 case DW_TAG_pointer_type: 4005 return "DW_TAG_pointer_type"; 4006 case DW_TAG_reference_type: 4007 return "DW_TAG_reference_type"; 4008 case DW_TAG_compile_unit: 4009 return "DW_TAG_compile_unit"; 4010 case DW_TAG_string_type: 4011 return "DW_TAG_string_type"; 4012 case DW_TAG_structure_type: 4013 return "DW_TAG_structure_type"; 4014 case DW_TAG_subroutine_type: 4015 return "DW_TAG_subroutine_type"; 4016 case DW_TAG_typedef: 4017 return "DW_TAG_typedef"; 4018 case DW_TAG_union_type: 4019 return "DW_TAG_union_type"; 4020 case DW_TAG_unspecified_parameters: 4021 return "DW_TAG_unspecified_parameters"; 4022 case DW_TAG_variant: 4023 return "DW_TAG_variant"; 4024 case DW_TAG_common_block: 4025 return "DW_TAG_common_block"; 4026 case DW_TAG_common_inclusion: 4027 return "DW_TAG_common_inclusion"; 4028 case DW_TAG_inheritance: 4029 return "DW_TAG_inheritance"; 4030 case DW_TAG_inlined_subroutine: 4031 return "DW_TAG_inlined_subroutine"; 4032 case DW_TAG_module: 4033 return "DW_TAG_module"; 4034 case DW_TAG_ptr_to_member_type: 4035 return "DW_TAG_ptr_to_member_type"; 4036 case DW_TAG_set_type: 4037 return "DW_TAG_set_type"; 4038 case DW_TAG_subrange_type: 4039 return "DW_TAG_subrange_type"; 4040 case DW_TAG_with_stmt: 4041 return "DW_TAG_with_stmt"; 4042 case DW_TAG_access_declaration: 4043 return "DW_TAG_access_declaration"; 4044 case DW_TAG_base_type: 4045 return "DW_TAG_base_type"; 4046 case DW_TAG_catch_block: 4047 return "DW_TAG_catch_block"; 4048 case DW_TAG_const_type: 4049 return "DW_TAG_const_type"; 4050 case DW_TAG_constant: 4051 return "DW_TAG_constant"; 4052 case DW_TAG_enumerator: 4053 return "DW_TAG_enumerator"; 4054 case DW_TAG_file_type: 4055 return "DW_TAG_file_type"; 4056 case DW_TAG_friend: 4057 return "DW_TAG_friend"; 4058 case DW_TAG_namelist: 4059 return "DW_TAG_namelist"; 4060 case DW_TAG_namelist_item: 4061 return "DW_TAG_namelist_item"; 4062 case DW_TAG_namespace: 4063 return "DW_TAG_namespace"; 4064 case DW_TAG_packed_type: 4065 return "DW_TAG_packed_type"; 4066 case DW_TAG_subprogram: 4067 return "DW_TAG_subprogram"; 4068 case DW_TAG_template_type_param: 4069 return "DW_TAG_template_type_param"; 4070 case DW_TAG_template_value_param: 4071 return "DW_TAG_template_value_param"; 4072 case DW_TAG_thrown_type: 4073 return "DW_TAG_thrown_type"; 4074 case DW_TAG_try_block: 4075 return "DW_TAG_try_block"; 4076 case DW_TAG_variant_part: 4077 return "DW_TAG_variant_part"; 4078 case DW_TAG_variable: 4079 return "DW_TAG_variable"; 4080 case DW_TAG_volatile_type: 4081 return "DW_TAG_volatile_type"; 4082 case DW_TAG_MIPS_loop: 4083 return "DW_TAG_MIPS_loop"; 4084 case DW_TAG_format_label: 4085 return "DW_TAG_format_label"; 4086 case DW_TAG_function_template: 4087 return "DW_TAG_function_template"; 4088 case DW_TAG_class_template: 4089 return "DW_TAG_class_template"; 4090 case DW_TAG_GNU_BINCL: 4091 return "DW_TAG_GNU_BINCL"; 4092 case DW_TAG_GNU_EINCL: 4093 return "DW_TAG_GNU_EINCL"; 4094 default: 4095 return "DW_TAG_<unknown>"; 4096 } 4097} 4098 4099/* Convert a DWARF attribute code into its string name. */ 4100 4101static const char * 4102dwarf_attr_name (unsigned int attr) 4103{ 4104 switch (attr) 4105 { 4106 case DW_AT_sibling: 4107 return "DW_AT_sibling"; 4108 case DW_AT_location: 4109 return "DW_AT_location"; 4110 case DW_AT_name: 4111 return "DW_AT_name"; 4112 case DW_AT_ordering: 4113 return "DW_AT_ordering"; 4114 case DW_AT_subscr_data: 4115 return "DW_AT_subscr_data"; 4116 case DW_AT_byte_size: 4117 return "DW_AT_byte_size"; 4118 case DW_AT_bit_offset: 4119 return "DW_AT_bit_offset"; 4120 case DW_AT_bit_size: 4121 return "DW_AT_bit_size"; 4122 case DW_AT_element_list: 4123 return "DW_AT_element_list"; 4124 case DW_AT_stmt_list: 4125 return "DW_AT_stmt_list"; 4126 case DW_AT_low_pc: 4127 return "DW_AT_low_pc"; 4128 case DW_AT_high_pc: 4129 return "DW_AT_high_pc"; 4130 case DW_AT_language: 4131 return "DW_AT_language"; 4132 case DW_AT_member: 4133 return "DW_AT_member"; 4134 case DW_AT_discr: 4135 return "DW_AT_discr"; 4136 case DW_AT_discr_value: 4137 return "DW_AT_discr_value"; 4138 case DW_AT_visibility: 4139 return "DW_AT_visibility"; 4140 case DW_AT_import: 4141 return "DW_AT_import"; 4142 case DW_AT_string_length: 4143 return "DW_AT_string_length"; 4144 case DW_AT_common_reference: 4145 return "DW_AT_common_reference"; 4146 case DW_AT_comp_dir: 4147 return "DW_AT_comp_dir"; 4148 case DW_AT_const_value: 4149 return "DW_AT_const_value"; 4150 case DW_AT_containing_type: 4151 return "DW_AT_containing_type"; 4152 case DW_AT_default_value: 4153 return "DW_AT_default_value"; 4154 case DW_AT_inline: 4155 return "DW_AT_inline"; 4156 case DW_AT_is_optional: 4157 return "DW_AT_is_optional"; 4158 case DW_AT_lower_bound: 4159 return "DW_AT_lower_bound"; 4160 case DW_AT_producer: 4161 return "DW_AT_producer"; 4162 case DW_AT_prototyped: 4163 return "DW_AT_prototyped"; 4164 case DW_AT_return_addr: 4165 return "DW_AT_return_addr"; 4166 case DW_AT_start_scope: 4167 return "DW_AT_start_scope"; 4168 case DW_AT_stride_size: 4169 return "DW_AT_stride_size"; 4170 case DW_AT_upper_bound: 4171 return "DW_AT_upper_bound"; 4172 case DW_AT_abstract_origin: 4173 return "DW_AT_abstract_origin"; 4174 case DW_AT_accessibility: 4175 return "DW_AT_accessibility"; 4176 case DW_AT_address_class: 4177 return "DW_AT_address_class"; 4178 case DW_AT_artificial: 4179 return "DW_AT_artificial"; 4180 case DW_AT_base_types: 4181 return "DW_AT_base_types"; 4182 case DW_AT_calling_convention: 4183 return "DW_AT_calling_convention"; 4184 case DW_AT_count: 4185 return "DW_AT_count"; 4186 case DW_AT_data_member_location: 4187 return "DW_AT_data_member_location"; 4188 case DW_AT_decl_column: 4189 return "DW_AT_decl_column"; 4190 case DW_AT_decl_file: 4191 return "DW_AT_decl_file"; 4192 case DW_AT_decl_line: 4193 return "DW_AT_decl_line"; 4194 case DW_AT_declaration: 4195 return "DW_AT_declaration"; 4196 case DW_AT_discr_list: 4197 return "DW_AT_discr_list"; 4198 case DW_AT_encoding: 4199 return "DW_AT_encoding"; 4200 case DW_AT_external: 4201 return "DW_AT_external"; 4202 case DW_AT_frame_base: 4203 return "DW_AT_frame_base"; 4204 case DW_AT_friend: 4205 return "DW_AT_friend"; 4206 case DW_AT_identifier_case: 4207 return "DW_AT_identifier_case"; 4208 case DW_AT_macro_info: 4209 return "DW_AT_macro_info"; 4210 case DW_AT_namelist_items: 4211 return "DW_AT_namelist_items"; 4212 case DW_AT_priority: 4213 return "DW_AT_priority"; 4214 case DW_AT_segment: 4215 return "DW_AT_segment"; 4216 case DW_AT_specification: 4217 return "DW_AT_specification"; 4218 case DW_AT_static_link: 4219 return "DW_AT_static_link"; 4220 case DW_AT_type: 4221 return "DW_AT_type"; 4222 case DW_AT_use_location: 4223 return "DW_AT_use_location"; 4224 case DW_AT_variable_parameter: 4225 return "DW_AT_variable_parameter"; 4226 case DW_AT_virtuality: 4227 return "DW_AT_virtuality"; 4228 case DW_AT_vtable_elem_location: 4229 return "DW_AT_vtable_elem_location"; 4230 4231 case DW_AT_allocated: 4232 return "DW_AT_allocated"; 4233 case DW_AT_associated: 4234 return "DW_AT_associated"; 4235 case DW_AT_data_location: 4236 return "DW_AT_data_location"; 4237 case DW_AT_stride: 4238 return "DW_AT_stride"; 4239 case DW_AT_entry_pc: 4240 return "DW_AT_entry_pc"; 4241 case DW_AT_use_UTF8: 4242 return "DW_AT_use_UTF8"; 4243 case DW_AT_extension: 4244 return "DW_AT_extension"; 4245 case DW_AT_ranges: 4246 return "DW_AT_ranges"; 4247 case DW_AT_trampoline: 4248 return "DW_AT_trampoline"; 4249 case DW_AT_call_column: 4250 return "DW_AT_call_column"; 4251 case DW_AT_call_file: 4252 return "DW_AT_call_file"; 4253 case DW_AT_call_line: 4254 return "DW_AT_call_line"; 4255 4256 case DW_AT_MIPS_fde: 4257 return "DW_AT_MIPS_fde"; 4258 case DW_AT_MIPS_loop_begin: 4259 return "DW_AT_MIPS_loop_begin"; 4260 case DW_AT_MIPS_tail_loop_begin: 4261 return "DW_AT_MIPS_tail_loop_begin"; 4262 case DW_AT_MIPS_epilog_begin: 4263 return "DW_AT_MIPS_epilog_begin"; 4264 case DW_AT_MIPS_loop_unroll_factor: 4265 return "DW_AT_MIPS_loop_unroll_factor"; 4266 case DW_AT_MIPS_software_pipeline_depth: 4267 return "DW_AT_MIPS_software_pipeline_depth"; 4268 case DW_AT_MIPS_linkage_name: 4269 return "DW_AT_MIPS_linkage_name"; 4270 case DW_AT_MIPS_stride: 4271 return "DW_AT_MIPS_stride"; 4272 case DW_AT_MIPS_abstract_name: 4273 return "DW_AT_MIPS_abstract_name"; 4274 case DW_AT_MIPS_clone_origin: 4275 return "DW_AT_MIPS_clone_origin"; 4276 case DW_AT_MIPS_has_inlines: 4277 return "DW_AT_MIPS_has_inlines"; 4278 4279 case DW_AT_sf_names: 4280 return "DW_AT_sf_names"; 4281 case DW_AT_src_info: 4282 return "DW_AT_src_info"; 4283 case DW_AT_mac_info: 4284 return "DW_AT_mac_info"; 4285 case DW_AT_src_coords: 4286 return "DW_AT_src_coords"; 4287 case DW_AT_body_begin: 4288 return "DW_AT_body_begin"; 4289 case DW_AT_body_end: 4290 return "DW_AT_body_end"; 4291 case DW_AT_GNU_vector: 4292 return "DW_AT_GNU_vector"; 4293 4294 case DW_AT_VMS_rtnbeg_pd_address: 4295 return "DW_AT_VMS_rtnbeg_pd_address"; 4296 4297 default: 4298 return "DW_AT_<unknown>"; 4299 } 4300} 4301 4302/* Convert a DWARF value form code into its string name. */ 4303 4304static const char * 4305dwarf_form_name (unsigned int form) 4306{ 4307 switch (form) 4308 { 4309 case DW_FORM_addr: 4310 return "DW_FORM_addr"; 4311 case DW_FORM_block2: 4312 return "DW_FORM_block2"; 4313 case DW_FORM_block4: 4314 return "DW_FORM_block4"; 4315 case DW_FORM_data2: 4316 return "DW_FORM_data2"; 4317 case DW_FORM_data4: 4318 return "DW_FORM_data4"; 4319 case DW_FORM_data8: 4320 return "DW_FORM_data8"; 4321 case DW_FORM_string: 4322 return "DW_FORM_string"; 4323 case DW_FORM_block: 4324 return "DW_FORM_block"; 4325 case DW_FORM_block1: 4326 return "DW_FORM_block1"; 4327 case DW_FORM_data1: 4328 return "DW_FORM_data1"; 4329 case DW_FORM_flag: 4330 return "DW_FORM_flag"; 4331 case DW_FORM_sdata: 4332 return "DW_FORM_sdata"; 4333 case DW_FORM_strp: 4334 return "DW_FORM_strp"; 4335 case DW_FORM_udata: 4336 return "DW_FORM_udata"; 4337 case DW_FORM_ref_addr: 4338 return "DW_FORM_ref_addr"; 4339 case DW_FORM_ref1: 4340 return "DW_FORM_ref1"; 4341 case DW_FORM_ref2: 4342 return "DW_FORM_ref2"; 4343 case DW_FORM_ref4: 4344 return "DW_FORM_ref4"; 4345 case DW_FORM_ref8: 4346 return "DW_FORM_ref8"; 4347 case DW_FORM_ref_udata: 4348 return "DW_FORM_ref_udata"; 4349 case DW_FORM_indirect: 4350 return "DW_FORM_indirect"; 4351 default: 4352 return "DW_FORM_<unknown>"; 4353 } 4354} 4355 4356/* Convert a DWARF type code into its string name. */ 4357 4358#if 0 4359static const char * 4360dwarf_type_encoding_name (unsigned enc) 4361{ 4362 switch (enc) 4363 { 4364 case DW_ATE_address: 4365 return "DW_ATE_address"; 4366 case DW_ATE_boolean: 4367 return "DW_ATE_boolean"; 4368 case DW_ATE_complex_float: 4369 return "DW_ATE_complex_float"; 4370 case DW_ATE_float: 4371 return "DW_ATE_float"; 4372 case DW_ATE_signed: 4373 return "DW_ATE_signed"; 4374 case DW_ATE_signed_char: 4375 return "DW_ATE_signed_char"; 4376 case DW_ATE_unsigned: 4377 return "DW_ATE_unsigned"; 4378 case DW_ATE_unsigned_char: 4379 return "DW_ATE_unsigned_char"; 4380 default: 4381 return "DW_ATE_<unknown>"; 4382 } 4383} 4384#endif 4385 4386/* Determine the "ultimate origin" of a decl. The decl may be an inlined 4387 instance of an inlined instance of a decl which is local to an inline 4388 function, so we have to trace all of the way back through the origin chain 4389 to find out what sort of node actually served as the original seed for the 4390 given block. */ 4391 4392static tree 4393decl_ultimate_origin (tree decl) 4394{ 4395 /* output_inline_function sets DECL_ABSTRACT_ORIGIN for all the 4396 nodes in the function to point to themselves; ignore that if 4397 we're trying to output the abstract instance of this function. */ 4398 if (DECL_ABSTRACT (decl) && DECL_ABSTRACT_ORIGIN (decl) == decl) 4399 return NULL_TREE; 4400 4401#ifdef ENABLE_CHECKING 4402 if (DECL_FROM_INLINE (DECL_ORIGIN (decl))) 4403 /* Since the DECL_ABSTRACT_ORIGIN for a DECL is supposed to be the 4404 most distant ancestor, this should never happen. */ 4405 abort (); 4406#endif 4407 4408 return DECL_ABSTRACT_ORIGIN (decl); 4409} 4410 4411/* Determine the "ultimate origin" of a block. The block may be an inlined 4412 instance of an inlined instance of a block which is local to an inline 4413 function, so we have to trace all of the way back through the origin chain 4414 to find out what sort of node actually served as the original seed for the 4415 given block. */ 4416 4417static tree 4418block_ultimate_origin (tree block) 4419{ 4420 tree immediate_origin = BLOCK_ABSTRACT_ORIGIN (block); 4421 4422 /* output_inline_function sets BLOCK_ABSTRACT_ORIGIN for all the 4423 nodes in the function to point to themselves; ignore that if 4424 we're trying to output the abstract instance of this function. */ 4425 if (BLOCK_ABSTRACT (block) && immediate_origin == block) 4426 return NULL_TREE; 4427 4428 if (immediate_origin == NULL_TREE) 4429 return NULL_TREE; 4430 else 4431 { 4432 tree ret_val; 4433 tree lookahead = immediate_origin; 4434 4435 do 4436 { 4437 ret_val = lookahead; 4438 lookahead = (TREE_CODE (ret_val) == BLOCK 4439 ? BLOCK_ABSTRACT_ORIGIN (ret_val) : NULL); 4440 } 4441 while (lookahead != NULL && lookahead != ret_val); 4442 4443 return ret_val; 4444 } 4445} 4446 4447/* Get the class to which DECL belongs, if any. In g++, the DECL_CONTEXT 4448 of a virtual function may refer to a base class, so we check the 'this' 4449 parameter. */ 4450 4451static tree 4452decl_class_context (tree decl) 4453{ 4454 tree context = NULL_TREE; 4455 4456 if (TREE_CODE (decl) != FUNCTION_DECL || ! DECL_VINDEX (decl)) 4457 context = DECL_CONTEXT (decl); 4458 else 4459 context = TYPE_MAIN_VARIANT 4460 (TREE_TYPE (TREE_VALUE (TYPE_ARG_TYPES (TREE_TYPE (decl))))); 4461 4462 if (context && !TYPE_P (context)) 4463 context = NULL_TREE; 4464 4465 return context; 4466} 4467 4468/* Add an attribute/value pair to a DIE. We build the lists up in reverse 4469 addition order, and correct that in reverse_all_dies. */ 4470 4471static inline void 4472add_dwarf_attr (dw_die_ref die, dw_attr_ref attr) 4473{ 4474 if (die != NULL && attr != NULL) 4475 { 4476 attr->dw_attr_next = die->die_attr; 4477 die->die_attr = attr; 4478 } 4479} 4480 4481static inline enum dw_val_class 4482AT_class (dw_attr_ref a) 4483{ 4484 return a->dw_attr_val.val_class; 4485} 4486 4487/* Add a flag value attribute to a DIE. */ 4488 4489static inline void 4490add_AT_flag (dw_die_ref die, enum dwarf_attribute attr_kind, unsigned int flag) 4491{ 4492 dw_attr_ref attr = ggc_alloc (sizeof (dw_attr_node)); 4493 4494 attr->dw_attr_next = NULL; 4495 attr->dw_attr = attr_kind; 4496 attr->dw_attr_val.val_class = dw_val_class_flag; 4497 attr->dw_attr_val.v.val_flag = flag; 4498 add_dwarf_attr (die, attr); 4499} 4500 4501static inline unsigned 4502AT_flag (dw_attr_ref a) 4503{ 4504 if (a && AT_class (a) == dw_val_class_flag) 4505 return a->dw_attr_val.v.val_flag; 4506 4507 abort (); 4508} 4509 4510/* Add a signed integer attribute value to a DIE. */ 4511 4512static inline void 4513add_AT_int (dw_die_ref die, enum dwarf_attribute attr_kind, HOST_WIDE_INT int_val) 4514{ 4515 dw_attr_ref attr = ggc_alloc (sizeof (dw_attr_node)); 4516 4517 attr->dw_attr_next = NULL; 4518 attr->dw_attr = attr_kind; 4519 attr->dw_attr_val.val_class = dw_val_class_const; 4520 attr->dw_attr_val.v.val_int = int_val; 4521 add_dwarf_attr (die, attr); 4522} 4523 4524static inline HOST_WIDE_INT 4525AT_int (dw_attr_ref a) 4526{ 4527 if (a && AT_class (a) == dw_val_class_const) 4528 return a->dw_attr_val.v.val_int; 4529 4530 abort (); 4531} 4532 4533/* Add an unsigned integer attribute value to a DIE. */ 4534 4535static inline void 4536add_AT_unsigned (dw_die_ref die, enum dwarf_attribute attr_kind, 4537 unsigned HOST_WIDE_INT unsigned_val) 4538{ 4539 dw_attr_ref attr = ggc_alloc (sizeof (dw_attr_node)); 4540 4541 attr->dw_attr_next = NULL; 4542 attr->dw_attr = attr_kind; 4543 attr->dw_attr_val.val_class = dw_val_class_unsigned_const; 4544 attr->dw_attr_val.v.val_unsigned = unsigned_val; 4545 add_dwarf_attr (die, attr); 4546} 4547 4548static inline unsigned HOST_WIDE_INT 4549AT_unsigned (dw_attr_ref a) 4550{ 4551 if (a && AT_class (a) == dw_val_class_unsigned_const) 4552 return a->dw_attr_val.v.val_unsigned; 4553 4554 abort (); 4555} 4556 4557/* Add an unsigned double integer attribute value to a DIE. */ 4558 4559static inline void 4560add_AT_long_long (dw_die_ref die, enum dwarf_attribute attr_kind, 4561 long unsigned int val_hi, long unsigned int val_low) 4562{ 4563 dw_attr_ref attr = ggc_alloc (sizeof (dw_attr_node)); 4564 4565 attr->dw_attr_next = NULL; 4566 attr->dw_attr = attr_kind; 4567 attr->dw_attr_val.val_class = dw_val_class_long_long; 4568 attr->dw_attr_val.v.val_long_long.hi = val_hi; 4569 attr->dw_attr_val.v.val_long_long.low = val_low; 4570 add_dwarf_attr (die, attr); 4571} 4572 4573/* Add a floating point attribute value to a DIE and return it. */ 4574 4575static inline void 4576add_AT_vec (dw_die_ref die, enum dwarf_attribute attr_kind, 4577 unsigned int length, unsigned int elt_size, unsigned char *array) 4578{ 4579 dw_attr_ref attr = ggc_alloc (sizeof (dw_attr_node)); 4580 4581 attr->dw_attr_next = NULL; 4582 attr->dw_attr = attr_kind; 4583 attr->dw_attr_val.val_class = dw_val_class_vec; 4584 attr->dw_attr_val.v.val_vec.length = length; 4585 attr->dw_attr_val.v.val_vec.elt_size = elt_size; 4586 attr->dw_attr_val.v.val_vec.array = array; 4587 add_dwarf_attr (die, attr); 4588} 4589 4590/* Hash and equality functions for debug_str_hash. */ 4591 4592static hashval_t 4593debug_str_do_hash (const void *x) 4594{ 4595 return htab_hash_string (((const struct indirect_string_node *)x)->str); 4596} 4597 4598static int 4599debug_str_eq (const void *x1, const void *x2) 4600{ 4601 return strcmp ((((const struct indirect_string_node *)x1)->str), 4602 (const char *)x2) == 0; 4603} 4604 4605/* Add a string attribute value to a DIE. */ 4606 4607static inline void 4608add_AT_string (dw_die_ref die, enum dwarf_attribute attr_kind, const char *str) 4609{ 4610 dw_attr_ref attr = ggc_alloc (sizeof (dw_attr_node)); 4611 struct indirect_string_node *node; 4612 void **slot; 4613 4614 if (! debug_str_hash) 4615 debug_str_hash = htab_create_ggc (10, debug_str_do_hash, 4616 debug_str_eq, NULL); 4617 4618 slot = htab_find_slot_with_hash (debug_str_hash, str, 4619 htab_hash_string (str), INSERT); 4620 if (*slot == NULL) 4621 *slot = ggc_alloc_cleared (sizeof (struct indirect_string_node)); 4622 node = (struct indirect_string_node *) *slot; 4623 node->str = ggc_strdup (str); 4624 node->refcount++; 4625 4626 attr->dw_attr_next = NULL; 4627 attr->dw_attr = attr_kind; 4628 attr->dw_attr_val.val_class = dw_val_class_str; 4629 attr->dw_attr_val.v.val_str = node; 4630 add_dwarf_attr (die, attr); 4631} 4632 4633static inline const char * 4634AT_string (dw_attr_ref a) 4635{ 4636 if (a && AT_class (a) == dw_val_class_str) 4637 return a->dw_attr_val.v.val_str->str; 4638 4639 abort (); 4640} 4641 4642/* Find out whether a string should be output inline in DIE 4643 or out-of-line in .debug_str section. */ 4644 4645static int 4646AT_string_form (dw_attr_ref a) 4647{ 4648 if (a && AT_class (a) == dw_val_class_str) 4649 { 4650 struct indirect_string_node *node; 4651 unsigned int len; 4652 char label[32]; 4653 4654 node = a->dw_attr_val.v.val_str; 4655 if (node->form) 4656 return node->form; 4657 4658 len = strlen (node->str) + 1; 4659 4660 /* If the string is shorter or equal to the size of the reference, it is 4661 always better to put it inline. */ 4662 if (len <= DWARF_OFFSET_SIZE || node->refcount == 0) 4663 return node->form = DW_FORM_string; 4664 4665 /* If we cannot expect the linker to merge strings in .debug_str 4666 section, only put it into .debug_str if it is worth even in this 4667 single module. */ 4668 if ((DEBUG_STR_SECTION_FLAGS & SECTION_MERGE) == 0 4669 && (len - DWARF_OFFSET_SIZE) * node->refcount <= len) 4670 return node->form = DW_FORM_string; 4671 4672 ASM_GENERATE_INTERNAL_LABEL (label, "LASF", dw2_string_counter); 4673 ++dw2_string_counter; 4674 node->label = xstrdup (label); 4675 4676 return node->form = DW_FORM_strp; 4677 } 4678 4679 abort (); 4680} 4681 4682/* Add a DIE reference attribute value to a DIE. */ 4683 4684static inline void 4685add_AT_die_ref (dw_die_ref die, enum dwarf_attribute attr_kind, dw_die_ref targ_die) 4686{ 4687 dw_attr_ref attr = ggc_alloc (sizeof (dw_attr_node)); 4688 4689 attr->dw_attr_next = NULL; 4690 attr->dw_attr = attr_kind; 4691 attr->dw_attr_val.val_class = dw_val_class_die_ref; 4692 attr->dw_attr_val.v.val_die_ref.die = targ_die; 4693 attr->dw_attr_val.v.val_die_ref.external = 0; 4694 add_dwarf_attr (die, attr); 4695} 4696 4697/* Add an AT_specification attribute to a DIE, and also make the back 4698 pointer from the specification to the definition. */ 4699 4700static inline void 4701add_AT_specification (dw_die_ref die, dw_die_ref targ_die) 4702{ 4703 add_AT_die_ref (die, DW_AT_specification, targ_die); 4704 if (targ_die->die_definition) 4705 abort (); 4706 targ_die->die_definition = die; 4707} 4708 4709static inline dw_die_ref 4710AT_ref (dw_attr_ref a) 4711{ 4712 if (a && AT_class (a) == dw_val_class_die_ref) 4713 return a->dw_attr_val.v.val_die_ref.die; 4714 4715 abort (); 4716} 4717 4718static inline int 4719AT_ref_external (dw_attr_ref a) 4720{ 4721 if (a && AT_class (a) == dw_val_class_die_ref) 4722 return a->dw_attr_val.v.val_die_ref.external; 4723 4724 return 0; 4725} 4726 4727static inline void 4728set_AT_ref_external (dw_attr_ref a, int i) 4729{ 4730 if (a && AT_class (a) == dw_val_class_die_ref) 4731 a->dw_attr_val.v.val_die_ref.external = i; 4732 else 4733 abort (); 4734} 4735 4736/* Add an FDE reference attribute value to a DIE. */ 4737 4738static inline void 4739add_AT_fde_ref (dw_die_ref die, enum dwarf_attribute attr_kind, unsigned int targ_fde) 4740{ 4741 dw_attr_ref attr = ggc_alloc (sizeof (dw_attr_node)); 4742 4743 attr->dw_attr_next = NULL; 4744 attr->dw_attr = attr_kind; 4745 attr->dw_attr_val.val_class = dw_val_class_fde_ref; 4746 attr->dw_attr_val.v.val_fde_index = targ_fde; 4747 add_dwarf_attr (die, attr); 4748} 4749 4750/* Add a location description attribute value to a DIE. */ 4751 4752static inline void 4753add_AT_loc (dw_die_ref die, enum dwarf_attribute attr_kind, dw_loc_descr_ref loc) 4754{ 4755 dw_attr_ref attr = ggc_alloc (sizeof (dw_attr_node)); 4756 4757 attr->dw_attr_next = NULL; 4758 attr->dw_attr = attr_kind; 4759 attr->dw_attr_val.val_class = dw_val_class_loc; 4760 attr->dw_attr_val.v.val_loc = loc; 4761 add_dwarf_attr (die, attr); 4762} 4763 4764static inline dw_loc_descr_ref 4765AT_loc (dw_attr_ref a) 4766{ 4767 if (a && AT_class (a) == dw_val_class_loc) 4768 return a->dw_attr_val.v.val_loc; 4769 4770 abort (); 4771} 4772 4773static inline void 4774add_AT_loc_list (dw_die_ref die, enum dwarf_attribute attr_kind, dw_loc_list_ref loc_list) 4775{ 4776 dw_attr_ref attr = ggc_alloc (sizeof (dw_attr_node)); 4777 4778 attr->dw_attr_next = NULL; 4779 attr->dw_attr = attr_kind; 4780 attr->dw_attr_val.val_class = dw_val_class_loc_list; 4781 attr->dw_attr_val.v.val_loc_list = loc_list; 4782 add_dwarf_attr (die, attr); 4783 have_location_lists = 1; 4784} 4785 4786static inline dw_loc_list_ref 4787AT_loc_list (dw_attr_ref a) 4788{ 4789 if (a && AT_class (a) == dw_val_class_loc_list) 4790 return a->dw_attr_val.v.val_loc_list; 4791 4792 abort (); 4793} 4794 4795/* Add an address constant attribute value to a DIE. */ 4796 4797static inline void 4798add_AT_addr (dw_die_ref die, enum dwarf_attribute attr_kind, rtx addr) 4799{ 4800 dw_attr_ref attr = ggc_alloc (sizeof (dw_attr_node)); 4801 4802 attr->dw_attr_next = NULL; 4803 attr->dw_attr = attr_kind; 4804 attr->dw_attr_val.val_class = dw_val_class_addr; 4805 attr->dw_attr_val.v.val_addr = addr; 4806 add_dwarf_attr (die, attr); 4807} 4808 4809static inline rtx 4810AT_addr (dw_attr_ref a) 4811{ 4812 if (a && AT_class (a) == dw_val_class_addr) 4813 return a->dw_attr_val.v.val_addr; 4814 4815 abort (); 4816} 4817 4818/* Add a label identifier attribute value to a DIE. */ 4819 4820static inline void 4821add_AT_lbl_id (dw_die_ref die, enum dwarf_attribute attr_kind, const char *lbl_id) 4822{ 4823 dw_attr_ref attr = ggc_alloc (sizeof (dw_attr_node)); 4824 4825 attr->dw_attr_next = NULL; 4826 attr->dw_attr = attr_kind; 4827 attr->dw_attr_val.val_class = dw_val_class_lbl_id; 4828 attr->dw_attr_val.v.val_lbl_id = xstrdup (lbl_id); 4829 add_dwarf_attr (die, attr); 4830} 4831 4832/* Add a section offset attribute value to a DIE. */ 4833 4834static inline void 4835add_AT_lbl_offset (dw_die_ref die, enum dwarf_attribute attr_kind, const char *label) 4836{ 4837 dw_attr_ref attr = ggc_alloc (sizeof (dw_attr_node)); 4838 4839 attr->dw_attr_next = NULL; 4840 attr->dw_attr = attr_kind; 4841 attr->dw_attr_val.val_class = dw_val_class_lbl_offset; 4842 attr->dw_attr_val.v.val_lbl_id = xstrdup (label); 4843 add_dwarf_attr (die, attr); 4844} 4845 4846/* Add an offset attribute value to a DIE. */ 4847 4848static inline void 4849add_AT_offset (dw_die_ref die, enum dwarf_attribute attr_kind, 4850 unsigned HOST_WIDE_INT offset) 4851{ 4852 dw_attr_ref attr = ggc_alloc (sizeof (dw_attr_node)); 4853 4854 attr->dw_attr_next = NULL; 4855 attr->dw_attr = attr_kind; 4856 attr->dw_attr_val.val_class = dw_val_class_offset; 4857 attr->dw_attr_val.v.val_offset = offset; 4858 add_dwarf_attr (die, attr); 4859} 4860 4861/* Add an range_list attribute value to a DIE. */ 4862 4863static void 4864add_AT_range_list (dw_die_ref die, enum dwarf_attribute attr_kind, 4865 long unsigned int offset) 4866{ 4867 dw_attr_ref attr = ggc_alloc (sizeof (dw_attr_node)); 4868 4869 attr->dw_attr_next = NULL; 4870 attr->dw_attr = attr_kind; 4871 attr->dw_attr_val.val_class = dw_val_class_range_list; 4872 attr->dw_attr_val.v.val_offset = offset; 4873 add_dwarf_attr (die, attr); 4874} 4875 4876static inline const char * 4877AT_lbl (dw_attr_ref a) 4878{ 4879 if (a && (AT_class (a) == dw_val_class_lbl_id 4880 || AT_class (a) == dw_val_class_lbl_offset)) 4881 return a->dw_attr_val.v.val_lbl_id; 4882 4883 abort (); 4884} 4885 4886/* Get the attribute of type attr_kind. */ 4887 4888static dw_attr_ref 4889get_AT (dw_die_ref die, enum dwarf_attribute attr_kind) 4890{ 4891 dw_attr_ref a; 4892 dw_die_ref spec = NULL; 4893 4894 if (die != NULL) 4895 { 4896 for (a = die->die_attr; a != NULL; a = a->dw_attr_next) 4897 if (a->dw_attr == attr_kind) 4898 return a; 4899 else if (a->dw_attr == DW_AT_specification 4900 || a->dw_attr == DW_AT_abstract_origin) 4901 spec = AT_ref (a); 4902 4903 if (spec) 4904 return get_AT (spec, attr_kind); 4905 } 4906 4907 return NULL; 4908} 4909 4910/* Return the "low pc" attribute value, typically associated with a subprogram 4911 DIE. Return null if the "low pc" attribute is either not present, or if it 4912 cannot be represented as an assembler label identifier. */ 4913 4914static inline const char * 4915get_AT_low_pc (dw_die_ref die) 4916{ 4917 dw_attr_ref a = get_AT (die, DW_AT_low_pc); 4918 4919 return a ? AT_lbl (a) : NULL; 4920} 4921 4922/* Return the "high pc" attribute value, typically associated with a subprogram 4923 DIE. Return null if the "high pc" attribute is either not present, or if it 4924 cannot be represented as an assembler label identifier. */ 4925 4926static inline const char * 4927get_AT_hi_pc (dw_die_ref die) 4928{ 4929 dw_attr_ref a = get_AT (die, DW_AT_high_pc); 4930 4931 return a ? AT_lbl (a) : NULL; 4932} 4933 4934/* Return the value of the string attribute designated by ATTR_KIND, or 4935 NULL if it is not present. */ 4936 4937static inline const char * 4938get_AT_string (dw_die_ref die, enum dwarf_attribute attr_kind) 4939{ 4940 dw_attr_ref a = get_AT (die, attr_kind); 4941 4942 return a ? AT_string (a) : NULL; 4943} 4944 4945/* Return the value of the flag attribute designated by ATTR_KIND, or -1 4946 if it is not present. */ 4947 4948static inline int 4949get_AT_flag (dw_die_ref die, enum dwarf_attribute attr_kind) 4950{ 4951 dw_attr_ref a = get_AT (die, attr_kind); 4952 4953 return a ? AT_flag (a) : 0; 4954} 4955 4956/* Return the value of the unsigned attribute designated by ATTR_KIND, or 0 4957 if it is not present. */ 4958 4959static inline unsigned 4960get_AT_unsigned (dw_die_ref die, enum dwarf_attribute attr_kind) 4961{ 4962 dw_attr_ref a = get_AT (die, attr_kind); 4963 4964 return a ? AT_unsigned (a) : 0; 4965} 4966 4967static inline dw_die_ref 4968get_AT_ref (dw_die_ref die, enum dwarf_attribute attr_kind) 4969{ 4970 dw_attr_ref a = get_AT (die, attr_kind); 4971 4972 return a ? AT_ref (a) : NULL; 4973} 4974 4975/* Return TRUE if the language is C or C++. */ 4976 4977static inline bool 4978is_c_family (void) 4979{ 4980 unsigned int lang = get_AT_unsigned (comp_unit_die, DW_AT_language); 4981 4982 return (lang == DW_LANG_C || lang == DW_LANG_C89 4983 || lang == DW_LANG_C_plus_plus); 4984} 4985 4986/* Return TRUE if the language is C++. */ 4987 4988static inline bool 4989is_cxx (void) 4990{ 4991 return (get_AT_unsigned (comp_unit_die, DW_AT_language) 4992 == DW_LANG_C_plus_plus); 4993} 4994 4995/* Return TRUE if the language is Fortran. */ 4996 4997static inline bool 4998is_fortran (void) 4999{ 5000 unsigned int lang = get_AT_unsigned (comp_unit_die, DW_AT_language); 5001 5002 return lang == DW_LANG_Fortran77 || lang == DW_LANG_Fortran90; 5003} 5004 5005/* Return TRUE if the language is Java. */ 5006 5007static inline bool 5008is_java (void) 5009{ 5010 unsigned int lang = get_AT_unsigned (comp_unit_die, DW_AT_language); 5011 5012 return lang == DW_LANG_Java; 5013} 5014 5015/* Return TRUE if the language is Ada. */ 5016 5017static inline bool 5018is_ada (void) 5019{ 5020 unsigned int lang = get_AT_unsigned (comp_unit_die, DW_AT_language); 5021 5022 return lang == DW_LANG_Ada95 || lang == DW_LANG_Ada83; 5023} 5024 5025/* Free up the memory used by A. */ 5026 5027static inline void free_AT (dw_attr_ref); 5028static inline void 5029free_AT (dw_attr_ref a) 5030{ 5031 if (AT_class (a) == dw_val_class_str) 5032 if (a->dw_attr_val.v.val_str->refcount) 5033 a->dw_attr_val.v.val_str->refcount--; 5034} 5035 5036/* Remove the specified attribute if present. */ 5037 5038static void 5039remove_AT (dw_die_ref die, enum dwarf_attribute attr_kind) 5040{ 5041 dw_attr_ref *p; 5042 dw_attr_ref removed = NULL; 5043 5044 if (die != NULL) 5045 { 5046 for (p = &(die->die_attr); *p; p = &((*p)->dw_attr_next)) 5047 if ((*p)->dw_attr == attr_kind) 5048 { 5049 removed = *p; 5050 *p = (*p)->dw_attr_next; 5051 break; 5052 } 5053 5054 if (removed != 0) 5055 free_AT (removed); 5056 } 5057} 5058 5059/* Remove child die whose die_tag is specified tag. */ 5060 5061static void 5062remove_child_TAG (dw_die_ref die, enum dwarf_tag tag) 5063{ 5064 dw_die_ref current, prev, next; 5065 current = die->die_child; 5066 prev = NULL; 5067 while (current != NULL) 5068 { 5069 if (current->die_tag == tag) 5070 { 5071 next = current->die_sib; 5072 if (prev == NULL) 5073 die->die_child = next; 5074 else 5075 prev->die_sib = next; 5076 free_die (current); 5077 current = next; 5078 } 5079 else 5080 { 5081 prev = current; 5082 current = current->die_sib; 5083 } 5084 } 5085} 5086 5087/* Free up the memory used by DIE. */ 5088 5089static inline void 5090free_die (dw_die_ref die) 5091{ 5092 remove_children (die); 5093} 5094 5095/* Discard the children of this DIE. */ 5096 5097static void 5098remove_children (dw_die_ref die) 5099{ 5100 dw_die_ref child_die = die->die_child; 5101 5102 die->die_child = NULL; 5103 5104 while (child_die != NULL) 5105 { 5106 dw_die_ref tmp_die = child_die; 5107 dw_attr_ref a; 5108 5109 child_die = child_die->die_sib; 5110 5111 for (a = tmp_die->die_attr; a != NULL;) 5112 { 5113 dw_attr_ref tmp_a = a; 5114 5115 a = a->dw_attr_next; 5116 free_AT (tmp_a); 5117 } 5118 5119 free_die (tmp_die); 5120 } 5121} 5122 5123/* Add a child DIE below its parent. We build the lists up in reverse 5124 addition order, and correct that in reverse_all_dies. */ 5125 5126static inline void 5127add_child_die (dw_die_ref die, dw_die_ref child_die) 5128{ 5129 if (die != NULL && child_die != NULL) 5130 { 5131 if (die == child_die) 5132 abort (); 5133 5134 child_die->die_parent = die; 5135 child_die->die_sib = die->die_child; 5136 die->die_child = child_die; 5137 } 5138} 5139 5140/* Move CHILD, which must be a child of PARENT or the DIE for which PARENT 5141 is the specification, to the front of PARENT's list of children. */ 5142 5143static void 5144splice_child_die (dw_die_ref parent, dw_die_ref child) 5145{ 5146 dw_die_ref *p; 5147 5148 /* We want the declaration DIE from inside the class, not the 5149 specification DIE at toplevel. */ 5150 if (child->die_parent != parent) 5151 { 5152 dw_die_ref tmp = get_AT_ref (child, DW_AT_specification); 5153 5154 if (tmp) 5155 child = tmp; 5156 } 5157 5158 if (child->die_parent != parent 5159 && child->die_parent != get_AT_ref (parent, DW_AT_specification)) 5160 abort (); 5161 5162 for (p = &(child->die_parent->die_child); *p; p = &((*p)->die_sib)) 5163 if (*p == child) 5164 { 5165 *p = child->die_sib; 5166 break; 5167 } 5168 5169 child->die_parent = parent; 5170 child->die_sib = parent->die_child; 5171 parent->die_child = child; 5172} 5173 5174/* Return a pointer to a newly created DIE node. */ 5175 5176static inline dw_die_ref 5177new_die (enum dwarf_tag tag_value, dw_die_ref parent_die, tree t) 5178{ 5179 dw_die_ref die = ggc_alloc_cleared (sizeof (die_node)); 5180 5181 die->die_tag = tag_value; 5182 5183 if (parent_die != NULL) 5184 add_child_die (parent_die, die); 5185 else 5186 { 5187 limbo_die_node *limbo_node; 5188 5189 limbo_node = ggc_alloc_cleared (sizeof (limbo_die_node)); 5190 limbo_node->die = die; 5191 limbo_node->created_for = t; 5192 limbo_node->next = limbo_die_list; 5193 limbo_die_list = limbo_node; 5194 } 5195 5196 return die; 5197} 5198 5199/* Return the DIE associated with the given type specifier. */ 5200 5201static inline dw_die_ref 5202lookup_type_die (tree type) 5203{ 5204 return TYPE_SYMTAB_DIE (type); 5205} 5206 5207/* Equate a DIE to a given type specifier. */ 5208 5209static inline void 5210equate_type_number_to_die (tree type, dw_die_ref type_die) 5211{ 5212 TYPE_SYMTAB_DIE (type) = type_die; 5213} 5214 5215/* Return the DIE associated with a given declaration. */ 5216 5217static inline dw_die_ref 5218lookup_decl_die (tree decl) 5219{ 5220 unsigned decl_id = DECL_UID (decl); 5221 5222 return (decl_id < decl_die_table_in_use ? decl_die_table[decl_id] : NULL); 5223} 5224 5225/* Equate a DIE to a particular declaration. */ 5226 5227static void 5228equate_decl_number_to_die (tree decl, dw_die_ref decl_die) 5229{ 5230 unsigned int decl_id = DECL_UID (decl); 5231 unsigned int num_allocated; 5232 5233 if (decl_id >= decl_die_table_allocated) 5234 { 5235 num_allocated 5236 = ((decl_id + 1 + DECL_DIE_TABLE_INCREMENT - 1) 5237 / DECL_DIE_TABLE_INCREMENT) 5238 * DECL_DIE_TABLE_INCREMENT; 5239 5240 decl_die_table = ggc_realloc (decl_die_table, 5241 sizeof (dw_die_ref) * num_allocated); 5242 5243 memset (&decl_die_table[decl_die_table_allocated], 0, 5244 (num_allocated - decl_die_table_allocated) * sizeof (dw_die_ref)); 5245 decl_die_table_allocated = num_allocated; 5246 } 5247 5248 if (decl_id >= decl_die_table_in_use) 5249 decl_die_table_in_use = (decl_id + 1); 5250 5251 decl_die_table[decl_id] = decl_die; 5252} 5253 5254/* Keep track of the number of spaces used to indent the 5255 output of the debugging routines that print the structure of 5256 the DIE internal representation. */ 5257static int print_indent; 5258 5259/* Indent the line the number of spaces given by print_indent. */ 5260 5261static inline void 5262print_spaces (FILE *outfile) 5263{ 5264 fprintf (outfile, "%*s", print_indent, ""); 5265} 5266 5267/* Print the information associated with a given DIE, and its children. 5268 This routine is a debugging aid only. */ 5269 5270static void 5271print_die (dw_die_ref die, FILE *outfile) 5272{ 5273 dw_attr_ref a; 5274 dw_die_ref c; 5275 5276 print_spaces (outfile); 5277 fprintf (outfile, "DIE %4lu: %s\n", 5278 die->die_offset, dwarf_tag_name (die->die_tag)); 5279 print_spaces (outfile); 5280 fprintf (outfile, " abbrev id: %lu", die->die_abbrev); 5281 fprintf (outfile, " offset: %lu\n", die->die_offset); 5282 5283 for (a = die->die_attr; a != NULL; a = a->dw_attr_next) 5284 { 5285 print_spaces (outfile); 5286 fprintf (outfile, " %s: ", dwarf_attr_name (a->dw_attr)); 5287 5288 switch (AT_class (a)) 5289 { 5290 case dw_val_class_addr: 5291 fprintf (outfile, "address"); 5292 break; 5293 case dw_val_class_offset: 5294 fprintf (outfile, "offset"); 5295 break; 5296 case dw_val_class_loc: 5297 fprintf (outfile, "location descriptor"); 5298 break; 5299 case dw_val_class_loc_list: 5300 fprintf (outfile, "location list -> label:%s", 5301 AT_loc_list (a)->ll_symbol); 5302 break; 5303 case dw_val_class_range_list: 5304 fprintf (outfile, "range list"); 5305 break; 5306 case dw_val_class_const: 5307 fprintf (outfile, HOST_WIDE_INT_PRINT_DEC, AT_int (a)); 5308 break; 5309 case dw_val_class_unsigned_const: 5310 fprintf (outfile, HOST_WIDE_INT_PRINT_UNSIGNED, AT_unsigned (a)); 5311 break; 5312 case dw_val_class_long_long: 5313 fprintf (outfile, "constant (%lu,%lu)", 5314 a->dw_attr_val.v.val_long_long.hi, 5315 a->dw_attr_val.v.val_long_long.low); 5316 break; 5317 case dw_val_class_vec: 5318 fprintf (outfile, "floating-point or vector constant"); 5319 break; 5320 case dw_val_class_flag: 5321 fprintf (outfile, "%u", AT_flag (a)); 5322 break; 5323 case dw_val_class_die_ref: 5324 if (AT_ref (a) != NULL) 5325 { 5326 if (AT_ref (a)->die_symbol) 5327 fprintf (outfile, "die -> label: %s", AT_ref (a)->die_symbol); 5328 else 5329 fprintf (outfile, "die -> %lu", AT_ref (a)->die_offset); 5330 } 5331 else 5332 fprintf (outfile, "die -> <null>"); 5333 break; 5334 case dw_val_class_lbl_id: 5335 case dw_val_class_lbl_offset: 5336 fprintf (outfile, "label: %s", AT_lbl (a)); 5337 break; 5338 case dw_val_class_str: 5339 if (AT_string (a) != NULL) 5340 fprintf (outfile, "\"%s\"", AT_string (a)); 5341 else 5342 fprintf (outfile, "<null>"); 5343 break; 5344 default: 5345 break; 5346 } 5347 5348 fprintf (outfile, "\n"); 5349 } 5350 5351 if (die->die_child != NULL) 5352 { 5353 print_indent += 4; 5354 for (c = die->die_child; c != NULL; c = c->die_sib) 5355 print_die (c, outfile); 5356 5357 print_indent -= 4; 5358 } 5359 if (print_indent == 0) 5360 fprintf (outfile, "\n"); 5361} 5362 5363/* Print the contents of the source code line number correspondence table. 5364 This routine is a debugging aid only. */ 5365 5366static void 5367print_dwarf_line_table (FILE *outfile) 5368{ 5369 unsigned i; 5370 dw_line_info_ref line_info; 5371 5372 fprintf (outfile, "\n\nDWARF source line information\n"); 5373 for (i = 1; i < line_info_table_in_use; i++) 5374 { 5375 line_info = &line_info_table[i]; 5376 fprintf (outfile, "%5d: ", i); 5377 fprintf (outfile, "%-20s", 5378 VARRAY_CHAR_PTR (file_table, line_info->dw_file_num)); 5379 fprintf (outfile, "%6ld", line_info->dw_line_num); 5380 fprintf (outfile, "\n"); 5381 } 5382 5383 fprintf (outfile, "\n\n"); 5384} 5385 5386/* Print the information collected for a given DIE. */ 5387 5388void 5389debug_dwarf_die (dw_die_ref die) 5390{ 5391 print_die (die, stderr); 5392} 5393 5394/* Print all DWARF information collected for the compilation unit. 5395 This routine is a debugging aid only. */ 5396 5397void 5398debug_dwarf (void) 5399{ 5400 print_indent = 0; 5401 print_die (comp_unit_die, stderr); 5402 if (! DWARF2_ASM_LINE_DEBUG_INFO) 5403 print_dwarf_line_table (stderr); 5404} 5405 5406/* We build up the lists of children and attributes by pushing new ones 5407 onto the beginning of the list. Reverse the lists for DIE so that 5408 they are in order of addition. */ 5409 5410static void 5411reverse_die_lists (dw_die_ref die) 5412{ 5413 dw_die_ref c, cp, cn; 5414 dw_attr_ref a, ap, an; 5415 5416 for (a = die->die_attr, ap = 0; a; a = an) 5417 { 5418 an = a->dw_attr_next; 5419 a->dw_attr_next = ap; 5420 ap = a; 5421 } 5422 5423 die->die_attr = ap; 5424 5425 for (c = die->die_child, cp = 0; c; c = cn) 5426 { 5427 cn = c->die_sib; 5428 c->die_sib = cp; 5429 cp = c; 5430 } 5431 5432 die->die_child = cp; 5433} 5434 5435/* reverse_die_lists only reverses the single die you pass it. Since we used to 5436 reverse all dies in add_sibling_attributes, which runs through all the dies, 5437 it would reverse all the dies. Now, however, since we don't call 5438 reverse_die_lists in add_sibling_attributes, we need a routine to 5439 recursively reverse all the dies. This is that routine. */ 5440 5441static void 5442reverse_all_dies (dw_die_ref die) 5443{ 5444 dw_die_ref c; 5445 5446 reverse_die_lists (die); 5447 5448 for (c = die->die_child; c; c = c->die_sib) 5449 reverse_all_dies (c); 5450} 5451 5452/* Start a new compilation unit DIE for an include file. OLD_UNIT is the CU 5453 for the enclosing include file, if any. BINCL_DIE is the DW_TAG_GNU_BINCL 5454 DIE that marks the start of the DIEs for this include file. */ 5455 5456static dw_die_ref 5457push_new_compile_unit (dw_die_ref old_unit, dw_die_ref bincl_die) 5458{ 5459 const char *filename = get_AT_string (bincl_die, DW_AT_name); 5460 dw_die_ref new_unit = gen_compile_unit_die (filename); 5461 5462 new_unit->die_sib = old_unit; 5463 return new_unit; 5464} 5465 5466/* Close an include-file CU and reopen the enclosing one. */ 5467 5468static dw_die_ref 5469pop_compile_unit (dw_die_ref old_unit) 5470{ 5471 dw_die_ref new_unit = old_unit->die_sib; 5472 5473 old_unit->die_sib = NULL; 5474 return new_unit; 5475} 5476 5477#define CHECKSUM(FOO) md5_process_bytes (&(FOO), sizeof (FOO), ctx) 5478#define CHECKSUM_STRING(FOO) md5_process_bytes ((FOO), strlen (FOO), ctx) 5479 5480/* Calculate the checksum of a location expression. */ 5481 5482static inline void 5483loc_checksum (dw_loc_descr_ref loc, struct md5_ctx *ctx) 5484{ 5485 CHECKSUM (loc->dw_loc_opc); 5486 CHECKSUM (loc->dw_loc_oprnd1); 5487 CHECKSUM (loc->dw_loc_oprnd2); 5488} 5489 5490/* Calculate the checksum of an attribute. */ 5491 5492static void 5493attr_checksum (dw_attr_ref at, struct md5_ctx *ctx, int *mark) 5494{ 5495 dw_loc_descr_ref loc; 5496 rtx r; 5497 5498 CHECKSUM (at->dw_attr); 5499 5500 /* We don't care about differences in file numbering. */ 5501 if (at->dw_attr == DW_AT_decl_file 5502 /* Or that this was compiled with a different compiler snapshot; if 5503 the output is the same, that's what matters. */ 5504 || at->dw_attr == DW_AT_producer) 5505 return; 5506 5507 switch (AT_class (at)) 5508 { 5509 case dw_val_class_const: 5510 CHECKSUM (at->dw_attr_val.v.val_int); 5511 break; 5512 case dw_val_class_unsigned_const: 5513 CHECKSUM (at->dw_attr_val.v.val_unsigned); 5514 break; 5515 case dw_val_class_long_long: 5516 CHECKSUM (at->dw_attr_val.v.val_long_long); 5517 break; 5518 case dw_val_class_vec: 5519 CHECKSUM (at->dw_attr_val.v.val_vec); 5520 break; 5521 case dw_val_class_flag: 5522 CHECKSUM (at->dw_attr_val.v.val_flag); 5523 break; 5524 case dw_val_class_str: 5525 CHECKSUM_STRING (AT_string (at)); 5526 break; 5527 5528 case dw_val_class_addr: 5529 r = AT_addr (at); 5530 switch (GET_CODE (r)) 5531 { 5532 case SYMBOL_REF: 5533 CHECKSUM_STRING (XSTR (r, 0)); 5534 break; 5535 5536 default: 5537 abort (); 5538 } 5539 break; 5540 5541 case dw_val_class_offset: 5542 CHECKSUM (at->dw_attr_val.v.val_offset); 5543 break; 5544 5545 case dw_val_class_loc: 5546 for (loc = AT_loc (at); loc; loc = loc->dw_loc_next) 5547 loc_checksum (loc, ctx); 5548 break; 5549 5550 case dw_val_class_die_ref: 5551 die_checksum (AT_ref (at), ctx, mark); 5552 break; 5553 5554 case dw_val_class_fde_ref: 5555 case dw_val_class_lbl_id: 5556 case dw_val_class_lbl_offset: 5557 break; 5558 5559 default: 5560 break; 5561 } 5562} 5563 5564/* Calculate the checksum of a DIE. */ 5565 5566static void 5567die_checksum (dw_die_ref die, struct md5_ctx *ctx, int *mark) 5568{ 5569 dw_die_ref c; 5570 dw_attr_ref a; 5571 5572 /* To avoid infinite recursion. */ 5573 if (die->die_mark) 5574 { 5575 CHECKSUM (die->die_mark); 5576 return; 5577 } 5578 die->die_mark = ++(*mark); 5579 5580 CHECKSUM (die->die_tag); 5581 5582 for (a = die->die_attr; a; a = a->dw_attr_next) 5583 attr_checksum (a, ctx, mark); 5584 5585 for (c = die->die_child; c; c = c->die_sib) 5586 die_checksum (c, ctx, mark); 5587} 5588 5589#undef CHECKSUM 5590#undef CHECKSUM_STRING 5591 5592/* Do the location expressions look same? */ 5593static inline int 5594same_loc_p (dw_loc_descr_ref loc1, dw_loc_descr_ref loc2, int *mark) 5595{ 5596 return loc1->dw_loc_opc == loc2->dw_loc_opc 5597 && same_dw_val_p (&loc1->dw_loc_oprnd1, &loc2->dw_loc_oprnd1, mark) 5598 && same_dw_val_p (&loc1->dw_loc_oprnd2, &loc2->dw_loc_oprnd2, mark); 5599} 5600 5601/* Do the values look the same? */ 5602static int 5603same_dw_val_p (dw_val_node *v1, dw_val_node *v2, int *mark) 5604{ 5605 dw_loc_descr_ref loc1, loc2; 5606 rtx r1, r2; 5607 5608 if (v1->val_class != v2->val_class) 5609 return 0; 5610 5611 switch (v1->val_class) 5612 { 5613 case dw_val_class_const: 5614 return v1->v.val_int == v2->v.val_int; 5615 case dw_val_class_unsigned_const: 5616 return v1->v.val_unsigned == v2->v.val_unsigned; 5617 case dw_val_class_long_long: 5618 return v1->v.val_long_long.hi == v2->v.val_long_long.hi 5619 && v1->v.val_long_long.low == v2->v.val_long_long.low; 5620 case dw_val_class_vec: 5621 if (v1->v.val_vec.length != v2->v.val_vec.length 5622 || v1->v.val_vec.elt_size != v2->v.val_vec.elt_size) 5623 return 0; 5624 if (memcmp (v1->v.val_vec.array, v2->v.val_vec.array, 5625 v1->v.val_vec.length * v1->v.val_vec.elt_size)) 5626 return 0; 5627 return 1; 5628 case dw_val_class_flag: 5629 return v1->v.val_flag == v2->v.val_flag; 5630 case dw_val_class_str: 5631 return !strcmp(v1->v.val_str->str, v2->v.val_str->str); 5632 5633 case dw_val_class_addr: 5634 r1 = v1->v.val_addr; 5635 r2 = v2->v.val_addr; 5636 if (GET_CODE (r1) != GET_CODE (r2)) 5637 return 0; 5638 switch (GET_CODE (r1)) 5639 { 5640 case SYMBOL_REF: 5641 return !strcmp (XSTR (r1, 0), XSTR (r2, 0)); 5642 5643 default: 5644 abort (); 5645 } 5646 5647 case dw_val_class_offset: 5648 return v1->v.val_offset == v2->v.val_offset; 5649 5650 case dw_val_class_loc: 5651 for (loc1 = v1->v.val_loc, loc2 = v2->v.val_loc; 5652 loc1 && loc2; 5653 loc1 = loc1->dw_loc_next, loc2 = loc2->dw_loc_next) 5654 if (!same_loc_p (loc1, loc2, mark)) 5655 return 0; 5656 return !loc1 && !loc2; 5657 5658 case dw_val_class_die_ref: 5659 return same_die_p (v1->v.val_die_ref.die, v2->v.val_die_ref.die, mark); 5660 5661 case dw_val_class_fde_ref: 5662 case dw_val_class_lbl_id: 5663 case dw_val_class_lbl_offset: 5664 return 1; 5665 5666 default: 5667 return 1; 5668 } 5669} 5670 5671/* Do the attributes look the same? */ 5672 5673static int 5674same_attr_p (dw_attr_ref at1, dw_attr_ref at2, int *mark) 5675{ 5676 if (at1->dw_attr != at2->dw_attr) 5677 return 0; 5678 5679 /* We don't care about differences in file numbering. */ 5680 if (at1->dw_attr == DW_AT_decl_file 5681 /* Or that this was compiled with a different compiler snapshot; if 5682 the output is the same, that's what matters. */ 5683 || at1->dw_attr == DW_AT_producer) 5684 return 1; 5685 5686 return same_dw_val_p (&at1->dw_attr_val, &at2->dw_attr_val, mark); 5687} 5688 5689/* Do the dies look the same? */ 5690 5691static int 5692same_die_p (dw_die_ref die1, dw_die_ref die2, int *mark) 5693{ 5694 dw_die_ref c1, c2; 5695 dw_attr_ref a1, a2; 5696 5697 /* To avoid infinite recursion. */ 5698 if (die1->die_mark) 5699 return die1->die_mark == die2->die_mark; 5700 die1->die_mark = die2->die_mark = ++(*mark); 5701 5702 if (die1->die_tag != die2->die_tag) 5703 return 0; 5704 5705 for (a1 = die1->die_attr, a2 = die2->die_attr; 5706 a1 && a2; 5707 a1 = a1->dw_attr_next, a2 = a2->dw_attr_next) 5708 if (!same_attr_p (a1, a2, mark)) 5709 return 0; 5710 if (a1 || a2) 5711 return 0; 5712 5713 for (c1 = die1->die_child, c2 = die2->die_child; 5714 c1 && c2; 5715 c1 = c1->die_sib, c2 = c2->die_sib) 5716 if (!same_die_p (c1, c2, mark)) 5717 return 0; 5718 if (c1 || c2) 5719 return 0; 5720 5721 return 1; 5722} 5723 5724/* Do the dies look the same? Wrapper around same_die_p. */ 5725 5726static int 5727same_die_p_wrap (dw_die_ref die1, dw_die_ref die2) 5728{ 5729 int mark = 0; 5730 int ret = same_die_p (die1, die2, &mark); 5731 5732 unmark_all_dies (die1); 5733 unmark_all_dies (die2); 5734 5735 return ret; 5736} 5737 5738/* The prefix to attach to symbols on DIEs in the current comdat debug 5739 info section. */ 5740static char *comdat_symbol_id; 5741 5742/* The index of the current symbol within the current comdat CU. */ 5743static unsigned int comdat_symbol_number; 5744 5745/* Calculate the MD5 checksum of the compilation unit DIE UNIT_DIE and its 5746 children, and set comdat_symbol_id accordingly. */ 5747 5748static void 5749compute_section_prefix (dw_die_ref unit_die) 5750{ 5751 const char *die_name = get_AT_string (unit_die, DW_AT_name); 5752 const char *base = die_name ? lbasename (die_name) : "anonymous"; 5753 char *name = alloca (strlen (base) + 64); 5754 char *p; 5755 int i, mark; 5756 unsigned char checksum[16]; 5757 struct md5_ctx ctx; 5758 5759 /* Compute the checksum of the DIE, then append part of it as hex digits to 5760 the name filename of the unit. */ 5761 5762 md5_init_ctx (&ctx); 5763 mark = 0; 5764 die_checksum (unit_die, &ctx, &mark); 5765 unmark_all_dies (unit_die); 5766 md5_finish_ctx (&ctx, checksum); 5767 5768 sprintf (name, "%s.", base); 5769 clean_symbol_name (name); 5770 5771 p = name + strlen (name); 5772 for (i = 0; i < 4; i++) 5773 { 5774 sprintf (p, "%.2x", checksum[i]); 5775 p += 2; 5776 } 5777 5778 comdat_symbol_id = unit_die->die_symbol = xstrdup (name); 5779 comdat_symbol_number = 0; 5780} 5781 5782/* Returns nonzero if DIE represents a type, in the sense of TYPE_P. */ 5783 5784static int 5785is_type_die (dw_die_ref die) 5786{ 5787 switch (die->die_tag) 5788 { 5789 case DW_TAG_array_type: 5790 case DW_TAG_class_type: 5791 case DW_TAG_enumeration_type: 5792 case DW_TAG_pointer_type: 5793 case DW_TAG_reference_type: 5794 case DW_TAG_string_type: 5795 case DW_TAG_structure_type: 5796 case DW_TAG_subroutine_type: 5797 case DW_TAG_union_type: 5798 case DW_TAG_ptr_to_member_type: 5799 case DW_TAG_set_type: 5800 case DW_TAG_subrange_type: 5801 case DW_TAG_base_type: 5802 case DW_TAG_const_type: 5803 case DW_TAG_file_type: 5804 case DW_TAG_packed_type: 5805 case DW_TAG_volatile_type: 5806 case DW_TAG_typedef: 5807 return 1; 5808 default: 5809 return 0; 5810 } 5811} 5812 5813/* Returns 1 iff C is the sort of DIE that should go into a COMDAT CU. 5814 Basically, we want to choose the bits that are likely to be shared between 5815 compilations (types) and leave out the bits that are specific to individual 5816 compilations (functions). */ 5817 5818static int 5819is_comdat_die (dw_die_ref c) 5820{ 5821 /* I think we want to leave base types and __vtbl_ptr_type in the main CU, as 5822 we do for stabs. The advantage is a greater likelihood of sharing between 5823 objects that don't include headers in the same order (and therefore would 5824 put the base types in a different comdat). jason 8/28/00 */ 5825 5826 if (c->die_tag == DW_TAG_base_type) 5827 return 0; 5828 5829 if (c->die_tag == DW_TAG_pointer_type 5830 || c->die_tag == DW_TAG_reference_type 5831 || c->die_tag == DW_TAG_const_type 5832 || c->die_tag == DW_TAG_volatile_type) 5833 { 5834 dw_die_ref t = get_AT_ref (c, DW_AT_type); 5835 5836 return t ? is_comdat_die (t) : 0; 5837 } 5838 5839 return is_type_die (c); 5840} 5841 5842/* Returns 1 iff C is the sort of DIE that might be referred to from another 5843 compilation unit. */ 5844 5845static int 5846is_symbol_die (dw_die_ref c) 5847{ 5848 return (is_type_die (c) 5849 || (get_AT (c, DW_AT_declaration) 5850 && !get_AT (c, DW_AT_specification))); 5851} 5852 5853static char * 5854gen_internal_sym (const char *prefix) 5855{ 5856 char buf[256]; 5857 5858 ASM_GENERATE_INTERNAL_LABEL (buf, prefix, label_num++); 5859 return xstrdup (buf); 5860} 5861 5862/* Assign symbols to all worthy DIEs under DIE. */ 5863 5864static void 5865assign_symbol_names (dw_die_ref die) 5866{ 5867 dw_die_ref c; 5868 5869 if (is_symbol_die (die)) 5870 { 5871 if (comdat_symbol_id) 5872 { 5873 char *p = alloca (strlen (comdat_symbol_id) + 64); 5874 5875 sprintf (p, "%s.%s.%x", DIE_LABEL_PREFIX, 5876 comdat_symbol_id, comdat_symbol_number++); 5877 die->die_symbol = xstrdup (p); 5878 } 5879 else 5880 die->die_symbol = gen_internal_sym ("LDIE"); 5881 } 5882 5883 for (c = die->die_child; c != NULL; c = c->die_sib) 5884 assign_symbol_names (c); 5885} 5886 5887struct cu_hash_table_entry 5888{ 5889 dw_die_ref cu; 5890 unsigned min_comdat_num, max_comdat_num; 5891 struct cu_hash_table_entry *next; 5892}; 5893 5894/* Routines to manipulate hash table of CUs. */ 5895static hashval_t 5896htab_cu_hash (const void *of) 5897{ 5898 const struct cu_hash_table_entry *entry = of; 5899 5900 return htab_hash_string (entry->cu->die_symbol); 5901} 5902 5903static int 5904htab_cu_eq (const void *of1, const void *of2) 5905{ 5906 const struct cu_hash_table_entry *entry1 = of1; 5907 const struct die_struct *entry2 = of2; 5908 5909 return !strcmp (entry1->cu->die_symbol, entry2->die_symbol); 5910} 5911 5912static void 5913htab_cu_del (void *what) 5914{ 5915 struct cu_hash_table_entry *next, *entry = what; 5916 5917 while (entry) 5918 { 5919 next = entry->next; 5920 free (entry); 5921 entry = next; 5922 } 5923} 5924 5925/* Check whether we have already seen this CU and set up SYM_NUM 5926 accordingly. */ 5927static int 5928check_duplicate_cu (dw_die_ref cu, htab_t htable, unsigned int *sym_num) 5929{ 5930 struct cu_hash_table_entry dummy; 5931 struct cu_hash_table_entry **slot, *entry, *last = &dummy; 5932 5933 dummy.max_comdat_num = 0; 5934 5935 slot = (struct cu_hash_table_entry **) 5936 htab_find_slot_with_hash (htable, cu, htab_hash_string (cu->die_symbol), 5937 INSERT); 5938 entry = *slot; 5939 5940 for (; entry; last = entry, entry = entry->next) 5941 { 5942 if (same_die_p_wrap (cu, entry->cu)) 5943 break; 5944 } 5945 5946 if (entry) 5947 { 5948 *sym_num = entry->min_comdat_num; 5949 return 1; 5950 } 5951 5952 entry = xcalloc (1, sizeof (struct cu_hash_table_entry)); 5953 entry->cu = cu; 5954 entry->min_comdat_num = *sym_num = last->max_comdat_num; 5955 entry->next = *slot; 5956 *slot = entry; 5957 5958 return 0; 5959} 5960 5961/* Record SYM_NUM to record of CU in HTABLE. */ 5962static void 5963record_comdat_symbol_number (dw_die_ref cu, htab_t htable, unsigned int sym_num) 5964{ 5965 struct cu_hash_table_entry **slot, *entry; 5966 5967 slot = (struct cu_hash_table_entry **) 5968 htab_find_slot_with_hash (htable, cu, htab_hash_string (cu->die_symbol), 5969 NO_INSERT); 5970 entry = *slot; 5971 5972 entry->max_comdat_num = sym_num; 5973} 5974 5975/* Traverse the DIE (which is always comp_unit_die), and set up 5976 additional compilation units for each of the include files we see 5977 bracketed by BINCL/EINCL. */ 5978 5979static void 5980break_out_includes (dw_die_ref die) 5981{ 5982 dw_die_ref *ptr; 5983 dw_die_ref unit = NULL; 5984 limbo_die_node *node, **pnode; 5985 htab_t cu_hash_table; 5986 5987 for (ptr = &(die->die_child); *ptr;) 5988 { 5989 dw_die_ref c = *ptr; 5990 5991 if (c->die_tag == DW_TAG_GNU_BINCL || c->die_tag == DW_TAG_GNU_EINCL 5992 || (unit && is_comdat_die (c))) 5993 { 5994 /* This DIE is for a secondary CU; remove it from the main one. */ 5995 *ptr = c->die_sib; 5996 5997 if (c->die_tag == DW_TAG_GNU_BINCL) 5998 { 5999 unit = push_new_compile_unit (unit, c); 6000 free_die (c); 6001 } 6002 else if (c->die_tag == DW_TAG_GNU_EINCL) 6003 { 6004 unit = pop_compile_unit (unit); 6005 free_die (c); 6006 } 6007 else 6008 add_child_die (unit, c); 6009 } 6010 else 6011 { 6012 /* Leave this DIE in the main CU. */ 6013 ptr = &(c->die_sib); 6014 continue; 6015 } 6016 } 6017 6018#if 0 6019 /* We can only use this in debugging, since the frontend doesn't check 6020 to make sure that we leave every include file we enter. */ 6021 if (unit != NULL) 6022 abort (); 6023#endif 6024 6025 assign_symbol_names (die); 6026 cu_hash_table = htab_create (10, htab_cu_hash, htab_cu_eq, htab_cu_del); 6027 for (node = limbo_die_list, pnode = &limbo_die_list; 6028 node; 6029 node = node->next) 6030 { 6031 int is_dupl; 6032 6033 compute_section_prefix (node->die); 6034 is_dupl = check_duplicate_cu (node->die, cu_hash_table, 6035 &comdat_symbol_number); 6036 assign_symbol_names (node->die); 6037 if (is_dupl) 6038 *pnode = node->next; 6039 else 6040 { 6041 pnode = &node->next; 6042 record_comdat_symbol_number (node->die, cu_hash_table, 6043 comdat_symbol_number); 6044 } 6045 } 6046 htab_delete (cu_hash_table); 6047} 6048 6049/* Traverse the DIE and add a sibling attribute if it may have the 6050 effect of speeding up access to siblings. To save some space, 6051 avoid generating sibling attributes for DIE's without children. */ 6052 6053static void 6054add_sibling_attributes (dw_die_ref die) 6055{ 6056 dw_die_ref c; 6057 6058 if (die->die_tag != DW_TAG_compile_unit 6059 && die->die_sib && die->die_child != NULL) 6060 /* Add the sibling link to the front of the attribute list. */ 6061 add_AT_die_ref (die, DW_AT_sibling, die->die_sib); 6062 6063 for (c = die->die_child; c != NULL; c = c->die_sib) 6064 add_sibling_attributes (c); 6065} 6066 6067/* Output all location lists for the DIE and its children. */ 6068 6069static void 6070output_location_lists (dw_die_ref die) 6071{ 6072 dw_die_ref c; 6073 dw_attr_ref d_attr; 6074 6075 for (d_attr = die->die_attr; d_attr; d_attr = d_attr->dw_attr_next) 6076 if (AT_class (d_attr) == dw_val_class_loc_list) 6077 output_loc_list (AT_loc_list (d_attr)); 6078 6079 for (c = die->die_child; c != NULL; c = c->die_sib) 6080 output_location_lists (c); 6081 6082} 6083 6084/* The format of each DIE (and its attribute value pairs) is encoded in an 6085 abbreviation table. This routine builds the abbreviation table and assigns 6086 a unique abbreviation id for each abbreviation entry. The children of each 6087 die are visited recursively. */ 6088 6089static void 6090build_abbrev_table (dw_die_ref die) 6091{ 6092 unsigned long abbrev_id; 6093 unsigned int n_alloc; 6094 dw_die_ref c; 6095 dw_attr_ref d_attr, a_attr; 6096 6097 /* Scan the DIE references, and mark as external any that refer to 6098 DIEs from other CUs (i.e. those which are not marked). */ 6099 for (d_attr = die->die_attr; d_attr; d_attr = d_attr->dw_attr_next) 6100 if (AT_class (d_attr) == dw_val_class_die_ref 6101 && AT_ref (d_attr)->die_mark == 0) 6102 { 6103 if (AT_ref (d_attr)->die_symbol == 0) 6104 abort (); 6105 6106 set_AT_ref_external (d_attr, 1); 6107 } 6108 6109 for (abbrev_id = 1; abbrev_id < abbrev_die_table_in_use; ++abbrev_id) 6110 { 6111 dw_die_ref abbrev = abbrev_die_table[abbrev_id]; 6112 6113 if (abbrev->die_tag == die->die_tag) 6114 { 6115 if ((abbrev->die_child != NULL) == (die->die_child != NULL)) 6116 { 6117 a_attr = abbrev->die_attr; 6118 d_attr = die->die_attr; 6119 6120 while (a_attr != NULL && d_attr != NULL) 6121 { 6122 if ((a_attr->dw_attr != d_attr->dw_attr) 6123 || (value_format (a_attr) != value_format (d_attr))) 6124 break; 6125 6126 a_attr = a_attr->dw_attr_next; 6127 d_attr = d_attr->dw_attr_next; 6128 } 6129 6130 if (a_attr == NULL && d_attr == NULL) 6131 break; 6132 } 6133 } 6134 } 6135 6136 if (abbrev_id >= abbrev_die_table_in_use) 6137 { 6138 if (abbrev_die_table_in_use >= abbrev_die_table_allocated) 6139 { 6140 n_alloc = abbrev_die_table_allocated + ABBREV_DIE_TABLE_INCREMENT; 6141 abbrev_die_table = ggc_realloc (abbrev_die_table, 6142 sizeof (dw_die_ref) * n_alloc); 6143 6144 memset (&abbrev_die_table[abbrev_die_table_allocated], 0, 6145 (n_alloc - abbrev_die_table_allocated) * sizeof (dw_die_ref)); 6146 abbrev_die_table_allocated = n_alloc; 6147 } 6148 6149 ++abbrev_die_table_in_use; 6150 abbrev_die_table[abbrev_id] = die; 6151 } 6152 6153 die->die_abbrev = abbrev_id; 6154 for (c = die->die_child; c != NULL; c = c->die_sib) 6155 build_abbrev_table (c); 6156} 6157 6158/* Return the power-of-two number of bytes necessary to represent VALUE. */ 6159 6160static int 6161constant_size (long unsigned int value) 6162{ 6163 int log; 6164 6165 if (value == 0) 6166 log = 0; 6167 else 6168 log = floor_log2 (value); 6169 6170 log = log / 8; 6171 log = 1 << (floor_log2 (log) + 1); 6172 6173 return log; 6174} 6175 6176/* Return the size of a DIE as it is represented in the 6177 .debug_info section. */ 6178 6179static unsigned long 6180size_of_die (dw_die_ref die) 6181{ 6182 unsigned long size = 0; 6183 dw_attr_ref a; 6184 6185 size += size_of_uleb128 (die->die_abbrev); 6186 for (a = die->die_attr; a != NULL; a = a->dw_attr_next) 6187 { 6188 switch (AT_class (a)) 6189 { 6190 case dw_val_class_addr: 6191 size += DWARF2_ADDR_SIZE; 6192 break; 6193 case dw_val_class_offset: 6194 size += DWARF_OFFSET_SIZE; 6195 break; 6196 case dw_val_class_loc: 6197 { 6198 unsigned long lsize = size_of_locs (AT_loc (a)); 6199 6200 /* Block length. */ 6201 size += constant_size (lsize); 6202 size += lsize; 6203 } 6204 break; 6205 case dw_val_class_loc_list: 6206 size += DWARF_OFFSET_SIZE; 6207 break; 6208 case dw_val_class_range_list: 6209 size += DWARF_OFFSET_SIZE; 6210 break; 6211 case dw_val_class_const: 6212 size += size_of_sleb128 (AT_int (a)); 6213 break; 6214 case dw_val_class_unsigned_const: 6215 size += constant_size (AT_unsigned (a)); 6216 break; 6217 case dw_val_class_long_long: 6218 size += 1 + 2*HOST_BITS_PER_LONG/HOST_BITS_PER_CHAR; /* block */ 6219 break; 6220 case dw_val_class_vec: 6221 size += 1 + (a->dw_attr_val.v.val_vec.length 6222 * a->dw_attr_val.v.val_vec.elt_size); /* block */ 6223 break; 6224 case dw_val_class_flag: 6225 size += 1; 6226 break; 6227 case dw_val_class_die_ref: 6228 if (AT_ref_external (a)) 6229 size += DWARF2_ADDR_SIZE; 6230 else 6231 size += DWARF_OFFSET_SIZE; 6232 break; 6233 case dw_val_class_fde_ref: 6234 size += DWARF_OFFSET_SIZE; 6235 break; 6236 case dw_val_class_lbl_id: 6237 size += DWARF2_ADDR_SIZE; 6238 break; 6239 case dw_val_class_lbl_offset: 6240 size += DWARF_OFFSET_SIZE; 6241 break; 6242 case dw_val_class_str: 6243 if (AT_string_form (a) == DW_FORM_strp) 6244 size += DWARF_OFFSET_SIZE; 6245 else 6246 size += strlen (a->dw_attr_val.v.val_str->str) + 1; 6247 break; 6248 default: 6249 abort (); 6250 } 6251 } 6252 6253 return size; 6254} 6255 6256/* Size the debugging information associated with a given DIE. Visits the 6257 DIE's children recursively. Updates the global variable next_die_offset, on 6258 each time through. Uses the current value of next_die_offset to update the 6259 die_offset field in each DIE. */ 6260 6261static void 6262calc_die_sizes (dw_die_ref die) 6263{ 6264 dw_die_ref c; 6265 6266 die->die_offset = next_die_offset; 6267 next_die_offset += size_of_die (die); 6268 6269 for (c = die->die_child; c != NULL; c = c->die_sib) 6270 calc_die_sizes (c); 6271 6272 if (die->die_child != NULL) 6273 /* Count the null byte used to terminate sibling lists. */ 6274 next_die_offset += 1; 6275} 6276 6277/* Set the marks for a die and its children. We do this so 6278 that we know whether or not a reference needs to use FORM_ref_addr; only 6279 DIEs in the same CU will be marked. We used to clear out the offset 6280 and use that as the flag, but ran into ordering problems. */ 6281 6282static void 6283mark_dies (dw_die_ref die) 6284{ 6285 dw_die_ref c; 6286 6287 if (die->die_mark) 6288 abort (); 6289 6290 die->die_mark = 1; 6291 for (c = die->die_child; c; c = c->die_sib) 6292 mark_dies (c); 6293} 6294 6295/* Clear the marks for a die and its children. */ 6296 6297static void 6298unmark_dies (dw_die_ref die) 6299{ 6300 dw_die_ref c; 6301 6302 if (!die->die_mark) 6303 abort (); 6304 6305 die->die_mark = 0; 6306 for (c = die->die_child; c; c = c->die_sib) 6307 unmark_dies (c); 6308} 6309 6310/* Clear the marks for a die, its children and referred dies. */ 6311 6312static void 6313unmark_all_dies (dw_die_ref die) 6314{ 6315 dw_die_ref c; 6316 dw_attr_ref a; 6317 6318 if (!die->die_mark) 6319 return; 6320 die->die_mark = 0; 6321 6322 for (c = die->die_child; c; c = c->die_sib) 6323 unmark_all_dies (c); 6324 6325 for (a = die->die_attr; a; a = a->dw_attr_next) 6326 if (AT_class (a) == dw_val_class_die_ref) 6327 unmark_all_dies (AT_ref (a)); 6328} 6329 6330/* Return the size of the .debug_pubnames table generated for the 6331 compilation unit. */ 6332 6333static unsigned long 6334size_of_pubnames (void) 6335{ 6336 unsigned long size; 6337 unsigned i; 6338 6339 size = DWARF_PUBNAMES_HEADER_SIZE; 6340 for (i = 0; i < pubname_table_in_use; i++) 6341 { 6342 pubname_ref p = &pubname_table[i]; 6343 size += DWARF_OFFSET_SIZE + strlen (p->name) + 1; 6344 } 6345 6346 size += DWARF_OFFSET_SIZE; 6347 return size; 6348} 6349 6350/* Return the size of the information in the .debug_aranges section. */ 6351 6352static unsigned long 6353size_of_aranges (void) 6354{ 6355 unsigned long size; 6356 6357 size = DWARF_ARANGES_HEADER_SIZE; 6358 6359 /* Count the address/length pair for this compilation unit. */ 6360 size += 2 * DWARF2_ADDR_SIZE; 6361 size += 2 * DWARF2_ADDR_SIZE * arange_table_in_use; 6362 6363 /* Count the two zero words used to terminated the address range table. */ 6364 size += 2 * DWARF2_ADDR_SIZE; 6365 return size; 6366} 6367 6368/* Select the encoding of an attribute value. */ 6369 6370static enum dwarf_form 6371value_format (dw_attr_ref a) 6372{ 6373 switch (a->dw_attr_val.val_class) 6374 { 6375 case dw_val_class_addr: 6376 return DW_FORM_addr; 6377 case dw_val_class_range_list: 6378 case dw_val_class_offset: 6379 if (DWARF_OFFSET_SIZE == 4) 6380 return DW_FORM_data4; 6381 if (DWARF_OFFSET_SIZE == 8) 6382 return DW_FORM_data8; 6383 abort (); 6384 case dw_val_class_loc_list: 6385 /* FIXME: Could be DW_FORM_data8, with a > 32 bit size 6386 .debug_loc section */ 6387 return DW_FORM_data4; 6388 case dw_val_class_loc: 6389 switch (constant_size (size_of_locs (AT_loc (a)))) 6390 { 6391 case 1: 6392 return DW_FORM_block1; 6393 case 2: 6394 return DW_FORM_block2; 6395 default: 6396 abort (); 6397 } 6398 case dw_val_class_const: 6399 return DW_FORM_sdata; 6400 case dw_val_class_unsigned_const: 6401 switch (constant_size (AT_unsigned (a))) 6402 { 6403 case 1: 6404 return DW_FORM_data1; 6405 case 2: 6406 return DW_FORM_data2; 6407 case 4: 6408 return DW_FORM_data4; 6409 case 8: 6410 return DW_FORM_data8; 6411 default: 6412 abort (); 6413 } 6414 case dw_val_class_long_long: 6415 return DW_FORM_block1; 6416 case dw_val_class_vec: 6417 return DW_FORM_block1; 6418 case dw_val_class_flag: 6419 return DW_FORM_flag; 6420 case dw_val_class_die_ref: 6421 if (AT_ref_external (a)) 6422 return DW_FORM_ref_addr; 6423 else 6424 return DW_FORM_ref; 6425 case dw_val_class_fde_ref: 6426 return DW_FORM_data; 6427 case dw_val_class_lbl_id: 6428 return DW_FORM_addr; 6429 case dw_val_class_lbl_offset: 6430 return DW_FORM_data; 6431 case dw_val_class_str: 6432 return AT_string_form (a); 6433 6434 default: 6435 abort (); 6436 } 6437} 6438 6439/* Output the encoding of an attribute value. */ 6440 6441static void 6442output_value_format (dw_attr_ref a) 6443{ 6444 enum dwarf_form form = value_format (a); 6445 6446 dw2_asm_output_data_uleb128 (form, "(%s)", dwarf_form_name (form)); 6447} 6448 6449/* Output the .debug_abbrev section which defines the DIE abbreviation 6450 table. */ 6451 6452static void 6453output_abbrev_section (void) 6454{ 6455 unsigned long abbrev_id; 6456 6457 dw_attr_ref a_attr; 6458 6459 for (abbrev_id = 1; abbrev_id < abbrev_die_table_in_use; ++abbrev_id) 6460 { 6461 dw_die_ref abbrev = abbrev_die_table[abbrev_id]; 6462 6463 dw2_asm_output_data_uleb128 (abbrev_id, "(abbrev code)"); 6464 dw2_asm_output_data_uleb128 (abbrev->die_tag, "(TAG: %s)", 6465 dwarf_tag_name (abbrev->die_tag)); 6466 6467 if (abbrev->die_child != NULL) 6468 dw2_asm_output_data (1, DW_children_yes, "DW_children_yes"); 6469 else 6470 dw2_asm_output_data (1, DW_children_no, "DW_children_no"); 6471 6472 for (a_attr = abbrev->die_attr; a_attr != NULL; 6473 a_attr = a_attr->dw_attr_next) 6474 { 6475 dw2_asm_output_data_uleb128 (a_attr->dw_attr, "(%s)", 6476 dwarf_attr_name (a_attr->dw_attr)); 6477 output_value_format (a_attr); 6478 } 6479 6480 dw2_asm_output_data (1, 0, NULL); 6481 dw2_asm_output_data (1, 0, NULL); 6482 } 6483 6484 /* Terminate the table. */ 6485 dw2_asm_output_data (1, 0, NULL); 6486} 6487 6488/* Output a symbol we can use to refer to this DIE from another CU. */ 6489 6490static inline void 6491output_die_symbol (dw_die_ref die) 6492{ 6493 char *sym = die->die_symbol; 6494 6495 if (sym == 0) 6496 return; 6497 6498 if (strncmp (sym, DIE_LABEL_PREFIX, sizeof (DIE_LABEL_PREFIX) - 1) == 0) 6499 /* We make these global, not weak; if the target doesn't support 6500 .linkonce, it doesn't support combining the sections, so debugging 6501 will break. */ 6502 (*targetm.asm_out.globalize_label) (asm_out_file, sym); 6503 6504 ASM_OUTPUT_LABEL (asm_out_file, sym); 6505} 6506 6507/* Return a new location list, given the begin and end range, and the 6508 expression. gensym tells us whether to generate a new internal symbol for 6509 this location list node, which is done for the head of the list only. */ 6510 6511static inline dw_loc_list_ref 6512new_loc_list (dw_loc_descr_ref expr, const char *begin, const char *end, 6513 const char *section, unsigned int gensym) 6514{ 6515 dw_loc_list_ref retlist = ggc_alloc_cleared (sizeof (dw_loc_list_node)); 6516 6517 retlist->begin = begin; 6518 retlist->end = end; 6519 retlist->expr = expr; 6520 retlist->section = section; 6521 if (gensym) 6522 retlist->ll_symbol = gen_internal_sym ("LLST"); 6523 6524 return retlist; 6525} 6526 6527/* Add a location description expression to a location list. */ 6528 6529static inline void 6530add_loc_descr_to_loc_list (dw_loc_list_ref *list_head, dw_loc_descr_ref descr, 6531 const char *begin, const char *end, 6532 const char *section) 6533{ 6534 dw_loc_list_ref *d; 6535 6536 /* Find the end of the chain. */ 6537 for (d = list_head; (*d) != NULL; d = &(*d)->dw_loc_next) 6538 ; 6539 6540 /* Add a new location list node to the list. */ 6541 *d = new_loc_list (descr, begin, end, section, 0); 6542} 6543 6544/* Output the location list given to us. */ 6545 6546static void 6547output_loc_list (dw_loc_list_ref list_head) 6548{ 6549 dw_loc_list_ref curr = list_head; 6550 6551 ASM_OUTPUT_LABEL (asm_out_file, list_head->ll_symbol); 6552 6553 /* ??? This shouldn't be needed now that we've forced the 6554 compilation unit base address to zero when there is code 6555 in more than one section. */ 6556 if (strcmp (curr->section, ".text") == 0) 6557 { 6558 /* dw2_asm_output_data will mask off any extra bits in the ~0. */ 6559 dw2_asm_output_data (DWARF2_ADDR_SIZE, ~(unsigned HOST_WIDE_INT) 0, 6560 "Location list base address specifier fake entry"); 6561 dw2_asm_output_offset (DWARF2_ADDR_SIZE, curr->section, 6562 "Location list base address specifier base"); 6563 } 6564 6565 for (curr = list_head; curr != NULL; curr = curr->dw_loc_next) 6566 { 6567 unsigned long size; 6568 6569 dw2_asm_output_delta (DWARF2_ADDR_SIZE, curr->begin, curr->section, 6570 "Location list begin address (%s)", 6571 list_head->ll_symbol); 6572 dw2_asm_output_delta (DWARF2_ADDR_SIZE, curr->end, curr->section, 6573 "Location list end address (%s)", 6574 list_head->ll_symbol); 6575 size = size_of_locs (curr->expr); 6576 6577 /* Output the block length for this list of location operations. */ 6578 if (size > 0xffff) 6579 abort (); 6580 dw2_asm_output_data (2, size, "%s", "Location expression size"); 6581 6582 output_loc_sequence (curr->expr); 6583 } 6584 6585 dw2_asm_output_data (DWARF_OFFSET_SIZE, 0, 6586 "Location list terminator begin (%s)", 6587 list_head->ll_symbol); 6588 dw2_asm_output_data (DWARF_OFFSET_SIZE, 0, 6589 "Location list terminator end (%s)", 6590 list_head->ll_symbol); 6591} 6592 6593/* Output the DIE and its attributes. Called recursively to generate 6594 the definitions of each child DIE. */ 6595 6596static void 6597output_die (dw_die_ref die) 6598{ 6599 dw_attr_ref a; 6600 dw_die_ref c; 6601 unsigned long size; 6602 6603 /* If someone in another CU might refer to us, set up a symbol for 6604 them to point to. */ 6605 if (die->die_symbol) 6606 output_die_symbol (die); 6607 6608 dw2_asm_output_data_uleb128 (die->die_abbrev, "(DIE (0x%lx) %s)", 6609 die->die_offset, dwarf_tag_name (die->die_tag)); 6610 6611 for (a = die->die_attr; a != NULL; a = a->dw_attr_next) 6612 { 6613 const char *name = dwarf_attr_name (a->dw_attr); 6614 6615 switch (AT_class (a)) 6616 { 6617 case dw_val_class_addr: 6618 dw2_asm_output_addr_rtx (DWARF2_ADDR_SIZE, AT_addr (a), "%s", name); 6619 break; 6620 6621 case dw_val_class_offset: 6622 dw2_asm_output_data (DWARF_OFFSET_SIZE, a->dw_attr_val.v.val_offset, 6623 "%s", name); 6624 break; 6625 6626 case dw_val_class_range_list: 6627 { 6628 char *p = strchr (ranges_section_label, '\0'); 6629 6630 sprintf (p, "+" HOST_WIDE_INT_PRINT_HEX, 6631 a->dw_attr_val.v.val_offset); 6632 dw2_asm_output_offset (DWARF_OFFSET_SIZE, ranges_section_label, 6633 "%s", name); 6634 *p = '\0'; 6635 } 6636 break; 6637 6638 case dw_val_class_loc: 6639 size = size_of_locs (AT_loc (a)); 6640 6641 /* Output the block length for this list of location operations. */ 6642 dw2_asm_output_data (constant_size (size), size, "%s", name); 6643 6644 output_loc_sequence (AT_loc (a)); 6645 break; 6646 6647 case dw_val_class_const: 6648 /* ??? It would be slightly more efficient to use a scheme like is 6649 used for unsigned constants below, but gdb 4.x does not sign 6650 extend. Gdb 5.x does sign extend. */ 6651 dw2_asm_output_data_sleb128 (AT_int (a), "%s", name); 6652 break; 6653 6654 case dw_val_class_unsigned_const: 6655 dw2_asm_output_data (constant_size (AT_unsigned (a)), 6656 AT_unsigned (a), "%s", name); 6657 break; 6658 6659 case dw_val_class_long_long: 6660 { 6661 unsigned HOST_WIDE_INT first, second; 6662 6663 dw2_asm_output_data (1, 6664 2 * HOST_BITS_PER_LONG / HOST_BITS_PER_CHAR, 6665 "%s", name); 6666 6667 if (WORDS_BIG_ENDIAN) 6668 { 6669 first = a->dw_attr_val.v.val_long_long.hi; 6670 second = a->dw_attr_val.v.val_long_long.low; 6671 } 6672 else 6673 { 6674 first = a->dw_attr_val.v.val_long_long.low; 6675 second = a->dw_attr_val.v.val_long_long.hi; 6676 } 6677 6678 dw2_asm_output_data (HOST_BITS_PER_LONG / HOST_BITS_PER_CHAR, 6679 first, "long long constant"); 6680 dw2_asm_output_data (HOST_BITS_PER_LONG / HOST_BITS_PER_CHAR, 6681 second, NULL); 6682 } 6683 break; 6684 6685 case dw_val_class_vec: 6686 { 6687 unsigned int elt_size = a->dw_attr_val.v.val_vec.elt_size; 6688 unsigned int len = a->dw_attr_val.v.val_vec.length; 6689 unsigned int i; 6690 unsigned char *p; 6691 6692 dw2_asm_output_data (1, len * elt_size, "%s", name); 6693 if (elt_size > sizeof (HOST_WIDE_INT)) 6694 { 6695 elt_size /= 2; 6696 len *= 2; 6697 } 6698 for (i = 0, p = a->dw_attr_val.v.val_vec.array; 6699 i < len; 6700 i++, p += elt_size) 6701 dw2_asm_output_data (elt_size, extract_int (p, elt_size), 6702 "fp or vector constant word %u", i); 6703 break; 6704 } 6705 6706 case dw_val_class_flag: 6707 dw2_asm_output_data (1, AT_flag (a), "%s", name); 6708 break; 6709 6710 case dw_val_class_loc_list: 6711 { 6712 char *sym = AT_loc_list (a)->ll_symbol; 6713 6714 if (sym == 0) 6715 abort (); 6716 dw2_asm_output_delta (DWARF_OFFSET_SIZE, sym, 6717 loc_section_label, "%s", name); 6718 } 6719 break; 6720 6721 case dw_val_class_die_ref: 6722 if (AT_ref_external (a)) 6723 { 6724 char *sym = AT_ref (a)->die_symbol; 6725 6726 if (sym == 0) 6727 abort (); 6728 dw2_asm_output_offset (DWARF2_ADDR_SIZE, sym, "%s", name); 6729 } 6730 else if (AT_ref (a)->die_offset == 0) 6731 abort (); 6732 else 6733 dw2_asm_output_data (DWARF_OFFSET_SIZE, AT_ref (a)->die_offset, 6734 "%s", name); 6735 break; 6736 6737 case dw_val_class_fde_ref: 6738 { 6739 char l1[20]; 6740 6741 ASM_GENERATE_INTERNAL_LABEL (l1, FDE_LABEL, 6742 a->dw_attr_val.v.val_fde_index * 2); 6743 dw2_asm_output_offset (DWARF_OFFSET_SIZE, l1, "%s", name); 6744 } 6745 break; 6746 6747 case dw_val_class_lbl_id: 6748 dw2_asm_output_addr (DWARF2_ADDR_SIZE, AT_lbl (a), "%s", name); 6749 break; 6750 6751 case dw_val_class_lbl_offset: 6752 dw2_asm_output_offset (DWARF_OFFSET_SIZE, AT_lbl (a), "%s", name); 6753 break; 6754 6755 case dw_val_class_str: 6756 if (AT_string_form (a) == DW_FORM_strp) 6757 dw2_asm_output_offset (DWARF_OFFSET_SIZE, 6758 a->dw_attr_val.v.val_str->label, 6759 "%s: \"%s\"", name, AT_string (a)); 6760 else 6761 dw2_asm_output_nstring (AT_string (a), -1, "%s", name); 6762 break; 6763 6764 default: 6765 abort (); 6766 } 6767 } 6768 6769 for (c = die->die_child; c != NULL; c = c->die_sib) 6770 output_die (c); 6771 6772 /* Add null byte to terminate sibling list. */ 6773 if (die->die_child != NULL) 6774 dw2_asm_output_data (1, 0, "end of children of DIE 0x%lx", 6775 die->die_offset); 6776} 6777 6778/* Output the compilation unit that appears at the beginning of the 6779 .debug_info section, and precedes the DIE descriptions. */ 6780 6781static void 6782output_compilation_unit_header (void) 6783{ 6784 if (DWARF_INITIAL_LENGTH_SIZE - DWARF_OFFSET_SIZE == 4) 6785 dw2_asm_output_data (4, 0xffffffff, 6786 "Initial length escape value indicating 64-bit DWARF extension"); 6787 dw2_asm_output_data (DWARF_OFFSET_SIZE, 6788 next_die_offset - DWARF_INITIAL_LENGTH_SIZE, 6789 "Length of Compilation Unit Info"); 6790 dw2_asm_output_data (2, DWARF_VERSION, "DWARF version number"); 6791 dw2_asm_output_offset (DWARF_OFFSET_SIZE, abbrev_section_label, 6792 "Offset Into Abbrev. Section"); 6793 dw2_asm_output_data (1, DWARF2_ADDR_SIZE, "Pointer Size (in bytes)"); 6794} 6795 6796/* Output the compilation unit DIE and its children. */ 6797 6798static void 6799output_comp_unit (dw_die_ref die, int output_if_empty) 6800{ 6801 const char *secname; 6802 char *oldsym, *tmp; 6803 6804 /* Unless we are outputting main CU, we may throw away empty ones. */ 6805 if (!output_if_empty && die->die_child == NULL) 6806 return; 6807 6808 /* Even if there are no children of this DIE, we must output the information 6809 about the compilation unit. Otherwise, on an empty translation unit, we 6810 will generate a present, but empty, .debug_info section. IRIX 6.5 `nm' 6811 will then complain when examining the file. First mark all the DIEs in 6812 this CU so we know which get local refs. */ 6813 mark_dies (die); 6814 6815 build_abbrev_table (die); 6816 6817 /* Initialize the beginning DIE offset - and calculate sizes/offsets. */ 6818 next_die_offset = DWARF_COMPILE_UNIT_HEADER_SIZE; 6819 calc_die_sizes (die); 6820 6821 oldsym = die->die_symbol; 6822 if (oldsym) 6823 { 6824 tmp = alloca (strlen (oldsym) + 24); 6825 6826 sprintf (tmp, ".gnu.linkonce.wi.%s", oldsym); 6827 secname = tmp; 6828 die->die_symbol = NULL; 6829 } 6830 else 6831 secname = (const char *) DEBUG_INFO_SECTION; 6832 6833 /* Output debugging information. */ 6834 named_section_flags (secname, SECTION_DEBUG); 6835 output_compilation_unit_header (); 6836 output_die (die); 6837 6838 /* Leave the marks on the main CU, so we can check them in 6839 output_pubnames. */ 6840 if (oldsym) 6841 { 6842 unmark_dies (die); 6843 die->die_symbol = oldsym; 6844 } 6845} 6846 6847/* The DWARF2 pubname for a nested thingy looks like "A::f". The 6848 output of lang_hooks.decl_printable_name for C++ looks like 6849 "A::f(int)". Let's drop the argument list, and maybe the scope. */ 6850 6851static const char * 6852dwarf2_name (tree decl, int scope) 6853{ 6854 return (*lang_hooks.decl_printable_name) (decl, scope ? 1 : 0); 6855} 6856 6857/* Add a new entry to .debug_pubnames if appropriate. */ 6858 6859static void 6860add_pubname (tree decl, dw_die_ref die) 6861{ 6862 pubname_ref p; 6863 6864 if (! TREE_PUBLIC (decl)) 6865 return; 6866 6867 if (pubname_table_in_use == pubname_table_allocated) 6868 { 6869 pubname_table_allocated += PUBNAME_TABLE_INCREMENT; 6870 pubname_table 6871 = ggc_realloc (pubname_table, 6872 (pubname_table_allocated * sizeof (pubname_entry))); 6873 memset (pubname_table + pubname_table_in_use, 0, 6874 PUBNAME_TABLE_INCREMENT * sizeof (pubname_entry)); 6875 } 6876 6877 p = &pubname_table[pubname_table_in_use++]; 6878 p->die = die; 6879 p->name = xstrdup (dwarf2_name (decl, 1)); 6880} 6881 6882/* Output the public names table used to speed up access to externally 6883 visible names. For now, only generate entries for externally 6884 visible procedures. */ 6885 6886static void 6887output_pubnames (void) 6888{ 6889 unsigned i; 6890 unsigned long pubnames_length = size_of_pubnames (); 6891 6892 if (DWARF_INITIAL_LENGTH_SIZE - DWARF_OFFSET_SIZE == 4) 6893 dw2_asm_output_data (4, 0xffffffff, 6894 "Initial length escape value indicating 64-bit DWARF extension"); 6895 dw2_asm_output_data (DWARF_OFFSET_SIZE, pubnames_length, 6896 "Length of Public Names Info"); 6897 dw2_asm_output_data (2, DWARF_VERSION, "DWARF Version"); 6898 dw2_asm_output_offset (DWARF_OFFSET_SIZE, debug_info_section_label, 6899 "Offset of Compilation Unit Info"); 6900 dw2_asm_output_data (DWARF_OFFSET_SIZE, next_die_offset, 6901 "Compilation Unit Length"); 6902 6903 for (i = 0; i < pubname_table_in_use; i++) 6904 { 6905 pubname_ref pub = &pubname_table[i]; 6906 6907 /* We shouldn't see pubnames for DIEs outside of the main CU. */ 6908 if (pub->die->die_mark == 0) 6909 abort (); 6910 6911 dw2_asm_output_data (DWARF_OFFSET_SIZE, pub->die->die_offset, 6912 "DIE offset"); 6913 6914 dw2_asm_output_nstring (pub->name, -1, "external name"); 6915 } 6916 6917 dw2_asm_output_data (DWARF_OFFSET_SIZE, 0, NULL); 6918} 6919 6920/* Add a new entry to .debug_aranges if appropriate. */ 6921 6922static void 6923add_arange (tree decl, dw_die_ref die) 6924{ 6925 if (! DECL_SECTION_NAME (decl)) 6926 return; 6927 6928 if (arange_table_in_use == arange_table_allocated) 6929 { 6930 arange_table_allocated += ARANGE_TABLE_INCREMENT; 6931 arange_table = ggc_realloc (arange_table, 6932 (arange_table_allocated 6933 * sizeof (dw_die_ref))); 6934 memset (arange_table + arange_table_in_use, 0, 6935 ARANGE_TABLE_INCREMENT * sizeof (dw_die_ref)); 6936 } 6937 6938 arange_table[arange_table_in_use++] = die; 6939} 6940 6941/* Output the information that goes into the .debug_aranges table. 6942 Namely, define the beginning and ending address range of the 6943 text section generated for this compilation unit. */ 6944 6945static void 6946output_aranges (void) 6947{ 6948 unsigned i; 6949 unsigned long aranges_length = size_of_aranges (); 6950 6951 if (DWARF_INITIAL_LENGTH_SIZE - DWARF_OFFSET_SIZE == 4) 6952 dw2_asm_output_data (4, 0xffffffff, 6953 "Initial length escape value indicating 64-bit DWARF extension"); 6954 dw2_asm_output_data (DWARF_OFFSET_SIZE, aranges_length, 6955 "Length of Address Ranges Info"); 6956 dw2_asm_output_data (2, DWARF_VERSION, "DWARF Version"); 6957 dw2_asm_output_offset (DWARF_OFFSET_SIZE, debug_info_section_label, 6958 "Offset of Compilation Unit Info"); 6959 dw2_asm_output_data (1, DWARF2_ADDR_SIZE, "Size of Address"); 6960 dw2_asm_output_data (1, 0, "Size of Segment Descriptor"); 6961 6962 /* We need to align to twice the pointer size here. */ 6963 if (DWARF_ARANGES_PAD_SIZE) 6964 { 6965 /* Pad using a 2 byte words so that padding is correct for any 6966 pointer size. */ 6967 dw2_asm_output_data (2, 0, "Pad to %d byte boundary", 6968 2 * DWARF2_ADDR_SIZE); 6969 for (i = 2; i < (unsigned) DWARF_ARANGES_PAD_SIZE; i += 2) 6970 dw2_asm_output_data (2, 0, NULL); 6971 } 6972 6973 dw2_asm_output_addr (DWARF2_ADDR_SIZE, text_section_label, "Address"); 6974 dw2_asm_output_delta (DWARF2_ADDR_SIZE, text_end_label, 6975 text_section_label, "Length"); 6976 6977 for (i = 0; i < arange_table_in_use; i++) 6978 { 6979 dw_die_ref die = arange_table[i]; 6980 6981 /* We shouldn't see aranges for DIEs outside of the main CU. */ 6982 if (die->die_mark == 0) 6983 abort (); 6984 6985 if (die->die_tag == DW_TAG_subprogram) 6986 { 6987 dw2_asm_output_addr (DWARF2_ADDR_SIZE, get_AT_low_pc (die), 6988 "Address"); 6989 dw2_asm_output_delta (DWARF2_ADDR_SIZE, get_AT_hi_pc (die), 6990 get_AT_low_pc (die), "Length"); 6991 } 6992 else 6993 { 6994 /* A static variable; extract the symbol from DW_AT_location. 6995 Note that this code isn't currently hit, as we only emit 6996 aranges for functions (jason 9/23/99). */ 6997 dw_attr_ref a = get_AT (die, DW_AT_location); 6998 dw_loc_descr_ref loc; 6999 7000 if (! a || AT_class (a) != dw_val_class_loc) 7001 abort (); 7002 7003 loc = AT_loc (a); 7004 if (loc->dw_loc_opc != DW_OP_addr) 7005 abort (); 7006 7007 dw2_asm_output_addr_rtx (DWARF2_ADDR_SIZE, 7008 loc->dw_loc_oprnd1.v.val_addr, "Address"); 7009 dw2_asm_output_data (DWARF2_ADDR_SIZE, 7010 get_AT_unsigned (die, DW_AT_byte_size), 7011 "Length"); 7012 } 7013 } 7014 7015 /* Output the terminator words. */ 7016 dw2_asm_output_data (DWARF2_ADDR_SIZE, 0, NULL); 7017 dw2_asm_output_data (DWARF2_ADDR_SIZE, 0, NULL); 7018} 7019 7020/* Add a new entry to .debug_ranges. Return the offset at which it 7021 was placed. */ 7022 7023static unsigned int 7024add_ranges (tree block) 7025{ 7026 unsigned int in_use = ranges_table_in_use; 7027 7028 if (in_use == ranges_table_allocated) 7029 { 7030 ranges_table_allocated += RANGES_TABLE_INCREMENT; 7031 ranges_table 7032 = ggc_realloc (ranges_table, (ranges_table_allocated 7033 * sizeof (struct dw_ranges_struct))); 7034 memset (ranges_table + ranges_table_in_use, 0, 7035 RANGES_TABLE_INCREMENT * sizeof (struct dw_ranges_struct)); 7036 } 7037 7038 ranges_table[in_use].block_num = (block ? BLOCK_NUMBER (block) : 0); 7039 ranges_table_in_use = in_use + 1; 7040 7041 return in_use * 2 * DWARF2_ADDR_SIZE; 7042} 7043 7044static void 7045output_ranges (void) 7046{ 7047 unsigned i; 7048 static const char *const start_fmt = "Offset 0x%x"; 7049 const char *fmt = start_fmt; 7050 7051 for (i = 0; i < ranges_table_in_use; i++) 7052 { 7053 int block_num = ranges_table[i].block_num; 7054 7055 if (block_num) 7056 { 7057 char blabel[MAX_ARTIFICIAL_LABEL_BYTES]; 7058 char elabel[MAX_ARTIFICIAL_LABEL_BYTES]; 7059 7060 ASM_GENERATE_INTERNAL_LABEL (blabel, BLOCK_BEGIN_LABEL, block_num); 7061 ASM_GENERATE_INTERNAL_LABEL (elabel, BLOCK_END_LABEL, block_num); 7062 7063 /* If all code is in the text section, then the compilation 7064 unit base address defaults to DW_AT_low_pc, which is the 7065 base of the text section. */ 7066 if (separate_line_info_table_in_use == 0) 7067 { 7068 dw2_asm_output_delta (DWARF2_ADDR_SIZE, blabel, 7069 text_section_label, 7070 fmt, i * 2 * DWARF2_ADDR_SIZE); 7071 dw2_asm_output_delta (DWARF2_ADDR_SIZE, elabel, 7072 text_section_label, NULL); 7073 } 7074 7075 /* Otherwise, we add a DW_AT_entry_pc attribute to force the 7076 compilation unit base address to zero, which allows us to 7077 use absolute addresses, and not worry about whether the 7078 target supports cross-section arithmetic. */ 7079 else 7080 { 7081 dw2_asm_output_addr (DWARF2_ADDR_SIZE, blabel, 7082 fmt, i * 2 * DWARF2_ADDR_SIZE); 7083 dw2_asm_output_addr (DWARF2_ADDR_SIZE, elabel, NULL); 7084 } 7085 7086 fmt = NULL; 7087 } 7088 else 7089 { 7090 dw2_asm_output_data (DWARF2_ADDR_SIZE, 0, NULL); 7091 dw2_asm_output_data (DWARF2_ADDR_SIZE, 0, NULL); 7092 fmt = start_fmt; 7093 } 7094 } 7095} 7096 7097/* Data structure containing information about input files. */ 7098struct file_info 7099{ 7100 char *path; /* Complete file name. */ 7101 char *fname; /* File name part. */ 7102 int length; /* Length of entire string. */ 7103 int file_idx; /* Index in input file table. */ 7104 int dir_idx; /* Index in directory table. */ 7105}; 7106 7107/* Data structure containing information about directories with source 7108 files. */ 7109struct dir_info 7110{ 7111 char *path; /* Path including directory name. */ 7112 int length; /* Path length. */ 7113 int prefix; /* Index of directory entry which is a prefix. */ 7114 int count; /* Number of files in this directory. */ 7115 int dir_idx; /* Index of directory used as base. */ 7116 int used; /* Used in the end? */ 7117}; 7118 7119/* Callback function for file_info comparison. We sort by looking at 7120 the directories in the path. */ 7121 7122static int 7123file_info_cmp (const void *p1, const void *p2) 7124{ 7125 const struct file_info *s1 = p1; 7126 const struct file_info *s2 = p2; 7127 unsigned char *cp1; 7128 unsigned char *cp2; 7129 7130 /* Take care of file names without directories. We need to make sure that 7131 we return consistent values to qsort since some will get confused if 7132 we return the same value when identical operands are passed in opposite 7133 orders. So if neither has a directory, return 0 and otherwise return 7134 1 or -1 depending on which one has the directory. */ 7135 if ((s1->path == s1->fname || s2->path == s2->fname)) 7136 return (s2->path == s2->fname) - (s1->path == s1->fname); 7137 7138 cp1 = (unsigned char *) s1->path; 7139 cp2 = (unsigned char *) s2->path; 7140 7141 while (1) 7142 { 7143 ++cp1; 7144 ++cp2; 7145 /* Reached the end of the first path? If so, handle like above. */ 7146 if ((cp1 == (unsigned char *) s1->fname) 7147 || (cp2 == (unsigned char *) s2->fname)) 7148 return ((cp2 == (unsigned char *) s2->fname) 7149 - (cp1 == (unsigned char *) s1->fname)); 7150 7151 /* Character of current path component the same? */ 7152 else if (*cp1 != *cp2) 7153 return *cp1 - *cp2; 7154 } 7155} 7156 7157/* Output the directory table and the file name table. We try to minimize 7158 the total amount of memory needed. A heuristic is used to avoid large 7159 slowdowns with many input files. */ 7160 7161static void 7162output_file_names (void) 7163{ 7164 struct file_info *files; 7165 struct dir_info *dirs; 7166 int *saved; 7167 int *savehere; 7168 int *backmap; 7169 size_t ndirs; 7170 int idx_offset; 7171 size_t i; 7172 int idx; 7173 7174 /* Handle the case where file_table is empty. */ 7175 if (VARRAY_ACTIVE_SIZE (file_table) <= 1) 7176 { 7177 dw2_asm_output_data (1, 0, "End directory table"); 7178 dw2_asm_output_data (1, 0, "End file name table"); 7179 return; 7180 } 7181 7182 /* Allocate the various arrays we need. */ 7183 files = alloca (VARRAY_ACTIVE_SIZE (file_table) * sizeof (struct file_info)); 7184 dirs = alloca (VARRAY_ACTIVE_SIZE (file_table) * sizeof (struct dir_info)); 7185 7186 /* Sort the file names. */ 7187 for (i = 1; i < VARRAY_ACTIVE_SIZE (file_table); i++) 7188 { 7189 char *f; 7190 7191 /* Skip all leading "./". */ 7192 f = VARRAY_CHAR_PTR (file_table, i); 7193 while (f[0] == '.' && f[1] == '/') 7194 f += 2; 7195 7196 /* Create a new array entry. */ 7197 files[i].path = f; 7198 files[i].length = strlen (f); 7199 files[i].file_idx = i; 7200 7201 /* Search for the file name part. */ 7202 f = strrchr (f, '/'); 7203 files[i].fname = f == NULL ? files[i].path : f + 1; 7204 } 7205 7206 qsort (files + 1, VARRAY_ACTIVE_SIZE (file_table) - 1, 7207 sizeof (files[0]), file_info_cmp); 7208 7209 /* Find all the different directories used. */ 7210 dirs[0].path = files[1].path; 7211 dirs[0].length = files[1].fname - files[1].path; 7212 dirs[0].prefix = -1; 7213 dirs[0].count = 1; 7214 dirs[0].dir_idx = 0; 7215 dirs[0].used = 0; 7216 files[1].dir_idx = 0; 7217 ndirs = 1; 7218 7219 for (i = 2; i < VARRAY_ACTIVE_SIZE (file_table); i++) 7220 if (files[i].fname - files[i].path == dirs[ndirs - 1].length 7221 && memcmp (dirs[ndirs - 1].path, files[i].path, 7222 dirs[ndirs - 1].length) == 0) 7223 { 7224 /* Same directory as last entry. */ 7225 files[i].dir_idx = ndirs - 1; 7226 ++dirs[ndirs - 1].count; 7227 } 7228 else 7229 { 7230 size_t j; 7231 7232 /* This is a new directory. */ 7233 dirs[ndirs].path = files[i].path; 7234 dirs[ndirs].length = files[i].fname - files[i].path; 7235 dirs[ndirs].count = 1; 7236 dirs[ndirs].dir_idx = ndirs; 7237 dirs[ndirs].used = 0; 7238 files[i].dir_idx = ndirs; 7239 7240 /* Search for a prefix. */ 7241 dirs[ndirs].prefix = -1; 7242 for (j = 0; j < ndirs; j++) 7243 if (dirs[j].length < dirs[ndirs].length 7244 && dirs[j].length > 1 7245 && (dirs[ndirs].prefix == -1 7246 || dirs[j].length > dirs[dirs[ndirs].prefix].length) 7247 && memcmp (dirs[j].path, dirs[ndirs].path, dirs[j].length) == 0) 7248 dirs[ndirs].prefix = j; 7249 7250 ++ndirs; 7251 } 7252 7253 /* Now to the actual work. We have to find a subset of the directories which 7254 allow expressing the file name using references to the directory table 7255 with the least amount of characters. We do not do an exhaustive search 7256 where we would have to check out every combination of every single 7257 possible prefix. Instead we use a heuristic which provides nearly optimal 7258 results in most cases and never is much off. */ 7259 saved = alloca (ndirs * sizeof (int)); 7260 savehere = alloca (ndirs * sizeof (int)); 7261 7262 memset (saved, '\0', ndirs * sizeof (saved[0])); 7263 for (i = 0; i < ndirs; i++) 7264 { 7265 size_t j; 7266 int total; 7267 7268 /* We can always save some space for the current directory. But this 7269 does not mean it will be enough to justify adding the directory. */ 7270 savehere[i] = dirs[i].length; 7271 total = (savehere[i] - saved[i]) * dirs[i].count; 7272 7273 for (j = i + 1; j < ndirs; j++) 7274 { 7275 savehere[j] = 0; 7276 if (saved[j] < dirs[i].length) 7277 { 7278 /* Determine whether the dirs[i] path is a prefix of the 7279 dirs[j] path. */ 7280 int k; 7281 7282 k = dirs[j].prefix; 7283 while (k != -1 && k != (int) i) 7284 k = dirs[k].prefix; 7285 7286 if (k == (int) i) 7287 { 7288 /* Yes it is. We can possibly safe some memory but 7289 writing the filenames in dirs[j] relative to 7290 dirs[i]. */ 7291 savehere[j] = dirs[i].length; 7292 total += (savehere[j] - saved[j]) * dirs[j].count; 7293 } 7294 } 7295 } 7296 7297 /* Check whether we can safe enough to justify adding the dirs[i] 7298 directory. */ 7299 if (total > dirs[i].length + 1) 7300 { 7301 /* It's worthwhile adding. */ 7302 for (j = i; j < ndirs; j++) 7303 if (savehere[j] > 0) 7304 { 7305 /* Remember how much we saved for this directory so far. */ 7306 saved[j] = savehere[j]; 7307 7308 /* Remember the prefix directory. */ 7309 dirs[j].dir_idx = i; 7310 } 7311 } 7312 } 7313 7314 /* We have to emit them in the order they appear in the file_table array 7315 since the index is used in the debug info generation. To do this 7316 efficiently we generate a back-mapping of the indices first. */ 7317 backmap = alloca (VARRAY_ACTIVE_SIZE (file_table) * sizeof (int)); 7318 for (i = 1; i < VARRAY_ACTIVE_SIZE (file_table); i++) 7319 { 7320 backmap[files[i].file_idx] = i; 7321 7322 /* Mark this directory as used. */ 7323 dirs[dirs[files[i].dir_idx].dir_idx].used = 1; 7324 } 7325 7326 /* That was it. We are ready to emit the information. First emit the 7327 directory name table. We have to make sure the first actually emitted 7328 directory name has index one; zero is reserved for the current working 7329 directory. Make sure we do not confuse these indices with the one for the 7330 constructed table (even though most of the time they are identical). */ 7331 idx = 1; 7332 idx_offset = dirs[0].length > 0 ? 1 : 0; 7333 for (i = 1 - idx_offset; i < ndirs; i++) 7334 if (dirs[i].used != 0) 7335 { 7336 dirs[i].used = idx++; 7337 dw2_asm_output_nstring (dirs[i].path, dirs[i].length - 1, 7338 "Directory Entry: 0x%x", dirs[i].used); 7339 } 7340 7341 dw2_asm_output_data (1, 0, "End directory table"); 7342 7343 /* Correct the index for the current working directory entry if it 7344 exists. */ 7345 if (idx_offset == 0) 7346 dirs[0].used = 0; 7347 7348 /* Now write all the file names. */ 7349 for (i = 1; i < VARRAY_ACTIVE_SIZE (file_table); i++) 7350 { 7351 int file_idx = backmap[i]; 7352 int dir_idx = dirs[files[file_idx].dir_idx].dir_idx; 7353 7354 dw2_asm_output_nstring (files[file_idx].path + dirs[dir_idx].length, -1, 7355 "File Entry: 0x%lx", (unsigned long) i); 7356 7357 /* Include directory index. */ 7358 dw2_asm_output_data_uleb128 (dirs[dir_idx].used, NULL); 7359 7360 /* Modification time. */ 7361 dw2_asm_output_data_uleb128 (0, NULL); 7362 7363 /* File length in bytes. */ 7364 dw2_asm_output_data_uleb128 (0, NULL); 7365 } 7366 7367 dw2_asm_output_data (1, 0, "End file name table"); 7368} 7369 7370 7371/* Output the source line number correspondence information. This 7372 information goes into the .debug_line section. */ 7373 7374static void 7375output_line_info (void) 7376{ 7377 char l1[20], l2[20], p1[20], p2[20]; 7378 char line_label[MAX_ARTIFICIAL_LABEL_BYTES]; 7379 char prev_line_label[MAX_ARTIFICIAL_LABEL_BYTES]; 7380 unsigned opc; 7381 unsigned n_op_args; 7382 unsigned long lt_index; 7383 unsigned long current_line; 7384 long line_offset; 7385 long line_delta; 7386 unsigned long current_file; 7387 unsigned long function; 7388 7389 ASM_GENERATE_INTERNAL_LABEL (l1, LINE_NUMBER_BEGIN_LABEL, 0); 7390 ASM_GENERATE_INTERNAL_LABEL (l2, LINE_NUMBER_END_LABEL, 0); 7391 ASM_GENERATE_INTERNAL_LABEL (p1, LN_PROLOG_AS_LABEL, 0); 7392 ASM_GENERATE_INTERNAL_LABEL (p2, LN_PROLOG_END_LABEL, 0); 7393 7394 if (DWARF_INITIAL_LENGTH_SIZE - DWARF_OFFSET_SIZE == 4) 7395 dw2_asm_output_data (4, 0xffffffff, 7396 "Initial length escape value indicating 64-bit DWARF extension"); 7397 dw2_asm_output_delta (DWARF_OFFSET_SIZE, l2, l1, 7398 "Length of Source Line Info"); 7399 ASM_OUTPUT_LABEL (asm_out_file, l1); 7400 7401 dw2_asm_output_data (2, DWARF_VERSION, "DWARF Version"); 7402 dw2_asm_output_delta (DWARF_OFFSET_SIZE, p2, p1, "Prolog Length"); 7403 ASM_OUTPUT_LABEL (asm_out_file, p1); 7404 7405 /* Define the architecture-dependent minimum instruction length (in 7406 bytes). In this implementation of DWARF, this field is used for 7407 information purposes only. Since GCC generates assembly language, 7408 we have no a priori knowledge of how many instruction bytes are 7409 generated for each source line, and therefore can use only the 7410 DW_LNE_set_address and DW_LNS_fixed_advance_pc line information 7411 commands. Accordingly, we fix this as `1', which is "correct 7412 enough" for all architectures, and don't let the target override. */ 7413 dw2_asm_output_data (1, 1, 7414 "Minimum Instruction Length"); 7415 7416 dw2_asm_output_data (1, DWARF_LINE_DEFAULT_IS_STMT_START, 7417 "Default is_stmt_start flag"); 7418 dw2_asm_output_data (1, DWARF_LINE_BASE, 7419 "Line Base Value (Special Opcodes)"); 7420 dw2_asm_output_data (1, DWARF_LINE_RANGE, 7421 "Line Range Value (Special Opcodes)"); 7422 dw2_asm_output_data (1, DWARF_LINE_OPCODE_BASE, 7423 "Special Opcode Base"); 7424 7425 for (opc = 1; opc < DWARF_LINE_OPCODE_BASE; opc++) 7426 { 7427 switch (opc) 7428 { 7429 case DW_LNS_advance_pc: 7430 case DW_LNS_advance_line: 7431 case DW_LNS_set_file: 7432 case DW_LNS_set_column: 7433 case DW_LNS_fixed_advance_pc: 7434 n_op_args = 1; 7435 break; 7436 default: 7437 n_op_args = 0; 7438 break; 7439 } 7440 7441 dw2_asm_output_data (1, n_op_args, "opcode: 0x%x has %d args", 7442 opc, n_op_args); 7443 } 7444 7445 /* Write out the information about the files we use. */ 7446 output_file_names (); 7447 ASM_OUTPUT_LABEL (asm_out_file, p2); 7448 7449 /* We used to set the address register to the first location in the text 7450 section here, but that didn't accomplish anything since we already 7451 have a line note for the opening brace of the first function. */ 7452 7453 /* Generate the line number to PC correspondence table, encoded as 7454 a series of state machine operations. */ 7455 current_file = 1; 7456 current_line = 1; 7457 strcpy (prev_line_label, text_section_label); 7458 for (lt_index = 1; lt_index < line_info_table_in_use; ++lt_index) 7459 { 7460 dw_line_info_ref line_info = &line_info_table[lt_index]; 7461 7462#if 0 7463 /* Disable this optimization for now; GDB wants to see two line notes 7464 at the beginning of a function so it can find the end of the 7465 prologue. */ 7466 7467 /* Don't emit anything for redundant notes. Just updating the 7468 address doesn't accomplish anything, because we already assume 7469 that anything after the last address is this line. */ 7470 if (line_info->dw_line_num == current_line 7471 && line_info->dw_file_num == current_file) 7472 continue; 7473#endif 7474 7475 /* Emit debug info for the address of the current line. 7476 7477 Unfortunately, we have little choice here currently, and must always 7478 use the most general form. GCC does not know the address delta 7479 itself, so we can't use DW_LNS_advance_pc. Many ports do have length 7480 attributes which will give an upper bound on the address range. We 7481 could perhaps use length attributes to determine when it is safe to 7482 use DW_LNS_fixed_advance_pc. */ 7483 7484 ASM_GENERATE_INTERNAL_LABEL (line_label, LINE_CODE_LABEL, lt_index); 7485 if (0) 7486 { 7487 /* This can handle deltas up to 0xffff. This takes 3 bytes. */ 7488 dw2_asm_output_data (1, DW_LNS_fixed_advance_pc, 7489 "DW_LNS_fixed_advance_pc"); 7490 dw2_asm_output_delta (2, line_label, prev_line_label, NULL); 7491 } 7492 else 7493 { 7494 /* This can handle any delta. This takes 7495 4+DWARF2_ADDR_SIZE bytes. */ 7496 dw2_asm_output_data (1, 0, "DW_LNE_set_address"); 7497 dw2_asm_output_data_uleb128 (1 + DWARF2_ADDR_SIZE, NULL); 7498 dw2_asm_output_data (1, DW_LNE_set_address, NULL); 7499 dw2_asm_output_addr (DWARF2_ADDR_SIZE, line_label, NULL); 7500 } 7501 7502 strcpy (prev_line_label, line_label); 7503 7504 /* Emit debug info for the source file of the current line, if 7505 different from the previous line. */ 7506 if (line_info->dw_file_num != current_file) 7507 { 7508 current_file = line_info->dw_file_num; 7509 dw2_asm_output_data (1, DW_LNS_set_file, "DW_LNS_set_file"); 7510 dw2_asm_output_data_uleb128 (current_file, "(\"%s\")", 7511 VARRAY_CHAR_PTR (file_table, 7512 current_file)); 7513 } 7514 7515 /* Emit debug info for the current line number, choosing the encoding 7516 that uses the least amount of space. */ 7517 if (line_info->dw_line_num != current_line) 7518 { 7519 line_offset = line_info->dw_line_num - current_line; 7520 line_delta = line_offset - DWARF_LINE_BASE; 7521 current_line = line_info->dw_line_num; 7522 if (line_delta >= 0 && line_delta < (DWARF_LINE_RANGE - 1)) 7523 /* This can handle deltas from -10 to 234, using the current 7524 definitions of DWARF_LINE_BASE and DWARF_LINE_RANGE. This 7525 takes 1 byte. */ 7526 dw2_asm_output_data (1, DWARF_LINE_OPCODE_BASE + line_delta, 7527 "line %lu", current_line); 7528 else 7529 { 7530 /* This can handle any delta. This takes at least 4 bytes, 7531 depending on the value being encoded. */ 7532 dw2_asm_output_data (1, DW_LNS_advance_line, 7533 "advance to line %lu", current_line); 7534 dw2_asm_output_data_sleb128 (line_offset, NULL); 7535 dw2_asm_output_data (1, DW_LNS_copy, "DW_LNS_copy"); 7536 } 7537 } 7538 else 7539 /* We still need to start a new row, so output a copy insn. */ 7540 dw2_asm_output_data (1, DW_LNS_copy, "DW_LNS_copy"); 7541 } 7542 7543 /* Emit debug info for the address of the end of the function. */ 7544 if (0) 7545 { 7546 dw2_asm_output_data (1, DW_LNS_fixed_advance_pc, 7547 "DW_LNS_fixed_advance_pc"); 7548 dw2_asm_output_delta (2, text_end_label, prev_line_label, NULL); 7549 } 7550 else 7551 { 7552 dw2_asm_output_data (1, 0, "DW_LNE_set_address"); 7553 dw2_asm_output_data_uleb128 (1 + DWARF2_ADDR_SIZE, NULL); 7554 dw2_asm_output_data (1, DW_LNE_set_address, NULL); 7555 dw2_asm_output_addr (DWARF2_ADDR_SIZE, text_end_label, NULL); 7556 } 7557 7558 dw2_asm_output_data (1, 0, "DW_LNE_end_sequence"); 7559 dw2_asm_output_data_uleb128 (1, NULL); 7560 dw2_asm_output_data (1, DW_LNE_end_sequence, NULL); 7561 7562 function = 0; 7563 current_file = 1; 7564 current_line = 1; 7565 for (lt_index = 0; lt_index < separate_line_info_table_in_use;) 7566 { 7567 dw_separate_line_info_ref line_info 7568 = &separate_line_info_table[lt_index]; 7569 7570#if 0 7571 /* Don't emit anything for redundant notes. */ 7572 if (line_info->dw_line_num == current_line 7573 && line_info->dw_file_num == current_file 7574 && line_info->function == function) 7575 goto cont; 7576#endif 7577 7578 /* Emit debug info for the address of the current line. If this is 7579 a new function, or the first line of a function, then we need 7580 to handle it differently. */ 7581 ASM_GENERATE_INTERNAL_LABEL (line_label, SEPARATE_LINE_CODE_LABEL, 7582 lt_index); 7583 if (function != line_info->function) 7584 { 7585 function = line_info->function; 7586 7587 /* Set the address register to the first line in the function. */ 7588 dw2_asm_output_data (1, 0, "DW_LNE_set_address"); 7589 dw2_asm_output_data_uleb128 (1 + DWARF2_ADDR_SIZE, NULL); 7590 dw2_asm_output_data (1, DW_LNE_set_address, NULL); 7591 dw2_asm_output_addr (DWARF2_ADDR_SIZE, line_label, NULL); 7592 } 7593 else 7594 { 7595 /* ??? See the DW_LNS_advance_pc comment above. */ 7596 if (0) 7597 { 7598 dw2_asm_output_data (1, DW_LNS_fixed_advance_pc, 7599 "DW_LNS_fixed_advance_pc"); 7600 dw2_asm_output_delta (2, line_label, prev_line_label, NULL); 7601 } 7602 else 7603 { 7604 dw2_asm_output_data (1, 0, "DW_LNE_set_address"); 7605 dw2_asm_output_data_uleb128 (1 + DWARF2_ADDR_SIZE, NULL); 7606 dw2_asm_output_data (1, DW_LNE_set_address, NULL); 7607 dw2_asm_output_addr (DWARF2_ADDR_SIZE, line_label, NULL); 7608 } 7609 } 7610 7611 strcpy (prev_line_label, line_label); 7612 7613 /* Emit debug info for the source file of the current line, if 7614 different from the previous line. */ 7615 if (line_info->dw_file_num != current_file) 7616 { 7617 current_file = line_info->dw_file_num; 7618 dw2_asm_output_data (1, DW_LNS_set_file, "DW_LNS_set_file"); 7619 dw2_asm_output_data_uleb128 (current_file, "(\"%s\")", 7620 VARRAY_CHAR_PTR (file_table, 7621 current_file)); 7622 } 7623 7624 /* Emit debug info for the current line number, choosing the encoding 7625 that uses the least amount of space. */ 7626 if (line_info->dw_line_num != current_line) 7627 { 7628 line_offset = line_info->dw_line_num - current_line; 7629 line_delta = line_offset - DWARF_LINE_BASE; 7630 current_line = line_info->dw_line_num; 7631 if (line_delta >= 0 && line_delta < (DWARF_LINE_RANGE - 1)) 7632 dw2_asm_output_data (1, DWARF_LINE_OPCODE_BASE + line_delta, 7633 "line %lu", current_line); 7634 else 7635 { 7636 dw2_asm_output_data (1, DW_LNS_advance_line, 7637 "advance to line %lu", current_line); 7638 dw2_asm_output_data_sleb128 (line_offset, NULL); 7639 dw2_asm_output_data (1, DW_LNS_copy, "DW_LNS_copy"); 7640 } 7641 } 7642 else 7643 dw2_asm_output_data (1, DW_LNS_copy, "DW_LNS_copy"); 7644 7645#if 0 7646 cont: 7647#endif 7648 7649 lt_index++; 7650 7651 /* If we're done with a function, end its sequence. */ 7652 if (lt_index == separate_line_info_table_in_use 7653 || separate_line_info_table[lt_index].function != function) 7654 { 7655 current_file = 1; 7656 current_line = 1; 7657 7658 /* Emit debug info for the address of the end of the function. */ 7659 ASM_GENERATE_INTERNAL_LABEL (line_label, FUNC_END_LABEL, function); 7660 if (0) 7661 { 7662 dw2_asm_output_data (1, DW_LNS_fixed_advance_pc, 7663 "DW_LNS_fixed_advance_pc"); 7664 dw2_asm_output_delta (2, line_label, prev_line_label, NULL); 7665 } 7666 else 7667 { 7668 dw2_asm_output_data (1, 0, "DW_LNE_set_address"); 7669 dw2_asm_output_data_uleb128 (1 + DWARF2_ADDR_SIZE, NULL); 7670 dw2_asm_output_data (1, DW_LNE_set_address, NULL); 7671 dw2_asm_output_addr (DWARF2_ADDR_SIZE, line_label, NULL); 7672 } 7673 7674 /* Output the marker for the end of this sequence. */ 7675 dw2_asm_output_data (1, 0, "DW_LNE_end_sequence"); 7676 dw2_asm_output_data_uleb128 (1, NULL); 7677 dw2_asm_output_data (1, DW_LNE_end_sequence, NULL); 7678 } 7679 } 7680 7681 /* Output the marker for the end of the line number info. */ 7682 ASM_OUTPUT_LABEL (asm_out_file, l2); 7683} 7684 7685/* Given a pointer to a tree node for some base type, return a pointer to 7686 a DIE that describes the given type. 7687 7688 This routine must only be called for GCC type nodes that correspond to 7689 Dwarf base (fundamental) types. */ 7690 7691static dw_die_ref 7692base_type_die (tree type) 7693{ 7694 dw_die_ref base_type_result; 7695 const char *type_name; 7696 enum dwarf_type encoding; 7697 tree name = TYPE_NAME (type); 7698 7699 if (TREE_CODE (type) == ERROR_MARK || TREE_CODE (type) == VOID_TYPE) 7700 return 0; 7701 7702 if (name) 7703 { 7704 if (TREE_CODE (name) == TYPE_DECL) 7705 name = DECL_NAME (name); 7706 7707 type_name = IDENTIFIER_POINTER (name); 7708 } 7709 else 7710 type_name = "__unknown__"; 7711 7712 switch (TREE_CODE (type)) 7713 { 7714 case INTEGER_TYPE: 7715 /* Carefully distinguish the C character types, without messing 7716 up if the language is not C. Note that we check only for the names 7717 that contain spaces; other names might occur by coincidence in other 7718 languages. */ 7719 if (! (TYPE_PRECISION (type) == CHAR_TYPE_SIZE 7720 && (type == char_type_node 7721 || ! strcmp (type_name, "signed char") 7722 || ! strcmp (type_name, "unsigned char")))) 7723 { 7724 if (TREE_UNSIGNED (type)) 7725 encoding = DW_ATE_unsigned; 7726 else 7727 encoding = DW_ATE_signed; 7728 break; 7729 } 7730 /* else fall through. */ 7731 7732 case CHAR_TYPE: 7733 /* GNU Pascal/Ada CHAR type. Not used in C. */ 7734 if (TREE_UNSIGNED (type)) 7735 encoding = DW_ATE_unsigned_char; 7736 else 7737 encoding = DW_ATE_signed_char; 7738 break; 7739 7740 case REAL_TYPE: 7741 encoding = DW_ATE_float; 7742 break; 7743 7744 /* Dwarf2 doesn't know anything about complex ints, so use 7745 a user defined type for it. */ 7746 case COMPLEX_TYPE: 7747 if (TREE_CODE (TREE_TYPE (type)) == REAL_TYPE) 7748 encoding = DW_ATE_complex_float; 7749 else 7750 encoding = DW_ATE_lo_user; 7751 break; 7752 7753 case BOOLEAN_TYPE: 7754 /* GNU FORTRAN/Ada/C++ BOOLEAN type. */ 7755 encoding = DW_ATE_boolean; 7756 break; 7757 7758 default: 7759 /* No other TREE_CODEs are Dwarf fundamental types. */ 7760 abort (); 7761 } 7762 7763 base_type_result = new_die (DW_TAG_base_type, comp_unit_die, type); 7764 if (demangle_name_func) 7765 type_name = (*demangle_name_func) (type_name); 7766 7767 add_AT_string (base_type_result, DW_AT_name, type_name); 7768 add_AT_unsigned (base_type_result, DW_AT_byte_size, 7769 int_size_in_bytes (type)); 7770 add_AT_unsigned (base_type_result, DW_AT_encoding, encoding); 7771 7772 return base_type_result; 7773} 7774 7775/* Given a pointer to an arbitrary ..._TYPE tree node, return a pointer to 7776 the Dwarf "root" type for the given input type. The Dwarf "root" type of 7777 a given type is generally the same as the given type, except that if the 7778 given type is a pointer or reference type, then the root type of the given 7779 type is the root type of the "basis" type for the pointer or reference 7780 type. (This definition of the "root" type is recursive.) Also, the root 7781 type of a `const' qualified type or a `volatile' qualified type is the 7782 root type of the given type without the qualifiers. */ 7783 7784static tree 7785root_type (tree type) 7786{ 7787 if (TREE_CODE (type) == ERROR_MARK) 7788 return error_mark_node; 7789 7790 switch (TREE_CODE (type)) 7791 { 7792 case ERROR_MARK: 7793 return error_mark_node; 7794 7795 case POINTER_TYPE: 7796 case REFERENCE_TYPE: 7797 return type_main_variant (root_type (TREE_TYPE (type))); 7798 7799 default: 7800 return type_main_variant (type); 7801 } 7802} 7803 7804/* Given a pointer to an arbitrary ..._TYPE tree node, return nonzero if the 7805 given input type is a Dwarf "fundamental" type. Otherwise return null. */ 7806 7807static inline int 7808is_base_type (tree type) 7809{ 7810 switch (TREE_CODE (type)) 7811 { 7812 case ERROR_MARK: 7813 case VOID_TYPE: 7814 case INTEGER_TYPE: 7815 case REAL_TYPE: 7816 case COMPLEX_TYPE: 7817 case BOOLEAN_TYPE: 7818 case CHAR_TYPE: 7819 return 1; 7820 7821 case SET_TYPE: 7822 case ARRAY_TYPE: 7823 case RECORD_TYPE: 7824 case UNION_TYPE: 7825 case QUAL_UNION_TYPE: 7826 case ENUMERAL_TYPE: 7827 case FUNCTION_TYPE: 7828 case METHOD_TYPE: 7829 case POINTER_TYPE: 7830 case REFERENCE_TYPE: 7831 case FILE_TYPE: 7832 case OFFSET_TYPE: 7833 case LANG_TYPE: 7834 case VECTOR_TYPE: 7835 return 0; 7836 7837 default: 7838 abort (); 7839 } 7840 7841 return 0; 7842} 7843 7844/* Given a pointer to a tree node, assumed to be some kind of a ..._TYPE 7845 node, return the size in bits for the type if it is a constant, or else 7846 return the alignment for the type if the type's size is not constant, or 7847 else return BITS_PER_WORD if the type actually turns out to be an 7848 ERROR_MARK node. */ 7849 7850static inline unsigned HOST_WIDE_INT 7851simple_type_size_in_bits (tree type) 7852{ 7853 if (TREE_CODE (type) == ERROR_MARK) 7854 return BITS_PER_WORD; 7855 else if (TYPE_SIZE (type) == NULL_TREE) 7856 return 0; 7857 else if (host_integerp (TYPE_SIZE (type), 1)) 7858 return tree_low_cst (TYPE_SIZE (type), 1); 7859 else 7860 return TYPE_ALIGN (type); 7861} 7862 7863/* Return true if the debug information for the given type should be 7864 emitted as a subrange type. */ 7865 7866static inline bool 7867is_subrange_type (tree type) 7868{ 7869 tree subtype = TREE_TYPE (type); 7870 7871 if (TREE_CODE (type) == INTEGER_TYPE 7872 && subtype != NULL_TREE) 7873 { 7874 if (TREE_CODE (subtype) == INTEGER_TYPE) 7875 return true; 7876 if (TREE_CODE (subtype) == ENUMERAL_TYPE) 7877 return true; 7878 } 7879 return false; 7880} 7881 7882/* Given a pointer to a tree node for a subrange type, return a pointer 7883 to a DIE that describes the given type. */ 7884 7885static dw_die_ref 7886subrange_type_die (tree type, dw_die_ref context_die) 7887{ 7888 dw_die_ref subtype_die; 7889 dw_die_ref subrange_die; 7890 tree name = TYPE_NAME (type); 7891 const HOST_WIDE_INT size_in_bytes = int_size_in_bytes (type); 7892 7893 if (context_die == NULL) 7894 context_die = comp_unit_die; 7895 7896 if (TREE_CODE (TREE_TYPE (type)) == ENUMERAL_TYPE) 7897 subtype_die = gen_enumeration_type_die (TREE_TYPE (type), context_die); 7898 else 7899 subtype_die = base_type_die (TREE_TYPE (type)); 7900 7901 subrange_die = new_die (DW_TAG_subrange_type, context_die, type); 7902 7903 if (name != NULL) 7904 { 7905 if (TREE_CODE (name) == TYPE_DECL) 7906 name = DECL_NAME (name); 7907 add_name_attribute (subrange_die, IDENTIFIER_POINTER (name)); 7908 } 7909 7910 if (int_size_in_bytes (TREE_TYPE (type)) != size_in_bytes) 7911 { 7912 /* The size of the subrange type and its base type do not match, 7913 so we need to generate a size attribute for the subrange type. */ 7914 add_AT_unsigned (subrange_die, DW_AT_byte_size, size_in_bytes); 7915 } 7916 7917 if (TYPE_MIN_VALUE (type) != NULL) 7918 add_bound_info (subrange_die, DW_AT_lower_bound, 7919 TYPE_MIN_VALUE (type)); 7920 if (TYPE_MAX_VALUE (type) != NULL) 7921 add_bound_info (subrange_die, DW_AT_upper_bound, 7922 TYPE_MAX_VALUE (type)); 7923 add_AT_die_ref (subrange_die, DW_AT_type, subtype_die); 7924 7925 return subrange_die; 7926} 7927 7928/* Given a pointer to an arbitrary ..._TYPE tree node, return a debugging 7929 entry that chains various modifiers in front of the given type. */ 7930 7931static dw_die_ref 7932modified_type_die (tree type, int is_const_type, int is_volatile_type, 7933 dw_die_ref context_die) 7934{ 7935 enum tree_code code = TREE_CODE (type); 7936 dw_die_ref mod_type_die = NULL; 7937 dw_die_ref sub_die = NULL; 7938 tree item_type = NULL; 7939 7940 if (code != ERROR_MARK) 7941 { 7942 tree qualified_type; 7943 7944 /* See if we already have the appropriately qualified variant of 7945 this type. */ 7946 qualified_type 7947 = get_qualified_type (type, 7948 ((is_const_type ? TYPE_QUAL_CONST : 0) 7949 | (is_volatile_type 7950 ? TYPE_QUAL_VOLATILE : 0))); 7951 7952 /* If we do, then we can just use its DIE, if it exists. */ 7953 if (qualified_type) 7954 { 7955 mod_type_die = lookup_type_die (qualified_type); 7956 if (mod_type_die) 7957 return mod_type_die; 7958 } 7959 7960 /* Handle C typedef types. */ 7961 if (qualified_type && TYPE_NAME (qualified_type) 7962 && TREE_CODE (TYPE_NAME (qualified_type)) == TYPE_DECL 7963 && DECL_ORIGINAL_TYPE (TYPE_NAME (qualified_type))) 7964 { 7965 tree type_name = TYPE_NAME (qualified_type); 7966 tree dtype = TREE_TYPE (type_name); 7967 7968 if (qualified_type == dtype) 7969 { 7970 /* For a named type, use the typedef. */ 7971 gen_type_die (qualified_type, context_die); 7972 mod_type_die = lookup_type_die (qualified_type); 7973 } 7974 else if (is_const_type < TYPE_READONLY (dtype) 7975 || is_volatile_type < TYPE_VOLATILE (dtype)) 7976 /* cv-unqualified version of named type. Just use the unnamed 7977 type to which it refers. */ 7978 mod_type_die 7979 = modified_type_die (DECL_ORIGINAL_TYPE (type_name), 7980 is_const_type, is_volatile_type, 7981 context_die); 7982 7983 /* Else cv-qualified version of named type; fall through. */ 7984 } 7985 7986 if (mod_type_die) 7987 /* OK. */ 7988 ; 7989 else if (is_const_type) 7990 { 7991 mod_type_die = new_die (DW_TAG_const_type, comp_unit_die, type); 7992 sub_die = modified_type_die (type, 0, is_volatile_type, context_die); 7993 } 7994 else if (is_volatile_type) 7995 { 7996 mod_type_die = new_die (DW_TAG_volatile_type, comp_unit_die, type); 7997 sub_die = modified_type_die (type, 0, 0, context_die); 7998 } 7999 else if (code == POINTER_TYPE) 8000 { 8001 mod_type_die = new_die (DW_TAG_pointer_type, comp_unit_die, type); 8002 add_AT_unsigned (mod_type_die, DW_AT_byte_size, 8003 simple_type_size_in_bits (type) / BITS_PER_UNIT); 8004#if 0 8005 add_AT_unsigned (mod_type_die, DW_AT_address_class, 0); 8006#endif 8007 item_type = TREE_TYPE (type); 8008 } 8009 else if (code == REFERENCE_TYPE) 8010 { 8011 mod_type_die = new_die (DW_TAG_reference_type, comp_unit_die, type); 8012 add_AT_unsigned (mod_type_die, DW_AT_byte_size, 8013 simple_type_size_in_bits (type) / BITS_PER_UNIT); 8014#if 0 8015 add_AT_unsigned (mod_type_die, DW_AT_address_class, 0); 8016#endif 8017 item_type = TREE_TYPE (type); 8018 } 8019 else if (is_subrange_type (type)) 8020 mod_type_die = subrange_type_die (type, context_die); 8021 else if (is_base_type (type)) 8022 mod_type_die = base_type_die (type); 8023 else 8024 { 8025 gen_type_die (type, context_die); 8026 8027 /* We have to get the type_main_variant here (and pass that to the 8028 `lookup_type_die' routine) because the ..._TYPE node we have 8029 might simply be a *copy* of some original type node (where the 8030 copy was created to help us keep track of typedef names) and 8031 that copy might have a different TYPE_UID from the original 8032 ..._TYPE node. */ 8033 if (TREE_CODE (type) != VECTOR_TYPE) 8034 mod_type_die = lookup_type_die (type_main_variant (type)); 8035 else 8036 /* Vectors have the debugging information in the type, 8037 not the main variant. */ 8038 mod_type_die = lookup_type_die (type); 8039 if (mod_type_die == NULL) 8040 abort (); 8041 } 8042 8043 /* We want to equate the qualified type to the die below. */ 8044 type = qualified_type; 8045 } 8046 8047 if (type) 8048 equate_type_number_to_die (type, mod_type_die); 8049 if (item_type) 8050 /* We must do this after the equate_type_number_to_die call, in case 8051 this is a recursive type. This ensures that the modified_type_die 8052 recursion will terminate even if the type is recursive. Recursive 8053 types are possible in Ada. */ 8054 sub_die = modified_type_die (item_type, 8055 TYPE_READONLY (item_type), 8056 TYPE_VOLATILE (item_type), 8057 context_die); 8058 8059 if (sub_die != NULL) 8060 add_AT_die_ref (mod_type_die, DW_AT_type, sub_die); 8061 8062 return mod_type_die; 8063} 8064 8065/* Given a pointer to an arbitrary ..._TYPE tree node, return true if it is 8066 an enumerated type. */ 8067 8068static inline int 8069type_is_enum (tree type) 8070{ 8071 return TREE_CODE (type) == ENUMERAL_TYPE; 8072} 8073 8074/* Return the DBX register number described by a given RTL node. */ 8075 8076static unsigned int 8077dbx_reg_number (rtx rtl) 8078{ 8079 unsigned regno = REGNO (rtl); 8080 8081 if (regno >= FIRST_PSEUDO_REGISTER) 8082 abort (); 8083 8084 return DBX_REGISTER_NUMBER (regno); 8085} 8086 8087/* Return a location descriptor that designates a machine register or 8088 zero if there is none. */ 8089 8090static dw_loc_descr_ref 8091reg_loc_descriptor (rtx rtl) 8092{ 8093 unsigned reg; 8094 rtx regs; 8095 8096 if (REGNO (rtl) >= FIRST_PSEUDO_REGISTER) 8097 return 0; 8098 8099 reg = dbx_reg_number (rtl); 8100 regs = (*targetm.dwarf_register_span) (rtl); 8101 8102 if (HARD_REGNO_NREGS (REGNO (rtl), GET_MODE (rtl)) > 1 8103 || regs) 8104 return multiple_reg_loc_descriptor (rtl, regs); 8105 else 8106 return one_reg_loc_descriptor (reg); 8107} 8108 8109/* Return a location descriptor that designates a machine register for 8110 a given hard register number. */ 8111 8112static dw_loc_descr_ref 8113one_reg_loc_descriptor (unsigned int regno) 8114{ 8115 if (regno <= 31) 8116 return new_loc_descr (DW_OP_reg0 + regno, 0, 0); 8117 else 8118 return new_loc_descr (DW_OP_regx, regno, 0); 8119} 8120 8121/* Given an RTL of a register, return a location descriptor that 8122 designates a value that spans more than one register. */ 8123 8124static dw_loc_descr_ref 8125multiple_reg_loc_descriptor (rtx rtl, rtx regs) 8126{ 8127 int nregs, size, i; 8128 unsigned reg; 8129 dw_loc_descr_ref loc_result = NULL; 8130 8131 reg = dbx_reg_number (rtl); 8132 nregs = HARD_REGNO_NREGS (REGNO (rtl), GET_MODE (rtl)); 8133 8134 /* Simple, contiguous registers. */ 8135 if (regs == NULL_RTX) 8136 { 8137 size = GET_MODE_SIZE (GET_MODE (rtl)) / nregs; 8138 8139 loc_result = NULL; 8140 while (nregs--) 8141 { 8142 dw_loc_descr_ref t; 8143 8144 t = one_reg_loc_descriptor (reg); 8145 add_loc_descr (&loc_result, t); 8146 add_loc_descr (&loc_result, new_loc_descr (DW_OP_piece, size, 0)); 8147 ++reg; 8148 } 8149 return loc_result; 8150 } 8151 8152 /* Now onto stupid register sets in non contiguous locations. */ 8153 8154 if (GET_CODE (regs) != PARALLEL) 8155 abort (); 8156 8157 size = GET_MODE_SIZE (GET_MODE (XVECEXP (regs, 0, 0))); 8158 loc_result = NULL; 8159 8160 for (i = 0; i < XVECLEN (regs, 0); ++i) 8161 { 8162 dw_loc_descr_ref t; 8163 8164 t = one_reg_loc_descriptor (REGNO (XVECEXP (regs, 0, i))); 8165 add_loc_descr (&loc_result, t); 8166 size = GET_MODE_SIZE (GET_MODE (XVECEXP (regs, 0, 0))); 8167 add_loc_descr (&loc_result, new_loc_descr (DW_OP_piece, size, 0)); 8168 } 8169 return loc_result; 8170} 8171 8172/* Return a location descriptor that designates a constant. */ 8173 8174static dw_loc_descr_ref 8175int_loc_descriptor (HOST_WIDE_INT i) 8176{ 8177 enum dwarf_location_atom op; 8178 8179 /* Pick the smallest representation of a constant, rather than just 8180 defaulting to the LEB encoding. */ 8181 if (i >= 0) 8182 { 8183 if (i <= 31) 8184 op = DW_OP_lit0 + i; 8185 else if (i <= 0xff) 8186 op = DW_OP_const1u; 8187 else if (i <= 0xffff) 8188 op = DW_OP_const2u; 8189 else if (HOST_BITS_PER_WIDE_INT == 32 8190 || i <= 0xffffffff) 8191 op = DW_OP_const4u; 8192 else 8193 op = DW_OP_constu; 8194 } 8195 else 8196 { 8197 if (i >= -0x80) 8198 op = DW_OP_const1s; 8199 else if (i >= -0x8000) 8200 op = DW_OP_const2s; 8201 else if (HOST_BITS_PER_WIDE_INT == 32 8202 || i >= -0x80000000) 8203 op = DW_OP_const4s; 8204 else 8205 op = DW_OP_consts; 8206 } 8207 8208 return new_loc_descr (op, i, 0); 8209} 8210 8211/* Return a location descriptor that designates a base+offset location. */ 8212 8213static dw_loc_descr_ref 8214based_loc_descr (unsigned int reg, HOST_WIDE_INT offset) 8215{ 8216 dw_loc_descr_ref loc_result; 8217 /* For the "frame base", we use the frame pointer or stack pointer 8218 registers, since the RTL for local variables is relative to one of 8219 them. */ 8220 unsigned fp_reg = DBX_REGISTER_NUMBER (frame_pointer_needed 8221 ? HARD_FRAME_POINTER_REGNUM 8222 : STACK_POINTER_REGNUM); 8223 8224 if (reg == fp_reg) 8225 loc_result = new_loc_descr (DW_OP_fbreg, offset, 0); 8226 else if (reg <= 31) 8227 loc_result = new_loc_descr (DW_OP_breg0 + reg, offset, 0); 8228 else 8229 loc_result = new_loc_descr (DW_OP_bregx, reg, offset); 8230 8231 return loc_result; 8232} 8233 8234/* Return true if this RTL expression describes a base+offset calculation. */ 8235 8236static inline int 8237is_based_loc (rtx rtl) 8238{ 8239 return (GET_CODE (rtl) == PLUS 8240 && ((GET_CODE (XEXP (rtl, 0)) == REG 8241 && REGNO (XEXP (rtl, 0)) < FIRST_PSEUDO_REGISTER 8242 && GET_CODE (XEXP (rtl, 1)) == CONST_INT))); 8243} 8244 8245/* The following routine converts the RTL for a variable or parameter 8246 (resident in memory) into an equivalent Dwarf representation of a 8247 mechanism for getting the address of that same variable onto the top of a 8248 hypothetical "address evaluation" stack. 8249 8250 When creating memory location descriptors, we are effectively transforming 8251 the RTL for a memory-resident object into its Dwarf postfix expression 8252 equivalent. This routine recursively descends an RTL tree, turning 8253 it into Dwarf postfix code as it goes. 8254 8255 MODE is the mode of the memory reference, needed to handle some 8256 autoincrement addressing modes. 8257 8258 Return 0 if we can't represent the location. */ 8259 8260static dw_loc_descr_ref 8261mem_loc_descriptor (rtx rtl, enum machine_mode mode) 8262{ 8263 dw_loc_descr_ref mem_loc_result = NULL; 8264 8265 /* Note that for a dynamically sized array, the location we will generate a 8266 description of here will be the lowest numbered location which is 8267 actually within the array. That's *not* necessarily the same as the 8268 zeroth element of the array. */ 8269 8270 rtl = (*targetm.delegitimize_address) (rtl); 8271 8272 switch (GET_CODE (rtl)) 8273 { 8274 case POST_INC: 8275 case POST_DEC: 8276 case POST_MODIFY: 8277 /* POST_INC and POST_DEC can be handled just like a SUBREG. So we 8278 just fall into the SUBREG code. */ 8279 8280 /* ... fall through ... */ 8281 8282 case SUBREG: 8283 /* The case of a subreg may arise when we have a local (register) 8284 variable or a formal (register) parameter which doesn't quite fill 8285 up an entire register. For now, just assume that it is 8286 legitimate to make the Dwarf info refer to the whole register which 8287 contains the given subreg. */ 8288 rtl = SUBREG_REG (rtl); 8289 8290 /* ... fall through ... */ 8291 8292 case REG: 8293 /* Whenever a register number forms a part of the description of the 8294 method for calculating the (dynamic) address of a memory resident 8295 object, DWARF rules require the register number be referred to as 8296 a "base register". This distinction is not based in any way upon 8297 what category of register the hardware believes the given register 8298 belongs to. This is strictly DWARF terminology we're dealing with 8299 here. Note that in cases where the location of a memory-resident 8300 data object could be expressed as: OP_ADD (OP_BASEREG (basereg), 8301 OP_CONST (0)) the actual DWARF location descriptor that we generate 8302 may just be OP_BASEREG (basereg). This may look deceptively like 8303 the object in question was allocated to a register (rather than in 8304 memory) so DWARF consumers need to be aware of the subtle 8305 distinction between OP_REG and OP_BASEREG. */ 8306 if (REGNO (rtl) < FIRST_PSEUDO_REGISTER) 8307 mem_loc_result = based_loc_descr (dbx_reg_number (rtl), 0); 8308 break; 8309 8310 case MEM: 8311 mem_loc_result = mem_loc_descriptor (XEXP (rtl, 0), GET_MODE (rtl)); 8312 if (mem_loc_result != 0) 8313 add_loc_descr (&mem_loc_result, new_loc_descr (DW_OP_deref, 0, 0)); 8314 break; 8315 8316 case LO_SUM: 8317 rtl = XEXP (rtl, 1); 8318 8319 /* ... fall through ... */ 8320 8321 case LABEL_REF: 8322 /* Some ports can transform a symbol ref into a label ref, because 8323 the symbol ref is too far away and has to be dumped into a constant 8324 pool. */ 8325 case CONST: 8326 case SYMBOL_REF: 8327 /* Alternatively, the symbol in the constant pool might be referenced 8328 by a different symbol. */ 8329 if (GET_CODE (rtl) == SYMBOL_REF && CONSTANT_POOL_ADDRESS_P (rtl)) 8330 { 8331 bool marked; 8332 rtx tmp = get_pool_constant_mark (rtl, &marked); 8333 8334 if (GET_CODE (tmp) == SYMBOL_REF) 8335 { 8336 rtl = tmp; 8337 if (CONSTANT_POOL_ADDRESS_P (tmp)) 8338 get_pool_constant_mark (tmp, &marked); 8339 else 8340 marked = true; 8341 } 8342 8343 /* If all references to this pool constant were optimized away, 8344 it was not output and thus we can't represent it. 8345 FIXME: might try to use DW_OP_const_value here, though 8346 DW_OP_piece complicates it. */ 8347 if (!marked) 8348 return 0; 8349 } 8350 8351 mem_loc_result = new_loc_descr (DW_OP_addr, 0, 0); 8352 mem_loc_result->dw_loc_oprnd1.val_class = dw_val_class_addr; 8353 mem_loc_result->dw_loc_oprnd1.v.val_addr = rtl; 8354 VARRAY_PUSH_RTX (used_rtx_varray, rtl); 8355 break; 8356 8357 case PRE_MODIFY: 8358 /* Extract the PLUS expression nested inside and fall into 8359 PLUS code below. */ 8360 rtl = XEXP (rtl, 1); 8361 goto plus; 8362 8363 case PRE_INC: 8364 case PRE_DEC: 8365 /* Turn these into a PLUS expression and fall into the PLUS code 8366 below. */ 8367 rtl = gen_rtx_PLUS (word_mode, XEXP (rtl, 0), 8368 GEN_INT (GET_CODE (rtl) == PRE_INC 8369 ? GET_MODE_UNIT_SIZE (mode) 8370 : -GET_MODE_UNIT_SIZE (mode))); 8371 8372 /* ... fall through ... */ 8373 8374 case PLUS: 8375 plus: 8376 if (is_based_loc (rtl)) 8377 mem_loc_result = based_loc_descr (dbx_reg_number (XEXP (rtl, 0)), 8378 INTVAL (XEXP (rtl, 1))); 8379 else 8380 { 8381 mem_loc_result = mem_loc_descriptor (XEXP (rtl, 0), mode); 8382 if (mem_loc_result == 0) 8383 break; 8384 8385 if (GET_CODE (XEXP (rtl, 1)) == CONST_INT 8386 && INTVAL (XEXP (rtl, 1)) >= 0) 8387 add_loc_descr (&mem_loc_result, 8388 new_loc_descr (DW_OP_plus_uconst, 8389 INTVAL (XEXP (rtl, 1)), 0)); 8390 else 8391 { 8392 add_loc_descr (&mem_loc_result, 8393 mem_loc_descriptor (XEXP (rtl, 1), mode)); 8394 add_loc_descr (&mem_loc_result, 8395 new_loc_descr (DW_OP_plus, 0, 0)); 8396 } 8397 } 8398 break; 8399 8400 case MULT: 8401 { 8402 /* If a pseudo-reg is optimized away, it is possible for it to 8403 be replaced with a MEM containing a multiply. */ 8404 dw_loc_descr_ref op0 = mem_loc_descriptor (XEXP (rtl, 0), mode); 8405 dw_loc_descr_ref op1 = mem_loc_descriptor (XEXP (rtl, 1), mode); 8406 8407 if (op0 == 0 || op1 == 0) 8408 break; 8409 8410 mem_loc_result = op0; 8411 add_loc_descr (&mem_loc_result, op1); 8412 add_loc_descr (&mem_loc_result, new_loc_descr (DW_OP_mul, 0, 0)); 8413 break; 8414 } 8415 8416 case CONST_INT: 8417 mem_loc_result = int_loc_descriptor (INTVAL (rtl)); 8418 break; 8419 8420 case ADDRESSOF: 8421 /* If this is a MEM, return its address. Otherwise, we can't 8422 represent this. */ 8423 if (GET_CODE (XEXP (rtl, 0)) == MEM) 8424 return mem_loc_descriptor (XEXP (XEXP (rtl, 0), 0), mode); 8425 else 8426 return 0; 8427 8428 default: 8429 abort (); 8430 } 8431 8432 return mem_loc_result; 8433} 8434 8435/* Return a descriptor that describes the concatenation of two locations. 8436 This is typically a complex variable. */ 8437 8438static dw_loc_descr_ref 8439concat_loc_descriptor (rtx x0, rtx x1) 8440{ 8441 dw_loc_descr_ref cc_loc_result = NULL; 8442 dw_loc_descr_ref x0_ref = loc_descriptor (x0); 8443 dw_loc_descr_ref x1_ref = loc_descriptor (x1); 8444 8445 if (x0_ref == 0 || x1_ref == 0) 8446 return 0; 8447 8448 cc_loc_result = x0_ref; 8449 add_loc_descr (&cc_loc_result, 8450 new_loc_descr (DW_OP_piece, 8451 GET_MODE_SIZE (GET_MODE (x0)), 0)); 8452 8453 add_loc_descr (&cc_loc_result, x1_ref); 8454 add_loc_descr (&cc_loc_result, 8455 new_loc_descr (DW_OP_piece, 8456 GET_MODE_SIZE (GET_MODE (x1)), 0)); 8457 8458 return cc_loc_result; 8459} 8460 8461/* Output a proper Dwarf location descriptor for a variable or parameter 8462 which is either allocated in a register or in a memory location. For a 8463 register, we just generate an OP_REG and the register number. For a 8464 memory location we provide a Dwarf postfix expression describing how to 8465 generate the (dynamic) address of the object onto the address stack. 8466 8467 If we don't know how to describe it, return 0. */ 8468 8469static dw_loc_descr_ref 8470loc_descriptor (rtx rtl) 8471{ 8472 dw_loc_descr_ref loc_result = NULL; 8473 8474 switch (GET_CODE (rtl)) 8475 { 8476 case SUBREG: 8477 /* The case of a subreg may arise when we have a local (register) 8478 variable or a formal (register) parameter which doesn't quite fill 8479 up an entire register. For now, just assume that it is 8480 legitimate to make the Dwarf info refer to the whole register which 8481 contains the given subreg. */ 8482 rtl = SUBREG_REG (rtl); 8483 8484 /* ... fall through ... */ 8485 8486 case REG: 8487 loc_result = reg_loc_descriptor (rtl); 8488 break; 8489 8490 case MEM: 8491 loc_result = mem_loc_descriptor (XEXP (rtl, 0), GET_MODE (rtl)); 8492 break; 8493 8494 case CONCAT: 8495 loc_result = concat_loc_descriptor (XEXP (rtl, 0), XEXP (rtl, 1)); 8496 break; 8497 8498 default: 8499 abort (); 8500 } 8501 8502 return loc_result; 8503} 8504 8505/* Similar, but generate the descriptor from trees instead of rtl. This comes 8506 up particularly with variable length arrays. If ADDRESSP is nonzero, we are 8507 looking for an address. Otherwise, we return a value. If we can't make a 8508 descriptor, return 0. */ 8509 8510static dw_loc_descr_ref 8511loc_descriptor_from_tree (tree loc, int addressp) 8512{ 8513 dw_loc_descr_ref ret, ret1; 8514 int indirect_p = 0; 8515 int unsignedp = TREE_UNSIGNED (TREE_TYPE (loc)); 8516 enum dwarf_location_atom op; 8517 8518 /* ??? Most of the time we do not take proper care for sign/zero 8519 extending the values properly. Hopefully this won't be a real 8520 problem... */ 8521 8522 switch (TREE_CODE (loc)) 8523 { 8524 case ERROR_MARK: 8525 return 0; 8526 8527 case WITH_RECORD_EXPR: 8528 case PLACEHOLDER_EXPR: 8529 /* This case involves extracting fields from an object to determine the 8530 position of other fields. We don't try to encode this here. The 8531 only user of this is Ada, which encodes the needed information using 8532 the names of types. */ 8533 return 0; 8534 8535 case CALL_EXPR: 8536 return 0; 8537 8538 case PREINCREMENT_EXPR: 8539 case PREDECREMENT_EXPR: 8540 case POSTINCREMENT_EXPR: 8541 case POSTDECREMENT_EXPR: 8542 /* There are no opcodes for these operations. */ 8543 return 0; 8544 8545 case ADDR_EXPR: 8546 /* We can support this only if we can look through conversions and 8547 find an INDIRECT_EXPR. */ 8548 for (loc = TREE_OPERAND (loc, 0); 8549 TREE_CODE (loc) == CONVERT_EXPR || TREE_CODE (loc) == NOP_EXPR 8550 || TREE_CODE (loc) == NON_LVALUE_EXPR 8551 || TREE_CODE (loc) == VIEW_CONVERT_EXPR 8552 || TREE_CODE (loc) == SAVE_EXPR; 8553 loc = TREE_OPERAND (loc, 0)) 8554 ; 8555 8556 return (TREE_CODE (loc) == INDIRECT_REF 8557 ? loc_descriptor_from_tree (TREE_OPERAND (loc, 0), addressp) 8558 : 0); 8559 8560 case VAR_DECL: 8561 if (DECL_THREAD_LOCAL (loc)) 8562 { 8563 rtx rtl; 8564 8565#ifndef ASM_OUTPUT_DWARF_DTPREL 8566 /* If this is not defined, we have no way to emit the data. */ 8567 return 0; 8568#endif 8569 8570 /* The way DW_OP_GNU_push_tls_address is specified, we can only 8571 look up addresses of objects in the current module. */ 8572 if (DECL_EXTERNAL (loc)) 8573 return 0; 8574 8575 rtl = rtl_for_decl_location (loc); 8576 if (rtl == NULL_RTX) 8577 return 0; 8578 8579 if (GET_CODE (rtl) != MEM) 8580 return 0; 8581 rtl = XEXP (rtl, 0); 8582 if (! CONSTANT_P (rtl)) 8583 return 0; 8584 8585 ret = new_loc_descr (INTERNAL_DW_OP_tls_addr, 0, 0); 8586 ret->dw_loc_oprnd1.val_class = dw_val_class_addr; 8587 ret->dw_loc_oprnd1.v.val_addr = rtl; 8588 8589 ret1 = new_loc_descr (DW_OP_GNU_push_tls_address, 0, 0); 8590 add_loc_descr (&ret, ret1); 8591 8592 indirect_p = 1; 8593 break; 8594 } 8595 /* Fall through. */ 8596 8597 case PARM_DECL: 8598 { 8599 rtx rtl = rtl_for_decl_location (loc); 8600 8601 if (rtl == NULL_RTX) 8602 return 0; 8603 else if (CONSTANT_P (rtl)) 8604 { 8605 ret = new_loc_descr (DW_OP_addr, 0, 0); 8606 ret->dw_loc_oprnd1.val_class = dw_val_class_addr; 8607 ret->dw_loc_oprnd1.v.val_addr = rtl; 8608 indirect_p = 1; 8609 } 8610 else 8611 { 8612 enum machine_mode mode = GET_MODE (rtl); 8613 8614 if (GET_CODE (rtl) == MEM) 8615 { 8616 indirect_p = 1; 8617 rtl = XEXP (rtl, 0); 8618 } 8619 8620 ret = mem_loc_descriptor (rtl, mode); 8621 } 8622 } 8623 break; 8624 8625 case INDIRECT_REF: 8626 ret = loc_descriptor_from_tree (TREE_OPERAND (loc, 0), 0); 8627 indirect_p = 1; 8628 break; 8629 8630 case COMPOUND_EXPR: 8631 return loc_descriptor_from_tree (TREE_OPERAND (loc, 1), addressp); 8632 8633 case NOP_EXPR: 8634 case CONVERT_EXPR: 8635 case NON_LVALUE_EXPR: 8636 case VIEW_CONVERT_EXPR: 8637 case SAVE_EXPR: 8638 case MODIFY_EXPR: 8639 return loc_descriptor_from_tree (TREE_OPERAND (loc, 0), addressp); 8640 8641 case COMPONENT_REF: 8642 case BIT_FIELD_REF: 8643 case ARRAY_REF: 8644 case ARRAY_RANGE_REF: 8645 { 8646 tree obj, offset; 8647 HOST_WIDE_INT bitsize, bitpos, bytepos; 8648 enum machine_mode mode; 8649 int volatilep; 8650 8651 obj = get_inner_reference (loc, &bitsize, &bitpos, &offset, &mode, 8652 &unsignedp, &volatilep); 8653 8654 if (obj == loc) 8655 return 0; 8656 8657 ret = loc_descriptor_from_tree (obj, 1); 8658 if (ret == 0 8659 || bitpos % BITS_PER_UNIT != 0 || bitsize % BITS_PER_UNIT != 0) 8660 return 0; 8661 8662 if (offset != NULL_TREE) 8663 { 8664 /* Variable offset. */ 8665 add_loc_descr (&ret, loc_descriptor_from_tree (offset, 0)); 8666 add_loc_descr (&ret, new_loc_descr (DW_OP_plus, 0, 0)); 8667 } 8668 8669 if (!addressp) 8670 indirect_p = 1; 8671 8672 bytepos = bitpos / BITS_PER_UNIT; 8673 if (bytepos > 0) 8674 add_loc_descr (&ret, new_loc_descr (DW_OP_plus_uconst, bytepos, 0)); 8675 else if (bytepos < 0) 8676 { 8677 add_loc_descr (&ret, int_loc_descriptor (bytepos)); 8678 add_loc_descr (&ret, new_loc_descr (DW_OP_plus, 0, 0)); 8679 } 8680 break; 8681 } 8682 8683 case INTEGER_CST: 8684 if (host_integerp (loc, 0)) 8685 ret = int_loc_descriptor (tree_low_cst (loc, 0)); 8686 else 8687 return 0; 8688 break; 8689 8690 case CONSTRUCTOR: 8691 { 8692 /* Get an RTL for this, if something has been emitted. */ 8693 rtx rtl = lookup_constant_def (loc); 8694 enum machine_mode mode; 8695 8696 if (GET_CODE (rtl) != MEM) 8697 return 0; 8698 mode = GET_MODE (rtl); 8699 rtl = XEXP (rtl, 0); 8700 8701 rtl = (*targetm.delegitimize_address) (rtl); 8702 8703 indirect_p = 1; 8704 ret = mem_loc_descriptor (rtl, mode); 8705 break; 8706 } 8707 8708 case TRUTH_AND_EXPR: 8709 case TRUTH_ANDIF_EXPR: 8710 case BIT_AND_EXPR: 8711 op = DW_OP_and; 8712 goto do_binop; 8713 8714 case TRUTH_XOR_EXPR: 8715 case BIT_XOR_EXPR: 8716 op = DW_OP_xor; 8717 goto do_binop; 8718 8719 case TRUTH_OR_EXPR: 8720 case TRUTH_ORIF_EXPR: 8721 case BIT_IOR_EXPR: 8722 op = DW_OP_or; 8723 goto do_binop; 8724 8725 case FLOOR_DIV_EXPR: 8726 case CEIL_DIV_EXPR: 8727 case ROUND_DIV_EXPR: 8728 case TRUNC_DIV_EXPR: 8729 op = DW_OP_div; 8730 goto do_binop; 8731 8732 case MINUS_EXPR: 8733 op = DW_OP_minus; 8734 goto do_binop; 8735 8736 case FLOOR_MOD_EXPR: 8737 case CEIL_MOD_EXPR: 8738 case ROUND_MOD_EXPR: 8739 case TRUNC_MOD_EXPR: 8740 op = DW_OP_mod; 8741 goto do_binop; 8742 8743 case MULT_EXPR: 8744 op = DW_OP_mul; 8745 goto do_binop; 8746 8747 case LSHIFT_EXPR: 8748 op = DW_OP_shl; 8749 goto do_binop; 8750 8751 case RSHIFT_EXPR: 8752 op = (unsignedp ? DW_OP_shr : DW_OP_shra); 8753 goto do_binop; 8754 8755 case PLUS_EXPR: 8756 if (TREE_CODE (TREE_OPERAND (loc, 1)) == INTEGER_CST 8757 && host_integerp (TREE_OPERAND (loc, 1), 0)) 8758 { 8759 ret = loc_descriptor_from_tree (TREE_OPERAND (loc, 0), 0); 8760 if (ret == 0) 8761 return 0; 8762 8763 add_loc_descr (&ret, 8764 new_loc_descr (DW_OP_plus_uconst, 8765 tree_low_cst (TREE_OPERAND (loc, 1), 8766 0), 8767 0)); 8768 break; 8769 } 8770 8771 op = DW_OP_plus; 8772 goto do_binop; 8773 8774 case LE_EXPR: 8775 if (TREE_UNSIGNED (TREE_TYPE (TREE_OPERAND (loc, 0)))) 8776 return 0; 8777 8778 op = DW_OP_le; 8779 goto do_binop; 8780 8781 case GE_EXPR: 8782 if (TREE_UNSIGNED (TREE_TYPE (TREE_OPERAND (loc, 0)))) 8783 return 0; 8784 8785 op = DW_OP_ge; 8786 goto do_binop; 8787 8788 case LT_EXPR: 8789 if (TREE_UNSIGNED (TREE_TYPE (TREE_OPERAND (loc, 0)))) 8790 return 0; 8791 8792 op = DW_OP_lt; 8793 goto do_binop; 8794 8795 case GT_EXPR: 8796 if (TREE_UNSIGNED (TREE_TYPE (TREE_OPERAND (loc, 0)))) 8797 return 0; 8798 8799 op = DW_OP_gt; 8800 goto do_binop; 8801 8802 case EQ_EXPR: 8803 op = DW_OP_eq; 8804 goto do_binop; 8805 8806 case NE_EXPR: 8807 op = DW_OP_ne; 8808 goto do_binop; 8809 8810 do_binop: 8811 ret = loc_descriptor_from_tree (TREE_OPERAND (loc, 0), 0); 8812 ret1 = loc_descriptor_from_tree (TREE_OPERAND (loc, 1), 0); 8813 if (ret == 0 || ret1 == 0) 8814 return 0; 8815 8816 add_loc_descr (&ret, ret1); 8817 add_loc_descr (&ret, new_loc_descr (op, 0, 0)); 8818 break; 8819 8820 case TRUTH_NOT_EXPR: 8821 case BIT_NOT_EXPR: 8822 op = DW_OP_not; 8823 goto do_unop; 8824 8825 case ABS_EXPR: 8826 op = DW_OP_abs; 8827 goto do_unop; 8828 8829 case NEGATE_EXPR: 8830 op = DW_OP_neg; 8831 goto do_unop; 8832 8833 do_unop: 8834 ret = loc_descriptor_from_tree (TREE_OPERAND (loc, 0), 0); 8835 if (ret == 0) 8836 return 0; 8837 8838 add_loc_descr (&ret, new_loc_descr (op, 0, 0)); 8839 break; 8840 8841 case MAX_EXPR: 8842 loc = build (COND_EXPR, TREE_TYPE (loc), 8843 build (LT_EXPR, integer_type_node, 8844 TREE_OPERAND (loc, 0), TREE_OPERAND (loc, 1)), 8845 TREE_OPERAND (loc, 1), TREE_OPERAND (loc, 0)); 8846 8847 /* ... fall through ... */ 8848 8849 case COND_EXPR: 8850 { 8851 dw_loc_descr_ref lhs 8852 = loc_descriptor_from_tree (TREE_OPERAND (loc, 1), 0); 8853 dw_loc_descr_ref rhs 8854 = loc_descriptor_from_tree (TREE_OPERAND (loc, 2), 0); 8855 dw_loc_descr_ref bra_node, jump_node, tmp; 8856 8857 ret = loc_descriptor_from_tree (TREE_OPERAND (loc, 0), 0); 8858 if (ret == 0 || lhs == 0 || rhs == 0) 8859 return 0; 8860 8861 bra_node = new_loc_descr (DW_OP_bra, 0, 0); 8862 add_loc_descr (&ret, bra_node); 8863 8864 add_loc_descr (&ret, rhs); 8865 jump_node = new_loc_descr (DW_OP_skip, 0, 0); 8866 add_loc_descr (&ret, jump_node); 8867 8868 add_loc_descr (&ret, lhs); 8869 bra_node->dw_loc_oprnd1.val_class = dw_val_class_loc; 8870 bra_node->dw_loc_oprnd1.v.val_loc = lhs; 8871 8872 /* ??? Need a node to point the skip at. Use a nop. */ 8873 tmp = new_loc_descr (DW_OP_nop, 0, 0); 8874 add_loc_descr (&ret, tmp); 8875 jump_node->dw_loc_oprnd1.val_class = dw_val_class_loc; 8876 jump_node->dw_loc_oprnd1.v.val_loc = tmp; 8877 } 8878 break; 8879 8880 case EXPR_WITH_FILE_LOCATION: 8881 return loc_descriptor_from_tree (EXPR_WFL_NODE (loc), addressp); 8882 8883 case FIX_TRUNC_EXPR: 8884 case FIX_CEIL_EXPR: 8885 case FIX_FLOOR_EXPR: 8886 case FIX_ROUND_EXPR: 8887 return 0; 8888 8889 default: 8890 /* Leave front-end specific codes as simply unknown. This comes 8891 up, for instance, with the C STMT_EXPR. */ 8892 if ((unsigned int) TREE_CODE (loc) 8893 >= (unsigned int) LAST_AND_UNUSED_TREE_CODE) 8894 return 0; 8895 8896#ifdef ENABLE_CHECKING 8897 /* Otherwise this is a generic code; we should just lists all of 8898 these explicitly. Aborting means we forgot one. */ 8899 abort (); 8900#else 8901 /* In a release build, we want to degrade gracefully: better to 8902 generate incomplete debugging information than to crash. */ 8903 return NULL; 8904#endif 8905 } 8906 8907 /* Show if we can't fill the request for an address. */ 8908 if (addressp && indirect_p == 0) 8909 return 0; 8910 8911 /* If we've got an address and don't want one, dereference. */ 8912 if (!addressp && indirect_p > 0) 8913 { 8914 HOST_WIDE_INT size = int_size_in_bytes (TREE_TYPE (loc)); 8915 8916 if (size > DWARF2_ADDR_SIZE || size == -1) 8917 return 0; 8918 else if (size == DWARF2_ADDR_SIZE) 8919 op = DW_OP_deref; 8920 else 8921 op = DW_OP_deref_size; 8922 8923 add_loc_descr (&ret, new_loc_descr (op, size, 0)); 8924 } 8925 8926 return ret; 8927} 8928 8929/* Given a value, round it up to the lowest multiple of `boundary' 8930 which is not less than the value itself. */ 8931 8932static inline HOST_WIDE_INT 8933ceiling (HOST_WIDE_INT value, unsigned int boundary) 8934{ 8935 return (((value + boundary - 1) / boundary) * boundary); 8936} 8937 8938/* Given a pointer to what is assumed to be a FIELD_DECL node, return a 8939 pointer to the declared type for the relevant field variable, or return 8940 `integer_type_node' if the given node turns out to be an 8941 ERROR_MARK node. */ 8942 8943static inline tree 8944field_type (tree decl) 8945{ 8946 tree type; 8947 8948 if (TREE_CODE (decl) == ERROR_MARK) 8949 return integer_type_node; 8950 8951 type = DECL_BIT_FIELD_TYPE (decl); 8952 if (type == NULL_TREE) 8953 type = TREE_TYPE (decl); 8954 8955 return type; 8956} 8957 8958/* Given a pointer to a tree node, return the alignment in bits for 8959 it, or else return BITS_PER_WORD if the node actually turns out to 8960 be an ERROR_MARK node. */ 8961 8962static inline unsigned 8963simple_type_align_in_bits (tree type) 8964{ 8965 return (TREE_CODE (type) != ERROR_MARK) ? TYPE_ALIGN (type) : BITS_PER_WORD; 8966} 8967 8968static inline unsigned 8969simple_decl_align_in_bits (tree decl) 8970{ 8971 return (TREE_CODE (decl) != ERROR_MARK) ? DECL_ALIGN (decl) : BITS_PER_WORD; 8972} 8973 8974/* Given a pointer to a FIELD_DECL, compute and return the byte offset of the 8975 lowest addressed byte of the "containing object" for the given FIELD_DECL, 8976 or return 0 if we are unable to determine what that offset is, either 8977 because the argument turns out to be a pointer to an ERROR_MARK node, or 8978 because the offset is actually variable. (We can't handle the latter case 8979 just yet). */ 8980 8981static HOST_WIDE_INT 8982field_byte_offset (tree decl) 8983{ 8984 unsigned int type_align_in_bits; 8985 unsigned int decl_align_in_bits; 8986 unsigned HOST_WIDE_INT type_size_in_bits; 8987 HOST_WIDE_INT object_offset_in_bits; 8988 tree type; 8989 tree field_size_tree; 8990 HOST_WIDE_INT bitpos_int; 8991 HOST_WIDE_INT deepest_bitpos; 8992 unsigned HOST_WIDE_INT field_size_in_bits; 8993 8994 if (TREE_CODE (decl) == ERROR_MARK) 8995 return 0; 8996 else if (TREE_CODE (decl) != FIELD_DECL) 8997 abort (); 8998 8999 type = field_type (decl); 9000 field_size_tree = DECL_SIZE (decl); 9001 9002 /* The size could be unspecified if there was an error, or for 9003 a flexible array member. */ 9004 if (! field_size_tree) 9005 field_size_tree = bitsize_zero_node; 9006 9007 /* We cannot yet cope with fields whose positions are variable, so 9008 for now, when we see such things, we simply return 0. Someday, we may 9009 be able to handle such cases, but it will be damn difficult. */ 9010 if (! host_integerp (bit_position (decl), 0)) 9011 return 0; 9012 9013 bitpos_int = int_bit_position (decl); 9014 9015 /* If we don't know the size of the field, pretend it's a full word. */ 9016 if (host_integerp (field_size_tree, 1)) 9017 field_size_in_bits = tree_low_cst (field_size_tree, 1); 9018 else 9019 field_size_in_bits = BITS_PER_WORD; 9020 9021 type_size_in_bits = simple_type_size_in_bits (type); 9022 type_align_in_bits = simple_type_align_in_bits (type); 9023 decl_align_in_bits = simple_decl_align_in_bits (decl); 9024 9025 /* The GCC front-end doesn't make any attempt to keep track of the starting 9026 bit offset (relative to the start of the containing structure type) of the 9027 hypothetical "containing object" for a bit-field. Thus, when computing 9028 the byte offset value for the start of the "containing object" of a 9029 bit-field, we must deduce this information on our own. This can be rather 9030 tricky to do in some cases. For example, handling the following structure 9031 type definition when compiling for an i386/i486 target (which only aligns 9032 long long's to 32-bit boundaries) can be very tricky: 9033 9034 struct S { int field1; long long field2:31; }; 9035 9036 Fortunately, there is a simple rule-of-thumb which can be used in such 9037 cases. When compiling for an i386/i486, GCC will allocate 8 bytes for the 9038 structure shown above. It decides to do this based upon one simple rule 9039 for bit-field allocation. GCC allocates each "containing object" for each 9040 bit-field at the first (i.e. lowest addressed) legitimate alignment 9041 boundary (based upon the required minimum alignment for the declared type 9042 of the field) which it can possibly use, subject to the condition that 9043 there is still enough available space remaining in the containing object 9044 (when allocated at the selected point) to fully accommodate all of the 9045 bits of the bit-field itself. 9046 9047 This simple rule makes it obvious why GCC allocates 8 bytes for each 9048 object of the structure type shown above. When looking for a place to 9049 allocate the "containing object" for `field2', the compiler simply tries 9050 to allocate a 64-bit "containing object" at each successive 32-bit 9051 boundary (starting at zero) until it finds a place to allocate that 64- 9052 bit field such that at least 31 contiguous (and previously unallocated) 9053 bits remain within that selected 64 bit field. (As it turns out, for the 9054 example above, the compiler finds it is OK to allocate the "containing 9055 object" 64-bit field at bit-offset zero within the structure type.) 9056 9057 Here we attempt to work backwards from the limited set of facts we're 9058 given, and we try to deduce from those facts, where GCC must have believed 9059 that the containing object started (within the structure type). The value 9060 we deduce is then used (by the callers of this routine) to generate 9061 DW_AT_location and DW_AT_bit_offset attributes for fields (both bit-fields 9062 and, in the case of DW_AT_location, regular fields as well). */ 9063 9064 /* Figure out the bit-distance from the start of the structure to the 9065 "deepest" bit of the bit-field. */ 9066 deepest_bitpos = bitpos_int + field_size_in_bits; 9067 9068 /* This is the tricky part. Use some fancy footwork to deduce where the 9069 lowest addressed bit of the containing object must be. */ 9070 object_offset_in_bits = deepest_bitpos - type_size_in_bits; 9071 9072 /* Round up to type_align by default. This works best for bitfields. */ 9073 object_offset_in_bits += type_align_in_bits - 1; 9074 object_offset_in_bits /= type_align_in_bits; 9075 object_offset_in_bits *= type_align_in_bits; 9076 9077 if (object_offset_in_bits > bitpos_int) 9078 { 9079 /* Sigh, the decl must be packed. */ 9080 object_offset_in_bits = deepest_bitpos - type_size_in_bits; 9081 9082 /* Round up to decl_align instead. */ 9083 object_offset_in_bits += decl_align_in_bits - 1; 9084 object_offset_in_bits /= decl_align_in_bits; 9085 object_offset_in_bits *= decl_align_in_bits; 9086 } 9087 9088 return object_offset_in_bits / BITS_PER_UNIT; 9089} 9090 9091/* The following routines define various Dwarf attributes and any data 9092 associated with them. */ 9093 9094/* Add a location description attribute value to a DIE. 9095 9096 This emits location attributes suitable for whole variables and 9097 whole parameters. Note that the location attributes for struct fields are 9098 generated by the routine `data_member_location_attribute' below. */ 9099 9100static inline void 9101add_AT_location_description (dw_die_ref die, enum dwarf_attribute attr_kind, 9102 dw_loc_descr_ref descr) 9103{ 9104 if (descr != 0) 9105 add_AT_loc (die, attr_kind, descr); 9106} 9107 9108/* Attach the specialized form of location attribute used for data members of 9109 struct and union types. In the special case of a FIELD_DECL node which 9110 represents a bit-field, the "offset" part of this special location 9111 descriptor must indicate the distance in bytes from the lowest-addressed 9112 byte of the containing struct or union type to the lowest-addressed byte of 9113 the "containing object" for the bit-field. (See the `field_byte_offset' 9114 function above). 9115 9116 For any given bit-field, the "containing object" is a hypothetical object 9117 (of some integral or enum type) within which the given bit-field lives. The 9118 type of this hypothetical "containing object" is always the same as the 9119 declared type of the individual bit-field itself (for GCC anyway... the 9120 DWARF spec doesn't actually mandate this). Note that it is the size (in 9121 bytes) of the hypothetical "containing object" which will be given in the 9122 DW_AT_byte_size attribute for this bit-field. (See the 9123 `byte_size_attribute' function below.) It is also used when calculating the 9124 value of the DW_AT_bit_offset attribute. (See the `bit_offset_attribute' 9125 function below.) */ 9126 9127static void 9128add_data_member_location_attribute (dw_die_ref die, tree decl) 9129{ 9130 HOST_WIDE_INT offset; 9131 dw_loc_descr_ref loc_descr = 0; 9132 9133 if (TREE_CODE (decl) == TREE_VEC) 9134 { 9135 /* We're working on the TAG_inheritance for a base class. */ 9136 if (TREE_VIA_VIRTUAL (decl) && is_cxx ()) 9137 { 9138 /* For C++ virtual bases we can't just use BINFO_OFFSET, as they 9139 aren't at a fixed offset from all (sub)objects of the same 9140 type. We need to extract the appropriate offset from our 9141 vtable. The following dwarf expression means 9142 9143 BaseAddr = ObAddr + *((*ObAddr) - Offset) 9144 9145 This is specific to the V3 ABI, of course. */ 9146 9147 dw_loc_descr_ref tmp; 9148 9149 /* Make a copy of the object address. */ 9150 tmp = new_loc_descr (DW_OP_dup, 0, 0); 9151 add_loc_descr (&loc_descr, tmp); 9152 9153 /* Extract the vtable address. */ 9154 tmp = new_loc_descr (DW_OP_deref, 0, 0); 9155 add_loc_descr (&loc_descr, tmp); 9156 9157 /* Calculate the address of the offset. */ 9158 offset = tree_low_cst (BINFO_VPTR_FIELD (decl), 0); 9159 if (offset >= 0) 9160 abort (); 9161 9162 tmp = int_loc_descriptor (-offset); 9163 add_loc_descr (&loc_descr, tmp); 9164 tmp = new_loc_descr (DW_OP_minus, 0, 0); 9165 add_loc_descr (&loc_descr, tmp); 9166 9167 /* Extract the offset. */ 9168 tmp = new_loc_descr (DW_OP_deref, 0, 0); 9169 add_loc_descr (&loc_descr, tmp); 9170 9171 /* Add it to the object address. */ 9172 tmp = new_loc_descr (DW_OP_plus, 0, 0); 9173 add_loc_descr (&loc_descr, tmp); 9174 } 9175 else 9176 offset = tree_low_cst (BINFO_OFFSET (decl), 0); 9177 } 9178 else 9179 offset = field_byte_offset (decl); 9180 9181 if (! loc_descr) 9182 { 9183 enum dwarf_location_atom op; 9184 9185 /* The DWARF2 standard says that we should assume that the structure 9186 address is already on the stack, so we can specify a structure field 9187 address by using DW_OP_plus_uconst. */ 9188 9189#ifdef MIPS_DEBUGGING_INFO 9190 /* ??? The SGI dwarf reader does not handle the DW_OP_plus_uconst 9191 operator correctly. It works only if we leave the offset on the 9192 stack. */ 9193 op = DW_OP_constu; 9194#else 9195 op = DW_OP_plus_uconst; 9196#endif 9197 9198 loc_descr = new_loc_descr (op, offset, 0); 9199 } 9200 9201 add_AT_loc (die, DW_AT_data_member_location, loc_descr); 9202} 9203 9204/* Writes integer values to dw_vec_const array. */ 9205 9206static void 9207insert_int (HOST_WIDE_INT val, unsigned int size, unsigned char *dest) 9208{ 9209 while (size != 0) 9210 { 9211 *dest++ = val & 0xff; 9212 val >>= 8; 9213 --size; 9214 } 9215} 9216 9217/* Reads integers from dw_vec_const array. Inverse of insert_int. */ 9218 9219static HOST_WIDE_INT 9220extract_int (const unsigned char *src, unsigned int size) 9221{ 9222 HOST_WIDE_INT val = 0; 9223 9224 src += size; 9225 while (size != 0) 9226 { 9227 val <<= 8; 9228 val |= *--src & 0xff; 9229 --size; 9230 } 9231 return val; 9232} 9233 9234/* Writes floating point values to dw_vec_const array. */ 9235 9236static void 9237insert_float (rtx rtl, unsigned char *array) 9238{ 9239 REAL_VALUE_TYPE rv; 9240 long val[4]; 9241 int i; 9242 9243 REAL_VALUE_FROM_CONST_DOUBLE (rv, rtl); 9244 real_to_target (val, &rv, GET_MODE (rtl)); 9245 9246 /* real_to_target puts 32-bit pieces in each long. Pack them. */ 9247 for (i = 0; i < GET_MODE_SIZE (GET_MODE (rtl)) / 4; i++) 9248 { 9249 insert_int (val[i], 4, array); 9250 array += 4; 9251 } 9252} 9253 9254/* Attach a DW_AT_const_value attribute for a variable or a parameter which 9255 does not have a "location" either in memory or in a register. These 9256 things can arise in GNU C when a constant is passed as an actual parameter 9257 to an inlined function. They can also arise in C++ where declared 9258 constants do not necessarily get memory "homes". */ 9259 9260static void 9261add_const_value_attribute (dw_die_ref die, rtx rtl) 9262{ 9263 switch (GET_CODE (rtl)) 9264 { 9265 case CONST_INT: 9266 { 9267 HOST_WIDE_INT val = INTVAL (rtl); 9268 9269 if (val < 0) 9270 add_AT_int (die, DW_AT_const_value, val); 9271 else 9272 add_AT_unsigned (die, DW_AT_const_value, (unsigned HOST_WIDE_INT) val); 9273 } 9274 break; 9275 9276 case CONST_DOUBLE: 9277 /* Note that a CONST_DOUBLE rtx could represent either an integer or a 9278 floating-point constant. A CONST_DOUBLE is used whenever the 9279 constant requires more than one word in order to be adequately 9280 represented. We output CONST_DOUBLEs as blocks. */ 9281 { 9282 enum machine_mode mode = GET_MODE (rtl); 9283 9284 if (GET_MODE_CLASS (mode) == MODE_FLOAT) 9285 { 9286 unsigned int length = GET_MODE_SIZE (mode); 9287 unsigned char *array = ggc_alloc (length); 9288 9289 insert_float (rtl, array); 9290 add_AT_vec (die, DW_AT_const_value, length / 4, 4, array); 9291 } 9292 else 9293 { 9294 /* ??? We really should be using HOST_WIDE_INT throughout. */ 9295 if (HOST_BITS_PER_LONG != HOST_BITS_PER_WIDE_INT) 9296 abort (); 9297 9298 add_AT_long_long (die, DW_AT_const_value, 9299 CONST_DOUBLE_HIGH (rtl), CONST_DOUBLE_LOW (rtl)); 9300 } 9301 } 9302 break; 9303 9304 case CONST_VECTOR: 9305 { 9306 enum machine_mode mode = GET_MODE (rtl); 9307 unsigned int elt_size = GET_MODE_UNIT_SIZE (mode); 9308 unsigned int length = CONST_VECTOR_NUNITS (rtl); 9309 unsigned char *array = ggc_alloc (length * elt_size); 9310 unsigned int i; 9311 unsigned char *p; 9312 9313 if (GET_MODE_CLASS (mode) == MODE_VECTOR_INT) 9314 { 9315 for (i = 0, p = array; i < length; i++, p += elt_size) 9316 { 9317 rtx elt = CONST_VECTOR_ELT (rtl, i); 9318 HOST_WIDE_INT lo, hi; 9319 if (GET_CODE (elt) == CONST_INT) 9320 { 9321 lo = INTVAL (elt); 9322 hi = -(lo < 0); 9323 } 9324 else if (GET_CODE (elt) == CONST_DOUBLE) 9325 { 9326 lo = CONST_DOUBLE_LOW (elt); 9327 hi = CONST_DOUBLE_HIGH (elt); 9328 } 9329 else 9330 abort (); 9331 9332 if (elt_size <= sizeof (HOST_WIDE_INT)) 9333 insert_int (lo, elt_size, p); 9334 else if (elt_size == 2 * sizeof (HOST_WIDE_INT)) 9335 { 9336 unsigned char *p0 = p; 9337 unsigned char *p1 = p + sizeof (HOST_WIDE_INT); 9338 9339 if (WORDS_BIG_ENDIAN) 9340 { 9341 p0 = p1; 9342 p1 = p; 9343 } 9344 insert_int (lo, sizeof (HOST_WIDE_INT), p0); 9345 insert_int (hi, sizeof (HOST_WIDE_INT), p1); 9346 } 9347 else 9348 abort (); 9349 } 9350 } 9351 else if (GET_MODE_CLASS (mode) == MODE_VECTOR_FLOAT) 9352 { 9353 for (i = 0, p = array; i < length; i++, p += elt_size) 9354 { 9355 rtx elt = CONST_VECTOR_ELT (rtl, i); 9356 insert_float (elt, p); 9357 } 9358 } 9359 else 9360 abort (); 9361 9362 add_AT_vec (die, DW_AT_const_value, length, elt_size, array); 9363 } 9364 break; 9365 9366 case CONST_STRING: 9367 add_AT_string (die, DW_AT_const_value, XSTR (rtl, 0)); 9368 break; 9369 9370 case SYMBOL_REF: 9371 case LABEL_REF: 9372 case CONST: 9373 add_AT_addr (die, DW_AT_const_value, rtl); 9374 VARRAY_PUSH_RTX (used_rtx_varray, rtl); 9375 break; 9376 9377 case PLUS: 9378 /* In cases where an inlined instance of an inline function is passed 9379 the address of an `auto' variable (which is local to the caller) we 9380 can get a situation where the DECL_RTL of the artificial local 9381 variable (for the inlining) which acts as a stand-in for the 9382 corresponding formal parameter (of the inline function) will look 9383 like (plus:SI (reg:SI FRAME_PTR) (const_int ...)). This is not 9384 exactly a compile-time constant expression, but it isn't the address 9385 of the (artificial) local variable either. Rather, it represents the 9386 *value* which the artificial local variable always has during its 9387 lifetime. We currently have no way to represent such quasi-constant 9388 values in Dwarf, so for now we just punt and generate nothing. */ 9389 break; 9390 9391 default: 9392 /* No other kinds of rtx should be possible here. */ 9393 abort (); 9394 } 9395 9396} 9397 9398static rtx 9399rtl_for_decl_location (tree decl) 9400{ 9401 rtx rtl; 9402 9403 /* Here we have to decide where we are going to say the parameter "lives" 9404 (as far as the debugger is concerned). We only have a couple of 9405 choices. GCC provides us with DECL_RTL and with DECL_INCOMING_RTL. 9406 9407 DECL_RTL normally indicates where the parameter lives during most of the 9408 activation of the function. If optimization is enabled however, this 9409 could be either NULL or else a pseudo-reg. Both of those cases indicate 9410 that the parameter doesn't really live anywhere (as far as the code 9411 generation parts of GCC are concerned) during most of the function's 9412 activation. That will happen (for example) if the parameter is never 9413 referenced within the function. 9414 9415 We could just generate a location descriptor here for all non-NULL 9416 non-pseudo values of DECL_RTL and ignore all of the rest, but we can be 9417 a little nicer than that if we also consider DECL_INCOMING_RTL in cases 9418 where DECL_RTL is NULL or is a pseudo-reg. 9419 9420 Note however that we can only get away with using DECL_INCOMING_RTL as 9421 a backup substitute for DECL_RTL in certain limited cases. In cases 9422 where DECL_ARG_TYPE (decl) indicates the same type as TREE_TYPE (decl), 9423 we can be sure that the parameter was passed using the same type as it is 9424 declared to have within the function, and that its DECL_INCOMING_RTL 9425 points us to a place where a value of that type is passed. 9426 9427 In cases where DECL_ARG_TYPE (decl) and TREE_TYPE (decl) are different, 9428 we cannot (in general) use DECL_INCOMING_RTL as a substitute for DECL_RTL 9429 because in these cases DECL_INCOMING_RTL points us to a value of some 9430 type which is *different* from the type of the parameter itself. Thus, 9431 if we tried to use DECL_INCOMING_RTL to generate a location attribute in 9432 such cases, the debugger would end up (for example) trying to fetch a 9433 `float' from a place which actually contains the first part of a 9434 `double'. That would lead to really incorrect and confusing 9435 output at debug-time. 9436 9437 So, in general, we *do not* use DECL_INCOMING_RTL as a backup for DECL_RTL 9438 in cases where DECL_ARG_TYPE (decl) != TREE_TYPE (decl). There 9439 are a couple of exceptions however. On little-endian machines we can 9440 get away with using DECL_INCOMING_RTL even when DECL_ARG_TYPE (decl) is 9441 not the same as TREE_TYPE (decl), but only when DECL_ARG_TYPE (decl) is 9442 an integral type that is smaller than TREE_TYPE (decl). These cases arise 9443 when (on a little-endian machine) a non-prototyped function has a 9444 parameter declared to be of type `short' or `char'. In such cases, 9445 TREE_TYPE (decl) will be `short' or `char', DECL_ARG_TYPE (decl) will 9446 be `int', and DECL_INCOMING_RTL will point to the lowest-order byte of the 9447 passed `int' value. If the debugger then uses that address to fetch 9448 a `short' or a `char' (on a little-endian machine) the result will be 9449 the correct data, so we allow for such exceptional cases below. 9450 9451 Note that our goal here is to describe the place where the given formal 9452 parameter lives during most of the function's activation (i.e. between the 9453 end of the prologue and the start of the epilogue). We'll do that as best 9454 as we can. Note however that if the given formal parameter is modified 9455 sometime during the execution of the function, then a stack backtrace (at 9456 debug-time) will show the function as having been called with the *new* 9457 value rather than the value which was originally passed in. This happens 9458 rarely enough that it is not a major problem, but it *is* a problem, and 9459 I'd like to fix it. 9460 9461 A future version of dwarf2out.c may generate two additional attributes for 9462 any given DW_TAG_formal_parameter DIE which will describe the "passed 9463 type" and the "passed location" for the given formal parameter in addition 9464 to the attributes we now generate to indicate the "declared type" and the 9465 "active location" for each parameter. This additional set of attributes 9466 could be used by debuggers for stack backtraces. Separately, note that 9467 sometimes DECL_RTL can be NULL and DECL_INCOMING_RTL can be NULL also. 9468 This happens (for example) for inlined-instances of inline function formal 9469 parameters which are never referenced. This really shouldn't be 9470 happening. All PARM_DECL nodes should get valid non-NULL 9471 DECL_INCOMING_RTL values, but integrate.c doesn't currently generate these 9472 values for inlined instances of inline function parameters, so when we see 9473 such cases, we are just out-of-luck for the time being (until integrate.c 9474 gets fixed). */ 9475 9476 /* Use DECL_RTL as the "location" unless we find something better. */ 9477 rtl = DECL_RTL_IF_SET (decl); 9478 9479 /* When generating abstract instances, ignore everything except 9480 constants, symbols living in memory, and symbols living in 9481 fixed registers. */ 9482 if (! reload_completed) 9483 { 9484 if (rtl 9485 && (CONSTANT_P (rtl) 9486 || (GET_CODE (rtl) == MEM 9487 && CONSTANT_P (XEXP (rtl, 0))) 9488 || (GET_CODE (rtl) == REG 9489 && TREE_CODE (decl) == VAR_DECL 9490 && TREE_STATIC (decl)))) 9491 { 9492 rtl = (*targetm.delegitimize_address) (rtl); 9493 return rtl; 9494 } 9495 rtl = NULL_RTX; 9496 } 9497 else if (TREE_CODE (decl) == PARM_DECL) 9498 { 9499 if (rtl == NULL_RTX || is_pseudo_reg (rtl)) 9500 { 9501 tree declared_type = TREE_TYPE (decl); 9502 tree passed_type = DECL_ARG_TYPE (decl); 9503 enum machine_mode dmode = TYPE_MODE (declared_type); 9504 enum machine_mode pmode = TYPE_MODE (passed_type); 9505 9506 /* This decl represents a formal parameter which was optimized out. 9507 Note that DECL_INCOMING_RTL may be NULL in here, but we handle 9508 all cases where (rtl == NULL_RTX) just below. */ 9509 if (dmode == pmode) 9510 rtl = DECL_INCOMING_RTL (decl); 9511 else if (SCALAR_INT_MODE_P (dmode) 9512 && GET_MODE_SIZE (dmode) <= GET_MODE_SIZE (pmode) 9513 && DECL_INCOMING_RTL (decl)) 9514 { 9515 rtx inc = DECL_INCOMING_RTL (decl); 9516 if (REG_P (inc)) 9517 rtl = inc; 9518 else if (GET_CODE (inc) == MEM) 9519 { 9520 if (BYTES_BIG_ENDIAN) 9521 rtl = adjust_address_nv (inc, dmode, 9522 GET_MODE_SIZE (pmode) 9523 - GET_MODE_SIZE (dmode)); 9524 else 9525 rtl = inc; 9526 } 9527 } 9528 } 9529 9530 /* If the parm was passed in registers, but lives on the stack, then 9531 make a big endian correction if the mode of the type of the 9532 parameter is not the same as the mode of the rtl. */ 9533 /* ??? This is the same series of checks that are made in dbxout.c before 9534 we reach the big endian correction code there. It isn't clear if all 9535 of these checks are necessary here, but keeping them all is the safe 9536 thing to do. */ 9537 else if (GET_CODE (rtl) == MEM 9538 && XEXP (rtl, 0) != const0_rtx 9539 && ! CONSTANT_P (XEXP (rtl, 0)) 9540 /* Not passed in memory. */ 9541 && GET_CODE (DECL_INCOMING_RTL (decl)) != MEM 9542 /* Not passed by invisible reference. */ 9543 && (GET_CODE (XEXP (rtl, 0)) != REG 9544 || REGNO (XEXP (rtl, 0)) == HARD_FRAME_POINTER_REGNUM 9545 || REGNO (XEXP (rtl, 0)) == STACK_POINTER_REGNUM 9546#if ARG_POINTER_REGNUM != HARD_FRAME_POINTER_REGNUM 9547 || REGNO (XEXP (rtl, 0)) == ARG_POINTER_REGNUM 9548#endif 9549 ) 9550 /* Big endian correction check. */ 9551 && BYTES_BIG_ENDIAN 9552 && TYPE_MODE (TREE_TYPE (decl)) != GET_MODE (rtl) 9553 && (GET_MODE_SIZE (TYPE_MODE (TREE_TYPE (decl))) 9554 < UNITS_PER_WORD)) 9555 { 9556 int offset = (UNITS_PER_WORD 9557 - GET_MODE_SIZE (TYPE_MODE (TREE_TYPE (decl)))); 9558 9559 rtl = gen_rtx_MEM (TYPE_MODE (TREE_TYPE (decl)), 9560 plus_constant (XEXP (rtl, 0), offset)); 9561 } 9562 } 9563 9564 if (rtl != NULL_RTX) 9565 { 9566 rtl = eliminate_regs (rtl, 0, NULL_RTX); 9567#ifdef LEAF_REG_REMAP 9568 if (current_function_uses_only_leaf_regs) 9569 leaf_renumber_regs_insn (rtl); 9570#endif 9571 } 9572 9573 /* A variable with no DECL_RTL but a DECL_INITIAL is a compile-time constant, 9574 and will have been substituted directly into all expressions that use it. 9575 C does not have such a concept, but C++ and other languages do. */ 9576 else if (TREE_CODE (decl) == VAR_DECL && DECL_INITIAL (decl)) 9577 { 9578 /* If a variable is initialized with a string constant without embedded 9579 zeros, build CONST_STRING. */ 9580 if (TREE_CODE (DECL_INITIAL (decl)) == STRING_CST 9581 && TREE_CODE (TREE_TYPE (decl)) == ARRAY_TYPE) 9582 { 9583 tree arrtype = TREE_TYPE (decl); 9584 tree enttype = TREE_TYPE (arrtype); 9585 tree domain = TYPE_DOMAIN (arrtype); 9586 tree init = DECL_INITIAL (decl); 9587 enum machine_mode mode = TYPE_MODE (enttype); 9588 9589 if (GET_MODE_CLASS (mode) == MODE_INT && GET_MODE_SIZE (mode) == 1 9590 && domain 9591 && integer_zerop (TYPE_MIN_VALUE (domain)) 9592 && compare_tree_int (TYPE_MAX_VALUE (domain), 9593 TREE_STRING_LENGTH (init) - 1) == 0 9594 && ((size_t) TREE_STRING_LENGTH (init) 9595 == strlen (TREE_STRING_POINTER (init)) + 1)) 9596 rtl = gen_rtx_CONST_STRING (VOIDmode, TREE_STRING_POINTER (init)); 9597 } 9598 /* If the initializer is something that we know will expand into an 9599 immediate RTL constant, expand it now. Expanding anything else 9600 tends to produce unresolved symbols; see debug/5770 and c++/6381. */ 9601 else if (TREE_CODE (DECL_INITIAL (decl)) == INTEGER_CST 9602 || TREE_CODE (DECL_INITIAL (decl)) == REAL_CST) 9603 { 9604 rtl = expand_expr (DECL_INITIAL (decl), NULL_RTX, VOIDmode, 9605 EXPAND_INITIALIZER); 9606 /* If expand_expr returns a MEM, it wasn't immediate. */ 9607 if (rtl && GET_CODE (rtl) == MEM) 9608 abort (); 9609 } 9610 } 9611 9612 if (rtl) 9613 rtl = (*targetm.delegitimize_address) (rtl); 9614 9615 /* If we don't look past the constant pool, we risk emitting a 9616 reference to a constant pool entry that isn't referenced from 9617 code, and thus is not emitted. */ 9618 if (rtl) 9619 rtl = avoid_constant_pool_reference (rtl); 9620 9621 return rtl; 9622} 9623 9624/* Generate *either* a DW_AT_location attribute or else a DW_AT_const_value 9625 data attribute for a variable or a parameter. We generate the 9626 DW_AT_const_value attribute only in those cases where the given variable 9627 or parameter does not have a true "location" either in memory or in a 9628 register. This can happen (for example) when a constant is passed as an 9629 actual argument in a call to an inline function. (It's possible that 9630 these things can crop up in other ways also.) Note that one type of 9631 constant value which can be passed into an inlined function is a constant 9632 pointer. This can happen for example if an actual argument in an inlined 9633 function call evaluates to a compile-time constant address. */ 9634 9635static void 9636add_location_or_const_value_attribute (dw_die_ref die, tree decl) 9637{ 9638 rtx rtl; 9639 dw_loc_descr_ref descr; 9640 9641 if (TREE_CODE (decl) == ERROR_MARK) 9642 return; 9643 else if (TREE_CODE (decl) != VAR_DECL && TREE_CODE (decl) != PARM_DECL) 9644 abort (); 9645 9646 rtl = rtl_for_decl_location (decl); 9647 if (rtl == NULL_RTX) 9648 return; 9649 9650 switch (GET_CODE (rtl)) 9651 { 9652 case ADDRESSOF: 9653 /* The address of a variable that was optimized away; 9654 don't emit anything. */ 9655 break; 9656 9657 case CONST_INT: 9658 case CONST_DOUBLE: 9659 case CONST_VECTOR: 9660 case CONST_STRING: 9661 case SYMBOL_REF: 9662 case LABEL_REF: 9663 case CONST: 9664 case PLUS: 9665 /* DECL_RTL could be (plus (reg ...) (const_int ...)) */ 9666 add_const_value_attribute (die, rtl); 9667 break; 9668 9669 case MEM: 9670 if (TREE_CODE (decl) == VAR_DECL && DECL_THREAD_LOCAL (decl)) 9671 { 9672 /* Need loc_descriptor_from_tree since that's where we know 9673 how to handle TLS variables. Want the object's address 9674 since the top-level DW_AT_location assumes such. See 9675 the confusion in loc_descriptor for reference. */ 9676 descr = loc_descriptor_from_tree (decl, 1); 9677 } 9678 else 9679 { 9680 case REG: 9681 case SUBREG: 9682 case CONCAT: 9683 descr = loc_descriptor (rtl); 9684 } 9685 add_AT_location_description (die, DW_AT_location, descr); 9686 break; 9687 9688 case PARALLEL: 9689 { 9690 rtvec par_elems = XVEC (rtl, 0); 9691 int num_elem = GET_NUM_ELEM (par_elems); 9692 enum machine_mode mode; 9693 int i; 9694 9695 /* Create the first one, so we have something to add to. */ 9696 descr = loc_descriptor (XEXP (RTVEC_ELT (par_elems, 0), 0)); 9697 mode = GET_MODE (XEXP (RTVEC_ELT (par_elems, 0), 0)); 9698 add_loc_descr (&descr, 9699 new_loc_descr (DW_OP_piece, GET_MODE_SIZE (mode), 0)); 9700 for (i = 1; i < num_elem; i++) 9701 { 9702 dw_loc_descr_ref temp; 9703 9704 temp = loc_descriptor (XEXP (RTVEC_ELT (par_elems, i), 0)); 9705 add_loc_descr (&descr, temp); 9706 mode = GET_MODE (XEXP (RTVEC_ELT (par_elems, i), 0)); 9707 add_loc_descr (&descr, 9708 new_loc_descr (DW_OP_piece, 9709 GET_MODE_SIZE (mode), 0)); 9710 } 9711 } 9712 add_AT_location_description (die, DW_AT_location, descr); 9713 break; 9714 9715 default: 9716 abort (); 9717 } 9718} 9719 9720/* If we don't have a copy of this variable in memory for some reason (such 9721 as a C++ member constant that doesn't have an out-of-line definition), 9722 we should tell the debugger about the constant value. */ 9723 9724static void 9725tree_add_const_value_attribute (dw_die_ref var_die, tree decl) 9726{ 9727 tree init = DECL_INITIAL (decl); 9728 tree type = TREE_TYPE (decl); 9729 9730 if (TREE_READONLY (decl) && ! TREE_THIS_VOLATILE (decl) && init 9731 && initializer_constant_valid_p (init, type) == null_pointer_node) 9732 /* OK */; 9733 else 9734 return; 9735 9736 switch (TREE_CODE (type)) 9737 { 9738 case INTEGER_TYPE: 9739 if (host_integerp (init, 0)) 9740 add_AT_unsigned (var_die, DW_AT_const_value, 9741 tree_low_cst (init, 0)); 9742 else 9743 add_AT_long_long (var_die, DW_AT_const_value, 9744 TREE_INT_CST_HIGH (init), 9745 TREE_INT_CST_LOW (init)); 9746 break; 9747 9748 default:; 9749 } 9750} 9751 9752/* Generate a DW_AT_name attribute given some string value to be included as 9753 the value of the attribute. */ 9754 9755static void 9756add_name_attribute (dw_die_ref die, const char *name_string) 9757{ 9758 if (name_string != NULL && *name_string != 0) 9759 { 9760 if (demangle_name_func) 9761 name_string = (*demangle_name_func) (name_string); 9762 9763 add_AT_string (die, DW_AT_name, name_string); 9764 } 9765} 9766 9767/* Generate a DW_AT_comp_dir attribute for DIE. */ 9768 9769static void 9770add_comp_dir_attribute (dw_die_ref die) 9771{ 9772 const char *wd = get_src_pwd (); 9773 if (wd != NULL) 9774 add_AT_string (die, DW_AT_comp_dir, wd); 9775} 9776 9777/* Given a tree node describing an array bound (either lower or upper) output 9778 a representation for that bound. */ 9779 9780static void 9781add_bound_info (dw_die_ref subrange_die, enum dwarf_attribute bound_attr, tree bound) 9782{ 9783 switch (TREE_CODE (bound)) 9784 { 9785 case ERROR_MARK: 9786 return; 9787 9788 /* All fixed-bounds are represented by INTEGER_CST nodes. */ 9789 case INTEGER_CST: 9790 if (! host_integerp (bound, 0) 9791 || (bound_attr == DW_AT_lower_bound 9792 && (((is_c_family () || is_java ()) && integer_zerop (bound)) 9793 || (is_fortran () && integer_onep (bound))))) 9794 /* use the default */ 9795 ; 9796 else 9797 add_AT_unsigned (subrange_die, bound_attr, tree_low_cst (bound, 0)); 9798 break; 9799 9800 case CONVERT_EXPR: 9801 case NOP_EXPR: 9802 case NON_LVALUE_EXPR: 9803 case VIEW_CONVERT_EXPR: 9804 add_bound_info (subrange_die, bound_attr, TREE_OPERAND (bound, 0)); 9805 break; 9806 9807 case SAVE_EXPR: 9808 /* If optimization is turned on, the SAVE_EXPRs that describe how to 9809 access the upper bound values may be bogus. If they refer to a 9810 register, they may only describe how to get at these values at the 9811 points in the generated code right after they have just been 9812 computed. Worse yet, in the typical case, the upper bound values 9813 will not even *be* computed in the optimized code (though the 9814 number of elements will), so these SAVE_EXPRs are entirely 9815 bogus. In order to compensate for this fact, we check here to see 9816 if optimization is enabled, and if so, we don't add an attribute 9817 for the (unknown and unknowable) upper bound. This should not 9818 cause too much trouble for existing (stupid?) debuggers because 9819 they have to deal with empty upper bounds location descriptions 9820 anyway in order to be able to deal with incomplete array types. 9821 Of course an intelligent debugger (GDB?) should be able to 9822 comprehend that a missing upper bound specification in an array 9823 type used for a storage class `auto' local array variable 9824 indicates that the upper bound is both unknown (at compile- time) 9825 and unknowable (at run-time) due to optimization. 9826 9827 We assume that a MEM rtx is safe because gcc wouldn't put the 9828 value there unless it was going to be used repeatedly in the 9829 function, i.e. for cleanups. */ 9830 if (SAVE_EXPR_RTL (bound) 9831 && (! optimize || GET_CODE (SAVE_EXPR_RTL (bound)) == MEM)) 9832 { 9833 dw_die_ref ctx = lookup_decl_die (current_function_decl); 9834 dw_die_ref decl_die = new_die (DW_TAG_variable, ctx, bound); 9835 rtx loc = SAVE_EXPR_RTL (bound); 9836 9837 /* If the RTL for the SAVE_EXPR is memory, handle the case where 9838 it references an outer function's frame. */ 9839 if (GET_CODE (loc) == MEM) 9840 { 9841 rtx new_addr = fix_lexical_addr (XEXP (loc, 0), bound); 9842 9843 if (XEXP (loc, 0) != new_addr) 9844 loc = gen_rtx_MEM (GET_MODE (loc), new_addr); 9845 } 9846 9847 add_AT_flag (decl_die, DW_AT_artificial, 1); 9848 add_type_attribute (decl_die, TREE_TYPE (bound), 1, 0, ctx); 9849 add_AT_location_description (decl_die, DW_AT_location, 9850 loc_descriptor (loc)); 9851 add_AT_die_ref (subrange_die, bound_attr, decl_die); 9852 } 9853 9854 /* Else leave out the attribute. */ 9855 break; 9856 9857 case VAR_DECL: 9858 case PARM_DECL: 9859 { 9860 dw_die_ref decl_die = lookup_decl_die (bound); 9861 9862 /* ??? Can this happen, or should the variable have been bound 9863 first? Probably it can, since I imagine that we try to create 9864 the types of parameters in the order in which they exist in 9865 the list, and won't have created a forward reference to a 9866 later parameter. */ 9867 if (decl_die != NULL) 9868 add_AT_die_ref (subrange_die, bound_attr, decl_die); 9869 break; 9870 } 9871 9872 default: 9873 { 9874 /* Otherwise try to create a stack operation procedure to 9875 evaluate the value of the array bound. */ 9876 9877 dw_die_ref ctx, decl_die; 9878 dw_loc_descr_ref loc; 9879 9880 loc = loc_descriptor_from_tree (bound, 0); 9881 if (loc == NULL) 9882 break; 9883 9884 if (current_function_decl == 0) 9885 ctx = comp_unit_die; 9886 else 9887 ctx = lookup_decl_die (current_function_decl); 9888 9889 /* If we weren't able to find a context, it's most likely the case 9890 that we are processing the return type of the function. So 9891 make a SAVE_EXPR to point to it and have the limbo DIE code 9892 find the proper die. The save_expr function doesn't always 9893 make a SAVE_EXPR, so do it ourselves. */ 9894 if (ctx == 0) 9895 bound = build (SAVE_EXPR, TREE_TYPE (bound), bound, 9896 current_function_decl, NULL_TREE); 9897 9898 decl_die = new_die (DW_TAG_variable, ctx, bound); 9899 add_AT_flag (decl_die, DW_AT_artificial, 1); 9900 add_type_attribute (decl_die, TREE_TYPE (bound), 1, 0, ctx); 9901 add_AT_loc (decl_die, DW_AT_location, loc); 9902 9903 add_AT_die_ref (subrange_die, bound_attr, decl_die); 9904 break; 9905 } 9906 } 9907} 9908 9909/* Note that the block of subscript information for an array type also 9910 includes information about the element type of type given array type. */ 9911 9912static void 9913add_subscript_info (dw_die_ref type_die, tree type) 9914{ 9915#ifndef MIPS_DEBUGGING_INFO 9916 unsigned dimension_number; 9917#endif 9918 tree lower, upper; 9919 dw_die_ref subrange_die; 9920 9921 /* The GNU compilers represent multidimensional array types as sequences of 9922 one dimensional array types whose element types are themselves array 9923 types. Here we squish that down, so that each multidimensional array 9924 type gets only one array_type DIE in the Dwarf debugging info. The draft 9925 Dwarf specification say that we are allowed to do this kind of 9926 compression in C (because there is no difference between an array or 9927 arrays and a multidimensional array in C) but for other source languages 9928 (e.g. Ada) we probably shouldn't do this. */ 9929 9930 /* ??? The SGI dwarf reader fails for multidimensional arrays with a 9931 const enum type. E.g. const enum machine_mode insn_operand_mode[2][10]. 9932 We work around this by disabling this feature. See also 9933 gen_array_type_die. */ 9934#ifndef MIPS_DEBUGGING_INFO 9935 for (dimension_number = 0; 9936 TREE_CODE (type) == ARRAY_TYPE; 9937 type = TREE_TYPE (type), dimension_number++) 9938#endif 9939 { 9940 tree domain = TYPE_DOMAIN (type); 9941 9942 /* Arrays come in three flavors: Unspecified bounds, fixed bounds, 9943 and (in GNU C only) variable bounds. Handle all three forms 9944 here. */ 9945 subrange_die = new_die (DW_TAG_subrange_type, type_die, NULL); 9946 if (domain) 9947 { 9948 /* We have an array type with specified bounds. */ 9949 lower = TYPE_MIN_VALUE (domain); 9950 upper = TYPE_MAX_VALUE (domain); 9951 9952 /* Define the index type. */ 9953 if (TREE_TYPE (domain)) 9954 { 9955 /* ??? This is probably an Ada unnamed subrange type. Ignore the 9956 TREE_TYPE field. We can't emit debug info for this 9957 because it is an unnamed integral type. */ 9958 if (TREE_CODE (domain) == INTEGER_TYPE 9959 && TYPE_NAME (domain) == NULL_TREE 9960 && TREE_CODE (TREE_TYPE (domain)) == INTEGER_TYPE 9961 && TYPE_NAME (TREE_TYPE (domain)) == NULL_TREE) 9962 ; 9963 else 9964 add_type_attribute (subrange_die, TREE_TYPE (domain), 0, 0, 9965 type_die); 9966 } 9967 9968 /* ??? If upper is NULL, the array has unspecified length, 9969 but it does have a lower bound. This happens with Fortran 9970 dimension arr(N:*) 9971 Since the debugger is definitely going to need to know N 9972 to produce useful results, go ahead and output the lower 9973 bound solo, and hope the debugger can cope. */ 9974 9975 add_bound_info (subrange_die, DW_AT_lower_bound, lower); 9976 if (upper) 9977 add_bound_info (subrange_die, DW_AT_upper_bound, upper); 9978 } 9979 9980 /* Otherwise we have an array type with an unspecified length. The 9981 DWARF-2 spec does not say how to handle this; let's just leave out the 9982 bounds. */ 9983 } 9984} 9985 9986static void 9987add_byte_size_attribute (dw_die_ref die, tree tree_node) 9988{ 9989 unsigned size; 9990 9991 switch (TREE_CODE (tree_node)) 9992 { 9993 case ERROR_MARK: 9994 size = 0; 9995 break; 9996 case ENUMERAL_TYPE: 9997 case RECORD_TYPE: 9998 case UNION_TYPE: 9999 case QUAL_UNION_TYPE: 10000 size = int_size_in_bytes (tree_node); 10001 break; 10002 case FIELD_DECL: 10003 /* For a data member of a struct or union, the DW_AT_byte_size is 10004 generally given as the number of bytes normally allocated for an 10005 object of the *declared* type of the member itself. This is true 10006 even for bit-fields. */ 10007 size = simple_type_size_in_bits (field_type (tree_node)) / BITS_PER_UNIT; 10008 break; 10009 default: 10010 abort (); 10011 } 10012 10013 /* Note that `size' might be -1 when we get to this point. If it is, that 10014 indicates that the byte size of the entity in question is variable. We 10015 have no good way of expressing this fact in Dwarf at the present time, 10016 so just let the -1 pass on through. */ 10017 add_AT_unsigned (die, DW_AT_byte_size, size); 10018} 10019 10020/* For a FIELD_DECL node which represents a bit-field, output an attribute 10021 which specifies the distance in bits from the highest order bit of the 10022 "containing object" for the bit-field to the highest order bit of the 10023 bit-field itself. 10024 10025 For any given bit-field, the "containing object" is a hypothetical object 10026 (of some integral or enum type) within which the given bit-field lives. The 10027 type of this hypothetical "containing object" is always the same as the 10028 declared type of the individual bit-field itself. The determination of the 10029 exact location of the "containing object" for a bit-field is rather 10030 complicated. It's handled by the `field_byte_offset' function (above). 10031 10032 Note that it is the size (in bytes) of the hypothetical "containing object" 10033 which will be given in the DW_AT_byte_size attribute for this bit-field. 10034 (See `byte_size_attribute' above). */ 10035 10036static inline void 10037add_bit_offset_attribute (dw_die_ref die, tree decl) 10038{ 10039 HOST_WIDE_INT object_offset_in_bytes = field_byte_offset (decl); 10040 tree type = DECL_BIT_FIELD_TYPE (decl); 10041 HOST_WIDE_INT bitpos_int; 10042 HOST_WIDE_INT highest_order_object_bit_offset; 10043 HOST_WIDE_INT highest_order_field_bit_offset; 10044 HOST_WIDE_INT unsigned bit_offset; 10045 10046 /* Must be a field and a bit field. */ 10047 if (!type 10048 || TREE_CODE (decl) != FIELD_DECL) 10049 abort (); 10050 10051 /* We can't yet handle bit-fields whose offsets are variable, so if we 10052 encounter such things, just return without generating any attribute 10053 whatsoever. Likewise for variable or too large size. */ 10054 if (! host_integerp (bit_position (decl), 0) 10055 || ! host_integerp (DECL_SIZE (decl), 1)) 10056 return; 10057 10058 bitpos_int = int_bit_position (decl); 10059 10060 /* Note that the bit offset is always the distance (in bits) from the 10061 highest-order bit of the "containing object" to the highest-order bit of 10062 the bit-field itself. Since the "high-order end" of any object or field 10063 is different on big-endian and little-endian machines, the computation 10064 below must take account of these differences. */ 10065 highest_order_object_bit_offset = object_offset_in_bytes * BITS_PER_UNIT; 10066 highest_order_field_bit_offset = bitpos_int; 10067 10068 if (! BYTES_BIG_ENDIAN) 10069 { 10070 highest_order_field_bit_offset += tree_low_cst (DECL_SIZE (decl), 0); 10071 highest_order_object_bit_offset += simple_type_size_in_bits (type); 10072 } 10073 10074 bit_offset 10075 = (! BYTES_BIG_ENDIAN 10076 ? highest_order_object_bit_offset - highest_order_field_bit_offset 10077 : highest_order_field_bit_offset - highest_order_object_bit_offset); 10078 10079 add_AT_unsigned (die, DW_AT_bit_offset, bit_offset); 10080} 10081 10082/* For a FIELD_DECL node which represents a bit field, output an attribute 10083 which specifies the length in bits of the given field. */ 10084 10085static inline void 10086add_bit_size_attribute (dw_die_ref die, tree decl) 10087{ 10088 /* Must be a field and a bit field. */ 10089 if (TREE_CODE (decl) != FIELD_DECL 10090 || ! DECL_BIT_FIELD_TYPE (decl)) 10091 abort (); 10092 10093 if (host_integerp (DECL_SIZE (decl), 1)) 10094 add_AT_unsigned (die, DW_AT_bit_size, tree_low_cst (DECL_SIZE (decl), 1)); 10095} 10096 10097/* If the compiled language is ANSI C, then add a 'prototyped' 10098 attribute, if arg types are given for the parameters of a function. */ 10099 10100static inline void 10101add_prototyped_attribute (dw_die_ref die, tree func_type) 10102{ 10103 if (get_AT_unsigned (comp_unit_die, DW_AT_language) == DW_LANG_C89 10104 && TYPE_ARG_TYPES (func_type) != NULL) 10105 add_AT_flag (die, DW_AT_prototyped, 1); 10106} 10107 10108/* Add an 'abstract_origin' attribute below a given DIE. The DIE is found 10109 by looking in either the type declaration or object declaration 10110 equate table. */ 10111 10112static inline void 10113add_abstract_origin_attribute (dw_die_ref die, tree origin) 10114{ 10115 dw_die_ref origin_die = NULL; 10116 10117 if (TREE_CODE (origin) != FUNCTION_DECL) 10118 { 10119 /* We may have gotten separated from the block for the inlined 10120 function, if we're in an exception handler or some such; make 10121 sure that the abstract function has been written out. 10122 10123 Doing this for nested functions is wrong, however; functions are 10124 distinct units, and our context might not even be inline. */ 10125 tree fn = origin; 10126 10127 if (TYPE_P (fn)) 10128 fn = TYPE_STUB_DECL (fn); 10129 10130 fn = decl_function_context (fn); 10131 if (fn) 10132 dwarf2out_abstract_function (fn); 10133 } 10134 10135 if (DECL_P (origin)) 10136 origin_die = lookup_decl_die (origin); 10137 else if (TYPE_P (origin)) 10138 origin_die = lookup_type_die (origin); 10139 10140 if (origin_die == NULL) 10141 abort (); 10142 10143 add_AT_die_ref (die, DW_AT_abstract_origin, origin_die); 10144} 10145 10146/* We do not currently support the pure_virtual attribute. */ 10147 10148static inline void 10149add_pure_or_virtual_attribute (dw_die_ref die, tree func_decl) 10150{ 10151 if (DECL_VINDEX (func_decl)) 10152 { 10153 add_AT_unsigned (die, DW_AT_virtuality, DW_VIRTUALITY_virtual); 10154 10155 if (host_integerp (DECL_VINDEX (func_decl), 0)) 10156 add_AT_loc (die, DW_AT_vtable_elem_location, 10157 new_loc_descr (DW_OP_constu, 10158 tree_low_cst (DECL_VINDEX (func_decl), 0), 10159 0)); 10160 10161 /* GNU extension: Record what type this method came from originally. */ 10162 if (debug_info_level > DINFO_LEVEL_TERSE) 10163 add_AT_die_ref (die, DW_AT_containing_type, 10164 lookup_type_die (DECL_CONTEXT (func_decl))); 10165 } 10166} 10167 10168/* Add source coordinate attributes for the given decl. */ 10169 10170static void 10171add_src_coords_attributes (dw_die_ref die, tree decl) 10172{ 10173 unsigned file_index = lookup_filename (DECL_SOURCE_FILE (decl)); 10174 10175 add_AT_unsigned (die, DW_AT_decl_file, file_index); 10176 add_AT_unsigned (die, DW_AT_decl_line, DECL_SOURCE_LINE (decl)); 10177} 10178 10179/* Add a DW_AT_name attribute and source coordinate attribute for the 10180 given decl, but only if it actually has a name. */ 10181 10182static void 10183add_name_and_src_coords_attributes (dw_die_ref die, tree decl) 10184{ 10185 tree decl_name; 10186 10187 decl_name = DECL_NAME (decl); 10188 if (decl_name != NULL && IDENTIFIER_POINTER (decl_name) != NULL) 10189 { 10190 add_name_attribute (die, dwarf2_name (decl, 0)); 10191 if (! DECL_ARTIFICIAL (decl)) 10192 add_src_coords_attributes (die, decl); 10193 10194 if ((TREE_CODE (decl) == FUNCTION_DECL || TREE_CODE (decl) == VAR_DECL) 10195 && TREE_PUBLIC (decl) 10196 && DECL_ASSEMBLER_NAME (decl) != DECL_NAME (decl) 10197 && !DECL_ABSTRACT (decl)) 10198 add_AT_string (die, DW_AT_MIPS_linkage_name, 10199 IDENTIFIER_POINTER (DECL_ASSEMBLER_NAME (decl))); 10200 } 10201 10202#ifdef VMS_DEBUGGING_INFO 10203 /* Get the function's name, as described by its RTL. This may be different 10204 from the DECL_NAME name used in the source file. */ 10205 if (TREE_CODE (decl) == FUNCTION_DECL && TREE_ASM_WRITTEN (decl)) 10206 { 10207 add_AT_addr (die, DW_AT_VMS_rtnbeg_pd_address, 10208 XEXP (DECL_RTL (decl), 0)); 10209 VARRAY_PUSH_RTX (used_rtx_varray, XEXP (DECL_RTL (decl), 0)); 10210 } 10211#endif 10212} 10213 10214/* Push a new declaration scope. */ 10215 10216static void 10217push_decl_scope (tree scope) 10218{ 10219 VARRAY_PUSH_TREE (decl_scope_table, scope); 10220} 10221 10222/* Pop a declaration scope. */ 10223 10224static inline void 10225pop_decl_scope (void) 10226{ 10227 if (VARRAY_ACTIVE_SIZE (decl_scope_table) <= 0) 10228 abort (); 10229 10230 VARRAY_POP (decl_scope_table); 10231} 10232 10233/* Return the DIE for the scope that immediately contains this type. 10234 Non-named types get global scope. Named types nested in other 10235 types get their containing scope if it's open, or global scope 10236 otherwise. All other types (i.e. function-local named types) get 10237 the current active scope. */ 10238 10239static dw_die_ref 10240scope_die_for (tree t, dw_die_ref context_die) 10241{ 10242 dw_die_ref scope_die = NULL; 10243 tree containing_scope; 10244 int i; 10245 10246 /* Non-types always go in the current scope. */ 10247 if (! TYPE_P (t)) 10248 abort (); 10249 10250 containing_scope = TYPE_CONTEXT (t); 10251 10252 /* Use the containing namespace if it was passed in (for a declaration). */ 10253 if (containing_scope && TREE_CODE (containing_scope) == NAMESPACE_DECL) 10254 { 10255 if (context_die == lookup_decl_die (containing_scope)) 10256 /* OK */; 10257 else 10258 containing_scope = NULL_TREE; 10259 } 10260 10261 /* Ignore function type "scopes" from the C frontend. They mean that 10262 a tagged type is local to a parmlist of a function declarator, but 10263 that isn't useful to DWARF. */ 10264 if (containing_scope && TREE_CODE (containing_scope) == FUNCTION_TYPE) 10265 containing_scope = NULL_TREE; 10266 10267 if (containing_scope == NULL_TREE 10268 || TREE_CODE (containing_scope) == TRANSLATION_UNIT_DECL) 10269 scope_die = comp_unit_die; 10270 else if (TYPE_P (containing_scope)) 10271 { 10272 /* For types, we can just look up the appropriate DIE. But 10273 first we check to see if we're in the middle of emitting it 10274 so we know where the new DIE should go. */ 10275 for (i = VARRAY_ACTIVE_SIZE (decl_scope_table) - 1; i >= 0; --i) 10276 if (VARRAY_TREE (decl_scope_table, i) == containing_scope) 10277 break; 10278 10279 if (i < 0) 10280 { 10281 if (debug_info_level > DINFO_LEVEL_TERSE 10282 && !TREE_ASM_WRITTEN (containing_scope)) 10283 abort (); 10284 10285 /* If none of the current dies are suitable, we get file scope. */ 10286 scope_die = comp_unit_die; 10287 } 10288 else 10289 scope_die = lookup_type_die (containing_scope); 10290 } 10291 else 10292 scope_die = context_die; 10293 10294 return scope_die; 10295} 10296 10297/* Returns nonzero if CONTEXT_DIE is internal to a function. */ 10298 10299static inline int 10300local_scope_p (dw_die_ref context_die) 10301{ 10302 for (; context_die; context_die = context_die->die_parent) 10303 if (context_die->die_tag == DW_TAG_inlined_subroutine 10304 || context_die->die_tag == DW_TAG_subprogram) 10305 return 1; 10306 10307 return 0; 10308} 10309 10310/* Returns nonzero if CONTEXT_DIE is a class or namespace, for deciding 10311 whether or not to treat a DIE in this context as a declaration. */ 10312 10313static inline int 10314class_or_namespace_scope_p (dw_die_ref context_die) 10315{ 10316 return (context_die 10317 && (context_die->die_tag == DW_TAG_structure_type 10318 || context_die->die_tag == DW_TAG_union_type 10319 || context_die->die_tag == DW_TAG_namespace)); 10320} 10321 10322/* Many forms of DIEs require a "type description" attribute. This 10323 routine locates the proper "type descriptor" die for the type given 10324 by 'type', and adds a DW_AT_type attribute below the given die. */ 10325 10326static void 10327add_type_attribute (dw_die_ref object_die, tree type, int decl_const, 10328 int decl_volatile, dw_die_ref context_die) 10329{ 10330 enum tree_code code = TREE_CODE (type); 10331 dw_die_ref type_die = NULL; 10332 10333 /* ??? If this type is an unnamed subrange type of an integral or 10334 floating-point type, use the inner type. This is because we have no 10335 support for unnamed types in base_type_die. This can happen if this is 10336 an Ada subrange type. Correct solution is emit a subrange type die. */ 10337 if ((code == INTEGER_TYPE || code == REAL_TYPE) 10338 && TREE_TYPE (type) != 0 && TYPE_NAME (type) == 0) 10339 type = TREE_TYPE (type), code = TREE_CODE (type); 10340 10341 if (code == ERROR_MARK 10342 /* Handle a special case. For functions whose return type is void, we 10343 generate *no* type attribute. (Note that no object may have type 10344 `void', so this only applies to function return types). */ 10345 || code == VOID_TYPE) 10346 return; 10347 10348 type_die = modified_type_die (type, 10349 decl_const || TYPE_READONLY (type), 10350 decl_volatile || TYPE_VOLATILE (type), 10351 context_die); 10352 10353 if (type_die != NULL) 10354 add_AT_die_ref (object_die, DW_AT_type, type_die); 10355} 10356 10357/* Given a tree pointer to a struct, class, union, or enum type node, return 10358 a pointer to the (string) tag name for the given type, or zero if the type 10359 was declared without a tag. */ 10360 10361static const char * 10362type_tag (tree type) 10363{ 10364 const char *name = 0; 10365 10366 if (TYPE_NAME (type) != 0) 10367 { 10368 tree t = 0; 10369 10370 /* Find the IDENTIFIER_NODE for the type name. */ 10371 if (TREE_CODE (TYPE_NAME (type)) == IDENTIFIER_NODE) 10372 t = TYPE_NAME (type); 10373 10374 /* The g++ front end makes the TYPE_NAME of *each* tagged type point to 10375 a TYPE_DECL node, regardless of whether or not a `typedef' was 10376 involved. */ 10377 else if (TREE_CODE (TYPE_NAME (type)) == TYPE_DECL 10378 && ! DECL_IGNORED_P (TYPE_NAME (type))) 10379 t = DECL_NAME (TYPE_NAME (type)); 10380 10381 /* Now get the name as a string, or invent one. */ 10382 if (t != 0) 10383 name = IDENTIFIER_POINTER (t); 10384 } 10385 10386 return (name == 0 || *name == '\0') ? 0 : name; 10387} 10388 10389/* Return the type associated with a data member, make a special check 10390 for bit field types. */ 10391 10392static inline tree 10393member_declared_type (tree member) 10394{ 10395 return (DECL_BIT_FIELD_TYPE (member) 10396 ? DECL_BIT_FIELD_TYPE (member) : TREE_TYPE (member)); 10397} 10398 10399/* Get the decl's label, as described by its RTL. This may be different 10400 from the DECL_NAME name used in the source file. */ 10401 10402#if 0 10403static const char * 10404decl_start_label (tree decl) 10405{ 10406 rtx x; 10407 const char *fnname; 10408 10409 x = DECL_RTL (decl); 10410 if (GET_CODE (x) != MEM) 10411 abort (); 10412 10413 x = XEXP (x, 0); 10414 if (GET_CODE (x) != SYMBOL_REF) 10415 abort (); 10416 10417 fnname = XSTR (x, 0); 10418 return fnname; 10419} 10420#endif 10421 10422/* These routines generate the internal representation of the DIE's for 10423 the compilation unit. Debugging information is collected by walking 10424 the declaration trees passed in from dwarf2out_decl(). */ 10425 10426static void 10427gen_array_type_die (tree type, dw_die_ref context_die) 10428{ 10429 dw_die_ref scope_die = scope_die_for (type, context_die); 10430 dw_die_ref array_die; 10431 tree element_type; 10432 10433 /* ??? The SGI dwarf reader fails for array of array of enum types unless 10434 the inner array type comes before the outer array type. Thus we must 10435 call gen_type_die before we call new_die. See below also. */ 10436#ifdef MIPS_DEBUGGING_INFO 10437 gen_type_die (TREE_TYPE (type), context_die); 10438#endif 10439 10440 array_die = new_die (DW_TAG_array_type, scope_die, type); 10441 add_name_attribute (array_die, type_tag (type)); 10442 equate_type_number_to_die (type, array_die); 10443 10444 if (TREE_CODE (type) == VECTOR_TYPE) 10445 { 10446 /* The frontend feeds us a representation for the vector as a struct 10447 containing an array. Pull out the array type. */ 10448 type = TREE_TYPE (TYPE_FIELDS (TYPE_DEBUG_REPRESENTATION_TYPE (type))); 10449 add_AT_flag (array_die, DW_AT_GNU_vector, 1); 10450 } 10451 10452#if 0 10453 /* We default the array ordering. SDB will probably do 10454 the right things even if DW_AT_ordering is not present. It's not even 10455 an issue until we start to get into multidimensional arrays anyway. If 10456 SDB is ever caught doing the Wrong Thing for multi-dimensional arrays, 10457 then we'll have to put the DW_AT_ordering attribute back in. (But if 10458 and when we find out that we need to put these in, we will only do so 10459 for multidimensional arrays. */ 10460 add_AT_unsigned (array_die, DW_AT_ordering, DW_ORD_row_major); 10461#endif 10462 10463#ifdef MIPS_DEBUGGING_INFO 10464 /* The SGI compilers handle arrays of unknown bound by setting 10465 AT_declaration and not emitting any subrange DIEs. */ 10466 if (! TYPE_DOMAIN (type)) 10467 add_AT_flag (array_die, DW_AT_declaration, 1); 10468 else 10469#endif 10470 add_subscript_info (array_die, type); 10471 10472 /* Add representation of the type of the elements of this array type. */ 10473 element_type = TREE_TYPE (type); 10474 10475 /* ??? The SGI dwarf reader fails for multidimensional arrays with a 10476 const enum type. E.g. const enum machine_mode insn_operand_mode[2][10]. 10477 We work around this by disabling this feature. See also 10478 add_subscript_info. */ 10479#ifndef MIPS_DEBUGGING_INFO 10480 while (TREE_CODE (element_type) == ARRAY_TYPE) 10481 element_type = TREE_TYPE (element_type); 10482 10483 gen_type_die (element_type, context_die); 10484#endif 10485 10486 add_type_attribute (array_die, element_type, 0, 0, context_die); 10487} 10488 10489static void 10490gen_set_type_die (tree type, dw_die_ref context_die) 10491{ 10492 dw_die_ref type_die 10493 = new_die (DW_TAG_set_type, scope_die_for (type, context_die), type); 10494 10495 equate_type_number_to_die (type, type_die); 10496 add_type_attribute (type_die, TREE_TYPE (type), 0, 0, context_die); 10497} 10498 10499#if 0 10500static void 10501gen_entry_point_die (tree decl, dw_die_ref context_die) 10502{ 10503 tree origin = decl_ultimate_origin (decl); 10504 dw_die_ref decl_die = new_die (DW_TAG_entry_point, context_die, decl); 10505 10506 if (origin != NULL) 10507 add_abstract_origin_attribute (decl_die, origin); 10508 else 10509 { 10510 add_name_and_src_coords_attributes (decl_die, decl); 10511 add_type_attribute (decl_die, TREE_TYPE (TREE_TYPE (decl)), 10512 0, 0, context_die); 10513 } 10514 10515 if (DECL_ABSTRACT (decl)) 10516 equate_decl_number_to_die (decl, decl_die); 10517 else 10518 add_AT_lbl_id (decl_die, DW_AT_low_pc, decl_start_label (decl)); 10519} 10520#endif 10521 10522/* Walk through the list of incomplete types again, trying once more to 10523 emit full debugging info for them. */ 10524 10525static void 10526retry_incomplete_types (void) 10527{ 10528 int i; 10529 10530 for (i = VARRAY_ACTIVE_SIZE (incomplete_types) - 1; i >= 0; i--) 10531 gen_type_die (VARRAY_TREE (incomplete_types, i), comp_unit_die); 10532} 10533 10534/* Generate a DIE to represent an inlined instance of an enumeration type. */ 10535 10536static void 10537gen_inlined_enumeration_type_die (tree type, dw_die_ref context_die) 10538{ 10539 dw_die_ref type_die = new_die (DW_TAG_enumeration_type, context_die, type); 10540 10541 /* We do not check for TREE_ASM_WRITTEN (type) being set, as the type may 10542 be incomplete and such types are not marked. */ 10543 add_abstract_origin_attribute (type_die, type); 10544} 10545 10546/* Generate a DIE to represent an inlined instance of a structure type. */ 10547 10548static void 10549gen_inlined_structure_type_die (tree type, dw_die_ref context_die) 10550{ 10551 dw_die_ref type_die = new_die (DW_TAG_structure_type, context_die, type); 10552 10553 /* We do not check for TREE_ASM_WRITTEN (type) being set, as the type may 10554 be incomplete and such types are not marked. */ 10555 add_abstract_origin_attribute (type_die, type); 10556} 10557 10558/* Generate a DIE to represent an inlined instance of a union type. */ 10559 10560static void 10561gen_inlined_union_type_die (tree type, dw_die_ref context_die) 10562{ 10563 dw_die_ref type_die = new_die (DW_TAG_union_type, context_die, type); 10564 10565 /* We do not check for TREE_ASM_WRITTEN (type) being set, as the type may 10566 be incomplete and such types are not marked. */ 10567 add_abstract_origin_attribute (type_die, type); 10568} 10569 10570/* Generate a DIE to represent an enumeration type. Note that these DIEs 10571 include all of the information about the enumeration values also. Each 10572 enumerated type name/value is listed as a child of the enumerated type 10573 DIE. */ 10574 10575static dw_die_ref 10576gen_enumeration_type_die (tree type, dw_die_ref context_die) 10577{ 10578 dw_die_ref type_die = lookup_type_die (type); 10579 10580 if (type_die == NULL) 10581 { 10582 type_die = new_die (DW_TAG_enumeration_type, 10583 scope_die_for (type, context_die), type); 10584 equate_type_number_to_die (type, type_die); 10585 add_name_attribute (type_die, type_tag (type)); 10586 } 10587 else if (! TYPE_SIZE (type)) 10588 return type_die; 10589 else 10590 remove_AT (type_die, DW_AT_declaration); 10591 10592 /* Handle a GNU C/C++ extension, i.e. incomplete enum types. If the 10593 given enum type is incomplete, do not generate the DW_AT_byte_size 10594 attribute or the DW_AT_element_list attribute. */ 10595 if (TYPE_SIZE (type)) 10596 { 10597 tree link; 10598 10599 TREE_ASM_WRITTEN (type) = 1; 10600 add_byte_size_attribute (type_die, type); 10601 if (TYPE_STUB_DECL (type) != NULL_TREE) 10602 add_src_coords_attributes (type_die, TYPE_STUB_DECL (type)); 10603 10604 /* If the first reference to this type was as the return type of an 10605 inline function, then it may not have a parent. Fix this now. */ 10606 if (type_die->die_parent == NULL) 10607 add_child_die (scope_die_for (type, context_die), type_die); 10608 10609 for (link = TYPE_FIELDS (type); 10610 link != NULL; link = TREE_CHAIN (link)) 10611 { 10612 dw_die_ref enum_die = new_die (DW_TAG_enumerator, type_die, link); 10613 tree value = TREE_VALUE (link); 10614 10615 add_name_attribute (enum_die, 10616 IDENTIFIER_POINTER (TREE_PURPOSE (link))); 10617 10618 if (host_integerp (value, TREE_UNSIGNED (TREE_TYPE (value)))) 10619 /* DWARF2 does not provide a way of indicating whether or 10620 not enumeration constants are signed or unsigned. GDB 10621 always assumes the values are signed, so we output all 10622 values as if they were signed. That means that 10623 enumeration constants with very large unsigned values 10624 will appear to have negative values in the debugger. */ 10625 add_AT_int (enum_die, DW_AT_const_value, 10626 tree_low_cst (value, tree_int_cst_sgn (value) > 0)); 10627 } 10628 } 10629 else 10630 add_AT_flag (type_die, DW_AT_declaration, 1); 10631 10632 return type_die; 10633} 10634 10635/* Generate a DIE to represent either a real live formal parameter decl or to 10636 represent just the type of some formal parameter position in some function 10637 type. 10638 10639 Note that this routine is a bit unusual because its argument may be a 10640 ..._DECL node (i.e. either a PARM_DECL or perhaps a VAR_DECL which 10641 represents an inlining of some PARM_DECL) or else some sort of a ..._TYPE 10642 node. If it's the former then this function is being called to output a 10643 DIE to represent a formal parameter object (or some inlining thereof). If 10644 it's the latter, then this function is only being called to output a 10645 DW_TAG_formal_parameter DIE to stand as a placeholder for some formal 10646 argument type of some subprogram type. */ 10647 10648static dw_die_ref 10649gen_formal_parameter_die (tree node, dw_die_ref context_die) 10650{ 10651 dw_die_ref parm_die 10652 = new_die (DW_TAG_formal_parameter, context_die, node); 10653 tree origin; 10654 10655 switch (TREE_CODE_CLASS (TREE_CODE (node))) 10656 { 10657 case 'd': 10658 origin = decl_ultimate_origin (node); 10659 if (origin != NULL) 10660 add_abstract_origin_attribute (parm_die, origin); 10661 else 10662 { 10663 add_name_and_src_coords_attributes (parm_die, node); 10664 add_type_attribute (parm_die, TREE_TYPE (node), 10665 TREE_READONLY (node), 10666 TREE_THIS_VOLATILE (node), 10667 context_die); 10668 if (DECL_ARTIFICIAL (node)) 10669 add_AT_flag (parm_die, DW_AT_artificial, 1); 10670 } 10671 10672 equate_decl_number_to_die (node, parm_die); 10673 if (! DECL_ABSTRACT (node)) 10674 add_location_or_const_value_attribute (parm_die, node); 10675 10676 break; 10677 10678 case 't': 10679 /* We were called with some kind of a ..._TYPE node. */ 10680 add_type_attribute (parm_die, node, 0, 0, context_die); 10681 break; 10682 10683 default: 10684 abort (); 10685 } 10686 10687 return parm_die; 10688} 10689 10690/* Generate a special type of DIE used as a stand-in for a trailing ellipsis 10691 at the end of an (ANSI prototyped) formal parameters list. */ 10692 10693static void 10694gen_unspecified_parameters_die (tree decl_or_type, dw_die_ref context_die) 10695{ 10696 new_die (DW_TAG_unspecified_parameters, context_die, decl_or_type); 10697} 10698 10699/* Generate a list of nameless DW_TAG_formal_parameter DIEs (and perhaps a 10700 DW_TAG_unspecified_parameters DIE) to represent the types of the formal 10701 parameters as specified in some function type specification (except for 10702 those which appear as part of a function *definition*). */ 10703 10704static void 10705gen_formal_types_die (tree function_or_method_type, dw_die_ref context_die) 10706{ 10707 tree link; 10708 tree formal_type = NULL; 10709 tree first_parm_type; 10710 tree arg; 10711 10712 if (TREE_CODE (function_or_method_type) == FUNCTION_DECL) 10713 { 10714 arg = DECL_ARGUMENTS (function_or_method_type); 10715 function_or_method_type = TREE_TYPE (function_or_method_type); 10716 } 10717 else 10718 arg = NULL_TREE; 10719 10720 first_parm_type = TYPE_ARG_TYPES (function_or_method_type); 10721 10722 /* Make our first pass over the list of formal parameter types and output a 10723 DW_TAG_formal_parameter DIE for each one. */ 10724 for (link = first_parm_type; link; ) 10725 { 10726 dw_die_ref parm_die; 10727 10728 formal_type = TREE_VALUE (link); 10729 if (formal_type == void_type_node) 10730 break; 10731 10732 /* Output a (nameless) DIE to represent the formal parameter itself. */ 10733 parm_die = gen_formal_parameter_die (formal_type, context_die); 10734 if ((TREE_CODE (function_or_method_type) == METHOD_TYPE 10735 && link == first_parm_type) 10736 || (arg && DECL_ARTIFICIAL (arg))) 10737 add_AT_flag (parm_die, DW_AT_artificial, 1); 10738 10739 link = TREE_CHAIN (link); 10740 if (arg) 10741 arg = TREE_CHAIN (arg); 10742 } 10743 10744 /* If this function type has an ellipsis, add a 10745 DW_TAG_unspecified_parameters DIE to the end of the parameter list. */ 10746 if (formal_type != void_type_node) 10747 gen_unspecified_parameters_die (function_or_method_type, context_die); 10748 10749 /* Make our second (and final) pass over the list of formal parameter types 10750 and output DIEs to represent those types (as necessary). */ 10751 for (link = TYPE_ARG_TYPES (function_or_method_type); 10752 link && TREE_VALUE (link); 10753 link = TREE_CHAIN (link)) 10754 gen_type_die (TREE_VALUE (link), context_die); 10755} 10756 10757/* We want to generate the DIE for TYPE so that we can generate the 10758 die for MEMBER, which has been defined; we will need to refer back 10759 to the member declaration nested within TYPE. If we're trying to 10760 generate minimal debug info for TYPE, processing TYPE won't do the 10761 trick; we need to attach the member declaration by hand. */ 10762 10763static void 10764gen_type_die_for_member (tree type, tree member, dw_die_ref context_die) 10765{ 10766 gen_type_die (type, context_die); 10767 10768 /* If we're trying to avoid duplicate debug info, we may not have 10769 emitted the member decl for this function. Emit it now. */ 10770 if (TYPE_DECL_SUPPRESS_DEBUG (TYPE_STUB_DECL (type)) 10771 && ! lookup_decl_die (member)) 10772 { 10773 if (decl_ultimate_origin (member)) 10774 abort (); 10775 10776 push_decl_scope (type); 10777 if (TREE_CODE (member) == FUNCTION_DECL) 10778 gen_subprogram_die (member, lookup_type_die (type)); 10779 else 10780 gen_variable_die (member, lookup_type_die (type)); 10781 10782 pop_decl_scope (); 10783 } 10784} 10785 10786/* Generate the DWARF2 info for the "abstract" instance of a function which we 10787 may later generate inlined and/or out-of-line instances of. */ 10788 10789static void 10790dwarf2out_abstract_function (tree decl) 10791{ 10792 dw_die_ref old_die; 10793 tree save_fn; 10794 tree context; 10795 int was_abstract = DECL_ABSTRACT (decl); 10796 10797 /* Make sure we have the actual abstract inline, not a clone. */ 10798 decl = DECL_ORIGIN (decl); 10799 10800 old_die = lookup_decl_die (decl); 10801 if (old_die && get_AT (old_die, DW_AT_inline)) 10802 /* We've already generated the abstract instance. */ 10803 return; 10804 10805 /* Be sure we've emitted the in-class declaration DIE (if any) first, so 10806 we don't get confused by DECL_ABSTRACT. */ 10807 if (debug_info_level > DINFO_LEVEL_TERSE) 10808 { 10809 context = decl_class_context (decl); 10810 if (context) 10811 gen_type_die_for_member 10812 (context, decl, decl_function_context (decl) ? NULL : comp_unit_die); 10813 } 10814 10815 /* Pretend we've just finished compiling this function. */ 10816 save_fn = current_function_decl; 10817 current_function_decl = decl; 10818 10819 set_decl_abstract_flags (decl, 1); 10820 dwarf2out_decl (decl); 10821 if (! was_abstract) 10822 set_decl_abstract_flags (decl, 0); 10823 10824 current_function_decl = save_fn; 10825} 10826 10827/* Generate a DIE to represent a declared function (either file-scope or 10828 block-local). */ 10829 10830static void 10831gen_subprogram_die (tree decl, dw_die_ref context_die) 10832{ 10833 char label_id[MAX_ARTIFICIAL_LABEL_BYTES]; 10834 tree origin = decl_ultimate_origin (decl); 10835 dw_die_ref subr_die; 10836 rtx fp_reg; 10837 tree fn_arg_types; 10838 tree outer_scope; 10839 dw_die_ref old_die = lookup_decl_die (decl); 10840 int declaration = (current_function_decl != decl 10841 || class_or_namespace_scope_p (context_die)); 10842 10843 /* It is possible to have both DECL_ABSTRACT and DECLARATION be true if we 10844 started to generate the abstract instance of an inline, decided to output 10845 its containing class, and proceeded to emit the declaration of the inline 10846 from the member list for the class. If so, DECLARATION takes priority; 10847 we'll get back to the abstract instance when done with the class. */ 10848 10849 /* The class-scope declaration DIE must be the primary DIE. */ 10850 if (origin && declaration && class_or_namespace_scope_p (context_die)) 10851 { 10852 origin = NULL; 10853 if (old_die) 10854 abort (); 10855 } 10856 10857 if (origin != NULL) 10858 { 10859 if (declaration && ! local_scope_p (context_die)) 10860 abort (); 10861 10862 /* Fixup die_parent for the abstract instance of a nested 10863 inline function. */ 10864 if (old_die && old_die->die_parent == NULL) 10865 add_child_die (context_die, old_die); 10866 10867 subr_die = new_die (DW_TAG_subprogram, context_die, decl); 10868 add_abstract_origin_attribute (subr_die, origin); 10869 } 10870 else if (old_die) 10871 { 10872 unsigned file_index = lookup_filename (DECL_SOURCE_FILE (decl)); 10873 10874 if (!get_AT_flag (old_die, DW_AT_declaration) 10875 /* We can have a normal definition following an inline one in the 10876 case of redefinition of GNU C extern inlines. 10877 It seems reasonable to use AT_specification in this case. */ 10878 && !get_AT (old_die, DW_AT_inline)) 10879 { 10880 /* ??? This can happen if there is a bug in the program, for 10881 instance, if it has duplicate function definitions. Ideally, 10882 we should detect this case and ignore it. For now, if we have 10883 already reported an error, any error at all, then assume that 10884 we got here because of an input error, not a dwarf2 bug. */ 10885 if (errorcount) 10886 return; 10887 abort (); 10888 } 10889 10890 /* If the definition comes from the same place as the declaration, 10891 maybe use the old DIE. We always want the DIE for this function 10892 that has the *_pc attributes to be under comp_unit_die so the 10893 debugger can find it. We also need to do this for abstract 10894 instances of inlines, since the spec requires the out-of-line copy 10895 to have the same parent. For local class methods, this doesn't 10896 apply; we just use the old DIE. */ 10897 if ((old_die->die_parent == comp_unit_die || context_die == NULL) 10898 && (DECL_ARTIFICIAL (decl) 10899 || (get_AT_unsigned (old_die, DW_AT_decl_file) == file_index 10900 && (get_AT_unsigned (old_die, DW_AT_decl_line) 10901 == (unsigned) DECL_SOURCE_LINE (decl))))) 10902 { 10903 subr_die = old_die; 10904 10905 /* Clear out the declaration attribute and the formal parameters. */ 10906 remove_AT (subr_die, DW_AT_declaration); 10907 remove_child_TAG (subr_die, DW_TAG_formal_parameter); 10908 } 10909 else 10910 { 10911 subr_die = new_die (DW_TAG_subprogram, context_die, decl); 10912 add_AT_specification (subr_die, old_die); 10913 if (get_AT_unsigned (old_die, DW_AT_decl_file) != file_index) 10914 add_AT_unsigned (subr_die, DW_AT_decl_file, file_index); 10915 if (get_AT_unsigned (old_die, DW_AT_decl_line) 10916 != (unsigned) DECL_SOURCE_LINE (decl)) 10917 add_AT_unsigned 10918 (subr_die, DW_AT_decl_line, DECL_SOURCE_LINE (decl)); 10919 } 10920 } 10921 else 10922 { 10923 subr_die = new_die (DW_TAG_subprogram, context_die, decl); 10924 10925 if (TREE_PUBLIC (decl)) 10926 add_AT_flag (subr_die, DW_AT_external, 1); 10927 10928 add_name_and_src_coords_attributes (subr_die, decl); 10929 if (debug_info_level > DINFO_LEVEL_TERSE) 10930 { 10931 add_prototyped_attribute (subr_die, TREE_TYPE (decl)); 10932 add_type_attribute (subr_die, TREE_TYPE (TREE_TYPE (decl)), 10933 0, 0, context_die); 10934 } 10935 10936 add_pure_or_virtual_attribute (subr_die, decl); 10937 if (DECL_ARTIFICIAL (decl)) 10938 add_AT_flag (subr_die, DW_AT_artificial, 1); 10939 10940 if (TREE_PROTECTED (decl)) 10941 add_AT_unsigned (subr_die, DW_AT_accessibility, DW_ACCESS_protected); 10942 else if (TREE_PRIVATE (decl)) 10943 add_AT_unsigned (subr_die, DW_AT_accessibility, DW_ACCESS_private); 10944 } 10945 10946 if (declaration) 10947 { 10948 if (!old_die || !get_AT (old_die, DW_AT_inline)) 10949 { 10950 add_AT_flag (subr_die, DW_AT_declaration, 1); 10951 10952 /* The first time we see a member function, it is in the context of 10953 the class to which it belongs. We make sure of this by emitting 10954 the class first. The next time is the definition, which is 10955 handled above. The two may come from the same source text. */ 10956 if (DECL_CONTEXT (decl) || DECL_ABSTRACT (decl)) 10957 equate_decl_number_to_die (decl, subr_die); 10958 } 10959 } 10960 else if (DECL_ABSTRACT (decl)) 10961 { 10962 if (DECL_DECLARED_INLINE_P (decl)) 10963 { 10964 if (cgraph_function_possibly_inlined_p (decl)) 10965 add_AT_unsigned (subr_die, DW_AT_inline, DW_INL_declared_inlined); 10966 else 10967 add_AT_unsigned (subr_die, DW_AT_inline, DW_INL_declared_not_inlined); 10968 } 10969 else 10970 { 10971 if (cgraph_function_possibly_inlined_p (decl)) 10972 add_AT_unsigned (subr_die, DW_AT_inline, DW_INL_inlined); 10973 else 10974 add_AT_unsigned (subr_die, DW_AT_inline, DW_INL_not_inlined); 10975 } 10976 10977 equate_decl_number_to_die (decl, subr_die); 10978 } 10979 else if (!DECL_EXTERNAL (decl)) 10980 { 10981 if (!old_die || !get_AT (old_die, DW_AT_inline)) 10982 equate_decl_number_to_die (decl, subr_die); 10983 10984 ASM_GENERATE_INTERNAL_LABEL (label_id, FUNC_BEGIN_LABEL, 10985 current_function_funcdef_no); 10986 add_AT_lbl_id (subr_die, DW_AT_low_pc, label_id); 10987 ASM_GENERATE_INTERNAL_LABEL (label_id, FUNC_END_LABEL, 10988 current_function_funcdef_no); 10989 add_AT_lbl_id (subr_die, DW_AT_high_pc, label_id); 10990 10991 add_pubname (decl, subr_die); 10992 add_arange (decl, subr_die); 10993 10994#ifdef MIPS_DEBUGGING_INFO 10995 /* Add a reference to the FDE for this routine. */ 10996 add_AT_fde_ref (subr_die, DW_AT_MIPS_fde, current_funcdef_fde); 10997#endif 10998 10999 /* Define the "frame base" location for this routine. We use the 11000 frame pointer or stack pointer registers, since the RTL for local 11001 variables is relative to one of them. */ 11002 fp_reg 11003 = frame_pointer_needed ? hard_frame_pointer_rtx : stack_pointer_rtx; 11004 add_AT_loc (subr_die, DW_AT_frame_base, reg_loc_descriptor (fp_reg)); 11005 11006#if 0 11007 /* ??? This fails for nested inline functions, because context_display 11008 is not part of the state saved/restored for inline functions. */ 11009 if (current_function_needs_context) 11010 add_AT_location_description (subr_die, DW_AT_static_link, 11011 loc_descriptor (lookup_static_chain (decl))); 11012#endif 11013 } 11014 11015 /* Now output descriptions of the arguments for this function. This gets 11016 (unnecessarily?) complex because of the fact that the DECL_ARGUMENT list 11017 for a FUNCTION_DECL doesn't indicate cases where there was a trailing 11018 `...' at the end of the formal parameter list. In order to find out if 11019 there was a trailing ellipsis or not, we must instead look at the type 11020 associated with the FUNCTION_DECL. This will be a node of type 11021 FUNCTION_TYPE. If the chain of type nodes hanging off of this 11022 FUNCTION_TYPE node ends with a void_type_node then there should *not* be 11023 an ellipsis at the end. */ 11024 11025 /* In the case where we are describing a mere function declaration, all we 11026 need to do here (and all we *can* do here) is to describe the *types* of 11027 its formal parameters. */ 11028 if (debug_info_level <= DINFO_LEVEL_TERSE) 11029 ; 11030 else if (declaration) 11031 gen_formal_types_die (decl, subr_die); 11032 else 11033 { 11034 /* Generate DIEs to represent all known formal parameters. */ 11035 tree arg_decls = DECL_ARGUMENTS (decl); 11036 tree parm; 11037 11038 /* When generating DIEs, generate the unspecified_parameters DIE 11039 instead if we come across the arg "__builtin_va_alist" */ 11040 for (parm = arg_decls; parm; parm = TREE_CHAIN (parm)) 11041 if (TREE_CODE (parm) == PARM_DECL) 11042 { 11043 if (DECL_NAME (parm) 11044 && !strcmp (IDENTIFIER_POINTER (DECL_NAME (parm)), 11045 "__builtin_va_alist")) 11046 gen_unspecified_parameters_die (parm, subr_die); 11047 else 11048 gen_decl_die (parm, subr_die); 11049 } 11050 11051 /* Decide whether we need an unspecified_parameters DIE at the end. 11052 There are 2 more cases to do this for: 1) the ansi ... declaration - 11053 this is detectable when the end of the arg list is not a 11054 void_type_node 2) an unprototyped function declaration (not a 11055 definition). This just means that we have no info about the 11056 parameters at all. */ 11057 fn_arg_types = TYPE_ARG_TYPES (TREE_TYPE (decl)); 11058 if (fn_arg_types != NULL) 11059 { 11060 /* This is the prototyped case, check for.... */ 11061 if (TREE_VALUE (tree_last (fn_arg_types)) != void_type_node) 11062 gen_unspecified_parameters_die (decl, subr_die); 11063 } 11064 else if (DECL_INITIAL (decl) == NULL_TREE) 11065 gen_unspecified_parameters_die (decl, subr_die); 11066 } 11067 11068 /* Output Dwarf info for all of the stuff within the body of the function 11069 (if it has one - it may be just a declaration). */ 11070 outer_scope = DECL_INITIAL (decl); 11071 11072 /* OUTER_SCOPE is a pointer to the outermost BLOCK node created to represent 11073 a function. This BLOCK actually represents the outermost binding contour 11074 for the function, i.e. the contour in which the function's formal 11075 parameters and labels get declared. Curiously, it appears that the front 11076 end doesn't actually put the PARM_DECL nodes for the current function onto 11077 the BLOCK_VARS list for this outer scope, but are strung off of the 11078 DECL_ARGUMENTS list for the function instead. 11079 11080 The BLOCK_VARS list for the `outer_scope' does provide us with a list of 11081 the LABEL_DECL nodes for the function however, and we output DWARF info 11082 for those in decls_for_scope. Just within the `outer_scope' there will be 11083 a BLOCK node representing the function's outermost pair of curly braces, 11084 and any blocks used for the base and member initializers of a C++ 11085 constructor function. */ 11086 if (! declaration && TREE_CODE (outer_scope) != ERROR_MARK) 11087 { 11088 current_function_has_inlines = 0; 11089 decls_for_scope (outer_scope, subr_die, 0); 11090 11091#if 0 && defined (MIPS_DEBUGGING_INFO) 11092 if (current_function_has_inlines) 11093 { 11094 add_AT_flag (subr_die, DW_AT_MIPS_has_inlines, 1); 11095 if (! comp_unit_has_inlines) 11096 { 11097 add_AT_flag (comp_unit_die, DW_AT_MIPS_has_inlines, 1); 11098 comp_unit_has_inlines = 1; 11099 } 11100 } 11101#endif 11102 } 11103} 11104 11105/* Generate a DIE to represent a declared data object. */ 11106 11107static void 11108gen_variable_die (tree decl, dw_die_ref context_die) 11109{ 11110 tree origin = decl_ultimate_origin (decl); 11111 dw_die_ref var_die = new_die (DW_TAG_variable, context_die, decl); 11112 11113 dw_die_ref old_die = lookup_decl_die (decl); 11114 int declaration = (DECL_EXTERNAL (decl) 11115 || class_or_namespace_scope_p (context_die)); 11116 11117 if (origin != NULL) 11118 add_abstract_origin_attribute (var_die, origin); 11119 11120 /* Loop unrolling can create multiple blocks that refer to the same 11121 static variable, so we must test for the DW_AT_declaration flag. 11122 11123 ??? Loop unrolling/reorder_blocks should perhaps be rewritten to 11124 copy decls and set the DECL_ABSTRACT flag on them instead of 11125 sharing them. 11126 11127 ??? Duplicated blocks have been rewritten to use .debug_ranges. */ 11128 else if (old_die && TREE_STATIC (decl) 11129 && get_AT_flag (old_die, DW_AT_declaration) == 1) 11130 { 11131 /* This is a definition of a C++ class level static. */ 11132 add_AT_specification (var_die, old_die); 11133 if (DECL_NAME (decl)) 11134 { 11135 unsigned file_index = lookup_filename (DECL_SOURCE_FILE (decl)); 11136 11137 if (get_AT_unsigned (old_die, DW_AT_decl_file) != file_index) 11138 add_AT_unsigned (var_die, DW_AT_decl_file, file_index); 11139 11140 if (get_AT_unsigned (old_die, DW_AT_decl_line) 11141 != (unsigned) DECL_SOURCE_LINE (decl)) 11142 11143 add_AT_unsigned (var_die, DW_AT_decl_line, 11144 DECL_SOURCE_LINE (decl)); 11145 } 11146 } 11147 else 11148 { 11149 add_name_and_src_coords_attributes (var_die, decl); 11150 add_type_attribute (var_die, TREE_TYPE (decl), TREE_READONLY (decl), 11151 TREE_THIS_VOLATILE (decl), context_die); 11152 11153 if (TREE_PUBLIC (decl)) 11154 add_AT_flag (var_die, DW_AT_external, 1); 11155 11156 if (DECL_ARTIFICIAL (decl)) 11157 add_AT_flag (var_die, DW_AT_artificial, 1); 11158 11159 if (TREE_PROTECTED (decl)) 11160 add_AT_unsigned (var_die, DW_AT_accessibility, DW_ACCESS_protected); 11161 else if (TREE_PRIVATE (decl)) 11162 add_AT_unsigned (var_die, DW_AT_accessibility, DW_ACCESS_private); 11163 } 11164 11165 if (declaration) 11166 add_AT_flag (var_die, DW_AT_declaration, 1); 11167 11168 if (class_or_namespace_scope_p (context_die) || DECL_ABSTRACT (decl)) 11169 equate_decl_number_to_die (decl, var_die); 11170 11171 if (! declaration && ! DECL_ABSTRACT (decl)) 11172 { 11173 add_location_or_const_value_attribute (var_die, decl); 11174 add_pubname (decl, var_die); 11175 } 11176 else 11177 tree_add_const_value_attribute (var_die, decl); 11178} 11179 11180/* Generate a DIE to represent a label identifier. */ 11181 11182static void 11183gen_label_die (tree decl, dw_die_ref context_die) 11184{ 11185 tree origin = decl_ultimate_origin (decl); 11186 dw_die_ref lbl_die = new_die (DW_TAG_label, context_die, decl); 11187 rtx insn; 11188 char label[MAX_ARTIFICIAL_LABEL_BYTES]; 11189 11190 if (origin != NULL) 11191 add_abstract_origin_attribute (lbl_die, origin); 11192 else 11193 add_name_and_src_coords_attributes (lbl_die, decl); 11194 11195 if (DECL_ABSTRACT (decl)) 11196 equate_decl_number_to_die (decl, lbl_die); 11197 else 11198 { 11199 insn = DECL_RTL_IF_SET (decl); 11200 11201 /* Deleted labels are programmer specified labels which have been 11202 eliminated because of various optimizations. We still emit them 11203 here so that it is possible to put breakpoints on them. */ 11204 if (insn 11205 && (GET_CODE (insn) == CODE_LABEL 11206 || ((GET_CODE (insn) == NOTE 11207 && NOTE_LINE_NUMBER (insn) == NOTE_INSN_DELETED_LABEL)))) 11208 { 11209 /* When optimization is enabled (via -O) some parts of the compiler 11210 (e.g. jump.c and cse.c) may try to delete CODE_LABEL insns which 11211 represent source-level labels which were explicitly declared by 11212 the user. This really shouldn't be happening though, so catch 11213 it if it ever does happen. */ 11214 if (INSN_DELETED_P (insn)) 11215 abort (); 11216 11217 ASM_GENERATE_INTERNAL_LABEL (label, "L", CODE_LABEL_NUMBER (insn)); 11218 add_AT_lbl_id (lbl_die, DW_AT_low_pc, label); 11219 } 11220 } 11221} 11222 11223/* Generate a DIE for a lexical block. */ 11224 11225static void 11226gen_lexical_block_die (tree stmt, dw_die_ref context_die, int depth) 11227{ 11228 dw_die_ref stmt_die = new_die (DW_TAG_lexical_block, context_die, stmt); 11229 char label[MAX_ARTIFICIAL_LABEL_BYTES]; 11230 11231 if (! BLOCK_ABSTRACT (stmt)) 11232 { 11233 if (BLOCK_FRAGMENT_CHAIN (stmt)) 11234 { 11235 tree chain; 11236 11237 add_AT_range_list (stmt_die, DW_AT_ranges, add_ranges (stmt)); 11238 11239 chain = BLOCK_FRAGMENT_CHAIN (stmt); 11240 do 11241 { 11242 add_ranges (chain); 11243 chain = BLOCK_FRAGMENT_CHAIN (chain); 11244 } 11245 while (chain); 11246 add_ranges (NULL); 11247 } 11248 else 11249 { 11250 ASM_GENERATE_INTERNAL_LABEL (label, BLOCK_BEGIN_LABEL, 11251 BLOCK_NUMBER (stmt)); 11252 add_AT_lbl_id (stmt_die, DW_AT_low_pc, label); 11253 ASM_GENERATE_INTERNAL_LABEL (label, BLOCK_END_LABEL, 11254 BLOCK_NUMBER (stmt)); 11255 add_AT_lbl_id (stmt_die, DW_AT_high_pc, label); 11256 } 11257 } 11258 11259 decls_for_scope (stmt, stmt_die, depth); 11260} 11261 11262/* Generate a DIE for an inlined subprogram. */ 11263 11264static void 11265gen_inlined_subroutine_die (tree stmt, dw_die_ref context_die, int depth) 11266{ 11267 tree decl = block_ultimate_origin (stmt); 11268 11269 /* Emit info for the abstract instance first, if we haven't yet. We 11270 must emit this even if the block is abstract, otherwise when we 11271 emit the block below (or elsewhere), we may end up trying to emit 11272 a die whose origin die hasn't been emitted, and crashing. */ 11273 dwarf2out_abstract_function (decl); 11274 11275 if (! BLOCK_ABSTRACT (stmt)) 11276 { 11277 dw_die_ref subr_die 11278 = new_die (DW_TAG_inlined_subroutine, context_die, stmt); 11279 char label[MAX_ARTIFICIAL_LABEL_BYTES]; 11280 11281 add_abstract_origin_attribute (subr_die, decl); 11282 ASM_GENERATE_INTERNAL_LABEL (label, BLOCK_BEGIN_LABEL, 11283 BLOCK_NUMBER (stmt)); 11284 add_AT_lbl_id (subr_die, DW_AT_low_pc, label); 11285 ASM_GENERATE_INTERNAL_LABEL (label, BLOCK_END_LABEL, 11286 BLOCK_NUMBER (stmt)); 11287 add_AT_lbl_id (subr_die, DW_AT_high_pc, label); 11288 decls_for_scope (stmt, subr_die, depth); 11289 current_function_has_inlines = 1; 11290 } 11291 else 11292 /* We may get here if we're the outer block of function A that was 11293 inlined into function B that was inlined into function C. When 11294 generating debugging info for C, dwarf2out_abstract_function(B) 11295 would mark all inlined blocks as abstract, including this one. 11296 So, we wouldn't (and shouldn't) expect labels to be generated 11297 for this one. Instead, just emit debugging info for 11298 declarations within the block. This is particularly important 11299 in the case of initializers of arguments passed from B to us: 11300 if they're statement expressions containing declarations, we 11301 wouldn't generate dies for their abstract variables, and then, 11302 when generating dies for the real variables, we'd die (pun 11303 intended :-) */ 11304 gen_lexical_block_die (stmt, context_die, depth); 11305} 11306 11307/* Generate a DIE for a field in a record, or structure. */ 11308 11309static void 11310gen_field_die (tree decl, dw_die_ref context_die) 11311{ 11312 dw_die_ref decl_die; 11313 11314 if (TREE_TYPE (decl) == error_mark_node) 11315 return; 11316 11317 decl_die = new_die (DW_TAG_member, context_die, decl); 11318 add_name_and_src_coords_attributes (decl_die, decl); 11319 add_type_attribute (decl_die, member_declared_type (decl), 11320 TREE_READONLY (decl), TREE_THIS_VOLATILE (decl), 11321 context_die); 11322 11323 if (DECL_BIT_FIELD_TYPE (decl)) 11324 { 11325 add_byte_size_attribute (decl_die, decl); 11326 add_bit_size_attribute (decl_die, decl); 11327 add_bit_offset_attribute (decl_die, decl); 11328 } 11329 11330 if (TREE_CODE (DECL_FIELD_CONTEXT (decl)) != UNION_TYPE) 11331 add_data_member_location_attribute (decl_die, decl); 11332 11333 if (DECL_ARTIFICIAL (decl)) 11334 add_AT_flag (decl_die, DW_AT_artificial, 1); 11335 11336 if (TREE_PROTECTED (decl)) 11337 add_AT_unsigned (decl_die, DW_AT_accessibility, DW_ACCESS_protected); 11338 else if (TREE_PRIVATE (decl)) 11339 add_AT_unsigned (decl_die, DW_AT_accessibility, DW_ACCESS_private); 11340} 11341 11342#if 0 11343/* Don't generate either pointer_type DIEs or reference_type DIEs here. 11344 Use modified_type_die instead. 11345 We keep this code here just in case these types of DIEs may be needed to 11346 represent certain things in other languages (e.g. Pascal) someday. */ 11347 11348static void 11349gen_pointer_type_die (tree type, dw_die_ref context_die) 11350{ 11351 dw_die_ref ptr_die 11352 = new_die (DW_TAG_pointer_type, scope_die_for (type, context_die), type); 11353 11354 equate_type_number_to_die (type, ptr_die); 11355 add_type_attribute (ptr_die, TREE_TYPE (type), 0, 0, context_die); 11356 add_AT_unsigned (mod_type_die, DW_AT_byte_size, PTR_SIZE); 11357} 11358 11359/* Don't generate either pointer_type DIEs or reference_type DIEs here. 11360 Use modified_type_die instead. 11361 We keep this code here just in case these types of DIEs may be needed to 11362 represent certain things in other languages (e.g. Pascal) someday. */ 11363 11364static void 11365gen_reference_type_die (tree type, dw_die_ref context_die) 11366{ 11367 dw_die_ref ref_die 11368 = new_die (DW_TAG_reference_type, scope_die_for (type, context_die), type); 11369 11370 equate_type_number_to_die (type, ref_die); 11371 add_type_attribute (ref_die, TREE_TYPE (type), 0, 0, context_die); 11372 add_AT_unsigned (mod_type_die, DW_AT_byte_size, PTR_SIZE); 11373} 11374#endif 11375 11376/* Generate a DIE for a pointer to a member type. */ 11377 11378static void 11379gen_ptr_to_mbr_type_die (tree type, dw_die_ref context_die) 11380{ 11381 dw_die_ref ptr_die 11382 = new_die (DW_TAG_ptr_to_member_type, 11383 scope_die_for (type, context_die), type); 11384 11385 equate_type_number_to_die (type, ptr_die); 11386 add_AT_die_ref (ptr_die, DW_AT_containing_type, 11387 lookup_type_die (TYPE_OFFSET_BASETYPE (type))); 11388 add_type_attribute (ptr_die, TREE_TYPE (type), 0, 0, context_die); 11389} 11390 11391/* Generate the DIE for the compilation unit. */ 11392 11393static dw_die_ref 11394gen_compile_unit_die (const char *filename) 11395{ 11396 dw_die_ref die; 11397 char producer[250]; 11398 const char *language_string = lang_hooks.name; 11399 int language; 11400 11401 die = new_die (DW_TAG_compile_unit, NULL, NULL); 11402 11403 if (filename) 11404 { 11405 add_name_attribute (die, filename); 11406 /* Don't add cwd for <built-in>. */ 11407 if (filename[0] != DIR_SEPARATOR && filename[0] != '<') 11408 add_comp_dir_attribute (die); 11409 } 11410 11411 sprintf (producer, "%s %s", language_string, version_string); 11412 11413#ifdef MIPS_DEBUGGING_INFO 11414 /* The MIPS/SGI compilers place the 'cc' command line options in the producer 11415 string. The SGI debugger looks for -g, -g1, -g2, or -g3; if they do 11416 not appear in the producer string, the debugger reaches the conclusion 11417 that the object file is stripped and has no debugging information. 11418 To get the MIPS/SGI debugger to believe that there is debugging 11419 information in the object file, we add a -g to the producer string. */ 11420 if (debug_info_level > DINFO_LEVEL_TERSE) 11421 strcat (producer, " -g"); 11422#endif 11423 11424 add_AT_string (die, DW_AT_producer, producer); 11425 11426 if (strcmp (language_string, "GNU C++") == 0) 11427 language = DW_LANG_C_plus_plus; 11428 else if (strcmp (language_string, "GNU Ada") == 0) 11429 language = DW_LANG_Ada95; 11430 else if (strcmp (language_string, "GNU F77") == 0) 11431 language = DW_LANG_Fortran77; 11432 else if (strcmp (language_string, "GNU Pascal") == 0) 11433 language = DW_LANG_Pascal83; 11434 else if (strcmp (language_string, "GNU Java") == 0) 11435 language = DW_LANG_Java; 11436 else 11437 language = DW_LANG_C89; 11438 11439 add_AT_unsigned (die, DW_AT_language, language); 11440 return die; 11441} 11442 11443/* Generate a DIE for a string type. */ 11444 11445static void 11446gen_string_type_die (tree type, dw_die_ref context_die) 11447{ 11448 dw_die_ref type_die 11449 = new_die (DW_TAG_string_type, scope_die_for (type, context_die), type); 11450 11451 equate_type_number_to_die (type, type_die); 11452 11453 /* ??? Fudge the string length attribute for now. 11454 TODO: add string length info. */ 11455#if 0 11456 string_length_attribute (TYPE_MAX_VALUE (TYPE_DOMAIN (type))); 11457 bound_representation (upper_bound, 0, 'u'); 11458#endif 11459} 11460 11461/* Generate the DIE for a base class. */ 11462 11463static void 11464gen_inheritance_die (tree binfo, tree access, dw_die_ref context_die) 11465{ 11466 dw_die_ref die = new_die (DW_TAG_inheritance, context_die, binfo); 11467 11468 add_type_attribute (die, BINFO_TYPE (binfo), 0, 0, context_die); 11469 add_data_member_location_attribute (die, binfo); 11470 11471 if (TREE_VIA_VIRTUAL (binfo)) 11472 add_AT_unsigned (die, DW_AT_virtuality, DW_VIRTUALITY_virtual); 11473 11474 if (access == access_public_node) 11475 add_AT_unsigned (die, DW_AT_accessibility, DW_ACCESS_public); 11476 else if (access == access_protected_node) 11477 add_AT_unsigned (die, DW_AT_accessibility, DW_ACCESS_protected); 11478} 11479 11480/* Generate a DIE for a class member. */ 11481 11482static void 11483gen_member_die (tree type, dw_die_ref context_die) 11484{ 11485 tree member; 11486 tree binfo = TYPE_BINFO (type); 11487 dw_die_ref child; 11488 11489 /* If this is not an incomplete type, output descriptions of each of its 11490 members. Note that as we output the DIEs necessary to represent the 11491 members of this record or union type, we will also be trying to output 11492 DIEs to represent the *types* of those members. However the `type' 11493 function (above) will specifically avoid generating type DIEs for member 11494 types *within* the list of member DIEs for this (containing) type except 11495 for those types (of members) which are explicitly marked as also being 11496 members of this (containing) type themselves. The g++ front- end can 11497 force any given type to be treated as a member of some other (containing) 11498 type by setting the TYPE_CONTEXT of the given (member) type to point to 11499 the TREE node representing the appropriate (containing) type. */ 11500 11501 /* First output info about the base classes. */ 11502 if (binfo && BINFO_BASETYPES (binfo)) 11503 { 11504 tree bases = BINFO_BASETYPES (binfo); 11505 tree accesses = BINFO_BASEACCESSES (binfo); 11506 int n_bases = TREE_VEC_LENGTH (bases); 11507 int i; 11508 11509 for (i = 0; i < n_bases; i++) 11510 gen_inheritance_die (TREE_VEC_ELT (bases, i), 11511 (accesses ? TREE_VEC_ELT (accesses, i) 11512 : access_public_node), context_die); 11513 } 11514 11515 /* Now output info about the data members and type members. */ 11516 for (member = TYPE_FIELDS (type); member; member = TREE_CHAIN (member)) 11517 { 11518 /* If we thought we were generating minimal debug info for TYPE 11519 and then changed our minds, some of the member declarations 11520 may have already been defined. Don't define them again, but 11521 do put them in the right order. */ 11522 11523 child = lookup_decl_die (member); 11524 if (child) 11525 splice_child_die (context_die, child); 11526 else 11527 gen_decl_die (member, context_die); 11528 } 11529 11530 /* Now output info about the function members (if any). */ 11531 for (member = TYPE_METHODS (type); member; member = TREE_CHAIN (member)) 11532 { 11533 /* Don't include clones in the member list. */ 11534 if (DECL_ABSTRACT_ORIGIN (member)) 11535 continue; 11536 11537 child = lookup_decl_die (member); 11538 if (child) 11539 splice_child_die (context_die, child); 11540 else 11541 gen_decl_die (member, context_die); 11542 } 11543} 11544 11545/* Generate a DIE for a structure or union type. If TYPE_DECL_SUPPRESS_DEBUG 11546 is set, we pretend that the type was never defined, so we only get the 11547 member DIEs needed by later specification DIEs. */ 11548 11549static void 11550gen_struct_or_union_type_die (tree type, dw_die_ref context_die) 11551{ 11552 dw_die_ref type_die = lookup_type_die (type); 11553 dw_die_ref scope_die = 0; 11554 int nested = 0; 11555 int complete = (TYPE_SIZE (type) 11556 && (! TYPE_STUB_DECL (type) 11557 || ! TYPE_DECL_SUPPRESS_DEBUG (TYPE_STUB_DECL (type)))); 11558 int ns_decl = (context_die && context_die->die_tag == DW_TAG_namespace); 11559 11560 if (type_die && ! complete) 11561 return; 11562 11563 if (TYPE_CONTEXT (type) != NULL_TREE 11564 && (AGGREGATE_TYPE_P (TYPE_CONTEXT (type)) 11565 || TREE_CODE (TYPE_CONTEXT (type)) == NAMESPACE_DECL)) 11566 nested = 1; 11567 11568 scope_die = scope_die_for (type, context_die); 11569 11570 if (! type_die || (nested && scope_die == comp_unit_die)) 11571 /* First occurrence of type or toplevel definition of nested class. */ 11572 { 11573 dw_die_ref old_die = type_die; 11574 11575 type_die = new_die (TREE_CODE (type) == RECORD_TYPE 11576 ? DW_TAG_structure_type : DW_TAG_union_type, 11577 scope_die, type); 11578 equate_type_number_to_die (type, type_die); 11579 if (old_die) 11580 add_AT_specification (type_die, old_die); 11581 else 11582 add_name_attribute (type_die, type_tag (type)); 11583 } 11584 else 11585 remove_AT (type_die, DW_AT_declaration); 11586 11587 /* If this type has been completed, then give it a byte_size attribute and 11588 then give a list of members. */ 11589 if (complete && !ns_decl) 11590 { 11591 /* Prevent infinite recursion in cases where the type of some member of 11592 this type is expressed in terms of this type itself. */ 11593 TREE_ASM_WRITTEN (type) = 1; 11594 add_byte_size_attribute (type_die, type); 11595 if (TYPE_STUB_DECL (type) != NULL_TREE) 11596 add_src_coords_attributes (type_die, TYPE_STUB_DECL (type)); 11597 11598 /* If the first reference to this type was as the return type of an 11599 inline function, then it may not have a parent. Fix this now. */ 11600 if (type_die->die_parent == NULL) 11601 add_child_die (scope_die, type_die); 11602 11603 push_decl_scope (type); 11604 gen_member_die (type, type_die); 11605 pop_decl_scope (); 11606 11607 /* GNU extension: Record what type our vtable lives in. */ 11608 if (TYPE_VFIELD (type)) 11609 { 11610 tree vtype = DECL_FCONTEXT (TYPE_VFIELD (type)); 11611 11612 gen_type_die (vtype, context_die); 11613 add_AT_die_ref (type_die, DW_AT_containing_type, 11614 lookup_type_die (vtype)); 11615 } 11616 } 11617 else 11618 { 11619 add_AT_flag (type_die, DW_AT_declaration, 1); 11620 11621 /* We don't need to do this for function-local types. */ 11622 if (TYPE_STUB_DECL (type) 11623 && ! decl_function_context (TYPE_STUB_DECL (type))) 11624 VARRAY_PUSH_TREE (incomplete_types, type); 11625 } 11626} 11627 11628/* Generate a DIE for a subroutine _type_. */ 11629 11630static void 11631gen_subroutine_type_die (tree type, dw_die_ref context_die) 11632{ 11633 tree return_type = TREE_TYPE (type); 11634 dw_die_ref subr_die 11635 = new_die (DW_TAG_subroutine_type, 11636 scope_die_for (type, context_die), type); 11637 11638 equate_type_number_to_die (type, subr_die); 11639 add_prototyped_attribute (subr_die, type); 11640 add_type_attribute (subr_die, return_type, 0, 0, context_die); 11641 gen_formal_types_die (type, subr_die); 11642} 11643 11644/* Generate a DIE for a type definition. */ 11645 11646static void 11647gen_typedef_die (tree decl, dw_die_ref context_die) 11648{ 11649 dw_die_ref type_die; 11650 tree origin; 11651 11652 if (TREE_ASM_WRITTEN (decl)) 11653 return; 11654 11655 TREE_ASM_WRITTEN (decl) = 1; 11656 type_die = new_die (DW_TAG_typedef, context_die, decl); 11657 origin = decl_ultimate_origin (decl); 11658 if (origin != NULL) 11659 add_abstract_origin_attribute (type_die, origin); 11660 else 11661 { 11662 tree type; 11663 11664 add_name_and_src_coords_attributes (type_die, decl); 11665 if (DECL_ORIGINAL_TYPE (decl)) 11666 { 11667 type = DECL_ORIGINAL_TYPE (decl); 11668 11669 if (type == TREE_TYPE (decl)) 11670 abort (); 11671 else 11672 equate_type_number_to_die (TREE_TYPE (decl), type_die); 11673 } 11674 else 11675 type = TREE_TYPE (decl); 11676 11677 add_type_attribute (type_die, type, TREE_READONLY (decl), 11678 TREE_THIS_VOLATILE (decl), context_die); 11679 } 11680 11681 if (DECL_ABSTRACT (decl)) 11682 equate_decl_number_to_die (decl, type_die); 11683} 11684 11685/* Generate a type description DIE. */ 11686 11687static void 11688gen_type_die (tree type, dw_die_ref context_die) 11689{ 11690 int need_pop; 11691 11692 if (type == NULL_TREE || type == error_mark_node) 11693 return; 11694 11695 if (TYPE_NAME (type) && TREE_CODE (TYPE_NAME (type)) == TYPE_DECL 11696 && DECL_ORIGINAL_TYPE (TYPE_NAME (type))) 11697 { 11698 if (TREE_ASM_WRITTEN (type)) 11699 return; 11700 11701 /* Prevent broken recursion; we can't hand off to the same type. */ 11702 if (DECL_ORIGINAL_TYPE (TYPE_NAME (type)) == type) 11703 abort (); 11704 11705 TREE_ASM_WRITTEN (type) = 1; 11706 gen_decl_die (TYPE_NAME (type), context_die); 11707 return; 11708 } 11709 11710 /* We are going to output a DIE to represent the unqualified version 11711 of this type (i.e. without any const or volatile qualifiers) so 11712 get the main variant (i.e. the unqualified version) of this type 11713 now. (Vectors are special because the debugging info is in the 11714 cloned type itself). */ 11715 if (TREE_CODE (type) != VECTOR_TYPE) 11716 type = type_main_variant (type); 11717 11718 if (TREE_ASM_WRITTEN (type)) 11719 return; 11720 11721 switch (TREE_CODE (type)) 11722 { 11723 case ERROR_MARK: 11724 break; 11725 11726 case POINTER_TYPE: 11727 case REFERENCE_TYPE: 11728 /* We must set TREE_ASM_WRITTEN in case this is a recursive type. This 11729 ensures that the gen_type_die recursion will terminate even if the 11730 type is recursive. Recursive types are possible in Ada. */ 11731 /* ??? We could perhaps do this for all types before the switch 11732 statement. */ 11733 TREE_ASM_WRITTEN (type) = 1; 11734 11735 /* For these types, all that is required is that we output a DIE (or a 11736 set of DIEs) to represent the "basis" type. */ 11737 gen_type_die (TREE_TYPE (type), context_die); 11738 break; 11739 11740 case OFFSET_TYPE: 11741 /* This code is used for C++ pointer-to-data-member types. 11742 Output a description of the relevant class type. */ 11743 gen_type_die (TYPE_OFFSET_BASETYPE (type), context_die); 11744 11745 /* Output a description of the type of the object pointed to. */ 11746 gen_type_die (TREE_TYPE (type), context_die); 11747 11748 /* Now output a DIE to represent this pointer-to-data-member type 11749 itself. */ 11750 gen_ptr_to_mbr_type_die (type, context_die); 11751 break; 11752 11753 case SET_TYPE: 11754 gen_type_die (TYPE_DOMAIN (type), context_die); 11755 gen_set_type_die (type, context_die); 11756 break; 11757 11758 case FILE_TYPE: 11759 gen_type_die (TREE_TYPE (type), context_die); 11760 abort (); /* No way to represent these in Dwarf yet! */ 11761 break; 11762 11763 case FUNCTION_TYPE: 11764 /* Force out return type (in case it wasn't forced out already). */ 11765 gen_type_die (TREE_TYPE (type), context_die); 11766 gen_subroutine_type_die (type, context_die); 11767 break; 11768 11769 case METHOD_TYPE: 11770 /* Force out return type (in case it wasn't forced out already). */ 11771 gen_type_die (TREE_TYPE (type), context_die); 11772 gen_subroutine_type_die (type, context_die); 11773 break; 11774 11775 case ARRAY_TYPE: 11776 if (TYPE_STRING_FLAG (type) && TREE_CODE (TREE_TYPE (type)) == CHAR_TYPE) 11777 { 11778 gen_type_die (TREE_TYPE (type), context_die); 11779 gen_string_type_die (type, context_die); 11780 } 11781 else 11782 gen_array_type_die (type, context_die); 11783 break; 11784 11785 case VECTOR_TYPE: 11786 gen_array_type_die (type, context_die); 11787 break; 11788 11789 case ENUMERAL_TYPE: 11790 case RECORD_TYPE: 11791 case UNION_TYPE: 11792 case QUAL_UNION_TYPE: 11793 /* If this is a nested type whose containing class hasn't been written 11794 out yet, writing it out will cover this one, too. This does not apply 11795 to instantiations of member class templates; they need to be added to 11796 the containing class as they are generated. FIXME: This hurts the 11797 idea of combining type decls from multiple TUs, since we can't predict 11798 what set of template instantiations we'll get. */ 11799 if (TYPE_CONTEXT (type) 11800 && AGGREGATE_TYPE_P (TYPE_CONTEXT (type)) 11801 && ! TREE_ASM_WRITTEN (TYPE_CONTEXT (type))) 11802 { 11803 gen_type_die (TYPE_CONTEXT (type), context_die); 11804 11805 if (TREE_ASM_WRITTEN (type)) 11806 return; 11807 11808 /* If that failed, attach ourselves to the stub. */ 11809 push_decl_scope (TYPE_CONTEXT (type)); 11810 context_die = lookup_type_die (TYPE_CONTEXT (type)); 11811 need_pop = 1; 11812 } 11813 else 11814 { 11815 declare_in_namespace (type, context_die); 11816 need_pop = 0; 11817 } 11818 11819 if (TREE_CODE (type) == ENUMERAL_TYPE) 11820 gen_enumeration_type_die (type, context_die); 11821 else 11822 gen_struct_or_union_type_die (type, context_die); 11823 11824 if (need_pop) 11825 pop_decl_scope (); 11826 11827 /* Don't set TREE_ASM_WRITTEN on an incomplete struct; we want to fix 11828 it up if it is ever completed. gen_*_type_die will set it for us 11829 when appropriate. */ 11830 return; 11831 11832 case VOID_TYPE: 11833 case INTEGER_TYPE: 11834 case REAL_TYPE: 11835 case COMPLEX_TYPE: 11836 case BOOLEAN_TYPE: 11837 case CHAR_TYPE: 11838 /* No DIEs needed for fundamental types. */ 11839 break; 11840 11841 case LANG_TYPE: 11842 /* No Dwarf representation currently defined. */ 11843 break; 11844 11845 default: 11846 abort (); 11847 } 11848 11849 TREE_ASM_WRITTEN (type) = 1; 11850} 11851 11852/* Generate a DIE for a tagged type instantiation. */ 11853 11854static void 11855gen_tagged_type_instantiation_die (tree type, dw_die_ref context_die) 11856{ 11857 if (type == NULL_TREE || type == error_mark_node) 11858 return; 11859 11860 /* We are going to output a DIE to represent the unqualified version of 11861 this type (i.e. without any const or volatile qualifiers) so make sure 11862 that we have the main variant (i.e. the unqualified version) of this 11863 type now. */ 11864 if (type != type_main_variant (type)) 11865 abort (); 11866 11867 /* Do not check TREE_ASM_WRITTEN (type) as it may not be set if this is 11868 an instance of an unresolved type. */ 11869 11870 switch (TREE_CODE (type)) 11871 { 11872 case ERROR_MARK: 11873 break; 11874 11875 case ENUMERAL_TYPE: 11876 gen_inlined_enumeration_type_die (type, context_die); 11877 break; 11878 11879 case RECORD_TYPE: 11880 gen_inlined_structure_type_die (type, context_die); 11881 break; 11882 11883 case UNION_TYPE: 11884 case QUAL_UNION_TYPE: 11885 gen_inlined_union_type_die (type, context_die); 11886 break; 11887 11888 default: 11889 abort (); 11890 } 11891} 11892 11893/* Generate a DW_TAG_lexical_block DIE followed by DIEs to represent all of the 11894 things which are local to the given block. */ 11895 11896static void 11897gen_block_die (tree stmt, dw_die_ref context_die, int depth) 11898{ 11899 int must_output_die = 0; 11900 tree origin; 11901 tree decl; 11902 enum tree_code origin_code; 11903 11904 /* Ignore blocks never really used to make RTL. */ 11905 if (stmt == NULL_TREE || !TREE_USED (stmt) 11906 || (!TREE_ASM_WRITTEN (stmt) && !BLOCK_ABSTRACT (stmt))) 11907 return; 11908 11909 /* If the block is one fragment of a non-contiguous block, do not 11910 process the variables, since they will have been done by the 11911 origin block. Do process subblocks. */ 11912 if (BLOCK_FRAGMENT_ORIGIN (stmt)) 11913 { 11914 tree sub; 11915 11916 for (sub = BLOCK_SUBBLOCKS (stmt); sub; sub = BLOCK_CHAIN (sub)) 11917 gen_block_die (sub, context_die, depth + 1); 11918 11919 return; 11920 } 11921 11922 /* Determine the "ultimate origin" of this block. This block may be an 11923 inlined instance of an inlined instance of inline function, so we have 11924 to trace all of the way back through the origin chain to find out what 11925 sort of node actually served as the original seed for the creation of 11926 the current block. */ 11927 origin = block_ultimate_origin (stmt); 11928 origin_code = (origin != NULL) ? TREE_CODE (origin) : ERROR_MARK; 11929 11930 /* Determine if we need to output any Dwarf DIEs at all to represent this 11931 block. */ 11932 if (origin_code == FUNCTION_DECL) 11933 /* The outer scopes for inlinings *must* always be represented. We 11934 generate DW_TAG_inlined_subroutine DIEs for them. (See below.) */ 11935 must_output_die = 1; 11936 else 11937 { 11938 /* In the case where the current block represents an inlining of the 11939 "body block" of an inline function, we must *NOT* output any DIE for 11940 this block because we have already output a DIE to represent the whole 11941 inlined function scope and the "body block" of any function doesn't 11942 really represent a different scope according to ANSI C rules. So we 11943 check here to make sure that this block does not represent a "body 11944 block inlining" before trying to set the MUST_OUTPUT_DIE flag. */ 11945 if (! is_body_block (origin ? origin : stmt)) 11946 { 11947 /* Determine if this block directly contains any "significant" 11948 local declarations which we will need to output DIEs for. */ 11949 if (debug_info_level > DINFO_LEVEL_TERSE) 11950 /* We are not in terse mode so *any* local declaration counts 11951 as being a "significant" one. */ 11952 must_output_die = (BLOCK_VARS (stmt) != NULL); 11953 else 11954 /* We are in terse mode, so only local (nested) function 11955 definitions count as "significant" local declarations. */ 11956 for (decl = BLOCK_VARS (stmt); 11957 decl != NULL; decl = TREE_CHAIN (decl)) 11958 if (TREE_CODE (decl) == FUNCTION_DECL 11959 && DECL_INITIAL (decl)) 11960 { 11961 must_output_die = 1; 11962 break; 11963 } 11964 } 11965 } 11966 11967 /* It would be a waste of space to generate a Dwarf DW_TAG_lexical_block 11968 DIE for any block which contains no significant local declarations at 11969 all. Rather, in such cases we just call `decls_for_scope' so that any 11970 needed Dwarf info for any sub-blocks will get properly generated. Note 11971 that in terse mode, our definition of what constitutes a "significant" 11972 local declaration gets restricted to include only inlined function 11973 instances and local (nested) function definitions. */ 11974 if (must_output_die) 11975 { 11976 if (origin_code == FUNCTION_DECL) 11977 gen_inlined_subroutine_die (stmt, context_die, depth); 11978 else 11979 gen_lexical_block_die (stmt, context_die, depth); 11980 } 11981 else 11982 decls_for_scope (stmt, context_die, depth); 11983} 11984 11985/* Generate all of the decls declared within a given scope and (recursively) 11986 all of its sub-blocks. */ 11987 11988static void 11989decls_for_scope (tree stmt, dw_die_ref context_die, int depth) 11990{ 11991 tree decl; 11992 tree subblocks; 11993 11994 /* Ignore blocks never really used to make RTL. */ 11995 if (stmt == NULL_TREE || ! TREE_USED (stmt)) 11996 return; 11997 11998 /* Output the DIEs to represent all of the data objects and typedefs 11999 declared directly within this block but not within any nested 12000 sub-blocks. Also, nested function and tag DIEs have been 12001 generated with a parent of NULL; fix that up now. */ 12002 for (decl = BLOCK_VARS (stmt); decl != NULL; decl = TREE_CHAIN (decl)) 12003 { 12004 dw_die_ref die; 12005 12006 if (TREE_CODE (decl) == FUNCTION_DECL) 12007 die = lookup_decl_die (decl); 12008 else if (TREE_CODE (decl) == TYPE_DECL && TYPE_DECL_IS_STUB (decl)) 12009 die = lookup_type_die (TREE_TYPE (decl)); 12010 else 12011 die = NULL; 12012 12013 if (die != NULL && die->die_parent == NULL) 12014 add_child_die (context_die, die); 12015 else 12016 gen_decl_die (decl, context_die); 12017 } 12018 12019 /* If we're at -g1, we're not interested in subblocks. */ 12020 if (debug_info_level <= DINFO_LEVEL_TERSE) 12021 return; 12022 12023 /* Output the DIEs to represent all sub-blocks (and the items declared 12024 therein) of this block. */ 12025 for (subblocks = BLOCK_SUBBLOCKS (stmt); 12026 subblocks != NULL; 12027 subblocks = BLOCK_CHAIN (subblocks)) 12028 gen_block_die (subblocks, context_die, depth + 1); 12029} 12030 12031/* Is this a typedef we can avoid emitting? */ 12032 12033static inline int 12034is_redundant_typedef (tree decl) 12035{ 12036 if (TYPE_DECL_IS_STUB (decl)) 12037 return 1; 12038 12039 if (DECL_ARTIFICIAL (decl) 12040 && DECL_CONTEXT (decl) 12041 && is_tagged_type (DECL_CONTEXT (decl)) 12042 && TREE_CODE (TYPE_NAME (DECL_CONTEXT (decl))) == TYPE_DECL 12043 && DECL_NAME (decl) == DECL_NAME (TYPE_NAME (DECL_CONTEXT (decl)))) 12044 /* Also ignore the artificial member typedef for the class name. */ 12045 return 1; 12046 12047 return 0; 12048} 12049 12050/* Returns the DIE for namespace NS or aborts. 12051 12052 Note that namespaces don't really have a lexical context, so there's no 12053 need to pass in a context_die. They always go inside their containing 12054 namespace, or comp_unit_die if none. */ 12055 12056static dw_die_ref 12057force_namespace_die (tree ns) 12058{ 12059 dw_die_ref ns_die; 12060 12061 dwarf2out_decl (ns); 12062 ns_die = lookup_decl_die (ns); 12063 if (!ns_die) 12064 abort(); 12065 12066 return ns_die; 12067} 12068 12069/* Force out any required namespaces to be able to output DECL, 12070 and return the new context_die for it, if it's changed. */ 12071 12072static dw_die_ref 12073setup_namespace_context (tree thing, dw_die_ref context_die) 12074{ 12075 tree context = DECL_P (thing) ? DECL_CONTEXT (thing) : TYPE_CONTEXT (thing); 12076 if (context && TREE_CODE (context) == NAMESPACE_DECL) 12077 /* Force out the namespace. */ 12078 context_die = force_namespace_die (context); 12079 12080 return context_die; 12081} 12082 12083/* Emit a declaration DIE for THING (which is either a DECL or a tagged 12084 type) within its namespace, if appropriate. 12085 12086 For compatibility with older debuggers, namespace DIEs only contain 12087 declarations; all definitions are emitted at CU scope. */ 12088 12089static void 12090declare_in_namespace (tree thing, dw_die_ref context_die) 12091{ 12092 dw_die_ref ns_context; 12093 12094 if (debug_info_level <= DINFO_LEVEL_TERSE) 12095 return; 12096 12097 ns_context = setup_namespace_context (thing, context_die); 12098 12099 if (ns_context != context_die) 12100 { 12101 if (DECL_P (thing)) 12102 gen_decl_die (thing, ns_context); 12103 else 12104 gen_type_die (thing, ns_context); 12105 } 12106} 12107 12108/* Generate a DIE for a namespace or namespace alias. */ 12109 12110static void 12111gen_namespace_die (tree decl) 12112{ 12113 dw_die_ref context_die = setup_namespace_context (decl, comp_unit_die); 12114 12115 /* Namespace aliases have a DECL_ABSTRACT_ORIGIN of the namespace 12116 they are an alias of. */ 12117 if (DECL_ABSTRACT_ORIGIN (decl) == NULL) 12118 { 12119 /* Output a real namespace. */ 12120 dw_die_ref namespace_die 12121 = new_die (DW_TAG_namespace, context_die, decl); 12122 add_name_and_src_coords_attributes (namespace_die, decl); 12123 equate_decl_number_to_die (decl, namespace_die); 12124 } 12125 else 12126 { 12127 /* Output a namespace alias. */ 12128 12129 /* Force out the namespace we are an alias of, if necessary. */ 12130 dw_die_ref origin_die 12131 = force_namespace_die (DECL_ABSTRACT_ORIGIN (decl)); 12132 12133 /* Now create the namespace alias DIE. */ 12134 dw_die_ref namespace_die 12135 = new_die (DW_TAG_imported_declaration, context_die, decl); 12136 add_name_and_src_coords_attributes (namespace_die, decl); 12137 add_AT_die_ref (namespace_die, DW_AT_import, origin_die); 12138 equate_decl_number_to_die (decl, namespace_die); 12139 } 12140} 12141 12142/* Generate Dwarf debug information for a decl described by DECL. */ 12143 12144static void 12145gen_decl_die (tree decl, dw_die_ref context_die) 12146{ 12147 tree origin; 12148 12149 if (DECL_P (decl) && DECL_IGNORED_P (decl)) 12150 return; 12151 12152 switch (TREE_CODE (decl)) 12153 { 12154 case ERROR_MARK: 12155 break; 12156 12157 case CONST_DECL: 12158 /* The individual enumerators of an enum type get output when we output 12159 the Dwarf representation of the relevant enum type itself. */ 12160 break; 12161 12162 case FUNCTION_DECL: 12163 /* Don't output any DIEs to represent mere function declarations, 12164 unless they are class members or explicit block externs. */ 12165 if (DECL_INITIAL (decl) == NULL_TREE && DECL_CONTEXT (decl) == NULL_TREE 12166 && (current_function_decl == NULL_TREE || DECL_ARTIFICIAL (decl))) 12167 break; 12168 12169 /* If we're emitting a clone, emit info for the abstract instance. */ 12170 if (DECL_ORIGIN (decl) != decl) 12171 dwarf2out_abstract_function (DECL_ABSTRACT_ORIGIN (decl)); 12172 12173 /* If we're emitting an out-of-line copy of an inline function, 12174 emit info for the abstract instance and set up to refer to it. */ 12175 else if (cgraph_function_possibly_inlined_p (decl) 12176 && ! DECL_ABSTRACT (decl) 12177 && ! class_or_namespace_scope_p (context_die) 12178 /* dwarf2out_abstract_function won't emit a die if this is just 12179 a declaration. We must avoid setting DECL_ABSTRACT_ORIGIN in 12180 that case, because that works only if we have a die. */ 12181 && DECL_INITIAL (decl) != NULL_TREE) 12182 { 12183 dwarf2out_abstract_function (decl); 12184 set_decl_origin_self (decl); 12185 } 12186 12187 /* Otherwise we're emitting the primary DIE for this decl. */ 12188 else if (debug_info_level > DINFO_LEVEL_TERSE) 12189 { 12190 /* Before we describe the FUNCTION_DECL itself, make sure that we 12191 have described its return type. */ 12192 gen_type_die (TREE_TYPE (TREE_TYPE (decl)), context_die); 12193 12194 /* And its virtual context. */ 12195 if (DECL_VINDEX (decl) != NULL_TREE) 12196 gen_type_die (DECL_CONTEXT (decl), context_die); 12197 12198 /* And its containing type. */ 12199 origin = decl_class_context (decl); 12200 if (origin != NULL_TREE) 12201 gen_type_die_for_member (origin, decl, context_die); 12202 12203 /* And its containing namespace. */ 12204 declare_in_namespace (decl, context_die); 12205 } 12206 12207 /* Now output a DIE to represent the function itself. */ 12208 gen_subprogram_die (decl, context_die); 12209 break; 12210 12211 case TYPE_DECL: 12212 /* If we are in terse mode, don't generate any DIEs to represent any 12213 actual typedefs. */ 12214 if (debug_info_level <= DINFO_LEVEL_TERSE) 12215 break; 12216 12217 /* In the special case of a TYPE_DECL node representing the declaration 12218 of some type tag, if the given TYPE_DECL is marked as having been 12219 instantiated from some other (original) TYPE_DECL node (e.g. one which 12220 was generated within the original definition of an inline function) we 12221 have to generate a special (abbreviated) DW_TAG_structure_type, 12222 DW_TAG_union_type, or DW_TAG_enumeration_type DIE here. */ 12223 if (TYPE_DECL_IS_STUB (decl) && decl_ultimate_origin (decl) != NULL_TREE) 12224 { 12225 gen_tagged_type_instantiation_die (TREE_TYPE (decl), context_die); 12226 break; 12227 } 12228 12229 if (is_redundant_typedef (decl)) 12230 gen_type_die (TREE_TYPE (decl), context_die); 12231 else 12232 /* Output a DIE to represent the typedef itself. */ 12233 gen_typedef_die (decl, context_die); 12234 break; 12235 12236 case LABEL_DECL: 12237 if (debug_info_level >= DINFO_LEVEL_NORMAL) 12238 gen_label_die (decl, context_die); 12239 break; 12240 12241 case VAR_DECL: 12242 /* If we are in terse mode, don't generate any DIEs to represent any 12243 variable declarations or definitions. */ 12244 if (debug_info_level <= DINFO_LEVEL_TERSE) 12245 break; 12246 12247 /* Output any DIEs that are needed to specify the type of this data 12248 object. */ 12249 gen_type_die (TREE_TYPE (decl), context_die); 12250 12251 /* And its containing type. */ 12252 origin = decl_class_context (decl); 12253 if (origin != NULL_TREE) 12254 gen_type_die_for_member (origin, decl, context_die); 12255 12256 /* And its containing namespace. */ 12257 declare_in_namespace (decl, context_die); 12258 12259 /* Now output the DIE to represent the data object itself. This gets 12260 complicated because of the possibility that the VAR_DECL really 12261 represents an inlined instance of a formal parameter for an inline 12262 function. */ 12263 origin = decl_ultimate_origin (decl); 12264 if (origin != NULL_TREE && TREE_CODE (origin) == PARM_DECL) 12265 gen_formal_parameter_die (decl, context_die); 12266 else 12267 gen_variable_die (decl, context_die); 12268 break; 12269 12270 case FIELD_DECL: 12271 /* Ignore the nameless fields that are used to skip bits but handle C++ 12272 anonymous unions. */ 12273 if (DECL_NAME (decl) != NULL_TREE 12274 || TREE_CODE (TREE_TYPE (decl)) == UNION_TYPE) 12275 { 12276 gen_type_die (member_declared_type (decl), context_die); 12277 gen_field_die (decl, context_die); 12278 } 12279 break; 12280 12281 case PARM_DECL: 12282 gen_type_die (TREE_TYPE (decl), context_die); 12283 gen_formal_parameter_die (decl, context_die); 12284 break; 12285 12286 case NAMESPACE_DECL: 12287 gen_namespace_die (decl); 12288 break; 12289 12290 default: 12291 if ((int)TREE_CODE (decl) > NUM_TREE_CODES) 12292 /* Probably some frontend-internal decl. Assume we don't care. */ 12293 break; 12294 abort (); 12295 } 12296} 12297 12298/* Add Ada "use" clause information for SGI Workshop debugger. */ 12299 12300void 12301dwarf2out_add_library_unit_info (const char *filename, const char *context_list) 12302{ 12303 unsigned int file_index; 12304 12305 if (filename != NULL) 12306 { 12307 dw_die_ref unit_die = new_die (DW_TAG_module, comp_unit_die, NULL); 12308 tree context_list_decl 12309 = build_decl (LABEL_DECL, get_identifier (context_list), 12310 void_type_node); 12311 12312 TREE_PUBLIC (context_list_decl) = TRUE; 12313 add_name_attribute (unit_die, context_list); 12314 file_index = lookup_filename (filename); 12315 add_AT_unsigned (unit_die, DW_AT_decl_file, file_index); 12316 add_pubname (context_list_decl, unit_die); 12317 } 12318} 12319 12320/* Output debug information for global decl DECL. Called from toplev.c after 12321 compilation proper has finished. */ 12322 12323static void 12324dwarf2out_global_decl (tree decl) 12325{ 12326 /* Output DWARF2 information for file-scope tentative data object 12327 declarations, file-scope (extern) function declarations (which had no 12328 corresponding body) and file-scope tagged type declarations and 12329 definitions which have not yet been forced out. */ 12330 if (TREE_CODE (decl) != FUNCTION_DECL || !DECL_INITIAL (decl)) 12331 dwarf2out_decl (decl); 12332} 12333 12334/* Write the debugging output for DECL. */ 12335 12336void 12337dwarf2out_decl (tree decl) 12338{ 12339 dw_die_ref context_die = comp_unit_die; 12340 12341 switch (TREE_CODE (decl)) 12342 { 12343 case ERROR_MARK: 12344 return; 12345 12346 case FUNCTION_DECL: 12347 /* What we would really like to do here is to filter out all mere 12348 file-scope declarations of file-scope functions which are never 12349 referenced later within this translation unit (and keep all of ones 12350 that *are* referenced later on) but we aren't clairvoyant, so we have 12351 no idea which functions will be referenced in the future (i.e. later 12352 on within the current translation unit). So here we just ignore all 12353 file-scope function declarations which are not also definitions. If 12354 and when the debugger needs to know something about these functions, 12355 it will have to hunt around and find the DWARF information associated 12356 with the definition of the function. 12357 12358 We can't just check DECL_EXTERNAL to find out which FUNCTION_DECL 12359 nodes represent definitions and which ones represent mere 12360 declarations. We have to check DECL_INITIAL instead. That's because 12361 the C front-end supports some weird semantics for "extern inline" 12362 function definitions. These can get inlined within the current 12363 translation unit (an thus, we need to generate Dwarf info for their 12364 abstract instances so that the Dwarf info for the concrete inlined 12365 instances can have something to refer to) but the compiler never 12366 generates any out-of-lines instances of such things (despite the fact 12367 that they *are* definitions). 12368 12369 The important point is that the C front-end marks these "extern 12370 inline" functions as DECL_EXTERNAL, but we need to generate DWARF for 12371 them anyway. Note that the C++ front-end also plays some similar games 12372 for inline function definitions appearing within include files which 12373 also contain `#pragma interface' pragmas. */ 12374 if (DECL_INITIAL (decl) == NULL_TREE) 12375 return; 12376 12377 /* If we're a nested function, initially use a parent of NULL; if we're 12378 a plain function, this will be fixed up in decls_for_scope. If 12379 we're a method, it will be ignored, since we already have a DIE. */ 12380 if (decl_function_context (decl) 12381 /* But if we're in terse mode, we don't care about scope. */ 12382 && debug_info_level > DINFO_LEVEL_TERSE) 12383 context_die = NULL; 12384 break; 12385 12386 case VAR_DECL: 12387 /* Ignore this VAR_DECL if it refers to a file-scope extern data object 12388 declaration and if the declaration was never even referenced from 12389 within this entire compilation unit. We suppress these DIEs in 12390 order to save space in the .debug section (by eliminating entries 12391 which are probably useless). Note that we must not suppress 12392 block-local extern declarations (whether used or not) because that 12393 would screw-up the debugger's name lookup mechanism and cause it to 12394 miss things which really ought to be in scope at a given point. */ 12395 if (DECL_EXTERNAL (decl) && !TREE_USED (decl)) 12396 return; 12397 12398 /* If we are in terse mode, don't generate any DIEs to represent any 12399 variable declarations or definitions. */ 12400 if (debug_info_level <= DINFO_LEVEL_TERSE) 12401 return; 12402 break; 12403 12404 case NAMESPACE_DECL: 12405 if (debug_info_level <= DINFO_LEVEL_TERSE) 12406 return; 12407 if (lookup_decl_die (decl) != NULL) 12408 return; 12409 break; 12410 12411 case TYPE_DECL: 12412 /* Don't emit stubs for types unless they are needed by other DIEs. */ 12413 if (TYPE_DECL_SUPPRESS_DEBUG (decl)) 12414 return; 12415 12416 /* Don't bother trying to generate any DIEs to represent any of the 12417 normal built-in types for the language we are compiling. */ 12418 if (DECL_SOURCE_LINE (decl) == 0) 12419 { 12420 /* OK, we need to generate one for `bool' so GDB knows what type 12421 comparisons have. */ 12422 if ((get_AT_unsigned (comp_unit_die, DW_AT_language) 12423 == DW_LANG_C_plus_plus) 12424 && TREE_CODE (TREE_TYPE (decl)) == BOOLEAN_TYPE 12425 && ! DECL_IGNORED_P (decl)) 12426 modified_type_die (TREE_TYPE (decl), 0, 0, NULL); 12427 12428 return; 12429 } 12430 12431 /* If we are in terse mode, don't generate any DIEs for types. */ 12432 if (debug_info_level <= DINFO_LEVEL_TERSE) 12433 return; 12434 12435 /* If we're a function-scope tag, initially use a parent of NULL; 12436 this will be fixed up in decls_for_scope. */ 12437 if (decl_function_context (decl)) 12438 context_die = NULL; 12439 12440 break; 12441 12442 default: 12443 return; 12444 } 12445 12446 gen_decl_die (decl, context_die); 12447} 12448 12449/* Output a marker (i.e. a label) for the beginning of the generated code for 12450 a lexical block. */ 12451 12452static void 12453dwarf2out_begin_block (unsigned int line ATTRIBUTE_UNUSED, 12454 unsigned int blocknum) 12455{ 12456 function_section (current_function_decl); 12457 ASM_OUTPUT_DEBUG_LABEL (asm_out_file, BLOCK_BEGIN_LABEL, blocknum); 12458} 12459 12460/* Output a marker (i.e. a label) for the end of the generated code for a 12461 lexical block. */ 12462 12463static void 12464dwarf2out_end_block (unsigned int line ATTRIBUTE_UNUSED, unsigned int blocknum) 12465{ 12466 function_section (current_function_decl); 12467 ASM_OUTPUT_DEBUG_LABEL (asm_out_file, BLOCK_END_LABEL, blocknum); 12468} 12469 12470/* Returns nonzero if it is appropriate not to emit any debugging 12471 information for BLOCK, because it doesn't contain any instructions. 12472 12473 Don't allow this for blocks with nested functions or local classes 12474 as we would end up with orphans, and in the presence of scheduling 12475 we may end up calling them anyway. */ 12476 12477static bool 12478dwarf2out_ignore_block (tree block) 12479{ 12480 tree decl; 12481 12482 for (decl = BLOCK_VARS (block); decl; decl = TREE_CHAIN (decl)) 12483 if (TREE_CODE (decl) == FUNCTION_DECL 12484 || (TREE_CODE (decl) == TYPE_DECL && TYPE_DECL_IS_STUB (decl))) 12485 return 0; 12486 12487 return 1; 12488} 12489 12490/* Lookup FILE_NAME (in the list of filenames that we know about here in 12491 dwarf2out.c) and return its "index". The index of each (known) filename is 12492 just a unique number which is associated with only that one filename. We 12493 need such numbers for the sake of generating labels (in the .debug_sfnames 12494 section) and references to those files numbers (in the .debug_srcinfo 12495 and.debug_macinfo sections). If the filename given as an argument is not 12496 found in our current list, add it to the list and assign it the next 12497 available unique index number. In order to speed up searches, we remember 12498 the index of the filename was looked up last. This handles the majority of 12499 all searches. */ 12500 12501static unsigned 12502lookup_filename (const char *file_name) 12503{ 12504 size_t i, n; 12505 char *save_file_name; 12506 12507 /* Check to see if the file name that was searched on the previous 12508 call matches this file name. If so, return the index. */ 12509 if (file_table_last_lookup_index != 0) 12510 { 12511 const char *last 12512 = VARRAY_CHAR_PTR (file_table, file_table_last_lookup_index); 12513 if (strcmp (file_name, last) == 0) 12514 return file_table_last_lookup_index; 12515 } 12516 12517 /* Didn't match the previous lookup, search the table */ 12518 n = VARRAY_ACTIVE_SIZE (file_table); 12519 for (i = 1; i < n; i++) 12520 if (strcmp (file_name, VARRAY_CHAR_PTR (file_table, i)) == 0) 12521 { 12522 file_table_last_lookup_index = i; 12523 return i; 12524 } 12525 12526 /* Add the new entry to the end of the filename table. */ 12527 file_table_last_lookup_index = n; 12528 save_file_name = (char *) ggc_strdup (file_name); 12529 VARRAY_PUSH_CHAR_PTR (file_table, save_file_name); 12530 VARRAY_PUSH_UINT (file_table_emitted, 0); 12531 12532 return i; 12533} 12534 12535static int 12536maybe_emit_file (int fileno) 12537{ 12538 if (DWARF2_ASM_LINE_DEBUG_INFO && fileno > 0) 12539 { 12540 if (!VARRAY_UINT (file_table_emitted, fileno)) 12541 { 12542 VARRAY_UINT (file_table_emitted, fileno) = ++emitcount; 12543 fprintf (asm_out_file, "\t.file %u ", 12544 VARRAY_UINT (file_table_emitted, fileno)); 12545 output_quoted_string (asm_out_file, 12546 VARRAY_CHAR_PTR (file_table, fileno)); 12547 fputc ('\n', asm_out_file); 12548 } 12549 return VARRAY_UINT (file_table_emitted, fileno); 12550 } 12551 else 12552 return fileno; 12553} 12554 12555static void 12556init_file_table (void) 12557{ 12558 /* Allocate the initial hunk of the file_table. */ 12559 VARRAY_CHAR_PTR_INIT (file_table, 64, "file_table"); 12560 VARRAY_UINT_INIT (file_table_emitted, 64, "file_table_emitted"); 12561 12562 /* Skip the first entry - file numbers begin at 1. */ 12563 VARRAY_PUSH_CHAR_PTR (file_table, NULL); 12564 VARRAY_PUSH_UINT (file_table_emitted, 0); 12565 file_table_last_lookup_index = 0; 12566} 12567 12568/* Output a label to mark the beginning of a source code line entry 12569 and record information relating to this source line, in 12570 'line_info_table' for later output of the .debug_line section. */ 12571 12572static void 12573dwarf2out_source_line (unsigned int line, const char *filename) 12574{ 12575 if (debug_info_level >= DINFO_LEVEL_NORMAL 12576 && line != 0) 12577 { 12578 function_section (current_function_decl); 12579 12580 /* If requested, emit something human-readable. */ 12581 if (flag_debug_asm) 12582 fprintf (asm_out_file, "\t%s %s:%d\n", ASM_COMMENT_START, 12583 filename, line); 12584 12585 if (DWARF2_ASM_LINE_DEBUG_INFO) 12586 { 12587 unsigned file_num = lookup_filename (filename); 12588 12589 file_num = maybe_emit_file (file_num); 12590 12591 /* Emit the .loc directive understood by GNU as. */ 12592 fprintf (asm_out_file, "\t.loc %d %d 0\n", file_num, line); 12593 12594 /* Indicate that line number info exists. */ 12595 line_info_table_in_use++; 12596 12597 /* Indicate that multiple line number tables exist. */ 12598 if (DECL_SECTION_NAME (current_function_decl)) 12599 separate_line_info_table_in_use++; 12600 } 12601 else if (DECL_SECTION_NAME (current_function_decl)) 12602 { 12603 dw_separate_line_info_ref line_info; 12604 (*targetm.asm_out.internal_label) (asm_out_file, SEPARATE_LINE_CODE_LABEL, 12605 separate_line_info_table_in_use); 12606 12607 /* expand the line info table if necessary */ 12608 if (separate_line_info_table_in_use 12609 == separate_line_info_table_allocated) 12610 { 12611 separate_line_info_table_allocated += LINE_INFO_TABLE_INCREMENT; 12612 separate_line_info_table 12613 = ggc_realloc (separate_line_info_table, 12614 separate_line_info_table_allocated 12615 * sizeof (dw_separate_line_info_entry)); 12616 memset (separate_line_info_table 12617 + separate_line_info_table_in_use, 12618 0, 12619 (LINE_INFO_TABLE_INCREMENT 12620 * sizeof (dw_separate_line_info_entry))); 12621 } 12622 12623 /* Add the new entry at the end of the line_info_table. */ 12624 line_info 12625 = &separate_line_info_table[separate_line_info_table_in_use++]; 12626 line_info->dw_file_num = lookup_filename (filename); 12627 line_info->dw_line_num = line; 12628 line_info->function = current_function_funcdef_no; 12629 } 12630 else 12631 { 12632 dw_line_info_ref line_info; 12633 12634 (*targetm.asm_out.internal_label) (asm_out_file, LINE_CODE_LABEL, 12635 line_info_table_in_use); 12636 12637 /* Expand the line info table if necessary. */ 12638 if (line_info_table_in_use == line_info_table_allocated) 12639 { 12640 line_info_table_allocated += LINE_INFO_TABLE_INCREMENT; 12641 line_info_table 12642 = ggc_realloc (line_info_table, 12643 (line_info_table_allocated 12644 * sizeof (dw_line_info_entry))); 12645 memset (line_info_table + line_info_table_in_use, 0, 12646 LINE_INFO_TABLE_INCREMENT * sizeof (dw_line_info_entry)); 12647 } 12648 12649 /* Add the new entry at the end of the line_info_table. */ 12650 line_info = &line_info_table[line_info_table_in_use++]; 12651 line_info->dw_file_num = lookup_filename (filename); 12652 line_info->dw_line_num = line; 12653 } 12654 } 12655} 12656 12657/* Record the beginning of a new source file. */ 12658 12659static void 12660dwarf2out_start_source_file (unsigned int lineno, const char *filename) 12661{ 12662 if (flag_eliminate_dwarf2_dups) 12663 { 12664 /* Record the beginning of the file for break_out_includes. */ 12665 dw_die_ref bincl_die; 12666 12667 bincl_die = new_die (DW_TAG_GNU_BINCL, comp_unit_die, NULL); 12668 add_AT_string (bincl_die, DW_AT_name, filename); 12669 } 12670 12671 if (debug_info_level >= DINFO_LEVEL_VERBOSE) 12672 { 12673 named_section_flags (DEBUG_MACINFO_SECTION, SECTION_DEBUG); 12674 dw2_asm_output_data (1, DW_MACINFO_start_file, "Start new file"); 12675 dw2_asm_output_data_uleb128 (lineno, "Included from line number %d", 12676 lineno); 12677 maybe_emit_file (lookup_filename (filename)); 12678 dw2_asm_output_data_uleb128 (lookup_filename (filename), 12679 "Filename we just started"); 12680 } 12681} 12682 12683/* Record the end of a source file. */ 12684 12685static void 12686dwarf2out_end_source_file (unsigned int lineno ATTRIBUTE_UNUSED) 12687{ 12688 if (flag_eliminate_dwarf2_dups) 12689 /* Record the end of the file for break_out_includes. */ 12690 new_die (DW_TAG_GNU_EINCL, comp_unit_die, NULL); 12691 12692 if (debug_info_level >= DINFO_LEVEL_VERBOSE) 12693 { 12694 named_section_flags (DEBUG_MACINFO_SECTION, SECTION_DEBUG); 12695 dw2_asm_output_data (1, DW_MACINFO_end_file, "End file"); 12696 } 12697} 12698 12699/* Called from debug_define in toplev.c. The `buffer' parameter contains 12700 the tail part of the directive line, i.e. the part which is past the 12701 initial whitespace, #, whitespace, directive-name, whitespace part. */ 12702 12703static void 12704dwarf2out_define (unsigned int lineno ATTRIBUTE_UNUSED, 12705 const char *buffer ATTRIBUTE_UNUSED) 12706{ 12707 if (debug_info_level >= DINFO_LEVEL_VERBOSE) 12708 { 12709 named_section_flags (DEBUG_MACINFO_SECTION, SECTION_DEBUG); 12710 dw2_asm_output_data (1, DW_MACINFO_define, "Define macro"); 12711 dw2_asm_output_data_uleb128 (lineno, "At line number %d", lineno); 12712 dw2_asm_output_nstring (buffer, -1, "The macro"); 12713 } 12714} 12715 12716/* Called from debug_undef in toplev.c. The `buffer' parameter contains 12717 the tail part of the directive line, i.e. the part which is past the 12718 initial whitespace, #, whitespace, directive-name, whitespace part. */ 12719 12720static void 12721dwarf2out_undef (unsigned int lineno ATTRIBUTE_UNUSED, 12722 const char *buffer ATTRIBUTE_UNUSED) 12723{ 12724 if (debug_info_level >= DINFO_LEVEL_VERBOSE) 12725 { 12726 named_section_flags (DEBUG_MACINFO_SECTION, SECTION_DEBUG); 12727 dw2_asm_output_data (1, DW_MACINFO_undef, "Undefine macro"); 12728 dw2_asm_output_data_uleb128 (lineno, "At line number %d", lineno); 12729 dw2_asm_output_nstring (buffer, -1, "The macro"); 12730 } 12731} 12732 12733/* Set up for Dwarf output at the start of compilation. */ 12734 12735static void 12736dwarf2out_init (const char *filename ATTRIBUTE_UNUSED) 12737{ 12738 init_file_table (); 12739 12740 /* Allocate the initial hunk of the decl_die_table. */ 12741 decl_die_table = ggc_alloc_cleared (DECL_DIE_TABLE_INCREMENT 12742 * sizeof (dw_die_ref)); 12743 decl_die_table_allocated = DECL_DIE_TABLE_INCREMENT; 12744 decl_die_table_in_use = 0; 12745 12746 /* Allocate the initial hunk of the decl_scope_table. */ 12747 VARRAY_TREE_INIT (decl_scope_table, 256, "decl_scope_table"); 12748 12749 /* Allocate the initial hunk of the abbrev_die_table. */ 12750 abbrev_die_table = ggc_alloc_cleared (ABBREV_DIE_TABLE_INCREMENT 12751 * sizeof (dw_die_ref)); 12752 abbrev_die_table_allocated = ABBREV_DIE_TABLE_INCREMENT; 12753 /* Zero-th entry is allocated, but unused */ 12754 abbrev_die_table_in_use = 1; 12755 12756 /* Allocate the initial hunk of the line_info_table. */ 12757 line_info_table = ggc_alloc_cleared (LINE_INFO_TABLE_INCREMENT 12758 * sizeof (dw_line_info_entry)); 12759 line_info_table_allocated = LINE_INFO_TABLE_INCREMENT; 12760 12761 /* Zero-th entry is allocated, but unused */ 12762 line_info_table_in_use = 1; 12763 12764 /* Generate the initial DIE for the .debug section. Note that the (string) 12765 value given in the DW_AT_name attribute of the DW_TAG_compile_unit DIE 12766 will (typically) be a relative pathname and that this pathname should be 12767 taken as being relative to the directory from which the compiler was 12768 invoked when the given (base) source file was compiled. We will fill 12769 in this value in dwarf2out_finish. */ 12770 comp_unit_die = gen_compile_unit_die (NULL); 12771 12772 VARRAY_TREE_INIT (incomplete_types, 64, "incomplete_types"); 12773 12774 VARRAY_RTX_INIT (used_rtx_varray, 32, "used_rtx_varray"); 12775 12776 ASM_GENERATE_INTERNAL_LABEL (text_end_label, TEXT_END_LABEL, 0); 12777 ASM_GENERATE_INTERNAL_LABEL (abbrev_section_label, 12778 DEBUG_ABBREV_SECTION_LABEL, 0); 12779 if (DWARF2_GENERATE_TEXT_SECTION_LABEL) 12780 ASM_GENERATE_INTERNAL_LABEL (text_section_label, TEXT_SECTION_LABEL, 0); 12781 else 12782 strcpy (text_section_label, stripattributes (TEXT_SECTION_NAME)); 12783 12784 ASM_GENERATE_INTERNAL_LABEL (debug_info_section_label, 12785 DEBUG_INFO_SECTION_LABEL, 0); 12786 ASM_GENERATE_INTERNAL_LABEL (debug_line_section_label, 12787 DEBUG_LINE_SECTION_LABEL, 0); 12788 ASM_GENERATE_INTERNAL_LABEL (ranges_section_label, 12789 DEBUG_RANGES_SECTION_LABEL, 0); 12790 named_section_flags (DEBUG_ABBREV_SECTION, SECTION_DEBUG); 12791 ASM_OUTPUT_LABEL (asm_out_file, abbrev_section_label); 12792 named_section_flags (DEBUG_INFO_SECTION, SECTION_DEBUG); 12793 ASM_OUTPUT_LABEL (asm_out_file, debug_info_section_label); 12794 named_section_flags (DEBUG_LINE_SECTION, SECTION_DEBUG); 12795 ASM_OUTPUT_LABEL (asm_out_file, debug_line_section_label); 12796 12797 if (debug_info_level >= DINFO_LEVEL_VERBOSE) 12798 { 12799 named_section_flags (DEBUG_MACINFO_SECTION, SECTION_DEBUG); 12800 ASM_GENERATE_INTERNAL_LABEL (macinfo_section_label, 12801 DEBUG_MACINFO_SECTION_LABEL, 0); 12802 ASM_OUTPUT_LABEL (asm_out_file, macinfo_section_label); 12803 } 12804 12805 if (DWARF2_GENERATE_TEXT_SECTION_LABEL) 12806 { 12807 text_section (); 12808 ASM_OUTPUT_LABEL (asm_out_file, text_section_label); 12809 } 12810} 12811 12812/* A helper function for dwarf2out_finish called through 12813 ht_forall. Emit one queued .debug_str string. */ 12814 12815static int 12816output_indirect_string (void **h, void *v ATTRIBUTE_UNUSED) 12817{ 12818 struct indirect_string_node *node = (struct indirect_string_node *) *h; 12819 12820 if (node->form == DW_FORM_strp) 12821 { 12822 named_section_flags (DEBUG_STR_SECTION, DEBUG_STR_SECTION_FLAGS); 12823 ASM_OUTPUT_LABEL (asm_out_file, node->label); 12824 assemble_string (node->str, strlen (node->str) + 1); 12825 } 12826 12827 return 1; 12828} 12829 12830 12831 12832/* Clear the marks for a die and its children. 12833 Be cool if the mark isn't set. */ 12834 12835static void 12836prune_unmark_dies (dw_die_ref die) 12837{ 12838 dw_die_ref c; 12839 die->die_mark = 0; 12840 for (c = die->die_child; c; c = c->die_sib) 12841 prune_unmark_dies (c); 12842} 12843 12844 12845/* Given DIE that we're marking as used, find any other dies 12846 it references as attributes and mark them as used. */ 12847 12848static void 12849prune_unused_types_walk_attribs (dw_die_ref die) 12850{ 12851 dw_attr_ref a; 12852 12853 for (a = die->die_attr; a != NULL; a = a->dw_attr_next) 12854 { 12855 if (a->dw_attr_val.val_class == dw_val_class_die_ref) 12856 { 12857 /* A reference to another DIE. 12858 Make sure that it will get emitted. */ 12859 prune_unused_types_mark (a->dw_attr_val.v.val_die_ref.die, 1); 12860 } 12861 else if (a->dw_attr == DW_AT_decl_file) 12862 { 12863 /* A reference to a file. Make sure the file name is emitted. */ 12864 a->dw_attr_val.v.val_unsigned = 12865 maybe_emit_file (a->dw_attr_val.v.val_unsigned); 12866 } 12867 } 12868} 12869 12870 12871/* Mark DIE as being used. If DOKIDS is true, then walk down 12872 to DIE's children. */ 12873 12874static void 12875prune_unused_types_mark (dw_die_ref die, int dokids) 12876{ 12877 dw_die_ref c; 12878 12879 if (die->die_mark == 0) 12880 { 12881 /* We haven't done this node yet. Mark it as used. */ 12882 die->die_mark = 1; 12883 12884 /* We also have to mark its parents as used. 12885 (But we don't want to mark our parents' kids due to this.) */ 12886 if (die->die_parent) 12887 prune_unused_types_mark (die->die_parent, 0); 12888 12889 /* Mark any referenced nodes. */ 12890 prune_unused_types_walk_attribs (die); 12891 12892 /* If this node is a specification, 12893 also mark the definition, if it exists. */ 12894 if (get_AT_flag (die, DW_AT_declaration) && die->die_definition) 12895 prune_unused_types_mark (die->die_definition, 1); 12896 } 12897 12898 if (dokids && die->die_mark != 2) 12899 { 12900 /* We need to walk the children, but haven't done so yet. 12901 Remember that we've walked the kids. */ 12902 die->die_mark = 2; 12903 12904 /* Walk them. */ 12905 for (c = die->die_child; c; c = c->die_sib) 12906 { 12907 /* If this is an array type, we need to make sure our 12908 kids get marked, even if they're types. */ 12909 if (die->die_tag == DW_TAG_array_type) 12910 prune_unused_types_mark (c, 1); 12911 else 12912 prune_unused_types_walk (c); 12913 } 12914 } 12915} 12916 12917 12918/* Walk the tree DIE and mark types that we actually use. */ 12919 12920static void 12921prune_unused_types_walk (dw_die_ref die) 12922{ 12923 dw_die_ref c; 12924 12925 /* Don't do anything if this node is already marked. */ 12926 if (die->die_mark) 12927 return; 12928 12929 switch (die->die_tag) { 12930 case DW_TAG_const_type: 12931 case DW_TAG_packed_type: 12932 case DW_TAG_pointer_type: 12933 case DW_TAG_reference_type: 12934 case DW_TAG_volatile_type: 12935 case DW_TAG_typedef: 12936 case DW_TAG_array_type: 12937 case DW_TAG_structure_type: 12938 case DW_TAG_union_type: 12939 case DW_TAG_class_type: 12940 case DW_TAG_friend: 12941 case DW_TAG_variant_part: 12942 case DW_TAG_enumeration_type: 12943 case DW_TAG_subroutine_type: 12944 case DW_TAG_string_type: 12945 case DW_TAG_set_type: 12946 case DW_TAG_subrange_type: 12947 case DW_TAG_ptr_to_member_type: 12948 case DW_TAG_file_type: 12949 /* It's a type node --- don't mark it. */ 12950 return; 12951 12952 default: 12953 /* Mark everything else. */ 12954 break; 12955 } 12956 12957 die->die_mark = 1; 12958 12959 /* Now, mark any dies referenced from here. */ 12960 prune_unused_types_walk_attribs (die); 12961 12962 /* Mark children. */ 12963 for (c = die->die_child; c; c = c->die_sib) 12964 prune_unused_types_walk (c); 12965} 12966 12967 12968/* Remove from the tree DIE any dies that aren't marked. */ 12969 12970static void 12971prune_unused_types_prune (dw_die_ref die) 12972{ 12973 dw_die_ref c, p, n; 12974 if (!die->die_mark) 12975 abort(); 12976 12977 p = NULL; 12978 for (c = die->die_child; c; c = n) 12979 { 12980 n = c->die_sib; 12981 if (c->die_mark) 12982 { 12983 prune_unused_types_prune (c); 12984 p = c; 12985 } 12986 else 12987 { 12988 if (p) 12989 p->die_sib = n; 12990 else 12991 die->die_child = n; 12992 free_die (c); 12993 } 12994 } 12995} 12996 12997 12998/* Remove dies representing declarations that we never use. */ 12999 13000static void 13001prune_unused_types (void) 13002{ 13003 unsigned int i; 13004 limbo_die_node *node; 13005 13006 /* Clear all the marks. */ 13007 prune_unmark_dies (comp_unit_die); 13008 for (node = limbo_die_list; node; node = node->next) 13009 prune_unmark_dies (node->die); 13010 13011 /* Set the mark on nodes that are actually used. */ 13012 prune_unused_types_walk (comp_unit_die); 13013 for (node = limbo_die_list; node; node = node->next) 13014 prune_unused_types_walk (node->die); 13015 13016 /* Also set the mark on nodes referenced from the 13017 pubname_table or arange_table. */ 13018 for (i = 0; i < pubname_table_in_use; i++) 13019 prune_unused_types_mark (pubname_table[i].die, 1); 13020 for (i = 0; i < arange_table_in_use; i++) 13021 prune_unused_types_mark (arange_table[i], 1); 13022 13023 /* Get rid of nodes that aren't marked. */ 13024 prune_unused_types_prune (comp_unit_die); 13025 for (node = limbo_die_list; node; node = node->next) 13026 prune_unused_types_prune (node->die); 13027 13028 /* Leave the marks clear. */ 13029 prune_unmark_dies (comp_unit_die); 13030 for (node = limbo_die_list; node; node = node->next) 13031 prune_unmark_dies (node->die); 13032} 13033 13034/* Output stuff that dwarf requires at the end of every file, 13035 and generate the DWARF-2 debugging info. */ 13036 13037static void 13038dwarf2out_finish (const char *filename) 13039{ 13040 limbo_die_node *node, *next_node; 13041 dw_die_ref die = 0; 13042 13043 /* Add the name for the main input file now. We delayed this from 13044 dwarf2out_init to avoid complications with PCH. */ 13045 add_name_attribute (comp_unit_die, filename); 13046 if (filename[0] != DIR_SEPARATOR) 13047 add_comp_dir_attribute (comp_unit_die); 13048 else if (get_AT (comp_unit_die, DW_AT_comp_dir) == NULL) 13049 { 13050 size_t i; 13051 for (i = 1; i < VARRAY_ACTIVE_SIZE (file_table); i++) 13052 if (VARRAY_CHAR_PTR (file_table, i)[0] != DIR_SEPARATOR 13053 /* Don't add cwd for <built-in>. */ 13054 && VARRAY_CHAR_PTR (file_table, i)[0] != '<') 13055 { 13056 add_comp_dir_attribute (comp_unit_die); 13057 break; 13058 } 13059 } 13060 13061 /* Traverse the limbo die list, and add parent/child links. The only 13062 dies without parents that should be here are concrete instances of 13063 inline functions, and the comp_unit_die. We can ignore the comp_unit_die. 13064 For concrete instances, we can get the parent die from the abstract 13065 instance. */ 13066 for (node = limbo_die_list; node; node = next_node) 13067 { 13068 next_node = node->next; 13069 die = node->die; 13070 13071 if (die->die_parent == NULL) 13072 { 13073 dw_die_ref origin = get_AT_ref (die, DW_AT_abstract_origin); 13074 tree context; 13075 13076 if (origin) 13077 add_child_die (origin->die_parent, die); 13078 else if (die == comp_unit_die) 13079 ; 13080 /* If this was an expression for a bound involved in a function 13081 return type, it may be a SAVE_EXPR for which we weren't able 13082 to find a DIE previously. So try now. */ 13083 else if (node->created_for 13084 && TREE_CODE (node->created_for) == SAVE_EXPR 13085 && 0 != (origin = (lookup_decl_die 13086 (SAVE_EXPR_CONTEXT 13087 (node->created_for))))) 13088 add_child_die (origin, die); 13089 else if (errorcount > 0 || sorrycount > 0) 13090 /* It's OK to be confused by errors in the input. */ 13091 add_child_die (comp_unit_die, die); 13092 else if (node->created_for 13093 && ((DECL_P (node->created_for) 13094 && (context = DECL_CONTEXT (node->created_for))) 13095 || (TYPE_P (node->created_for) 13096 && (context = TYPE_CONTEXT (node->created_for)))) 13097 && TREE_CODE (context) == FUNCTION_DECL) 13098 { 13099 /* In certain situations, the lexical block containing a 13100 nested function can be optimized away, which results 13101 in the nested function die being orphaned. Likewise 13102 with the return type of that nested function. Force 13103 this to be a child of the containing function. */ 13104 origin = lookup_decl_die (context); 13105 if (! origin) 13106 abort (); 13107 add_child_die (origin, die); 13108 } 13109 else 13110 abort (); 13111 } 13112 } 13113 13114 limbo_die_list = NULL; 13115 13116 /* Walk through the list of incomplete types again, trying once more to 13117 emit full debugging info for them. */ 13118 retry_incomplete_types (); 13119 13120 /* We need to reverse all the dies before break_out_includes, or 13121 we'll see the end of an include file before the beginning. */ 13122 reverse_all_dies (comp_unit_die); 13123 13124 if (flag_eliminate_unused_debug_types) 13125 prune_unused_types (); 13126 13127 /* Generate separate CUs for each of the include files we've seen. 13128 They will go into limbo_die_list. */ 13129 if (flag_eliminate_dwarf2_dups) 13130 break_out_includes (comp_unit_die); 13131 13132 /* Traverse the DIE's and add add sibling attributes to those DIE's 13133 that have children. */ 13134 add_sibling_attributes (comp_unit_die); 13135 for (node = limbo_die_list; node; node = node->next) 13136 add_sibling_attributes (node->die); 13137 13138 /* Output a terminator label for the .text section. */ 13139 text_section (); 13140 (*targetm.asm_out.internal_label) (asm_out_file, TEXT_END_LABEL, 0); 13141 13142 /* Output the source line correspondence table. We must do this 13143 even if there is no line information. Otherwise, on an empty 13144 translation unit, we will generate a present, but empty, 13145 .debug_info section. IRIX 6.5 `nm' will then complain when 13146 examining the file. */ 13147 if (! DWARF2_ASM_LINE_DEBUG_INFO) 13148 { 13149 named_section_flags (DEBUG_LINE_SECTION, SECTION_DEBUG); 13150 output_line_info (); 13151 } 13152 13153 /* Output location list section if necessary. */ 13154 if (have_location_lists) 13155 { 13156 /* Output the location lists info. */ 13157 named_section_flags (DEBUG_LOC_SECTION, SECTION_DEBUG); 13158 ASM_GENERATE_INTERNAL_LABEL (loc_section_label, 13159 DEBUG_LOC_SECTION_LABEL, 0); 13160 ASM_OUTPUT_LABEL (asm_out_file, loc_section_label); 13161 output_location_lists (die); 13162 have_location_lists = 0; 13163 } 13164 13165 /* We can only use the low/high_pc attributes if all of the code was 13166 in .text. */ 13167 if (separate_line_info_table_in_use == 0) 13168 { 13169 add_AT_lbl_id (comp_unit_die, DW_AT_low_pc, text_section_label); 13170 add_AT_lbl_id (comp_unit_die, DW_AT_high_pc, text_end_label); 13171 } 13172 13173 /* If it wasn't, we need to give .debug_loc and .debug_ranges an appropriate 13174 "base address". Use zero so that these addresses become absolute. */ 13175 else if (have_location_lists || ranges_table_in_use) 13176 add_AT_addr (comp_unit_die, DW_AT_entry_pc, const0_rtx); 13177 13178 if (debug_info_level >= DINFO_LEVEL_NORMAL) 13179 add_AT_lbl_offset (comp_unit_die, DW_AT_stmt_list, 13180 debug_line_section_label); 13181 13182 if (debug_info_level >= DINFO_LEVEL_VERBOSE) 13183 add_AT_lbl_offset (comp_unit_die, DW_AT_macro_info, macinfo_section_label); 13184 13185 /* Output all of the compilation units. We put the main one last so that 13186 the offsets are available to output_pubnames. */ 13187 for (node = limbo_die_list; node; node = node->next) 13188 output_comp_unit (node->die, 0); 13189 13190 output_comp_unit (comp_unit_die, 0); 13191 13192 /* Output the abbreviation table. */ 13193 named_section_flags (DEBUG_ABBREV_SECTION, SECTION_DEBUG); 13194 output_abbrev_section (); 13195 13196 /* Output public names table if necessary. */ 13197 if (pubname_table_in_use) 13198 { 13199 named_section_flags (DEBUG_PUBNAMES_SECTION, SECTION_DEBUG); 13200 output_pubnames (); 13201 } 13202 13203 /* Output the address range information. We only put functions in the arange 13204 table, so don't write it out if we don't have any. */ 13205 if (fde_table_in_use) 13206 { 13207 named_section_flags (DEBUG_ARANGES_SECTION, SECTION_DEBUG); 13208 output_aranges (); 13209 } 13210 13211 /* Output ranges section if necessary. */ 13212 if (ranges_table_in_use) 13213 { 13214 named_section_flags (DEBUG_RANGES_SECTION, SECTION_DEBUG); 13215 ASM_OUTPUT_LABEL (asm_out_file, ranges_section_label); 13216 output_ranges (); 13217 } 13218 13219 /* Have to end the primary source file. */ 13220 if (debug_info_level >= DINFO_LEVEL_VERBOSE) 13221 { 13222 named_section_flags (DEBUG_MACINFO_SECTION, SECTION_DEBUG); 13223 dw2_asm_output_data (1, DW_MACINFO_end_file, "End file"); 13224 dw2_asm_output_data (1, 0, "End compilation unit"); 13225 } 13226 13227 /* If we emitted any DW_FORM_strp form attribute, output the string 13228 table too. */ 13229 if (debug_str_hash) 13230 htab_traverse (debug_str_hash, output_indirect_string, NULL); 13231} 13232#else 13233 13234/* This should never be used, but its address is needed for comparisons. */ 13235const struct gcc_debug_hooks dwarf2_debug_hooks; 13236 13237#endif /* DWARF2_DEBUGGING_INFO */ 13238 13239#include "gt-dwarf2out.h" 13240