1/* Output Dwarf2 format symbol table information from GCC. 2 Copyright (C) 1992-2015 Free Software Foundation, Inc. 3 Contributed by Gary Funck (gary@intrepid.com). 4 Derived from DWARF 1 implementation of Ron Guilmette (rfg@monkeys.com). 5 Extensively modified by Jason Merrill (jason@cygnus.com). 6 7This file is part of GCC. 8 9GCC is free software; you can redistribute it and/or modify it under 10the terms of the GNU General Public License as published by the Free 11Software Foundation; either version 3, or (at your option) any later 12version. 13 14GCC is distributed in the hope that it will be useful, but WITHOUT ANY 15WARRANTY; without even the implied warranty of MERCHANTABILITY or 16FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License 17for more details. 18 19You should have received a copy of the GNU General Public License 20along with GCC; see the file COPYING3. If not see 21<http://www.gnu.org/licenses/>. */ 22 23/* TODO: Emit .debug_line header even when there are no functions, since 24 the file numbers are used by .debug_info. Alternately, leave 25 out locations for types and decls. 26 Avoid talking about ctors and op= for PODs. 27 Factor out common prologue sequences into multiple CIEs. */ 28 29/* The first part of this file deals with the DWARF 2 frame unwind 30 information, which is also used by the GCC efficient exception handling 31 mechanism. The second part, controlled only by an #ifdef 32 DWARF2_DEBUGGING_INFO, deals with the other DWARF 2 debugging 33 information. */ 34 35/* DWARF2 Abbreviation Glossary: 36 37 CFA = Canonical Frame Address 38 a fixed address on the stack which identifies a call frame. 39 We define it to be the value of SP just before the call insn. 40 The CFA register and offset, which may change during the course 41 of the function, are used to calculate its value at runtime. 42 43 CFI = Call Frame Instruction 44 an instruction for the DWARF2 abstract machine 45 46 CIE = Common Information Entry 47 information describing information common to one or more FDEs 48 49 DIE = Debugging Information Entry 50 51 FDE = Frame Description Entry 52 information describing the stack call frame, in particular, 53 how to restore registers 54 55 DW_CFA_... = DWARF2 CFA call frame instruction 56 DW_TAG_... = DWARF2 DIE tag */ 57 58#include "config.h" 59#include "system.h" 60#include "coretypes.h" 61#include "tm.h" 62#include "rtl.h" 63#include "hash-set.h" 64#include "machmode.h" 65#include "vec.h" 66#include "double-int.h" 67#include "input.h" 68#include "alias.h" 69#include "symtab.h" 70#include "wide-int.h" 71#include "inchash.h" 72#include "real.h" 73#include "tree.h" 74#include "fold-const.h" 75#include "stringpool.h" 76#include "stor-layout.h" 77#include "varasm.h" 78#include "hashtab.h" 79#include "hard-reg-set.h" 80#include "function.h" 81#include "emit-rtl.h" 82#include "hash-table.h" 83#include "version.h" 84#include "flags.h" 85#include "regs.h" 86#include "rtlhash.h" 87#include "insn-config.h" 88#include "reload.h" 89#include "output.h" 90#include "statistics.h" 91#include "fixed-value.h" 92#include "expmed.h" 93#include "dojump.h" 94#include "explow.h" 95#include "calls.h" 96#include "stmt.h" 97#include "expr.h" 98#include "except.h" 99#include "dwarf2.h" 100#include "dwarf2out.h" 101#include "dwarf2asm.h" 102#include "toplev.h" 103#include "md5.h" 104#include "tm_p.h" 105#include "diagnostic.h" 106#include "tree-pretty-print.h" 107#include "debug.h" 108#include "target.h" 109#include "common/common-target.h" 110#include "langhooks.h" 111#include "hash-map.h" 112#include "is-a.h" 113#include "plugin-api.h" 114#include "ipa-ref.h" 115#include "cgraph.h" 116#include "ira.h" 117#include "lra.h" 118#include "dumpfile.h" 119#include "opts.h" 120#include "tree-dfa.h" 121#include "gdb/gdb-index.h" 122#include "rtl-iter.h" 123 124static void dwarf2out_source_line (unsigned int, const char *, int, bool); 125static rtx_insn *last_var_location_insn; 126static rtx_insn *cached_next_real_insn; 127static void dwarf2out_decl (tree); 128 129#ifdef VMS_DEBUGGING_INFO 130int vms_file_stats_name (const char *, long long *, long *, char *, int *); 131 132/* Define this macro to be a nonzero value if the directory specifications 133 which are output in the debug info should end with a separator. */ 134#define DWARF2_DIR_SHOULD_END_WITH_SEPARATOR 1 135/* Define this macro to evaluate to a nonzero value if GCC should refrain 136 from generating indirect strings in DWARF2 debug information, for instance 137 if your target is stuck with an old version of GDB that is unable to 138 process them properly or uses VMS Debug. */ 139#define DWARF2_INDIRECT_STRING_SUPPORT_MISSING_ON_TARGET 1 140#else 141#define DWARF2_DIR_SHOULD_END_WITH_SEPARATOR 0 142#define DWARF2_INDIRECT_STRING_SUPPORT_MISSING_ON_TARGET 0 143#endif 144 145/* ??? Poison these here until it can be done generically. They've been 146 totally replaced in this file; make sure it stays that way. */ 147#undef DWARF2_UNWIND_INFO 148#undef DWARF2_FRAME_INFO 149#if (GCC_VERSION >= 3000) 150 #pragma GCC poison DWARF2_UNWIND_INFO DWARF2_FRAME_INFO 151#endif 152 153/* The size of the target's pointer type. */ 154#ifndef PTR_SIZE 155#define PTR_SIZE (POINTER_SIZE / BITS_PER_UNIT) 156#endif 157 158/* Array of RTXes referenced by the debugging information, which therefore 159 must be kept around forever. */ 160static GTY(()) vec<rtx, va_gc> *used_rtx_array; 161 162/* A pointer to the base of a list of incomplete types which might be 163 completed at some later time. incomplete_types_list needs to be a 164 vec<tree, va_gc> *because we want to tell the garbage collector about 165 it. */ 166static GTY(()) vec<tree, va_gc> *incomplete_types; 167 168/* A pointer to the base of a table of references to declaration 169 scopes. This table is a display which tracks the nesting 170 of declaration scopes at the current scope and containing 171 scopes. This table is used to find the proper place to 172 define type declaration DIE's. */ 173static GTY(()) vec<tree, va_gc> *decl_scope_table; 174 175/* Pointers to various DWARF2 sections. */ 176static GTY(()) section *debug_info_section; 177static GTY(()) section *debug_skeleton_info_section; 178static GTY(()) section *debug_abbrev_section; 179static GTY(()) section *debug_skeleton_abbrev_section; 180static GTY(()) section *debug_aranges_section; 181static GTY(()) section *debug_addr_section; 182static GTY(()) section *debug_macinfo_section; 183static GTY(()) section *debug_line_section; 184static GTY(()) section *debug_skeleton_line_section; 185static GTY(()) section *debug_loc_section; 186static GTY(()) section *debug_pubnames_section; 187static GTY(()) section *debug_pubtypes_section; 188static GTY(()) section *debug_str_section; 189static GTY(()) section *debug_str_dwo_section; 190static GTY(()) section *debug_str_offsets_section; 191static GTY(()) section *debug_ranges_section; 192static GTY(()) section *debug_frame_section; 193 194/* Maximum size (in bytes) of an artificially generated label. */ 195#define MAX_ARTIFICIAL_LABEL_BYTES 30 196 197/* According to the (draft) DWARF 3 specification, the initial length 198 should either be 4 or 12 bytes. When it's 12 bytes, the first 4 199 bytes are 0xffffffff, followed by the length stored in the next 8 200 bytes. 201 202 However, the SGI/MIPS ABI uses an initial length which is equal to 203 DWARF_OFFSET_SIZE. It is defined (elsewhere) accordingly. */ 204 205#ifndef DWARF_INITIAL_LENGTH_SIZE 206#define DWARF_INITIAL_LENGTH_SIZE (DWARF_OFFSET_SIZE == 4 ? 4 : 12) 207#endif 208 209/* Round SIZE up to the nearest BOUNDARY. */ 210#define DWARF_ROUND(SIZE,BOUNDARY) \ 211 ((((SIZE) + (BOUNDARY) - 1) / (BOUNDARY)) * (BOUNDARY)) 212 213/* CIE identifier. */ 214#if HOST_BITS_PER_WIDE_INT >= 64 215#define DWARF_CIE_ID \ 216 (unsigned HOST_WIDE_INT) (DWARF_OFFSET_SIZE == 4 ? DW_CIE_ID : DW64_CIE_ID) 217#else 218#define DWARF_CIE_ID DW_CIE_ID 219#endif 220 221 222/* A vector for a table that contains frame description 223 information for each routine. */ 224#define NOT_INDEXED (-1U) 225#define NO_INDEX_ASSIGNED (-2U) 226 227static GTY(()) vec<dw_fde_ref, va_gc> *fde_vec; 228 229struct GTY((for_user)) indirect_string_node { 230 const char *str; 231 unsigned int refcount; 232 enum dwarf_form form; 233 char *label; 234 unsigned int index; 235}; 236 237struct indirect_string_hasher : ggc_hasher<indirect_string_node *> 238{ 239 typedef const char *compare_type; 240 241 static hashval_t hash (indirect_string_node *); 242 static bool equal (indirect_string_node *, const char *); 243}; 244 245static GTY (()) hash_table<indirect_string_hasher> *debug_str_hash; 246 247/* With split_debug_info, both the comp_dir and dwo_name go in the 248 main object file, rather than the dwo, similar to the force_direct 249 parameter elsewhere but with additional complications: 250 251 1) The string is needed in both the main object file and the dwo. 252 That is, the comp_dir and dwo_name will appear in both places. 253 254 2) Strings can use three forms: DW_FORM_string, DW_FORM_strp or 255 DW_FORM_GNU_str_index. 256 257 3) GCC chooses the form to use late, depending on the size and 258 reference count. 259 260 Rather than forcing the all debug string handling functions and 261 callers to deal with these complications, simply use a separate, 262 special-cased string table for any attribute that should go in the 263 main object file. This limits the complexity to just the places 264 that need it. */ 265 266static GTY (()) hash_table<indirect_string_hasher> *skeleton_debug_str_hash; 267 268static GTY(()) int dw2_string_counter; 269 270/* True if the compilation unit places functions in more than one section. */ 271static GTY(()) bool have_multiple_function_sections = false; 272 273/* Whether the default text and cold text sections have been used at all. */ 274 275static GTY(()) bool text_section_used = false; 276static GTY(()) bool cold_text_section_used = false; 277 278/* The default cold text section. */ 279static GTY(()) section *cold_text_section; 280 281/* The DIE for C++14 'auto' in a function return type. */ 282static GTY(()) dw_die_ref auto_die; 283 284/* The DIE for C++14 'decltype(auto)' in a function return type. */ 285static GTY(()) dw_die_ref decltype_auto_die; 286 287/* Forward declarations for functions defined in this file. */ 288 289static char *stripattributes (const char *); 290static void output_call_frame_info (int); 291static void dwarf2out_note_section_used (void); 292 293/* Personality decl of current unit. Used only when assembler does not support 294 personality CFI. */ 295static GTY(()) rtx current_unit_personality; 296 297/* Data and reference forms for relocatable data. */ 298#define DW_FORM_data (DWARF_OFFSET_SIZE == 8 ? DW_FORM_data8 : DW_FORM_data4) 299#define DW_FORM_ref (DWARF_OFFSET_SIZE == 8 ? DW_FORM_ref8 : DW_FORM_ref4) 300 301#ifndef DEBUG_FRAME_SECTION 302#define DEBUG_FRAME_SECTION ".debug_frame" 303#endif 304 305#ifndef FUNC_BEGIN_LABEL 306#define FUNC_BEGIN_LABEL "LFB" 307#endif 308 309#ifndef FUNC_END_LABEL 310#define FUNC_END_LABEL "LFE" 311#endif 312 313#ifndef PROLOGUE_END_LABEL 314#define PROLOGUE_END_LABEL "LPE" 315#endif 316 317#ifndef EPILOGUE_BEGIN_LABEL 318#define EPILOGUE_BEGIN_LABEL "LEB" 319#endif 320 321#ifndef FRAME_BEGIN_LABEL 322#define FRAME_BEGIN_LABEL "Lframe" 323#endif 324#define CIE_AFTER_SIZE_LABEL "LSCIE" 325#define CIE_END_LABEL "LECIE" 326#define FDE_LABEL "LSFDE" 327#define FDE_AFTER_SIZE_LABEL "LASFDE" 328#define FDE_END_LABEL "LEFDE" 329#define LINE_NUMBER_BEGIN_LABEL "LSLT" 330#define LINE_NUMBER_END_LABEL "LELT" 331#define LN_PROLOG_AS_LABEL "LASLTP" 332#define LN_PROLOG_END_LABEL "LELTP" 333#define DIE_LABEL_PREFIX "DW" 334 335/* Match the base name of a file to the base name of a compilation unit. */ 336 337static int 338matches_main_base (const char *path) 339{ 340 /* Cache the last query. */ 341 static const char *last_path = NULL; 342 static int last_match = 0; 343 if (path != last_path) 344 { 345 const char *base; 346 int length = base_of_path (path, &base); 347 last_path = path; 348 last_match = (length == main_input_baselength 349 && memcmp (base, main_input_basename, length) == 0); 350 } 351 return last_match; 352} 353 354#ifdef DEBUG_DEBUG_STRUCT 355 356static int 357dump_struct_debug (tree type, enum debug_info_usage usage, 358 enum debug_struct_file criterion, int generic, 359 int matches, int result) 360{ 361 /* Find the type name. */ 362 tree type_decl = TYPE_STUB_DECL (type); 363 tree t = type_decl; 364 const char *name = 0; 365 if (TREE_CODE (t) == TYPE_DECL) 366 t = DECL_NAME (t); 367 if (t) 368 name = IDENTIFIER_POINTER (t); 369 370 fprintf (stderr, " struct %d %s %s %s %s %d %p %s\n", 371 criterion, 372 DECL_IN_SYSTEM_HEADER (type_decl) ? "sys" : "usr", 373 matches ? "bas" : "hdr", 374 generic ? "gen" : "ord", 375 usage == DINFO_USAGE_DFN ? ";" : 376 usage == DINFO_USAGE_DIR_USE ? "." : "*", 377 result, 378 (void*) type_decl, name); 379 return result; 380} 381#define DUMP_GSTRUCT(type, usage, criterion, generic, matches, result) \ 382 dump_struct_debug (type, usage, criterion, generic, matches, result) 383 384#else 385 386#define DUMP_GSTRUCT(type, usage, criterion, generic, matches, result) \ 387 (result) 388 389#endif 390 391/* Get the number of HOST_WIDE_INTs needed to represent the precision 392 of the number. Some constants have a large uniform precision, so 393 we get the precision needed for the actual value of the number. */ 394 395static unsigned int 396get_full_len (const wide_int &op) 397{ 398 int prec = wi::min_precision (op, UNSIGNED); 399 return ((prec + HOST_BITS_PER_WIDE_INT - 1) 400 / HOST_BITS_PER_WIDE_INT); 401} 402 403static bool 404should_emit_struct_debug (tree type, enum debug_info_usage usage) 405{ 406 enum debug_struct_file criterion; 407 tree type_decl; 408 bool generic = lang_hooks.types.generic_p (type); 409 410 if (generic) 411 criterion = debug_struct_generic[usage]; 412 else 413 criterion = debug_struct_ordinary[usage]; 414 415 if (criterion == DINFO_STRUCT_FILE_NONE) 416 return DUMP_GSTRUCT (type, usage, criterion, generic, false, false); 417 if (criterion == DINFO_STRUCT_FILE_ANY) 418 return DUMP_GSTRUCT (type, usage, criterion, generic, false, true); 419 420 type_decl = TYPE_STUB_DECL (TYPE_MAIN_VARIANT (type)); 421 422 if (type_decl != NULL) 423 { 424 if (criterion == DINFO_STRUCT_FILE_SYS && DECL_IN_SYSTEM_HEADER (type_decl)) 425 return DUMP_GSTRUCT (type, usage, criterion, generic, false, true); 426 427 if (matches_main_base (DECL_SOURCE_FILE (type_decl))) 428 return DUMP_GSTRUCT (type, usage, criterion, generic, true, true); 429 } 430 431 return DUMP_GSTRUCT (type, usage, criterion, generic, false, false); 432} 433 434/* Return a pointer to a copy of the section string name S with all 435 attributes stripped off, and an asterisk prepended (for assemble_name). */ 436 437static inline char * 438stripattributes (const char *s) 439{ 440 char *stripped = XNEWVEC (char, strlen (s) + 2); 441 char *p = stripped; 442 443 *p++ = '*'; 444 445 while (*s && *s != ',') 446 *p++ = *s++; 447 448 *p = '\0'; 449 return stripped; 450} 451 452/* Switch [BACK] to eh_frame_section. If we don't have an eh_frame_section, 453 switch to the data section instead, and write out a synthetic start label 454 for collect2 the first time around. */ 455 456static void 457switch_to_eh_frame_section (bool back) 458{ 459 tree label; 460 461#ifdef EH_FRAME_SECTION_NAME 462 if (eh_frame_section == 0) 463 { 464 int flags; 465 466 if (EH_TABLES_CAN_BE_READ_ONLY) 467 { 468 int fde_encoding; 469 int per_encoding; 470 int lsda_encoding; 471 472 fde_encoding = ASM_PREFERRED_EH_DATA_FORMAT (/*code=*/1, 473 /*global=*/0); 474 per_encoding = ASM_PREFERRED_EH_DATA_FORMAT (/*code=*/2, 475 /*global=*/1); 476 lsda_encoding = ASM_PREFERRED_EH_DATA_FORMAT (/*code=*/0, 477 /*global=*/0); 478 flags = ((! flag_pic 479 || ((fde_encoding & 0x70) != DW_EH_PE_absptr 480 && (fde_encoding & 0x70) != DW_EH_PE_aligned 481 && (per_encoding & 0x70) != DW_EH_PE_absptr 482 && (per_encoding & 0x70) != DW_EH_PE_aligned 483 && (lsda_encoding & 0x70) != DW_EH_PE_absptr 484 && (lsda_encoding & 0x70) != DW_EH_PE_aligned)) 485 ? 0 : SECTION_WRITE); 486 } 487 else 488 flags = SECTION_WRITE; 489 eh_frame_section = get_section (EH_FRAME_SECTION_NAME, flags, NULL); 490 } 491#endif /* EH_FRAME_SECTION_NAME */ 492 493 if (eh_frame_section) 494 switch_to_section (eh_frame_section); 495 else 496 { 497 /* We have no special eh_frame section. Put the information in 498 the data section and emit special labels to guide collect2. */ 499 switch_to_section (data_section); 500 501 if (!back) 502 { 503 label = get_file_function_name ("F"); 504 ASM_OUTPUT_ALIGN (asm_out_file, floor_log2 (PTR_SIZE)); 505 targetm.asm_out.globalize_label (asm_out_file, 506 IDENTIFIER_POINTER (label)); 507 ASM_OUTPUT_LABEL (asm_out_file, IDENTIFIER_POINTER (label)); 508 } 509 } 510} 511 512/* Switch [BACK] to the eh or debug frame table section, depending on 513 FOR_EH. */ 514 515static void 516switch_to_frame_table_section (int for_eh, bool back) 517{ 518 if (for_eh) 519 switch_to_eh_frame_section (back); 520 else 521 { 522 if (!debug_frame_section) 523 debug_frame_section = get_section (DEBUG_FRAME_SECTION, 524 SECTION_DEBUG, NULL); 525 switch_to_section (debug_frame_section); 526 } 527} 528 529/* Describe for the GTY machinery what parts of dw_cfi_oprnd1 are used. */ 530 531enum dw_cfi_oprnd_type 532dw_cfi_oprnd1_desc (enum dwarf_call_frame_info cfi) 533{ 534 switch (cfi) 535 { 536 case DW_CFA_nop: 537 case DW_CFA_GNU_window_save: 538 case DW_CFA_remember_state: 539 case DW_CFA_restore_state: 540 return dw_cfi_oprnd_unused; 541 542 case DW_CFA_set_loc: 543 case DW_CFA_advance_loc1: 544 case DW_CFA_advance_loc2: 545 case DW_CFA_advance_loc4: 546 case DW_CFA_MIPS_advance_loc8: 547 return dw_cfi_oprnd_addr; 548 549 case DW_CFA_offset: 550 case DW_CFA_offset_extended: 551 case DW_CFA_def_cfa: 552 case DW_CFA_offset_extended_sf: 553 case DW_CFA_def_cfa_sf: 554 case DW_CFA_restore: 555 case DW_CFA_restore_extended: 556 case DW_CFA_undefined: 557 case DW_CFA_same_value: 558 case DW_CFA_def_cfa_register: 559 case DW_CFA_register: 560 case DW_CFA_expression: 561 return dw_cfi_oprnd_reg_num; 562 563 case DW_CFA_def_cfa_offset: 564 case DW_CFA_GNU_args_size: 565 case DW_CFA_def_cfa_offset_sf: 566 return dw_cfi_oprnd_offset; 567 568 case DW_CFA_def_cfa_expression: 569 return dw_cfi_oprnd_loc; 570 571 default: 572 gcc_unreachable (); 573 } 574} 575 576/* Describe for the GTY machinery what parts of dw_cfi_oprnd2 are used. */ 577 578enum dw_cfi_oprnd_type 579dw_cfi_oprnd2_desc (enum dwarf_call_frame_info cfi) 580{ 581 switch (cfi) 582 { 583 case DW_CFA_def_cfa: 584 case DW_CFA_def_cfa_sf: 585 case DW_CFA_offset: 586 case DW_CFA_offset_extended_sf: 587 case DW_CFA_offset_extended: 588 return dw_cfi_oprnd_offset; 589 590 case DW_CFA_register: 591 return dw_cfi_oprnd_reg_num; 592 593 case DW_CFA_expression: 594 return dw_cfi_oprnd_loc; 595 596 default: 597 return dw_cfi_oprnd_unused; 598 } 599} 600 601/* Output one FDE. */ 602 603static void 604output_fde (dw_fde_ref fde, bool for_eh, bool second, 605 char *section_start_label, int fde_encoding, char *augmentation, 606 bool any_lsda_needed, int lsda_encoding) 607{ 608 const char *begin, *end; 609 static unsigned int j; 610 char l1[20], l2[20]; 611 612 targetm.asm_out.emit_unwind_label (asm_out_file, fde->decl, for_eh, 613 /* empty */ 0); 614 targetm.asm_out.internal_label (asm_out_file, FDE_LABEL, 615 for_eh + j); 616 ASM_GENERATE_INTERNAL_LABEL (l1, FDE_AFTER_SIZE_LABEL, for_eh + j); 617 ASM_GENERATE_INTERNAL_LABEL (l2, FDE_END_LABEL, for_eh + j); 618 if (DWARF_INITIAL_LENGTH_SIZE - DWARF_OFFSET_SIZE == 4 && !for_eh) 619 dw2_asm_output_data (4, 0xffffffff, "Initial length escape value" 620 " indicating 64-bit DWARF extension"); 621 dw2_asm_output_delta (for_eh ? 4 : DWARF_OFFSET_SIZE, l2, l1, 622 "FDE Length"); 623 ASM_OUTPUT_LABEL (asm_out_file, l1); 624 625 if (for_eh) 626 dw2_asm_output_delta (4, l1, section_start_label, "FDE CIE offset"); 627 else 628 dw2_asm_output_offset (DWARF_OFFSET_SIZE, section_start_label, 629 debug_frame_section, "FDE CIE offset"); 630 631 begin = second ? fde->dw_fde_second_begin : fde->dw_fde_begin; 632 end = second ? fde->dw_fde_second_end : fde->dw_fde_end; 633 634 if (for_eh) 635 { 636 rtx sym_ref = gen_rtx_SYMBOL_REF (Pmode, begin); 637 SYMBOL_REF_FLAGS (sym_ref) |= SYMBOL_FLAG_LOCAL; 638 dw2_asm_output_encoded_addr_rtx (fde_encoding, sym_ref, false, 639 "FDE initial location"); 640 dw2_asm_output_delta (size_of_encoded_value (fde_encoding), 641 end, begin, "FDE address range"); 642 } 643 else 644 { 645 dw2_asm_output_addr (DWARF2_ADDR_SIZE, begin, "FDE initial location"); 646 dw2_asm_output_delta (DWARF2_ADDR_SIZE, end, begin, "FDE address range"); 647 } 648 649 if (augmentation[0]) 650 { 651 if (any_lsda_needed) 652 { 653 int size = size_of_encoded_value (lsda_encoding); 654 655 if (lsda_encoding == DW_EH_PE_aligned) 656 { 657 int offset = ( 4 /* Length */ 658 + 4 /* CIE offset */ 659 + 2 * size_of_encoded_value (fde_encoding) 660 + 1 /* Augmentation size */ ); 661 int pad = -offset & (PTR_SIZE - 1); 662 663 size += pad; 664 gcc_assert (size_of_uleb128 (size) == 1); 665 } 666 667 dw2_asm_output_data_uleb128 (size, "Augmentation size"); 668 669 if (fde->uses_eh_lsda) 670 { 671 ASM_GENERATE_INTERNAL_LABEL (l1, second ? "LLSDAC" : "LLSDA", 672 fde->funcdef_number); 673 dw2_asm_output_encoded_addr_rtx (lsda_encoding, 674 gen_rtx_SYMBOL_REF (Pmode, l1), 675 false, 676 "Language Specific Data Area"); 677 } 678 else 679 { 680 if (lsda_encoding == DW_EH_PE_aligned) 681 ASM_OUTPUT_ALIGN (asm_out_file, floor_log2 (PTR_SIZE)); 682 dw2_asm_output_data (size_of_encoded_value (lsda_encoding), 0, 683 "Language Specific Data Area (none)"); 684 } 685 } 686 else 687 dw2_asm_output_data_uleb128 (0, "Augmentation size"); 688 } 689 690 /* Loop through the Call Frame Instructions associated with this FDE. */ 691 fde->dw_fde_current_label = begin; 692 { 693 size_t from, until, i; 694 695 from = 0; 696 until = vec_safe_length (fde->dw_fde_cfi); 697 698 if (fde->dw_fde_second_begin == NULL) 699 ; 700 else if (!second) 701 until = fde->dw_fde_switch_cfi_index; 702 else 703 from = fde->dw_fde_switch_cfi_index; 704 705 for (i = from; i < until; i++) 706 output_cfi ((*fde->dw_fde_cfi)[i], fde, for_eh); 707 } 708 709 /* If we are to emit a ref/link from function bodies to their frame tables, 710 do it now. This is typically performed to make sure that tables 711 associated with functions are dragged with them and not discarded in 712 garbage collecting links. We need to do this on a per function basis to 713 cope with -ffunction-sections. */ 714 715#ifdef ASM_OUTPUT_DWARF_TABLE_REF 716 /* Switch to the function section, emit the ref to the tables, and 717 switch *back* into the table section. */ 718 switch_to_section (function_section (fde->decl)); 719 ASM_OUTPUT_DWARF_TABLE_REF (section_start_label); 720 switch_to_frame_table_section (for_eh, true); 721#endif 722 723 /* Pad the FDE out to an address sized boundary. */ 724 ASM_OUTPUT_ALIGN (asm_out_file, 725 floor_log2 ((for_eh ? PTR_SIZE : DWARF2_ADDR_SIZE))); 726 ASM_OUTPUT_LABEL (asm_out_file, l2); 727 728 j += 2; 729} 730 731/* Return true if frame description entry FDE is needed for EH. */ 732 733static bool 734fde_needed_for_eh_p (dw_fde_ref fde) 735{ 736 if (flag_asynchronous_unwind_tables) 737 return true; 738 739 if (TARGET_USES_WEAK_UNWIND_INFO && DECL_WEAK (fde->decl)) 740 return true; 741 742 if (fde->uses_eh_lsda) 743 return true; 744 745 /* If exceptions are enabled, we have collected nothrow info. */ 746 if (flag_exceptions && (fde->all_throwers_are_sibcalls || fde->nothrow)) 747 return false; 748 749 return true; 750} 751 752/* Output the call frame information used to record information 753 that relates to calculating the frame pointer, and records the 754 location of saved registers. */ 755 756static void 757output_call_frame_info (int for_eh) 758{ 759 unsigned int i; 760 dw_fde_ref fde; 761 dw_cfi_ref cfi; 762 char l1[20], l2[20], section_start_label[20]; 763 bool any_lsda_needed = false; 764 char augmentation[6]; 765 int augmentation_size; 766 int fde_encoding = DW_EH_PE_absptr; 767 int per_encoding = DW_EH_PE_absptr; 768 int lsda_encoding = DW_EH_PE_absptr; 769 int return_reg; 770 rtx personality = NULL; 771 int dw_cie_version; 772 773 /* Don't emit a CIE if there won't be any FDEs. */ 774 if (!fde_vec) 775 return; 776 777 /* Nothing to do if the assembler's doing it all. */ 778 if (dwarf2out_do_cfi_asm ()) 779 return; 780 781 /* If we don't have any functions we'll want to unwind out of, don't emit 782 any EH unwind information. If we make FDEs linkonce, we may have to 783 emit an empty label for an FDE that wouldn't otherwise be emitted. We 784 want to avoid having an FDE kept around when the function it refers to 785 is discarded. Example where this matters: a primary function template 786 in C++ requires EH information, an explicit specialization doesn't. */ 787 if (for_eh) 788 { 789 bool any_eh_needed = false; 790 791 FOR_EACH_VEC_ELT (*fde_vec, i, fde) 792 { 793 if (fde->uses_eh_lsda) 794 any_eh_needed = any_lsda_needed = true; 795 else if (fde_needed_for_eh_p (fde)) 796 any_eh_needed = true; 797 else if (TARGET_USES_WEAK_UNWIND_INFO) 798 targetm.asm_out.emit_unwind_label (asm_out_file, fde->decl, 1, 1); 799 } 800 801 if (!any_eh_needed) 802 return; 803 } 804 805 /* We're going to be generating comments, so turn on app. */ 806 if (flag_debug_asm) 807 app_enable (); 808 809 /* Switch to the proper frame section, first time. */ 810 switch_to_frame_table_section (for_eh, false); 811 812 ASM_GENERATE_INTERNAL_LABEL (section_start_label, FRAME_BEGIN_LABEL, for_eh); 813 ASM_OUTPUT_LABEL (asm_out_file, section_start_label); 814 815 /* Output the CIE. */ 816 ASM_GENERATE_INTERNAL_LABEL (l1, CIE_AFTER_SIZE_LABEL, for_eh); 817 ASM_GENERATE_INTERNAL_LABEL (l2, CIE_END_LABEL, for_eh); 818 if (DWARF_INITIAL_LENGTH_SIZE - DWARF_OFFSET_SIZE == 4 && !for_eh) 819 dw2_asm_output_data (4, 0xffffffff, 820 "Initial length escape value indicating 64-bit DWARF extension"); 821 dw2_asm_output_delta (for_eh ? 4 : DWARF_OFFSET_SIZE, l2, l1, 822 "Length of Common Information Entry"); 823 ASM_OUTPUT_LABEL (asm_out_file, l1); 824 825 /* Now that the CIE pointer is PC-relative for EH, 826 use 0 to identify the CIE. */ 827 dw2_asm_output_data ((for_eh ? 4 : DWARF_OFFSET_SIZE), 828 (for_eh ? 0 : DWARF_CIE_ID), 829 "CIE Identifier Tag"); 830 831 /* Use the CIE version 3 for DWARF3; allow DWARF2 to continue to 832 use CIE version 1, unless that would produce incorrect results 833 due to overflowing the return register column. */ 834 return_reg = DWARF2_FRAME_REG_OUT (DWARF_FRAME_RETURN_COLUMN, for_eh); 835 dw_cie_version = 1; 836 if (return_reg >= 256 || dwarf_version > 2) 837 dw_cie_version = 3; 838 dw2_asm_output_data (1, dw_cie_version, "CIE Version"); 839 840 augmentation[0] = 0; 841 augmentation_size = 0; 842 843 personality = current_unit_personality; 844 if (for_eh) 845 { 846 char *p; 847 848 /* Augmentation: 849 z Indicates that a uleb128 is present to size the 850 augmentation section. 851 L Indicates the encoding (and thus presence) of 852 an LSDA pointer in the FDE augmentation. 853 R Indicates a non-default pointer encoding for 854 FDE code pointers. 855 P Indicates the presence of an encoding + language 856 personality routine in the CIE augmentation. */ 857 858 fde_encoding = ASM_PREFERRED_EH_DATA_FORMAT (/*code=*/1, /*global=*/0); 859 per_encoding = ASM_PREFERRED_EH_DATA_FORMAT (/*code=*/2, /*global=*/1); 860 lsda_encoding = ASM_PREFERRED_EH_DATA_FORMAT (/*code=*/0, /*global=*/0); 861 862 p = augmentation + 1; 863 if (personality) 864 { 865 *p++ = 'P'; 866 augmentation_size += 1 + size_of_encoded_value (per_encoding); 867 assemble_external_libcall (personality); 868 } 869 if (any_lsda_needed) 870 { 871 *p++ = 'L'; 872 augmentation_size += 1; 873 } 874 if (fde_encoding != DW_EH_PE_absptr) 875 { 876 *p++ = 'R'; 877 augmentation_size += 1; 878 } 879 if (p > augmentation + 1) 880 { 881 augmentation[0] = 'z'; 882 *p = '\0'; 883 } 884 885 /* Ug. Some platforms can't do unaligned dynamic relocations at all. */ 886 if (personality && per_encoding == DW_EH_PE_aligned) 887 { 888 int offset = ( 4 /* Length */ 889 + 4 /* CIE Id */ 890 + 1 /* CIE version */ 891 + strlen (augmentation) + 1 /* Augmentation */ 892 + size_of_uleb128 (1) /* Code alignment */ 893 + size_of_sleb128 (DWARF_CIE_DATA_ALIGNMENT) 894 + 1 /* RA column */ 895 + 1 /* Augmentation size */ 896 + 1 /* Personality encoding */ ); 897 int pad = -offset & (PTR_SIZE - 1); 898 899 augmentation_size += pad; 900 901 /* Augmentations should be small, so there's scarce need to 902 iterate for a solution. Die if we exceed one uleb128 byte. */ 903 gcc_assert (size_of_uleb128 (augmentation_size) == 1); 904 } 905 } 906 907 dw2_asm_output_nstring (augmentation, -1, "CIE Augmentation"); 908 if (dw_cie_version >= 4) 909 { 910 dw2_asm_output_data (1, DWARF2_ADDR_SIZE, "CIE Address Size"); 911 dw2_asm_output_data (1, 0, "CIE Segment Size"); 912 } 913 dw2_asm_output_data_uleb128 (1, "CIE Code Alignment Factor"); 914 dw2_asm_output_data_sleb128 (DWARF_CIE_DATA_ALIGNMENT, 915 "CIE Data Alignment Factor"); 916 917 if (dw_cie_version == 1) 918 dw2_asm_output_data (1, return_reg, "CIE RA Column"); 919 else 920 dw2_asm_output_data_uleb128 (return_reg, "CIE RA Column"); 921 922 if (augmentation[0]) 923 { 924 dw2_asm_output_data_uleb128 (augmentation_size, "Augmentation size"); 925 if (personality) 926 { 927 dw2_asm_output_data (1, per_encoding, "Personality (%s)", 928 eh_data_format_name (per_encoding)); 929 dw2_asm_output_encoded_addr_rtx (per_encoding, 930 personality, 931 true, NULL); 932 } 933 934 if (any_lsda_needed) 935 dw2_asm_output_data (1, lsda_encoding, "LSDA Encoding (%s)", 936 eh_data_format_name (lsda_encoding)); 937 938 if (fde_encoding != DW_EH_PE_absptr) 939 dw2_asm_output_data (1, fde_encoding, "FDE Encoding (%s)", 940 eh_data_format_name (fde_encoding)); 941 } 942 943 FOR_EACH_VEC_ELT (*cie_cfi_vec, i, cfi) 944 output_cfi (cfi, NULL, for_eh); 945 946 /* Pad the CIE out to an address sized boundary. */ 947 ASM_OUTPUT_ALIGN (asm_out_file, 948 floor_log2 (for_eh ? PTR_SIZE : DWARF2_ADDR_SIZE)); 949 ASM_OUTPUT_LABEL (asm_out_file, l2); 950 951 /* Loop through all of the FDE's. */ 952 FOR_EACH_VEC_ELT (*fde_vec, i, fde) 953 { 954 unsigned int k; 955 956 /* Don't emit EH unwind info for leaf functions that don't need it. */ 957 if (for_eh && !fde_needed_for_eh_p (fde)) 958 continue; 959 960 for (k = 0; k < (fde->dw_fde_second_begin ? 2 : 1); k++) 961 output_fde (fde, for_eh, k, section_start_label, fde_encoding, 962 augmentation, any_lsda_needed, lsda_encoding); 963 } 964 965 if (for_eh && targetm.terminate_dw2_eh_frame_info) 966 dw2_asm_output_data (4, 0, "End of Table"); 967 968 /* Turn off app to make assembly quicker. */ 969 if (flag_debug_asm) 970 app_disable (); 971} 972 973/* Emit .cfi_startproc and .cfi_personality/.cfi_lsda if needed. */ 974 975static void 976dwarf2out_do_cfi_startproc (bool second) 977{ 978 int enc; 979 rtx ref; 980 rtx personality = get_personality_function (current_function_decl); 981 982 fprintf (asm_out_file, "\t.cfi_startproc\n"); 983 984 if (personality) 985 { 986 enc = ASM_PREFERRED_EH_DATA_FORMAT (/*code=*/2, /*global=*/1); 987 ref = personality; 988 989 /* ??? The GAS support isn't entirely consistent. We have to 990 handle indirect support ourselves, but PC-relative is done 991 in the assembler. Further, the assembler can't handle any 992 of the weirder relocation types. */ 993 if (enc & DW_EH_PE_indirect) 994 ref = dw2_force_const_mem (ref, true); 995 996 fprintf (asm_out_file, "\t.cfi_personality %#x,", enc); 997 output_addr_const (asm_out_file, ref); 998 fputc ('\n', asm_out_file); 999 } 1000 1001 if (crtl->uses_eh_lsda) 1002 { 1003 char lab[20]; 1004 1005 enc = ASM_PREFERRED_EH_DATA_FORMAT (/*code=*/0, /*global=*/0); 1006 ASM_GENERATE_INTERNAL_LABEL (lab, second ? "LLSDAC" : "LLSDA", 1007 current_function_funcdef_no); 1008 ref = gen_rtx_SYMBOL_REF (Pmode, lab); 1009 SYMBOL_REF_FLAGS (ref) = SYMBOL_FLAG_LOCAL; 1010 1011 if (enc & DW_EH_PE_indirect) 1012 ref = dw2_force_const_mem (ref, true); 1013 1014 fprintf (asm_out_file, "\t.cfi_lsda %#x,", enc); 1015 output_addr_const (asm_out_file, ref); 1016 fputc ('\n', asm_out_file); 1017 } 1018} 1019 1020/* Allocate CURRENT_FDE. Immediately initialize all we can, noting that 1021 this allocation may be done before pass_final. */ 1022 1023dw_fde_ref 1024dwarf2out_alloc_current_fde (void) 1025{ 1026 dw_fde_ref fde; 1027 1028 fde = ggc_cleared_alloc<dw_fde_node> (); 1029 fde->decl = current_function_decl; 1030 fde->funcdef_number = current_function_funcdef_no; 1031 fde->fde_index = vec_safe_length (fde_vec); 1032 fde->all_throwers_are_sibcalls = crtl->all_throwers_are_sibcalls; 1033 fde->uses_eh_lsda = crtl->uses_eh_lsda; 1034 fde->nothrow = crtl->nothrow; 1035 fde->drap_reg = INVALID_REGNUM; 1036 fde->vdrap_reg = INVALID_REGNUM; 1037 1038 /* Record the FDE associated with this function. */ 1039 cfun->fde = fde; 1040 vec_safe_push (fde_vec, fde); 1041 1042 return fde; 1043} 1044 1045/* Output a marker (i.e. a label) for the beginning of a function, before 1046 the prologue. */ 1047 1048void 1049dwarf2out_begin_prologue (unsigned int line ATTRIBUTE_UNUSED, 1050 const char *file ATTRIBUTE_UNUSED) 1051{ 1052 char label[MAX_ARTIFICIAL_LABEL_BYTES]; 1053 char * dup_label; 1054 dw_fde_ref fde; 1055 section *fnsec; 1056 bool do_frame; 1057 1058 current_function_func_begin_label = NULL; 1059 1060 do_frame = dwarf2out_do_frame (); 1061 1062 /* ??? current_function_func_begin_label is also used by except.c for 1063 call-site information. We must emit this label if it might be used. */ 1064 if (!do_frame 1065 && (!flag_exceptions 1066 || targetm_common.except_unwind_info (&global_options) == UI_SJLJ)) 1067 return; 1068 1069 fnsec = function_section (current_function_decl); 1070 switch_to_section (fnsec); 1071 ASM_GENERATE_INTERNAL_LABEL (label, FUNC_BEGIN_LABEL, 1072 current_function_funcdef_no); 1073 ASM_OUTPUT_DEBUG_LABEL (asm_out_file, FUNC_BEGIN_LABEL, 1074 current_function_funcdef_no); 1075 dup_label = xstrdup (label); 1076 current_function_func_begin_label = dup_label; 1077 1078 /* We can elide the fde allocation if we're not emitting debug info. */ 1079 if (!do_frame) 1080 return; 1081 1082 /* Cater to the various TARGET_ASM_OUTPUT_MI_THUNK implementations that 1083 emit insns as rtx but bypass the bulk of rest_of_compilation, which 1084 would include pass_dwarf2_frame. If we've not created the FDE yet, 1085 do so now. */ 1086 fde = cfun->fde; 1087 if (fde == NULL) 1088 fde = dwarf2out_alloc_current_fde (); 1089 1090 /* Initialize the bits of CURRENT_FDE that were not available earlier. */ 1091 fde->dw_fde_begin = dup_label; 1092 fde->dw_fde_current_label = dup_label; 1093 fde->in_std_section = (fnsec == text_section 1094 || (cold_text_section && fnsec == cold_text_section)); 1095 1096 /* We only want to output line number information for the genuine dwarf2 1097 prologue case, not the eh frame case. */ 1098#ifdef DWARF2_DEBUGGING_INFO 1099 if (file) 1100 dwarf2out_source_line (line, file, 0, true); 1101#endif 1102 1103 if (dwarf2out_do_cfi_asm ()) 1104 dwarf2out_do_cfi_startproc (false); 1105 else 1106 { 1107 rtx personality = get_personality_function (current_function_decl); 1108 if (!current_unit_personality) 1109 current_unit_personality = personality; 1110 1111 /* We cannot keep a current personality per function as without CFI 1112 asm, at the point where we emit the CFI data, there is no current 1113 function anymore. */ 1114 if (personality && current_unit_personality != personality) 1115 sorry ("multiple EH personalities are supported only with assemblers " 1116 "supporting .cfi_personality directive"); 1117 } 1118} 1119 1120/* Output a marker (i.e. a label) for the end of the generated code 1121 for a function prologue. This gets called *after* the prologue code has 1122 been generated. */ 1123 1124void 1125dwarf2out_vms_end_prologue (unsigned int line ATTRIBUTE_UNUSED, 1126 const char *file ATTRIBUTE_UNUSED) 1127{ 1128 char label[MAX_ARTIFICIAL_LABEL_BYTES]; 1129 1130 /* Output a label to mark the endpoint of the code generated for this 1131 function. */ 1132 ASM_GENERATE_INTERNAL_LABEL (label, PROLOGUE_END_LABEL, 1133 current_function_funcdef_no); 1134 ASM_OUTPUT_DEBUG_LABEL (asm_out_file, PROLOGUE_END_LABEL, 1135 current_function_funcdef_no); 1136 cfun->fde->dw_fde_vms_end_prologue = xstrdup (label); 1137} 1138 1139/* Output a marker (i.e. a label) for the beginning of the generated code 1140 for a function epilogue. This gets called *before* the prologue code has 1141 been generated. */ 1142 1143void 1144dwarf2out_vms_begin_epilogue (unsigned int line ATTRIBUTE_UNUSED, 1145 const char *file ATTRIBUTE_UNUSED) 1146{ 1147 dw_fde_ref fde = cfun->fde; 1148 char label[MAX_ARTIFICIAL_LABEL_BYTES]; 1149 1150 if (fde->dw_fde_vms_begin_epilogue) 1151 return; 1152 1153 /* Output a label to mark the endpoint of the code generated for this 1154 function. */ 1155 ASM_GENERATE_INTERNAL_LABEL (label, EPILOGUE_BEGIN_LABEL, 1156 current_function_funcdef_no); 1157 ASM_OUTPUT_DEBUG_LABEL (asm_out_file, EPILOGUE_BEGIN_LABEL, 1158 current_function_funcdef_no); 1159 fde->dw_fde_vms_begin_epilogue = xstrdup (label); 1160} 1161 1162/* Output a marker (i.e. a label) for the absolute end of the generated code 1163 for a function definition. This gets called *after* the epilogue code has 1164 been generated. */ 1165 1166void 1167dwarf2out_end_epilogue (unsigned int line ATTRIBUTE_UNUSED, 1168 const char *file ATTRIBUTE_UNUSED) 1169{ 1170 dw_fde_ref fde; 1171 char label[MAX_ARTIFICIAL_LABEL_BYTES]; 1172 1173 last_var_location_insn = NULL; 1174 cached_next_real_insn = NULL; 1175 1176 if (dwarf2out_do_cfi_asm ()) 1177 fprintf (asm_out_file, "\t.cfi_endproc\n"); 1178 1179 /* Output a label to mark the endpoint of the code generated for this 1180 function. */ 1181 ASM_GENERATE_INTERNAL_LABEL (label, FUNC_END_LABEL, 1182 current_function_funcdef_no); 1183 ASM_OUTPUT_LABEL (asm_out_file, label); 1184 fde = cfun->fde; 1185 gcc_assert (fde != NULL); 1186 if (fde->dw_fde_second_begin == NULL) 1187 fde->dw_fde_end = xstrdup (label); 1188} 1189 1190void 1191dwarf2out_frame_finish (void) 1192{ 1193 /* Output call frame information. */ 1194 if (targetm.debug_unwind_info () == UI_DWARF2) 1195 output_call_frame_info (0); 1196 1197 /* Output another copy for the unwinder. */ 1198 if ((flag_unwind_tables || flag_exceptions) 1199 && targetm_common.except_unwind_info (&global_options) == UI_DWARF2) 1200 output_call_frame_info (1); 1201} 1202 1203/* Note that the current function section is being used for code. */ 1204 1205static void 1206dwarf2out_note_section_used (void) 1207{ 1208 section *sec = current_function_section (); 1209 if (sec == text_section) 1210 text_section_used = true; 1211 else if (sec == cold_text_section) 1212 cold_text_section_used = true; 1213} 1214 1215static void var_location_switch_text_section (void); 1216static void set_cur_line_info_table (section *); 1217 1218void 1219dwarf2out_switch_text_section (void) 1220{ 1221 section *sect; 1222 dw_fde_ref fde = cfun->fde; 1223 1224 gcc_assert (cfun && fde && fde->dw_fde_second_begin == NULL); 1225 1226 if (!in_cold_section_p) 1227 { 1228 fde->dw_fde_end = crtl->subsections.cold_section_end_label; 1229 fde->dw_fde_second_begin = crtl->subsections.hot_section_label; 1230 fde->dw_fde_second_end = crtl->subsections.hot_section_end_label; 1231 } 1232 else 1233 { 1234 fde->dw_fde_end = crtl->subsections.hot_section_end_label; 1235 fde->dw_fde_second_begin = crtl->subsections.cold_section_label; 1236 fde->dw_fde_second_end = crtl->subsections.cold_section_end_label; 1237 } 1238 have_multiple_function_sections = true; 1239 1240 /* There is no need to mark used sections when not debugging. */ 1241 if (cold_text_section != NULL) 1242 dwarf2out_note_section_used (); 1243 1244 if (dwarf2out_do_cfi_asm ()) 1245 fprintf (asm_out_file, "\t.cfi_endproc\n"); 1246 1247 /* Now do the real section switch. */ 1248 sect = current_function_section (); 1249 switch_to_section (sect); 1250 1251 fde->second_in_std_section 1252 = (sect == text_section 1253 || (cold_text_section && sect == cold_text_section)); 1254 1255 if (dwarf2out_do_cfi_asm ()) 1256 dwarf2out_do_cfi_startproc (true); 1257 1258 var_location_switch_text_section (); 1259 1260 if (cold_text_section != NULL) 1261 set_cur_line_info_table (sect); 1262} 1263 1264/* And now, the subset of the debugging information support code necessary 1265 for emitting location expressions. */ 1266 1267/* Data about a single source file. */ 1268struct GTY((for_user)) dwarf_file_data { 1269 const char * filename; 1270 int emitted_number; 1271}; 1272 1273typedef struct GTY(()) deferred_locations_struct 1274{ 1275 tree variable; 1276 dw_die_ref die; 1277} deferred_locations; 1278 1279 1280static GTY(()) vec<deferred_locations, va_gc> *deferred_locations_list; 1281 1282 1283/* Describe an entry into the .debug_addr section. */ 1284 1285enum ate_kind { 1286 ate_kind_rtx, 1287 ate_kind_rtx_dtprel, 1288 ate_kind_label 1289}; 1290 1291typedef struct GTY((for_user)) addr_table_entry_struct { 1292 enum ate_kind kind; 1293 unsigned int refcount; 1294 unsigned int index; 1295 union addr_table_entry_struct_union 1296 { 1297 rtx GTY ((tag ("0"))) rtl; 1298 char * GTY ((tag ("1"))) label; 1299 } 1300 GTY ((desc ("%1.kind"))) addr; 1301} 1302addr_table_entry; 1303 1304/* Location lists are ranges + location descriptions for that range, 1305 so you can track variables that are in different places over 1306 their entire life. */ 1307typedef struct GTY(()) dw_loc_list_struct { 1308 dw_loc_list_ref dw_loc_next; 1309 const char *begin; /* Label and addr_entry for start of range */ 1310 addr_table_entry *begin_entry; 1311 const char *end; /* Label for end of range */ 1312 char *ll_symbol; /* Label for beginning of location list. 1313 Only on head of list */ 1314 const char *section; /* Section this loclist is relative to */ 1315 dw_loc_descr_ref expr; 1316 hashval_t hash; 1317 /* True if all addresses in this and subsequent lists are known to be 1318 resolved. */ 1319 bool resolved_addr; 1320 /* True if this list has been replaced by dw_loc_next. */ 1321 bool replaced; 1322 bool emitted; 1323 /* True if the range should be emitted even if begin and end 1324 are the same. */ 1325 bool force; 1326} dw_loc_list_node; 1327 1328static dw_loc_descr_ref int_loc_descriptor (HOST_WIDE_INT); 1329 1330/* Convert a DWARF stack opcode into its string name. */ 1331 1332static const char * 1333dwarf_stack_op_name (unsigned int op) 1334{ 1335 const char *name = get_DW_OP_name (op); 1336 1337 if (name != NULL) 1338 return name; 1339 1340 return "OP_<unknown>"; 1341} 1342 1343/* Return a pointer to a newly allocated location description. Location 1344 descriptions are simple expression terms that can be strung 1345 together to form more complicated location (address) descriptions. */ 1346 1347static inline dw_loc_descr_ref 1348new_loc_descr (enum dwarf_location_atom op, unsigned HOST_WIDE_INT oprnd1, 1349 unsigned HOST_WIDE_INT oprnd2) 1350{ 1351 dw_loc_descr_ref descr = ggc_cleared_alloc<dw_loc_descr_node> (); 1352 1353 descr->dw_loc_opc = op; 1354 descr->dw_loc_oprnd1.val_class = dw_val_class_unsigned_const; 1355 descr->dw_loc_oprnd1.val_entry = NULL; 1356 descr->dw_loc_oprnd1.v.val_unsigned = oprnd1; 1357 descr->dw_loc_oprnd2.val_class = dw_val_class_unsigned_const; 1358 descr->dw_loc_oprnd2.val_entry = NULL; 1359 descr->dw_loc_oprnd2.v.val_unsigned = oprnd2; 1360 1361 return descr; 1362} 1363 1364/* Return a pointer to a newly allocated location description for 1365 REG and OFFSET. */ 1366 1367static inline dw_loc_descr_ref 1368new_reg_loc_descr (unsigned int reg, unsigned HOST_WIDE_INT offset) 1369{ 1370 if (reg <= 31) 1371 return new_loc_descr ((enum dwarf_location_atom) (DW_OP_breg0 + reg), 1372 offset, 0); 1373 else 1374 return new_loc_descr (DW_OP_bregx, reg, offset); 1375} 1376 1377/* Add a location description term to a location description expression. */ 1378 1379static inline void 1380add_loc_descr (dw_loc_descr_ref *list_head, dw_loc_descr_ref descr) 1381{ 1382 dw_loc_descr_ref *d; 1383 1384 /* Find the end of the chain. */ 1385 for (d = list_head; (*d) != NULL; d = &(*d)->dw_loc_next) 1386 ; 1387 1388 *d = descr; 1389} 1390 1391/* Compare two location operands for exact equality. */ 1392 1393static bool 1394dw_val_equal_p (dw_val_node *a, dw_val_node *b) 1395{ 1396 if (a->val_class != b->val_class) 1397 return false; 1398 switch (a->val_class) 1399 { 1400 case dw_val_class_none: 1401 return true; 1402 case dw_val_class_addr: 1403 return rtx_equal_p (a->v.val_addr, b->v.val_addr); 1404 1405 case dw_val_class_offset: 1406 case dw_val_class_unsigned_const: 1407 case dw_val_class_const: 1408 case dw_val_class_range_list: 1409 case dw_val_class_lineptr: 1410 case dw_val_class_macptr: 1411 /* These are all HOST_WIDE_INT, signed or unsigned. */ 1412 return a->v.val_unsigned == b->v.val_unsigned; 1413 1414 case dw_val_class_loc: 1415 return a->v.val_loc == b->v.val_loc; 1416 case dw_val_class_loc_list: 1417 return a->v.val_loc_list == b->v.val_loc_list; 1418 case dw_val_class_die_ref: 1419 return a->v.val_die_ref.die == b->v.val_die_ref.die; 1420 case dw_val_class_fde_ref: 1421 return a->v.val_fde_index == b->v.val_fde_index; 1422 case dw_val_class_lbl_id: 1423 case dw_val_class_high_pc: 1424 return strcmp (a->v.val_lbl_id, b->v.val_lbl_id) == 0; 1425 case dw_val_class_str: 1426 return a->v.val_str == b->v.val_str; 1427 case dw_val_class_flag: 1428 return a->v.val_flag == b->v.val_flag; 1429 case dw_val_class_file: 1430 return a->v.val_file == b->v.val_file; 1431 case dw_val_class_decl_ref: 1432 return a->v.val_decl_ref == b->v.val_decl_ref; 1433 1434 case dw_val_class_const_double: 1435 return (a->v.val_double.high == b->v.val_double.high 1436 && a->v.val_double.low == b->v.val_double.low); 1437 1438 case dw_val_class_wide_int: 1439 return *a->v.val_wide == *b->v.val_wide; 1440 1441 case dw_val_class_vec: 1442 { 1443 size_t a_len = a->v.val_vec.elt_size * a->v.val_vec.length; 1444 size_t b_len = b->v.val_vec.elt_size * b->v.val_vec.length; 1445 1446 return (a_len == b_len 1447 && !memcmp (a->v.val_vec.array, b->v.val_vec.array, a_len)); 1448 } 1449 1450 case dw_val_class_data8: 1451 return memcmp (a->v.val_data8, b->v.val_data8, 8) == 0; 1452 1453 case dw_val_class_vms_delta: 1454 return (!strcmp (a->v.val_vms_delta.lbl1, b->v.val_vms_delta.lbl1) 1455 && !strcmp (a->v.val_vms_delta.lbl1, b->v.val_vms_delta.lbl1)); 1456 } 1457 gcc_unreachable (); 1458} 1459 1460/* Compare two location atoms for exact equality. */ 1461 1462static bool 1463loc_descr_equal_p_1 (dw_loc_descr_ref a, dw_loc_descr_ref b) 1464{ 1465 if (a->dw_loc_opc != b->dw_loc_opc) 1466 return false; 1467 1468 /* ??? This is only ever set for DW_OP_constNu, for N equal to the 1469 address size, but since we always allocate cleared storage it 1470 should be zero for other types of locations. */ 1471 if (a->dtprel != b->dtprel) 1472 return false; 1473 1474 return (dw_val_equal_p (&a->dw_loc_oprnd1, &b->dw_loc_oprnd1) 1475 && dw_val_equal_p (&a->dw_loc_oprnd2, &b->dw_loc_oprnd2)); 1476} 1477 1478/* Compare two complete location expressions for exact equality. */ 1479 1480bool 1481loc_descr_equal_p (dw_loc_descr_ref a, dw_loc_descr_ref b) 1482{ 1483 while (1) 1484 { 1485 if (a == b) 1486 return true; 1487 if (a == NULL || b == NULL) 1488 return false; 1489 if (!loc_descr_equal_p_1 (a, b)) 1490 return false; 1491 1492 a = a->dw_loc_next; 1493 b = b->dw_loc_next; 1494 } 1495} 1496 1497 1498/* Add a constant OFFSET to a location expression. */ 1499 1500static void 1501loc_descr_plus_const (dw_loc_descr_ref *list_head, HOST_WIDE_INT offset) 1502{ 1503 dw_loc_descr_ref loc; 1504 HOST_WIDE_INT *p; 1505 1506 gcc_assert (*list_head != NULL); 1507 1508 if (!offset) 1509 return; 1510 1511 /* Find the end of the chain. */ 1512 for (loc = *list_head; loc->dw_loc_next != NULL; loc = loc->dw_loc_next) 1513 ; 1514 1515 p = NULL; 1516 if (loc->dw_loc_opc == DW_OP_fbreg 1517 || (loc->dw_loc_opc >= DW_OP_breg0 && loc->dw_loc_opc <= DW_OP_breg31)) 1518 p = &loc->dw_loc_oprnd1.v.val_int; 1519 else if (loc->dw_loc_opc == DW_OP_bregx) 1520 p = &loc->dw_loc_oprnd2.v.val_int; 1521 1522 /* If the last operation is fbreg, breg{0..31,x}, optimize by adjusting its 1523 offset. Don't optimize if an signed integer overflow would happen. */ 1524 if (p != NULL 1525 && ((offset > 0 && *p <= INTTYPE_MAXIMUM (HOST_WIDE_INT) - offset) 1526 || (offset < 0 && *p >= INTTYPE_MINIMUM (HOST_WIDE_INT) - offset))) 1527 *p += offset; 1528 1529 else if (offset > 0) 1530 loc->dw_loc_next = new_loc_descr (DW_OP_plus_uconst, offset, 0); 1531 1532 else 1533 { 1534 loc->dw_loc_next = int_loc_descriptor (-offset); 1535 add_loc_descr (&loc->dw_loc_next, new_loc_descr (DW_OP_minus, 0, 0)); 1536 } 1537} 1538 1539/* Add a constant OFFSET to a location list. */ 1540 1541static void 1542loc_list_plus_const (dw_loc_list_ref list_head, HOST_WIDE_INT offset) 1543{ 1544 dw_loc_list_ref d; 1545 for (d = list_head; d != NULL; d = d->dw_loc_next) 1546 loc_descr_plus_const (&d->expr, offset); 1547} 1548 1549#define DWARF_REF_SIZE \ 1550 (dwarf_version == 2 ? DWARF2_ADDR_SIZE : DWARF_OFFSET_SIZE) 1551 1552static unsigned long int get_base_type_offset (dw_die_ref); 1553 1554/* Return the size of a location descriptor. */ 1555 1556static unsigned long 1557size_of_loc_descr (dw_loc_descr_ref loc) 1558{ 1559 unsigned long size = 1; 1560 1561 switch (loc->dw_loc_opc) 1562 { 1563 case DW_OP_addr: 1564 size += DWARF2_ADDR_SIZE; 1565 break; 1566 case DW_OP_GNU_addr_index: 1567 case DW_OP_GNU_const_index: 1568 gcc_assert (loc->dw_loc_oprnd1.val_entry->index != NO_INDEX_ASSIGNED); 1569 size += size_of_uleb128 (loc->dw_loc_oprnd1.val_entry->index); 1570 break; 1571 case DW_OP_const1u: 1572 case DW_OP_const1s: 1573 size += 1; 1574 break; 1575 case DW_OP_const2u: 1576 case DW_OP_const2s: 1577 size += 2; 1578 break; 1579 case DW_OP_const4u: 1580 case DW_OP_const4s: 1581 size += 4; 1582 break; 1583 case DW_OP_const8u: 1584 case DW_OP_const8s: 1585 size += 8; 1586 break; 1587 case DW_OP_constu: 1588 size += size_of_uleb128 (loc->dw_loc_oprnd1.v.val_unsigned); 1589 break; 1590 case DW_OP_consts: 1591 size += size_of_sleb128 (loc->dw_loc_oprnd1.v.val_int); 1592 break; 1593 case DW_OP_pick: 1594 size += 1; 1595 break; 1596 case DW_OP_plus_uconst: 1597 size += size_of_uleb128 (loc->dw_loc_oprnd1.v.val_unsigned); 1598 break; 1599 case DW_OP_skip: 1600 case DW_OP_bra: 1601 size += 2; 1602 break; 1603 case DW_OP_breg0: 1604 case DW_OP_breg1: 1605 case DW_OP_breg2: 1606 case DW_OP_breg3: 1607 case DW_OP_breg4: 1608 case DW_OP_breg5: 1609 case DW_OP_breg6: 1610 case DW_OP_breg7: 1611 case DW_OP_breg8: 1612 case DW_OP_breg9: 1613 case DW_OP_breg10: 1614 case DW_OP_breg11: 1615 case DW_OP_breg12: 1616 case DW_OP_breg13: 1617 case DW_OP_breg14: 1618 case DW_OP_breg15: 1619 case DW_OP_breg16: 1620 case DW_OP_breg17: 1621 case DW_OP_breg18: 1622 case DW_OP_breg19: 1623 case DW_OP_breg20: 1624 case DW_OP_breg21: 1625 case DW_OP_breg22: 1626 case DW_OP_breg23: 1627 case DW_OP_breg24: 1628 case DW_OP_breg25: 1629 case DW_OP_breg26: 1630 case DW_OP_breg27: 1631 case DW_OP_breg28: 1632 case DW_OP_breg29: 1633 case DW_OP_breg30: 1634 case DW_OP_breg31: 1635 size += size_of_sleb128 (loc->dw_loc_oprnd1.v.val_int); 1636 break; 1637 case DW_OP_regx: 1638 size += size_of_uleb128 (loc->dw_loc_oprnd1.v.val_unsigned); 1639 break; 1640 case DW_OP_fbreg: 1641 size += size_of_sleb128 (loc->dw_loc_oprnd1.v.val_int); 1642 break; 1643 case DW_OP_bregx: 1644 size += size_of_uleb128 (loc->dw_loc_oprnd1.v.val_unsigned); 1645 size += size_of_sleb128 (loc->dw_loc_oprnd2.v.val_int); 1646 break; 1647 case DW_OP_piece: 1648 size += size_of_uleb128 (loc->dw_loc_oprnd1.v.val_unsigned); 1649 break; 1650 case DW_OP_bit_piece: 1651 size += size_of_uleb128 (loc->dw_loc_oprnd1.v.val_unsigned); 1652 size += size_of_uleb128 (loc->dw_loc_oprnd2.v.val_unsigned); 1653 break; 1654 case DW_OP_deref_size: 1655 case DW_OP_xderef_size: 1656 size += 1; 1657 break; 1658 case DW_OP_call2: 1659 size += 2; 1660 break; 1661 case DW_OP_call4: 1662 size += 4; 1663 break; 1664 case DW_OP_call_ref: 1665 size += DWARF_REF_SIZE; 1666 break; 1667 case DW_OP_implicit_value: 1668 size += size_of_uleb128 (loc->dw_loc_oprnd1.v.val_unsigned) 1669 + loc->dw_loc_oprnd1.v.val_unsigned; 1670 break; 1671 case DW_OP_GNU_implicit_pointer: 1672 size += DWARF_REF_SIZE + size_of_sleb128 (loc->dw_loc_oprnd2.v.val_int); 1673 break; 1674 case DW_OP_GNU_entry_value: 1675 { 1676 unsigned long op_size = size_of_locs (loc->dw_loc_oprnd1.v.val_loc); 1677 size += size_of_uleb128 (op_size) + op_size; 1678 break; 1679 } 1680 case DW_OP_GNU_const_type: 1681 { 1682 unsigned long o 1683 = get_base_type_offset (loc->dw_loc_oprnd1.v.val_die_ref.die); 1684 size += size_of_uleb128 (o) + 1; 1685 switch (loc->dw_loc_oprnd2.val_class) 1686 { 1687 case dw_val_class_vec: 1688 size += loc->dw_loc_oprnd2.v.val_vec.length 1689 * loc->dw_loc_oprnd2.v.val_vec.elt_size; 1690 break; 1691 case dw_val_class_const: 1692 size += HOST_BITS_PER_WIDE_INT / BITS_PER_UNIT; 1693 break; 1694 case dw_val_class_const_double: 1695 size += HOST_BITS_PER_DOUBLE_INT / BITS_PER_UNIT; 1696 break; 1697 case dw_val_class_wide_int: 1698 size += (get_full_len (*loc->dw_loc_oprnd2.v.val_wide) 1699 * HOST_BITS_PER_WIDE_INT / BITS_PER_UNIT); 1700 break; 1701 default: 1702 gcc_unreachable (); 1703 } 1704 break; 1705 } 1706 case DW_OP_GNU_regval_type: 1707 { 1708 unsigned long o 1709 = get_base_type_offset (loc->dw_loc_oprnd2.v.val_die_ref.die); 1710 size += size_of_uleb128 (loc->dw_loc_oprnd1.v.val_unsigned) 1711 + size_of_uleb128 (o); 1712 } 1713 break; 1714 case DW_OP_GNU_deref_type: 1715 { 1716 unsigned long o 1717 = get_base_type_offset (loc->dw_loc_oprnd2.v.val_die_ref.die); 1718 size += 1 + size_of_uleb128 (o); 1719 } 1720 break; 1721 case DW_OP_GNU_convert: 1722 case DW_OP_GNU_reinterpret: 1723 if (loc->dw_loc_oprnd1.val_class == dw_val_class_unsigned_const) 1724 size += size_of_uleb128 (loc->dw_loc_oprnd1.v.val_unsigned); 1725 else 1726 { 1727 unsigned long o 1728 = get_base_type_offset (loc->dw_loc_oprnd1.v.val_die_ref.die); 1729 size += size_of_uleb128 (o); 1730 } 1731 break; 1732 case DW_OP_GNU_parameter_ref: 1733 size += 4; 1734 break; 1735 default: 1736 break; 1737 } 1738 1739 return size; 1740} 1741 1742/* Return the size of a series of location descriptors. */ 1743 1744unsigned long 1745size_of_locs (dw_loc_descr_ref loc) 1746{ 1747 dw_loc_descr_ref l; 1748 unsigned long size; 1749 1750 /* If there are no skip or bra opcodes, don't fill in the dw_loc_addr 1751 field, to avoid writing to a PCH file. */ 1752 for (size = 0, l = loc; l != NULL; l = l->dw_loc_next) 1753 { 1754 if (l->dw_loc_opc == DW_OP_skip || l->dw_loc_opc == DW_OP_bra) 1755 break; 1756 size += size_of_loc_descr (l); 1757 } 1758 if (! l) 1759 return size; 1760 1761 for (size = 0, l = loc; l != NULL; l = l->dw_loc_next) 1762 { 1763 l->dw_loc_addr = size; 1764 size += size_of_loc_descr (l); 1765 } 1766 1767 return size; 1768} 1769 1770static HOST_WIDE_INT extract_int (const unsigned char *, unsigned); 1771static void get_ref_die_offset_label (char *, dw_die_ref); 1772static unsigned long int get_ref_die_offset (dw_die_ref); 1773 1774/* Output location description stack opcode's operands (if any). 1775 The for_eh_or_skip parameter controls whether register numbers are 1776 converted using DWARF2_FRAME_REG_OUT, which is needed in the case that 1777 hard reg numbers have been processed via DWARF_FRAME_REGNUM (i.e. for unwind 1778 info). This should be suppressed for the cases that have not been converted 1779 (i.e. symbolic debug info), by setting the parameter < 0. See PR47324. */ 1780 1781static void 1782output_loc_operands (dw_loc_descr_ref loc, int for_eh_or_skip) 1783{ 1784 dw_val_ref val1 = &loc->dw_loc_oprnd1; 1785 dw_val_ref val2 = &loc->dw_loc_oprnd2; 1786 1787 switch (loc->dw_loc_opc) 1788 { 1789#ifdef DWARF2_DEBUGGING_INFO 1790 case DW_OP_const2u: 1791 case DW_OP_const2s: 1792 dw2_asm_output_data (2, val1->v.val_int, NULL); 1793 break; 1794 case DW_OP_const4u: 1795 if (loc->dtprel) 1796 { 1797 gcc_assert (targetm.asm_out.output_dwarf_dtprel); 1798 targetm.asm_out.output_dwarf_dtprel (asm_out_file, 4, 1799 val1->v.val_addr); 1800 fputc ('\n', asm_out_file); 1801 break; 1802 } 1803 /* FALLTHRU */ 1804 case DW_OP_const4s: 1805 dw2_asm_output_data (4, val1->v.val_int, NULL); 1806 break; 1807 case DW_OP_const8u: 1808 if (loc->dtprel) 1809 { 1810 gcc_assert (targetm.asm_out.output_dwarf_dtprel); 1811 targetm.asm_out.output_dwarf_dtprel (asm_out_file, 8, 1812 val1->v.val_addr); 1813 fputc ('\n', asm_out_file); 1814 break; 1815 } 1816 /* FALLTHRU */ 1817 case DW_OP_const8s: 1818 gcc_assert (HOST_BITS_PER_WIDE_INT >= 64); 1819 dw2_asm_output_data (8, val1->v.val_int, NULL); 1820 break; 1821 case DW_OP_skip: 1822 case DW_OP_bra: 1823 { 1824 int offset; 1825 1826 gcc_assert (val1->val_class == dw_val_class_loc); 1827 offset = val1->v.val_loc->dw_loc_addr - (loc->dw_loc_addr + 3); 1828 1829 dw2_asm_output_data (2, offset, NULL); 1830 } 1831 break; 1832 case DW_OP_implicit_value: 1833 dw2_asm_output_data_uleb128 (val1->v.val_unsigned, NULL); 1834 switch (val2->val_class) 1835 { 1836 case dw_val_class_const: 1837 dw2_asm_output_data (val1->v.val_unsigned, val2->v.val_int, NULL); 1838 break; 1839 case dw_val_class_vec: 1840 { 1841 unsigned int elt_size = val2->v.val_vec.elt_size; 1842 unsigned int len = val2->v.val_vec.length; 1843 unsigned int i; 1844 unsigned char *p; 1845 1846 if (elt_size > sizeof (HOST_WIDE_INT)) 1847 { 1848 elt_size /= 2; 1849 len *= 2; 1850 } 1851 for (i = 0, p = val2->v.val_vec.array; 1852 i < len; 1853 i++, p += elt_size) 1854 dw2_asm_output_data (elt_size, extract_int (p, elt_size), 1855 "fp or vector constant word %u", i); 1856 } 1857 break; 1858 case dw_val_class_const_double: 1859 { 1860 unsigned HOST_WIDE_INT first, second; 1861 1862 if (WORDS_BIG_ENDIAN) 1863 { 1864 first = val2->v.val_double.high; 1865 second = val2->v.val_double.low; 1866 } 1867 else 1868 { 1869 first = val2->v.val_double.low; 1870 second = val2->v.val_double.high; 1871 } 1872 dw2_asm_output_data (HOST_BITS_PER_WIDE_INT / HOST_BITS_PER_CHAR, 1873 first, NULL); 1874 dw2_asm_output_data (HOST_BITS_PER_WIDE_INT / HOST_BITS_PER_CHAR, 1875 second, NULL); 1876 } 1877 break; 1878 case dw_val_class_wide_int: 1879 { 1880 int i; 1881 int len = get_full_len (*val2->v.val_wide); 1882 if (WORDS_BIG_ENDIAN) 1883 for (i = len - 1; i >= 0; --i) 1884 dw2_asm_output_data (HOST_BITS_PER_WIDE_INT / HOST_BITS_PER_CHAR, 1885 val2->v.val_wide->elt (i), NULL); 1886 else 1887 for (i = 0; i < len; ++i) 1888 dw2_asm_output_data (HOST_BITS_PER_WIDE_INT / HOST_BITS_PER_CHAR, 1889 val2->v.val_wide->elt (i), NULL); 1890 } 1891 break; 1892 case dw_val_class_addr: 1893 gcc_assert (val1->v.val_unsigned == DWARF2_ADDR_SIZE); 1894 dw2_asm_output_addr_rtx (DWARF2_ADDR_SIZE, val2->v.val_addr, NULL); 1895 break; 1896 default: 1897 gcc_unreachable (); 1898 } 1899 break; 1900#else 1901 case DW_OP_const2u: 1902 case DW_OP_const2s: 1903 case DW_OP_const4u: 1904 case DW_OP_const4s: 1905 case DW_OP_const8u: 1906 case DW_OP_const8s: 1907 case DW_OP_skip: 1908 case DW_OP_bra: 1909 case DW_OP_implicit_value: 1910 /* We currently don't make any attempt to make sure these are 1911 aligned properly like we do for the main unwind info, so 1912 don't support emitting things larger than a byte if we're 1913 only doing unwinding. */ 1914 gcc_unreachable (); 1915#endif 1916 case DW_OP_const1u: 1917 case DW_OP_const1s: 1918 dw2_asm_output_data (1, val1->v.val_int, NULL); 1919 break; 1920 case DW_OP_constu: 1921 dw2_asm_output_data_uleb128 (val1->v.val_unsigned, NULL); 1922 break; 1923 case DW_OP_consts: 1924 dw2_asm_output_data_sleb128 (val1->v.val_int, NULL); 1925 break; 1926 case DW_OP_pick: 1927 dw2_asm_output_data (1, val1->v.val_int, NULL); 1928 break; 1929 case DW_OP_plus_uconst: 1930 dw2_asm_output_data_uleb128 (val1->v.val_unsigned, NULL); 1931 break; 1932 case DW_OP_breg0: 1933 case DW_OP_breg1: 1934 case DW_OP_breg2: 1935 case DW_OP_breg3: 1936 case DW_OP_breg4: 1937 case DW_OP_breg5: 1938 case DW_OP_breg6: 1939 case DW_OP_breg7: 1940 case DW_OP_breg8: 1941 case DW_OP_breg9: 1942 case DW_OP_breg10: 1943 case DW_OP_breg11: 1944 case DW_OP_breg12: 1945 case DW_OP_breg13: 1946 case DW_OP_breg14: 1947 case DW_OP_breg15: 1948 case DW_OP_breg16: 1949 case DW_OP_breg17: 1950 case DW_OP_breg18: 1951 case DW_OP_breg19: 1952 case DW_OP_breg20: 1953 case DW_OP_breg21: 1954 case DW_OP_breg22: 1955 case DW_OP_breg23: 1956 case DW_OP_breg24: 1957 case DW_OP_breg25: 1958 case DW_OP_breg26: 1959 case DW_OP_breg27: 1960 case DW_OP_breg28: 1961 case DW_OP_breg29: 1962 case DW_OP_breg30: 1963 case DW_OP_breg31: 1964 dw2_asm_output_data_sleb128 (val1->v.val_int, NULL); 1965 break; 1966 case DW_OP_regx: 1967 { 1968 unsigned r = val1->v.val_unsigned; 1969 if (for_eh_or_skip >= 0) 1970 r = DWARF2_FRAME_REG_OUT (r, for_eh_or_skip); 1971 gcc_assert (size_of_uleb128 (r) 1972 == size_of_uleb128 (val1->v.val_unsigned)); 1973 dw2_asm_output_data_uleb128 (r, NULL); 1974 } 1975 break; 1976 case DW_OP_fbreg: 1977 dw2_asm_output_data_sleb128 (val1->v.val_int, NULL); 1978 break; 1979 case DW_OP_bregx: 1980 { 1981 unsigned r = val1->v.val_unsigned; 1982 if (for_eh_or_skip >= 0) 1983 r = DWARF2_FRAME_REG_OUT (r, for_eh_or_skip); 1984 gcc_assert (size_of_uleb128 (r) 1985 == size_of_uleb128 (val1->v.val_unsigned)); 1986 dw2_asm_output_data_uleb128 (r, NULL); 1987 dw2_asm_output_data_sleb128 (val2->v.val_int, NULL); 1988 } 1989 break; 1990 case DW_OP_piece: 1991 dw2_asm_output_data_uleb128 (val1->v.val_unsigned, NULL); 1992 break; 1993 case DW_OP_bit_piece: 1994 dw2_asm_output_data_uleb128 (val1->v.val_unsigned, NULL); 1995 dw2_asm_output_data_uleb128 (val2->v.val_unsigned, NULL); 1996 break; 1997 case DW_OP_deref_size: 1998 case DW_OP_xderef_size: 1999 dw2_asm_output_data (1, val1->v.val_int, NULL); 2000 break; 2001 2002 case DW_OP_addr: 2003 if (loc->dtprel) 2004 { 2005 if (targetm.asm_out.output_dwarf_dtprel) 2006 { 2007 targetm.asm_out.output_dwarf_dtprel (asm_out_file, 2008 DWARF2_ADDR_SIZE, 2009 val1->v.val_addr); 2010 fputc ('\n', asm_out_file); 2011 } 2012 else 2013 gcc_unreachable (); 2014 } 2015 else 2016 { 2017#ifdef DWARF2_DEBUGGING_INFO 2018 dw2_asm_output_addr_rtx (DWARF2_ADDR_SIZE, val1->v.val_addr, NULL); 2019#else 2020 gcc_unreachable (); 2021#endif 2022 } 2023 break; 2024 2025 case DW_OP_GNU_addr_index: 2026 case DW_OP_GNU_const_index: 2027 gcc_assert (loc->dw_loc_oprnd1.val_entry->index != NO_INDEX_ASSIGNED); 2028 dw2_asm_output_data_uleb128 (loc->dw_loc_oprnd1.val_entry->index, 2029 "(index into .debug_addr)"); 2030 break; 2031 2032 case DW_OP_GNU_implicit_pointer: 2033 { 2034 char label[MAX_ARTIFICIAL_LABEL_BYTES 2035 + HOST_BITS_PER_WIDE_INT / 2 + 2]; 2036 gcc_assert (val1->val_class == dw_val_class_die_ref); 2037 get_ref_die_offset_label (label, val1->v.val_die_ref.die); 2038 dw2_asm_output_offset (DWARF_REF_SIZE, label, debug_info_section, NULL); 2039 dw2_asm_output_data_sleb128 (val2->v.val_int, NULL); 2040 } 2041 break; 2042 2043 case DW_OP_GNU_entry_value: 2044 dw2_asm_output_data_uleb128 (size_of_locs (val1->v.val_loc), NULL); 2045 output_loc_sequence (val1->v.val_loc, for_eh_or_skip); 2046 break; 2047 2048 case DW_OP_GNU_const_type: 2049 { 2050 unsigned long o = get_base_type_offset (val1->v.val_die_ref.die), l; 2051 gcc_assert (o); 2052 dw2_asm_output_data_uleb128 (o, NULL); 2053 switch (val2->val_class) 2054 { 2055 case dw_val_class_const: 2056 l = HOST_BITS_PER_WIDE_INT / HOST_BITS_PER_CHAR; 2057 dw2_asm_output_data (1, l, NULL); 2058 dw2_asm_output_data (l, val2->v.val_int, NULL); 2059 break; 2060 case dw_val_class_vec: 2061 { 2062 unsigned int elt_size = val2->v.val_vec.elt_size; 2063 unsigned int len = val2->v.val_vec.length; 2064 unsigned int i; 2065 unsigned char *p; 2066 2067 l = len * elt_size; 2068 dw2_asm_output_data (1, l, NULL); 2069 if (elt_size > sizeof (HOST_WIDE_INT)) 2070 { 2071 elt_size /= 2; 2072 len *= 2; 2073 } 2074 for (i = 0, p = val2->v.val_vec.array; 2075 i < len; 2076 i++, p += elt_size) 2077 dw2_asm_output_data (elt_size, extract_int (p, elt_size), 2078 "fp or vector constant word %u", i); 2079 } 2080 break; 2081 case dw_val_class_const_double: 2082 { 2083 unsigned HOST_WIDE_INT first, second; 2084 l = HOST_BITS_PER_WIDE_INT / HOST_BITS_PER_CHAR; 2085 2086 dw2_asm_output_data (1, 2 * l, NULL); 2087 if (WORDS_BIG_ENDIAN) 2088 { 2089 first = val2->v.val_double.high; 2090 second = val2->v.val_double.low; 2091 } 2092 else 2093 { 2094 first = val2->v.val_double.low; 2095 second = val2->v.val_double.high; 2096 } 2097 dw2_asm_output_data (l, first, NULL); 2098 dw2_asm_output_data (l, second, NULL); 2099 } 2100 break; 2101 case dw_val_class_wide_int: 2102 { 2103 int i; 2104 int len = get_full_len (*val2->v.val_wide); 2105 l = HOST_BITS_PER_WIDE_INT / HOST_BITS_PER_CHAR; 2106 2107 dw2_asm_output_data (1, len * l, NULL); 2108 if (WORDS_BIG_ENDIAN) 2109 for (i = len - 1; i >= 0; --i) 2110 dw2_asm_output_data (l, val2->v.val_wide->elt (i), NULL); 2111 else 2112 for (i = 0; i < len; ++i) 2113 dw2_asm_output_data (l, val2->v.val_wide->elt (i), NULL); 2114 } 2115 break; 2116 default: 2117 gcc_unreachable (); 2118 } 2119 } 2120 break; 2121 case DW_OP_GNU_regval_type: 2122 { 2123 unsigned r = val1->v.val_unsigned; 2124 unsigned long o = get_base_type_offset (val2->v.val_die_ref.die); 2125 gcc_assert (o); 2126 if (for_eh_or_skip >= 0) 2127 { 2128 r = DWARF2_FRAME_REG_OUT (r, for_eh_or_skip); 2129 gcc_assert (size_of_uleb128 (r) 2130 == size_of_uleb128 (val1->v.val_unsigned)); 2131 } 2132 dw2_asm_output_data_uleb128 (r, NULL); 2133 dw2_asm_output_data_uleb128 (o, NULL); 2134 } 2135 break; 2136 case DW_OP_GNU_deref_type: 2137 { 2138 unsigned long o = get_base_type_offset (val2->v.val_die_ref.die); 2139 gcc_assert (o); 2140 dw2_asm_output_data (1, val1->v.val_int, NULL); 2141 dw2_asm_output_data_uleb128 (o, NULL); 2142 } 2143 break; 2144 case DW_OP_GNU_convert: 2145 case DW_OP_GNU_reinterpret: 2146 if (loc->dw_loc_oprnd1.val_class == dw_val_class_unsigned_const) 2147 dw2_asm_output_data_uleb128 (val1->v.val_unsigned, NULL); 2148 else 2149 { 2150 unsigned long o = get_base_type_offset (val1->v.val_die_ref.die); 2151 gcc_assert (o); 2152 dw2_asm_output_data_uleb128 (o, NULL); 2153 } 2154 break; 2155 2156 case DW_OP_GNU_parameter_ref: 2157 { 2158 unsigned long o; 2159 gcc_assert (val1->val_class == dw_val_class_die_ref); 2160 o = get_ref_die_offset (val1->v.val_die_ref.die); 2161 dw2_asm_output_data (4, o, NULL); 2162 } 2163 break; 2164 2165 default: 2166 /* Other codes have no operands. */ 2167 break; 2168 } 2169} 2170 2171/* Output a sequence of location operations. 2172 The for_eh_or_skip parameter controls whether register numbers are 2173 converted using DWARF2_FRAME_REG_OUT, which is needed in the case that 2174 hard reg numbers have been processed via DWARF_FRAME_REGNUM (i.e. for unwind 2175 info). This should be suppressed for the cases that have not been converted 2176 (i.e. symbolic debug info), by setting the parameter < 0. See PR47324. */ 2177 2178void 2179output_loc_sequence (dw_loc_descr_ref loc, int for_eh_or_skip) 2180{ 2181 for (; loc != NULL; loc = loc->dw_loc_next) 2182 { 2183 enum dwarf_location_atom opc = loc->dw_loc_opc; 2184 /* Output the opcode. */ 2185 if (for_eh_or_skip >= 0 2186 && opc >= DW_OP_breg0 && opc <= DW_OP_breg31) 2187 { 2188 unsigned r = (opc - DW_OP_breg0); 2189 r = DWARF2_FRAME_REG_OUT (r, for_eh_or_skip); 2190 gcc_assert (r <= 31); 2191 opc = (enum dwarf_location_atom) (DW_OP_breg0 + r); 2192 } 2193 else if (for_eh_or_skip >= 0 2194 && opc >= DW_OP_reg0 && opc <= DW_OP_reg31) 2195 { 2196 unsigned r = (opc - DW_OP_reg0); 2197 r = DWARF2_FRAME_REG_OUT (r, for_eh_or_skip); 2198 gcc_assert (r <= 31); 2199 opc = (enum dwarf_location_atom) (DW_OP_reg0 + r); 2200 } 2201 2202 dw2_asm_output_data (1, opc, 2203 "%s", dwarf_stack_op_name (opc)); 2204 2205 /* Output the operand(s) (if any). */ 2206 output_loc_operands (loc, for_eh_or_skip); 2207 } 2208} 2209 2210/* Output location description stack opcode's operands (if any). 2211 The output is single bytes on a line, suitable for .cfi_escape. */ 2212 2213static void 2214output_loc_operands_raw (dw_loc_descr_ref loc) 2215{ 2216 dw_val_ref val1 = &loc->dw_loc_oprnd1; 2217 dw_val_ref val2 = &loc->dw_loc_oprnd2; 2218 2219 switch (loc->dw_loc_opc) 2220 { 2221 case DW_OP_addr: 2222 case DW_OP_GNU_addr_index: 2223 case DW_OP_GNU_const_index: 2224 case DW_OP_implicit_value: 2225 /* We cannot output addresses in .cfi_escape, only bytes. */ 2226 gcc_unreachable (); 2227 2228 case DW_OP_const1u: 2229 case DW_OP_const1s: 2230 case DW_OP_pick: 2231 case DW_OP_deref_size: 2232 case DW_OP_xderef_size: 2233 fputc (',', asm_out_file); 2234 dw2_asm_output_data_raw (1, val1->v.val_int); 2235 break; 2236 2237 case DW_OP_const2u: 2238 case DW_OP_const2s: 2239 fputc (',', asm_out_file); 2240 dw2_asm_output_data_raw (2, val1->v.val_int); 2241 break; 2242 2243 case DW_OP_const4u: 2244 case DW_OP_const4s: 2245 fputc (',', asm_out_file); 2246 dw2_asm_output_data_raw (4, val1->v.val_int); 2247 break; 2248 2249 case DW_OP_const8u: 2250 case DW_OP_const8s: 2251 gcc_assert (HOST_BITS_PER_WIDE_INT >= 64); 2252 fputc (',', asm_out_file); 2253 dw2_asm_output_data_raw (8, val1->v.val_int); 2254 break; 2255 2256 case DW_OP_skip: 2257 case DW_OP_bra: 2258 { 2259 int offset; 2260 2261 gcc_assert (val1->val_class == dw_val_class_loc); 2262 offset = val1->v.val_loc->dw_loc_addr - (loc->dw_loc_addr + 3); 2263 2264 fputc (',', asm_out_file); 2265 dw2_asm_output_data_raw (2, offset); 2266 } 2267 break; 2268 2269 case DW_OP_regx: 2270 { 2271 unsigned r = DWARF2_FRAME_REG_OUT (val1->v.val_unsigned, 1); 2272 gcc_assert (size_of_uleb128 (r) 2273 == size_of_uleb128 (val1->v.val_unsigned)); 2274 fputc (',', asm_out_file); 2275 dw2_asm_output_data_uleb128_raw (r); 2276 } 2277 break; 2278 2279 case DW_OP_constu: 2280 case DW_OP_plus_uconst: 2281 case DW_OP_piece: 2282 fputc (',', asm_out_file); 2283 dw2_asm_output_data_uleb128_raw (val1->v.val_unsigned); 2284 break; 2285 2286 case DW_OP_bit_piece: 2287 fputc (',', asm_out_file); 2288 dw2_asm_output_data_uleb128_raw (val1->v.val_unsigned); 2289 dw2_asm_output_data_uleb128_raw (val2->v.val_unsigned); 2290 break; 2291 2292 case DW_OP_consts: 2293 case DW_OP_breg0: 2294 case DW_OP_breg1: 2295 case DW_OP_breg2: 2296 case DW_OP_breg3: 2297 case DW_OP_breg4: 2298 case DW_OP_breg5: 2299 case DW_OP_breg6: 2300 case DW_OP_breg7: 2301 case DW_OP_breg8: 2302 case DW_OP_breg9: 2303 case DW_OP_breg10: 2304 case DW_OP_breg11: 2305 case DW_OP_breg12: 2306 case DW_OP_breg13: 2307 case DW_OP_breg14: 2308 case DW_OP_breg15: 2309 case DW_OP_breg16: 2310 case DW_OP_breg17: 2311 case DW_OP_breg18: 2312 case DW_OP_breg19: 2313 case DW_OP_breg20: 2314 case DW_OP_breg21: 2315 case DW_OP_breg22: 2316 case DW_OP_breg23: 2317 case DW_OP_breg24: 2318 case DW_OP_breg25: 2319 case DW_OP_breg26: 2320 case DW_OP_breg27: 2321 case DW_OP_breg28: 2322 case DW_OP_breg29: 2323 case DW_OP_breg30: 2324 case DW_OP_breg31: 2325 case DW_OP_fbreg: 2326 fputc (',', asm_out_file); 2327 dw2_asm_output_data_sleb128_raw (val1->v.val_int); 2328 break; 2329 2330 case DW_OP_bregx: 2331 { 2332 unsigned r = DWARF2_FRAME_REG_OUT (val1->v.val_unsigned, 1); 2333 gcc_assert (size_of_uleb128 (r) 2334 == size_of_uleb128 (val1->v.val_unsigned)); 2335 fputc (',', asm_out_file); 2336 dw2_asm_output_data_uleb128_raw (r); 2337 fputc (',', asm_out_file); 2338 dw2_asm_output_data_sleb128_raw (val2->v.val_int); 2339 } 2340 break; 2341 2342 case DW_OP_GNU_implicit_pointer: 2343 case DW_OP_GNU_entry_value: 2344 case DW_OP_GNU_const_type: 2345 case DW_OP_GNU_regval_type: 2346 case DW_OP_GNU_deref_type: 2347 case DW_OP_GNU_convert: 2348 case DW_OP_GNU_reinterpret: 2349 case DW_OP_GNU_parameter_ref: 2350 gcc_unreachable (); 2351 break; 2352 2353 default: 2354 /* Other codes have no operands. */ 2355 break; 2356 } 2357} 2358 2359void 2360output_loc_sequence_raw (dw_loc_descr_ref loc) 2361{ 2362 while (1) 2363 { 2364 enum dwarf_location_atom opc = loc->dw_loc_opc; 2365 /* Output the opcode. */ 2366 if (opc >= DW_OP_breg0 && opc <= DW_OP_breg31) 2367 { 2368 unsigned r = (opc - DW_OP_breg0); 2369 r = DWARF2_FRAME_REG_OUT (r, 1); 2370 gcc_assert (r <= 31); 2371 opc = (enum dwarf_location_atom) (DW_OP_breg0 + r); 2372 } 2373 else if (opc >= DW_OP_reg0 && opc <= DW_OP_reg31) 2374 { 2375 unsigned r = (opc - DW_OP_reg0); 2376 r = DWARF2_FRAME_REG_OUT (r, 1); 2377 gcc_assert (r <= 31); 2378 opc = (enum dwarf_location_atom) (DW_OP_reg0 + r); 2379 } 2380 /* Output the opcode. */ 2381 fprintf (asm_out_file, "%#x", opc); 2382 output_loc_operands_raw (loc); 2383 2384 if (!loc->dw_loc_next) 2385 break; 2386 loc = loc->dw_loc_next; 2387 2388 fputc (',', asm_out_file); 2389 } 2390} 2391 2392/* This function builds a dwarf location descriptor sequence from a 2393 dw_cfa_location, adding the given OFFSET to the result of the 2394 expression. */ 2395 2396struct dw_loc_descr_node * 2397build_cfa_loc (dw_cfa_location *cfa, HOST_WIDE_INT offset) 2398{ 2399 struct dw_loc_descr_node *head, *tmp; 2400 2401 offset += cfa->offset; 2402 2403 if (cfa->indirect) 2404 { 2405 head = new_reg_loc_descr (cfa->reg, cfa->base_offset); 2406 head->dw_loc_oprnd1.val_class = dw_val_class_const; 2407 head->dw_loc_oprnd1.val_entry = NULL; 2408 tmp = new_loc_descr (DW_OP_deref, 0, 0); 2409 add_loc_descr (&head, tmp); 2410 if (offset != 0) 2411 { 2412 tmp = new_loc_descr (DW_OP_plus_uconst, offset, 0); 2413 add_loc_descr (&head, tmp); 2414 } 2415 } 2416 else 2417 head = new_reg_loc_descr (cfa->reg, offset); 2418 2419 return head; 2420} 2421 2422/* This function builds a dwarf location descriptor sequence for 2423 the address at OFFSET from the CFA when stack is aligned to 2424 ALIGNMENT byte. */ 2425 2426struct dw_loc_descr_node * 2427build_cfa_aligned_loc (dw_cfa_location *cfa, 2428 HOST_WIDE_INT offset, HOST_WIDE_INT alignment) 2429{ 2430 struct dw_loc_descr_node *head; 2431 unsigned int dwarf_fp 2432 = DWARF_FRAME_REGNUM (HARD_FRAME_POINTER_REGNUM); 2433 2434 /* When CFA is defined as FP+OFFSET, emulate stack alignment. */ 2435 if (cfa->reg == HARD_FRAME_POINTER_REGNUM && cfa->indirect == 0) 2436 { 2437 head = new_reg_loc_descr (dwarf_fp, 0); 2438 add_loc_descr (&head, int_loc_descriptor (alignment)); 2439 add_loc_descr (&head, new_loc_descr (DW_OP_and, 0, 0)); 2440 loc_descr_plus_const (&head, offset); 2441 } 2442 else 2443 head = new_reg_loc_descr (dwarf_fp, offset); 2444 return head; 2445} 2446 2447/* And now, the support for symbolic debugging information. */ 2448 2449/* .debug_str support. */ 2450 2451static void dwarf2out_init (const char *); 2452static void dwarf2out_finish (const char *); 2453static void dwarf2out_assembly_start (void); 2454static void dwarf2out_define (unsigned int, const char *); 2455static void dwarf2out_undef (unsigned int, const char *); 2456static void dwarf2out_start_source_file (unsigned, const char *); 2457static void dwarf2out_end_source_file (unsigned); 2458static void dwarf2out_function_decl (tree); 2459static void dwarf2out_begin_block (unsigned, unsigned); 2460static void dwarf2out_end_block (unsigned, unsigned); 2461static bool dwarf2out_ignore_block (const_tree); 2462static void dwarf2out_global_decl (tree); 2463static void dwarf2out_type_decl (tree, int); 2464static void dwarf2out_imported_module_or_decl (tree, tree, tree, bool); 2465static void dwarf2out_imported_module_or_decl_1 (tree, tree, tree, 2466 dw_die_ref); 2467static void dwarf2out_abstract_function (tree); 2468static void dwarf2out_var_location (rtx_insn *); 2469static void dwarf2out_begin_function (tree); 2470static void dwarf2out_end_function (unsigned int); 2471static void dwarf2out_register_main_translation_unit (tree unit); 2472static void dwarf2out_set_name (tree, tree); 2473 2474/* The debug hooks structure. */ 2475 2476const struct gcc_debug_hooks dwarf2_debug_hooks = 2477{ 2478 dwarf2out_init, 2479 dwarf2out_finish, 2480 dwarf2out_assembly_start, 2481 dwarf2out_define, 2482 dwarf2out_undef, 2483 dwarf2out_start_source_file, 2484 dwarf2out_end_source_file, 2485 dwarf2out_begin_block, 2486 dwarf2out_end_block, 2487 dwarf2out_ignore_block, 2488 dwarf2out_source_line, 2489 dwarf2out_begin_prologue, 2490#if VMS_DEBUGGING_INFO 2491 dwarf2out_vms_end_prologue, 2492 dwarf2out_vms_begin_epilogue, 2493#else 2494 debug_nothing_int_charstar, 2495 debug_nothing_int_charstar, 2496#endif 2497 dwarf2out_end_epilogue, 2498 dwarf2out_begin_function, 2499 dwarf2out_end_function, /* end_function */ 2500 dwarf2out_register_main_translation_unit, 2501 dwarf2out_function_decl, /* function_decl */ 2502 dwarf2out_global_decl, 2503 dwarf2out_type_decl, /* type_decl */ 2504 dwarf2out_imported_module_or_decl, 2505 debug_nothing_tree, /* deferred_inline_function */ 2506 /* The DWARF 2 backend tries to reduce debugging bloat by not 2507 emitting the abstract description of inline functions until 2508 something tries to reference them. */ 2509 dwarf2out_abstract_function, /* outlining_inline_function */ 2510 debug_nothing_rtx_code_label, /* label */ 2511 debug_nothing_int, /* handle_pch */ 2512 dwarf2out_var_location, 2513 dwarf2out_switch_text_section, 2514 dwarf2out_set_name, 2515 1, /* start_end_main_source_file */ 2516 TYPE_SYMTAB_IS_DIE /* tree_type_symtab_field */ 2517}; 2518 2519/* NOTE: In the comments in this file, many references are made to 2520 "Debugging Information Entries". This term is abbreviated as `DIE' 2521 throughout the remainder of this file. */ 2522 2523/* An internal representation of the DWARF output is built, and then 2524 walked to generate the DWARF debugging info. The walk of the internal 2525 representation is done after the entire program has been compiled. 2526 The types below are used to describe the internal representation. */ 2527 2528/* Whether to put type DIEs into their own section .debug_types instead 2529 of making them part of the .debug_info section. Only supported for 2530 Dwarf V4 or higher and the user didn't disable them through 2531 -fno-debug-types-section. It is more efficient to put them in a 2532 separate comdat sections since the linker will then be able to 2533 remove duplicates. But not all tools support .debug_types sections 2534 yet. */ 2535 2536#define use_debug_types (dwarf_version >= 4 && flag_debug_types_section) 2537 2538/* Various DIE's use offsets relative to the beginning of the 2539 .debug_info section to refer to each other. */ 2540 2541typedef long int dw_offset; 2542 2543/* Define typedefs here to avoid circular dependencies. */ 2544 2545typedef struct dw_attr_struct *dw_attr_ref; 2546typedef struct dw_line_info_struct *dw_line_info_ref; 2547typedef struct pubname_struct *pubname_ref; 2548typedef struct dw_ranges_struct *dw_ranges_ref; 2549typedef struct dw_ranges_by_label_struct *dw_ranges_by_label_ref; 2550typedef struct comdat_type_struct *comdat_type_node_ref; 2551 2552/* The entries in the line_info table more-or-less mirror the opcodes 2553 that are used in the real dwarf line table. Arrays of these entries 2554 are collected per section when DWARF2_ASM_LINE_DEBUG_INFO is not 2555 supported. */ 2556 2557enum dw_line_info_opcode { 2558 /* Emit DW_LNE_set_address; the operand is the label index. */ 2559 LI_set_address, 2560 2561 /* Emit a row to the matrix with the given line. This may be done 2562 via any combination of DW_LNS_copy, DW_LNS_advance_line, and 2563 special opcodes. */ 2564 LI_set_line, 2565 2566 /* Emit a DW_LNS_set_file. */ 2567 LI_set_file, 2568 2569 /* Emit a DW_LNS_set_column. */ 2570 LI_set_column, 2571 2572 /* Emit a DW_LNS_negate_stmt; the operand is ignored. */ 2573 LI_negate_stmt, 2574 2575 /* Emit a DW_LNS_set_prologue_end/epilogue_begin; the operand is ignored. */ 2576 LI_set_prologue_end, 2577 LI_set_epilogue_begin, 2578 2579 /* Emit a DW_LNE_set_discriminator. */ 2580 LI_set_discriminator 2581}; 2582 2583typedef struct GTY(()) dw_line_info_struct { 2584 enum dw_line_info_opcode opcode; 2585 unsigned int val; 2586} dw_line_info_entry; 2587 2588 2589typedef struct GTY(()) dw_line_info_table_struct { 2590 /* The label that marks the end of this section. */ 2591 const char *end_label; 2592 2593 /* The values for the last row of the matrix, as collected in the table. 2594 These are used to minimize the changes to the next row. */ 2595 unsigned int file_num; 2596 unsigned int line_num; 2597 unsigned int column_num; 2598 int discrim_num; 2599 bool is_stmt; 2600 bool in_use; 2601 2602 vec<dw_line_info_entry, va_gc> *entries; 2603} dw_line_info_table; 2604 2605typedef dw_line_info_table *dw_line_info_table_p; 2606 2607 2608/* Each DIE attribute has a field specifying the attribute kind, 2609 a link to the next attribute in the chain, and an attribute value. 2610 Attributes are typically linked below the DIE they modify. */ 2611 2612typedef struct GTY(()) dw_attr_struct { 2613 enum dwarf_attribute dw_attr; 2614 dw_val_node dw_attr_val; 2615} 2616dw_attr_node; 2617 2618 2619/* The Debugging Information Entry (DIE) structure. DIEs form a tree. 2620 The children of each node form a circular list linked by 2621 die_sib. die_child points to the node *before* the "first" child node. */ 2622 2623typedef struct GTY((chain_circular ("%h.die_sib"), for_user)) die_struct { 2624 union die_symbol_or_type_node 2625 { 2626 const char * GTY ((tag ("0"))) die_symbol; 2627 comdat_type_node_ref GTY ((tag ("1"))) die_type_node; 2628 } 2629 GTY ((desc ("%0.comdat_type_p"))) die_id; 2630 vec<dw_attr_node, va_gc> *die_attr; 2631 dw_die_ref die_parent; 2632 dw_die_ref die_child; 2633 dw_die_ref die_sib; 2634 dw_die_ref die_definition; /* ref from a specification to its definition */ 2635 dw_offset die_offset; 2636 unsigned long die_abbrev; 2637 int die_mark; 2638 unsigned int decl_id; 2639 enum dwarf_tag die_tag; 2640 /* Die is used and must not be pruned as unused. */ 2641 BOOL_BITFIELD die_perennial_p : 1; 2642 BOOL_BITFIELD comdat_type_p : 1; /* DIE has a type signature */ 2643 /* Lots of spare bits. */ 2644} 2645die_node; 2646 2647/* Evaluate 'expr' while 'c' is set to each child of DIE in order. */ 2648#define FOR_EACH_CHILD(die, c, expr) do { \ 2649 c = die->die_child; \ 2650 if (c) do { \ 2651 c = c->die_sib; \ 2652 expr; \ 2653 } while (c != die->die_child); \ 2654} while (0) 2655 2656/* The pubname structure */ 2657 2658typedef struct GTY(()) pubname_struct { 2659 dw_die_ref die; 2660 const char *name; 2661} 2662pubname_entry; 2663 2664 2665struct GTY(()) dw_ranges_struct { 2666 /* If this is positive, it's a block number, otherwise it's a 2667 bitwise-negated index into dw_ranges_by_label. */ 2668 int num; 2669}; 2670 2671/* A structure to hold a macinfo entry. */ 2672 2673typedef struct GTY(()) macinfo_struct { 2674 unsigned char code; 2675 unsigned HOST_WIDE_INT lineno; 2676 const char *info; 2677} 2678macinfo_entry; 2679 2680 2681struct GTY(()) dw_ranges_by_label_struct { 2682 const char *begin; 2683 const char *end; 2684}; 2685 2686/* The comdat type node structure. */ 2687typedef struct GTY(()) comdat_type_struct 2688{ 2689 dw_die_ref root_die; 2690 dw_die_ref type_die; 2691 dw_die_ref skeleton_die; 2692 char signature[DWARF_TYPE_SIGNATURE_SIZE]; 2693 struct comdat_type_struct *next; 2694} 2695comdat_type_node; 2696 2697/* The limbo die list structure. */ 2698typedef struct GTY(()) limbo_die_struct { 2699 dw_die_ref die; 2700 tree created_for; 2701 struct limbo_die_struct *next; 2702} 2703limbo_die_node; 2704 2705typedef struct skeleton_chain_struct 2706{ 2707 dw_die_ref old_die; 2708 dw_die_ref new_die; 2709 struct skeleton_chain_struct *parent; 2710} 2711skeleton_chain_node; 2712 2713/* Define a macro which returns nonzero for a TYPE_DECL which was 2714 implicitly generated for a type. 2715 2716 Note that, unlike the C front-end (which generates a NULL named 2717 TYPE_DECL node for each complete tagged type, each array type, 2718 and each function type node created) the C++ front-end generates 2719 a _named_ TYPE_DECL node for each tagged type node created. 2720 These TYPE_DECLs have DECL_ARTIFICIAL set, so we know not to 2721 generate a DW_TAG_typedef DIE for them. Likewise with the Ada 2722 front-end, but for each type, tagged or not. */ 2723 2724#define TYPE_DECL_IS_STUB(decl) \ 2725 (DECL_NAME (decl) == NULL_TREE \ 2726 || (DECL_ARTIFICIAL (decl) \ 2727 && ((decl == TYPE_STUB_DECL (TREE_TYPE (decl))) \ 2728 /* This is necessary for stub decls that \ 2729 appear in nested inline functions. */ \ 2730 || (DECL_ABSTRACT_ORIGIN (decl) != NULL_TREE \ 2731 && (decl_ultimate_origin (decl) \ 2732 == TYPE_STUB_DECL (TREE_TYPE (decl))))))) 2733 2734/* Information concerning the compilation unit's programming 2735 language, and compiler version. */ 2736 2737/* Fixed size portion of the DWARF compilation unit header. */ 2738#define DWARF_COMPILE_UNIT_HEADER_SIZE \ 2739 (DWARF_INITIAL_LENGTH_SIZE + DWARF_OFFSET_SIZE + 3) 2740 2741/* Fixed size portion of the DWARF comdat type unit header. */ 2742#define DWARF_COMDAT_TYPE_UNIT_HEADER_SIZE \ 2743 (DWARF_COMPILE_UNIT_HEADER_SIZE + DWARF_TYPE_SIGNATURE_SIZE \ 2744 + DWARF_OFFSET_SIZE) 2745 2746/* Fixed size portion of public names info. */ 2747#define DWARF_PUBNAMES_HEADER_SIZE (2 * DWARF_OFFSET_SIZE + 2) 2748 2749/* Fixed size portion of the address range info. */ 2750#define DWARF_ARANGES_HEADER_SIZE \ 2751 (DWARF_ROUND (DWARF_INITIAL_LENGTH_SIZE + DWARF_OFFSET_SIZE + 4, \ 2752 DWARF2_ADDR_SIZE * 2) \ 2753 - DWARF_INITIAL_LENGTH_SIZE) 2754 2755/* Size of padding portion in the address range info. It must be 2756 aligned to twice the pointer size. */ 2757#define DWARF_ARANGES_PAD_SIZE \ 2758 (DWARF_ROUND (DWARF_INITIAL_LENGTH_SIZE + DWARF_OFFSET_SIZE + 4, \ 2759 DWARF2_ADDR_SIZE * 2) \ 2760 - (DWARF_INITIAL_LENGTH_SIZE + DWARF_OFFSET_SIZE + 4)) 2761 2762/* Use assembler line directives if available. */ 2763#ifndef DWARF2_ASM_LINE_DEBUG_INFO 2764#ifdef HAVE_AS_DWARF2_DEBUG_LINE 2765#define DWARF2_ASM_LINE_DEBUG_INFO 1 2766#else 2767#define DWARF2_ASM_LINE_DEBUG_INFO 0 2768#endif 2769#endif 2770 2771/* Minimum line offset in a special line info. opcode. 2772 This value was chosen to give a reasonable range of values. */ 2773#define DWARF_LINE_BASE -10 2774 2775/* First special line opcode - leave room for the standard opcodes. */ 2776#define DWARF_LINE_OPCODE_BASE ((int)DW_LNS_set_isa + 1) 2777 2778/* Range of line offsets in a special line info. opcode. */ 2779#define DWARF_LINE_RANGE (254-DWARF_LINE_OPCODE_BASE+1) 2780 2781/* Flag that indicates the initial value of the is_stmt_start flag. 2782 In the present implementation, we do not mark any lines as 2783 the beginning of a source statement, because that information 2784 is not made available by the GCC front-end. */ 2785#define DWARF_LINE_DEFAULT_IS_STMT_START 1 2786 2787/* Maximum number of operations per instruction bundle. */ 2788#ifndef DWARF_LINE_DEFAULT_MAX_OPS_PER_INSN 2789#define DWARF_LINE_DEFAULT_MAX_OPS_PER_INSN 1 2790#endif 2791 2792/* This location is used by calc_die_sizes() to keep track 2793 the offset of each DIE within the .debug_info section. */ 2794static unsigned long next_die_offset; 2795 2796/* Record the root of the DIE's built for the current compilation unit. */ 2797static GTY(()) dw_die_ref single_comp_unit_die; 2798 2799/* A list of type DIEs that have been separated into comdat sections. */ 2800static GTY(()) comdat_type_node *comdat_type_list; 2801 2802/* A list of DIEs with a NULL parent waiting to be relocated. */ 2803static GTY(()) limbo_die_node *limbo_die_list; 2804 2805/* A list of DIEs for which we may have to generate 2806 DW_AT_{,MIPS_}linkage_name once their DECL_ASSEMBLER_NAMEs are set. */ 2807static GTY(()) limbo_die_node *deferred_asm_name; 2808 2809struct dwarf_file_hasher : ggc_hasher<dwarf_file_data *> 2810{ 2811 typedef const char *compare_type; 2812 2813 static hashval_t hash (dwarf_file_data *); 2814 static bool equal (dwarf_file_data *, const char *); 2815}; 2816 2817/* Filenames referenced by this compilation unit. */ 2818static GTY(()) hash_table<dwarf_file_hasher> *file_table; 2819 2820struct decl_die_hasher : ggc_hasher<die_node *> 2821{ 2822 typedef tree compare_type; 2823 2824 static hashval_t hash (die_node *); 2825 static bool equal (die_node *, tree); 2826}; 2827/* A hash table of references to DIE's that describe declarations. 2828 The key is a DECL_UID() which is a unique number identifying each decl. */ 2829static GTY (()) hash_table<decl_die_hasher> *decl_die_table; 2830 2831struct block_die_hasher : ggc_hasher<die_struct *> 2832{ 2833 static hashval_t hash (die_struct *); 2834 static bool equal (die_struct *, die_struct *); 2835}; 2836 2837/* A hash table of references to DIE's that describe COMMON blocks. 2838 The key is DECL_UID() ^ die_parent. */ 2839static GTY (()) hash_table<block_die_hasher> *common_block_die_table; 2840 2841typedef struct GTY(()) die_arg_entry_struct { 2842 dw_die_ref die; 2843 tree arg; 2844} die_arg_entry; 2845 2846 2847/* Node of the variable location list. */ 2848struct GTY ((chain_next ("%h.next"))) var_loc_node { 2849 /* Either NOTE_INSN_VAR_LOCATION, or, for SRA optimized variables, 2850 EXPR_LIST chain. For small bitsizes, bitsize is encoded 2851 in mode of the EXPR_LIST node and first EXPR_LIST operand 2852 is either NOTE_INSN_VAR_LOCATION for a piece with a known 2853 location or NULL for padding. For larger bitsizes, 2854 mode is 0 and first operand is a CONCAT with bitsize 2855 as first CONCAT operand and NOTE_INSN_VAR_LOCATION resp. 2856 NULL as second operand. */ 2857 rtx GTY (()) loc; 2858 const char * GTY (()) label; 2859 struct var_loc_node * GTY (()) next; 2860}; 2861 2862/* Variable location list. */ 2863struct GTY ((for_user)) var_loc_list_def { 2864 struct var_loc_node * GTY (()) first; 2865 2866 /* Pointer to the last but one or last element of the 2867 chained list. If the list is empty, both first and 2868 last are NULL, if the list contains just one node 2869 or the last node certainly is not redundant, it points 2870 to the last node, otherwise points to the last but one. 2871 Do not mark it for GC because it is marked through the chain. */ 2872 struct var_loc_node * GTY ((skip ("%h"))) last; 2873 2874 /* Pointer to the last element before section switch, 2875 if NULL, either sections weren't switched or first 2876 is after section switch. */ 2877 struct var_loc_node * GTY ((skip ("%h"))) last_before_switch; 2878 2879 /* DECL_UID of the variable decl. */ 2880 unsigned int decl_id; 2881}; 2882typedef struct var_loc_list_def var_loc_list; 2883 2884/* Call argument location list. */ 2885struct GTY ((chain_next ("%h.next"))) call_arg_loc_node { 2886 rtx GTY (()) call_arg_loc_note; 2887 const char * GTY (()) label; 2888 tree GTY (()) block; 2889 bool tail_call_p; 2890 rtx GTY (()) symbol_ref; 2891 struct call_arg_loc_node * GTY (()) next; 2892}; 2893 2894 2895struct decl_loc_hasher : ggc_hasher<var_loc_list *> 2896{ 2897 typedef const_tree compare_type; 2898 2899 static hashval_t hash (var_loc_list *); 2900 static bool equal (var_loc_list *, const_tree); 2901}; 2902 2903/* Table of decl location linked lists. */ 2904static GTY (()) hash_table<decl_loc_hasher> *decl_loc_table; 2905 2906/* Head and tail of call_arg_loc chain. */ 2907static GTY (()) struct call_arg_loc_node *call_arg_locations; 2908static struct call_arg_loc_node *call_arg_loc_last; 2909 2910/* Number of call sites in the current function. */ 2911static int call_site_count = -1; 2912/* Number of tail call sites in the current function. */ 2913static int tail_call_site_count = -1; 2914 2915/* Vector mapping block numbers to DW_TAG_{lexical_block,inlined_subroutine} 2916 DIEs. */ 2917static vec<dw_die_ref> block_map; 2918 2919/* A cached location list. */ 2920struct GTY ((for_user)) cached_dw_loc_list_def { 2921 /* The DECL_UID of the decl that this entry describes. */ 2922 unsigned int decl_id; 2923 2924 /* The cached location list. */ 2925 dw_loc_list_ref loc_list; 2926}; 2927typedef struct cached_dw_loc_list_def cached_dw_loc_list; 2928 2929struct dw_loc_list_hasher : ggc_hasher<cached_dw_loc_list *> 2930{ 2931 2932 typedef const_tree compare_type; 2933 2934 static hashval_t hash (cached_dw_loc_list *); 2935 static bool equal (cached_dw_loc_list *, const_tree); 2936}; 2937 2938/* Table of cached location lists. */ 2939static GTY (()) hash_table<dw_loc_list_hasher> *cached_dw_loc_list_table; 2940 2941/* A pointer to the base of a list of references to DIE's that 2942 are uniquely identified by their tag, presence/absence of 2943 children DIE's, and list of attribute/value pairs. */ 2944static GTY((length ("abbrev_die_table_allocated"))) 2945 dw_die_ref *abbrev_die_table; 2946 2947/* Number of elements currently allocated for abbrev_die_table. */ 2948static GTY(()) unsigned abbrev_die_table_allocated; 2949 2950/* Number of elements in type_die_table currently in use. */ 2951static GTY(()) unsigned abbrev_die_table_in_use; 2952 2953/* Size (in elements) of increments by which we may expand the 2954 abbrev_die_table. */ 2955#define ABBREV_DIE_TABLE_INCREMENT 256 2956 2957/* A global counter for generating labels for line number data. */ 2958static unsigned int line_info_label_num; 2959 2960/* The current table to which we should emit line number information 2961 for the current function. This will be set up at the beginning of 2962 assembly for the function. */ 2963static dw_line_info_table *cur_line_info_table; 2964 2965/* The two default tables of line number info. */ 2966static GTY(()) dw_line_info_table *text_section_line_info; 2967static GTY(()) dw_line_info_table *cold_text_section_line_info; 2968 2969/* The set of all non-default tables of line number info. */ 2970static GTY(()) vec<dw_line_info_table_p, va_gc> *separate_line_info; 2971 2972/* A flag to tell pubnames/types export if there is an info section to 2973 refer to. */ 2974static bool info_section_emitted; 2975 2976/* A pointer to the base of a table that contains a list of publicly 2977 accessible names. */ 2978static GTY (()) vec<pubname_entry, va_gc> *pubname_table; 2979 2980/* A pointer to the base of a table that contains a list of publicly 2981 accessible types. */ 2982static GTY (()) vec<pubname_entry, va_gc> *pubtype_table; 2983 2984/* A pointer to the base of a table that contains a list of macro 2985 defines/undefines (and file start/end markers). */ 2986static GTY (()) vec<macinfo_entry, va_gc> *macinfo_table; 2987 2988/* True if .debug_macinfo or .debug_macros section is going to be 2989 emitted. */ 2990#define have_macinfo \ 2991 (debug_info_level >= DINFO_LEVEL_VERBOSE \ 2992 && !macinfo_table->is_empty ()) 2993 2994/* Array of dies for which we should generate .debug_ranges info. */ 2995static GTY ((length ("ranges_table_allocated"))) dw_ranges_ref ranges_table; 2996 2997/* Number of elements currently allocated for ranges_table. */ 2998static GTY(()) unsigned ranges_table_allocated; 2999 3000/* Number of elements in ranges_table currently in use. */ 3001static GTY(()) unsigned ranges_table_in_use; 3002 3003/* Array of pairs of labels referenced in ranges_table. */ 3004static GTY ((length ("ranges_by_label_allocated"))) 3005 dw_ranges_by_label_ref ranges_by_label; 3006 3007/* Number of elements currently allocated for ranges_by_label. */ 3008static GTY(()) unsigned ranges_by_label_allocated; 3009 3010/* Number of elements in ranges_by_label currently in use. */ 3011static GTY(()) unsigned ranges_by_label_in_use; 3012 3013/* Size (in elements) of increments by which we may expand the 3014 ranges_table. */ 3015#define RANGES_TABLE_INCREMENT 64 3016 3017/* Whether we have location lists that need outputting */ 3018static GTY(()) bool have_location_lists; 3019 3020/* Unique label counter. */ 3021static GTY(()) unsigned int loclabel_num; 3022 3023/* Unique label counter for point-of-call tables. */ 3024static GTY(()) unsigned int poc_label_num; 3025 3026/* The last file entry emitted by maybe_emit_file(). */ 3027static GTY(()) struct dwarf_file_data * last_emitted_file; 3028 3029/* Number of internal labels generated by gen_internal_sym(). */ 3030static GTY(()) int label_num; 3031 3032/* Cached result of previous call to lookup_filename. */ 3033static GTY(()) struct dwarf_file_data * file_table_last_lookup; 3034 3035static GTY(()) vec<die_arg_entry, va_gc> *tmpl_value_parm_die_table; 3036 3037/* Instances of generic types for which we need to generate debug 3038 info that describe their generic parameters and arguments. That 3039 generation needs to happen once all types are properly laid out so 3040 we do it at the end of compilation. */ 3041static GTY(()) vec<tree, va_gc> *generic_type_instances; 3042 3043/* Offset from the "steady-state frame pointer" to the frame base, 3044 within the current function. */ 3045static HOST_WIDE_INT frame_pointer_fb_offset; 3046static bool frame_pointer_fb_offset_valid; 3047 3048static vec<dw_die_ref> base_types; 3049 3050/* Flags to represent a set of attribute classes for attributes that represent 3051 a scalar value (bounds, pointers, ...). */ 3052enum dw_scalar_form 3053{ 3054 dw_scalar_form_constant = 0x01, 3055 dw_scalar_form_exprloc = 0x02, 3056 dw_scalar_form_reference = 0x04 3057}; 3058 3059/* Forward declarations for functions defined in this file. */ 3060 3061static int is_pseudo_reg (const_rtx); 3062static tree type_main_variant (tree); 3063static int is_tagged_type (const_tree); 3064static const char *dwarf_tag_name (unsigned); 3065static const char *dwarf_attr_name (unsigned); 3066static const char *dwarf_form_name (unsigned); 3067static tree decl_ultimate_origin (const_tree); 3068static tree decl_class_context (tree); 3069static void add_dwarf_attr (dw_die_ref, dw_attr_ref); 3070static inline enum dw_val_class AT_class (dw_attr_ref); 3071static inline unsigned int AT_index (dw_attr_ref); 3072static void add_AT_flag (dw_die_ref, enum dwarf_attribute, unsigned); 3073static inline unsigned AT_flag (dw_attr_ref); 3074static void add_AT_int (dw_die_ref, enum dwarf_attribute, HOST_WIDE_INT); 3075static inline HOST_WIDE_INT AT_int (dw_attr_ref); 3076static void add_AT_unsigned (dw_die_ref, enum dwarf_attribute, unsigned HOST_WIDE_INT); 3077static inline unsigned HOST_WIDE_INT AT_unsigned (dw_attr_ref); 3078static void add_AT_double (dw_die_ref, enum dwarf_attribute, 3079 HOST_WIDE_INT, unsigned HOST_WIDE_INT); 3080static inline void add_AT_vec (dw_die_ref, enum dwarf_attribute, unsigned int, 3081 unsigned int, unsigned char *); 3082static void add_AT_data8 (dw_die_ref, enum dwarf_attribute, unsigned char *); 3083static void add_AT_string (dw_die_ref, enum dwarf_attribute, const char *); 3084static inline const char *AT_string (dw_attr_ref); 3085static enum dwarf_form AT_string_form (dw_attr_ref); 3086static void add_AT_die_ref (dw_die_ref, enum dwarf_attribute, dw_die_ref); 3087static void add_AT_specification (dw_die_ref, dw_die_ref); 3088static inline dw_die_ref AT_ref (dw_attr_ref); 3089static inline int AT_ref_external (dw_attr_ref); 3090static inline void set_AT_ref_external (dw_attr_ref, int); 3091static void add_AT_fde_ref (dw_die_ref, enum dwarf_attribute, unsigned); 3092static void add_AT_loc (dw_die_ref, enum dwarf_attribute, dw_loc_descr_ref); 3093static inline dw_loc_descr_ref AT_loc (dw_attr_ref); 3094static void add_AT_loc_list (dw_die_ref, enum dwarf_attribute, 3095 dw_loc_list_ref); 3096static inline dw_loc_list_ref AT_loc_list (dw_attr_ref); 3097static addr_table_entry *add_addr_table_entry (void *, enum ate_kind); 3098static void remove_addr_table_entry (addr_table_entry *); 3099static void add_AT_addr (dw_die_ref, enum dwarf_attribute, rtx, bool); 3100static inline rtx AT_addr (dw_attr_ref); 3101static void add_AT_lbl_id (dw_die_ref, enum dwarf_attribute, const char *); 3102static void add_AT_lineptr (dw_die_ref, enum dwarf_attribute, const char *); 3103static void add_AT_macptr (dw_die_ref, enum dwarf_attribute, const char *); 3104static void add_AT_offset (dw_die_ref, enum dwarf_attribute, 3105 unsigned HOST_WIDE_INT); 3106static void add_AT_range_list (dw_die_ref, enum dwarf_attribute, 3107 unsigned long, bool); 3108static inline const char *AT_lbl (dw_attr_ref); 3109static dw_attr_ref get_AT (dw_die_ref, enum dwarf_attribute); 3110static const char *get_AT_low_pc (dw_die_ref); 3111static const char *get_AT_hi_pc (dw_die_ref); 3112static const char *get_AT_string (dw_die_ref, enum dwarf_attribute); 3113static int get_AT_flag (dw_die_ref, enum dwarf_attribute); 3114static unsigned get_AT_unsigned (dw_die_ref, enum dwarf_attribute); 3115static inline dw_die_ref get_AT_ref (dw_die_ref, enum dwarf_attribute); 3116static bool is_cxx (void); 3117static bool is_fortran (void); 3118static bool is_ada (void); 3119static void remove_AT (dw_die_ref, enum dwarf_attribute); 3120static void remove_child_TAG (dw_die_ref, enum dwarf_tag); 3121static void add_child_die (dw_die_ref, dw_die_ref); 3122static dw_die_ref new_die (enum dwarf_tag, dw_die_ref, tree); 3123static dw_die_ref lookup_type_die (tree); 3124static dw_die_ref strip_naming_typedef (tree, dw_die_ref); 3125static dw_die_ref lookup_type_die_strip_naming_typedef (tree); 3126static void equate_type_number_to_die (tree, dw_die_ref); 3127static dw_die_ref lookup_decl_die (tree); 3128static var_loc_list *lookup_decl_loc (const_tree); 3129static void equate_decl_number_to_die (tree, dw_die_ref); 3130static struct var_loc_node *add_var_loc_to_decl (tree, rtx, const char *); 3131static void print_spaces (FILE *); 3132static void print_die (dw_die_ref, FILE *); 3133static dw_die_ref push_new_compile_unit (dw_die_ref, dw_die_ref); 3134static dw_die_ref pop_compile_unit (dw_die_ref); 3135static void loc_checksum (dw_loc_descr_ref, struct md5_ctx *); 3136static void attr_checksum (dw_attr_ref, struct md5_ctx *, int *); 3137static void die_checksum (dw_die_ref, struct md5_ctx *, int *); 3138static void checksum_sleb128 (HOST_WIDE_INT, struct md5_ctx *); 3139static void checksum_uleb128 (unsigned HOST_WIDE_INT, struct md5_ctx *); 3140static void loc_checksum_ordered (dw_loc_descr_ref, struct md5_ctx *); 3141static void attr_checksum_ordered (enum dwarf_tag, dw_attr_ref, 3142 struct md5_ctx *, int *); 3143struct checksum_attributes; 3144static void collect_checksum_attributes (struct checksum_attributes *, dw_die_ref); 3145static void die_checksum_ordered (dw_die_ref, struct md5_ctx *, int *); 3146static void checksum_die_context (dw_die_ref, struct md5_ctx *); 3147static void generate_type_signature (dw_die_ref, comdat_type_node *); 3148static int same_loc_p (dw_loc_descr_ref, dw_loc_descr_ref, int *); 3149static int same_dw_val_p (const dw_val_node *, const dw_val_node *, int *); 3150static int same_attr_p (dw_attr_ref, dw_attr_ref, int *); 3151static int same_die_p (dw_die_ref, dw_die_ref, int *); 3152static int same_die_p_wrap (dw_die_ref, dw_die_ref); 3153static void compute_section_prefix (dw_die_ref); 3154static int is_type_die (dw_die_ref); 3155static int is_comdat_die (dw_die_ref); 3156static int is_symbol_die (dw_die_ref); 3157static inline bool is_template_instantiation (dw_die_ref); 3158static void assign_symbol_names (dw_die_ref); 3159static void break_out_includes (dw_die_ref); 3160static int is_declaration_die (dw_die_ref); 3161static int should_move_die_to_comdat (dw_die_ref); 3162static dw_die_ref clone_as_declaration (dw_die_ref); 3163static dw_die_ref clone_die (dw_die_ref); 3164static dw_die_ref clone_tree (dw_die_ref); 3165static dw_die_ref copy_declaration_context (dw_die_ref, dw_die_ref); 3166static void generate_skeleton_ancestor_tree (skeleton_chain_node *); 3167static void generate_skeleton_bottom_up (skeleton_chain_node *); 3168static dw_die_ref generate_skeleton (dw_die_ref); 3169static dw_die_ref remove_child_or_replace_with_skeleton (dw_die_ref, 3170 dw_die_ref, 3171 dw_die_ref); 3172static void break_out_comdat_types (dw_die_ref); 3173static void copy_decls_for_unworthy_types (dw_die_ref); 3174 3175static void add_sibling_attributes (dw_die_ref); 3176static void output_location_lists (dw_die_ref); 3177static int constant_size (unsigned HOST_WIDE_INT); 3178static unsigned long size_of_die (dw_die_ref); 3179static void calc_die_sizes (dw_die_ref); 3180static void calc_base_type_die_sizes (void); 3181static void mark_dies (dw_die_ref); 3182static void unmark_dies (dw_die_ref); 3183static void unmark_all_dies (dw_die_ref); 3184static unsigned long size_of_pubnames (vec<pubname_entry, va_gc> *); 3185static unsigned long size_of_aranges (void); 3186static enum dwarf_form value_format (dw_attr_ref); 3187static void output_value_format (dw_attr_ref); 3188static void output_abbrev_section (void); 3189static void output_die_abbrevs (unsigned long, dw_die_ref); 3190static void output_die_symbol (dw_die_ref); 3191static void output_die (dw_die_ref); 3192static void output_compilation_unit_header (void); 3193static void output_comp_unit (dw_die_ref, int); 3194static void output_comdat_type_unit (comdat_type_node *); 3195static const char *dwarf2_name (tree, int); 3196static void add_pubname (tree, dw_die_ref); 3197static void add_enumerator_pubname (const char *, dw_die_ref); 3198static void add_pubname_string (const char *, dw_die_ref); 3199static void add_pubtype (tree, dw_die_ref); 3200static void output_pubnames (vec<pubname_entry, va_gc> *); 3201static void output_aranges (unsigned long); 3202static unsigned int add_ranges_num (int); 3203static unsigned int add_ranges (const_tree); 3204static void add_ranges_by_labels (dw_die_ref, const char *, const char *, 3205 bool *, bool); 3206static void output_ranges (void); 3207static dw_line_info_table *new_line_info_table (void); 3208static void output_line_info (bool); 3209static void output_file_names (void); 3210static dw_die_ref base_type_die (tree); 3211static int is_base_type (tree); 3212static dw_die_ref subrange_type_die (tree, tree, tree, dw_die_ref); 3213static int decl_quals (const_tree); 3214static dw_die_ref modified_type_die (tree, int, dw_die_ref); 3215static dw_die_ref generic_parameter_die (tree, tree, bool, dw_die_ref); 3216static dw_die_ref template_parameter_pack_die (tree, tree, dw_die_ref); 3217static int type_is_enum (const_tree); 3218static unsigned int dbx_reg_number (const_rtx); 3219static void add_loc_descr_op_piece (dw_loc_descr_ref *, int); 3220static dw_loc_descr_ref reg_loc_descriptor (rtx, enum var_init_status); 3221static dw_loc_descr_ref one_reg_loc_descriptor (unsigned int, 3222 enum var_init_status); 3223static dw_loc_descr_ref multiple_reg_loc_descriptor (rtx, rtx, 3224 enum var_init_status); 3225static dw_loc_descr_ref based_loc_descr (rtx, HOST_WIDE_INT, 3226 enum var_init_status); 3227static int is_based_loc (const_rtx); 3228static bool resolve_one_addr (rtx *); 3229static dw_loc_descr_ref concat_loc_descriptor (rtx, rtx, 3230 enum var_init_status); 3231static dw_loc_descr_ref loc_descriptor (rtx, machine_mode mode, 3232 enum var_init_status); 3233struct loc_descr_context; 3234static dw_loc_list_ref loc_list_from_tree (tree, int, 3235 const struct loc_descr_context *); 3236static dw_loc_descr_ref loc_descriptor_from_tree (tree, int, 3237 const struct loc_descr_context *); 3238static HOST_WIDE_INT ceiling (HOST_WIDE_INT, unsigned int); 3239static tree field_type (const_tree); 3240static unsigned int simple_type_align_in_bits (const_tree); 3241static unsigned int simple_decl_align_in_bits (const_tree); 3242static unsigned HOST_WIDE_INT simple_type_size_in_bits (const_tree); 3243static HOST_WIDE_INT field_byte_offset (const_tree); 3244static void add_AT_location_description (dw_die_ref, enum dwarf_attribute, 3245 dw_loc_list_ref); 3246static void add_data_member_location_attribute (dw_die_ref, tree); 3247static bool add_const_value_attribute (dw_die_ref, rtx); 3248static void insert_int (HOST_WIDE_INT, unsigned, unsigned char *); 3249static void insert_wide_int (const wide_int &, unsigned char *, int); 3250static void insert_float (const_rtx, unsigned char *); 3251static rtx rtl_for_decl_location (tree); 3252static bool add_location_or_const_value_attribute (dw_die_ref, tree, bool, 3253 enum dwarf_attribute); 3254static bool tree_add_const_value_attribute (dw_die_ref, tree); 3255static bool tree_add_const_value_attribute_for_decl (dw_die_ref, tree); 3256static void add_name_attribute (dw_die_ref, const char *); 3257static void add_gnat_descriptive_type_attribute (dw_die_ref, tree, dw_die_ref); 3258static void add_comp_dir_attribute (dw_die_ref); 3259static void add_scalar_info (dw_die_ref, enum dwarf_attribute, tree, int, 3260 const struct loc_descr_context *); 3261static void add_bound_info (dw_die_ref, enum dwarf_attribute, tree, 3262 const struct loc_descr_context *); 3263static void add_subscript_info (dw_die_ref, tree, bool); 3264static void add_byte_size_attribute (dw_die_ref, tree); 3265static void add_bit_offset_attribute (dw_die_ref, tree); 3266static void add_bit_size_attribute (dw_die_ref, tree); 3267static void add_prototyped_attribute (dw_die_ref, tree); 3268static dw_die_ref add_abstract_origin_attribute (dw_die_ref, tree); 3269static void add_pure_or_virtual_attribute (dw_die_ref, tree); 3270static void add_src_coords_attributes (dw_die_ref, tree); 3271static void add_name_and_src_coords_attributes (dw_die_ref, tree); 3272static void push_decl_scope (tree); 3273static void pop_decl_scope (void); 3274static dw_die_ref scope_die_for (tree, dw_die_ref); 3275static inline int local_scope_p (dw_die_ref); 3276static inline int class_scope_p (dw_die_ref); 3277static inline int class_or_namespace_scope_p (dw_die_ref); 3278static void add_type_attribute (dw_die_ref, tree, int, dw_die_ref); 3279static void add_calling_convention_attribute (dw_die_ref, tree); 3280static const char *type_tag (const_tree); 3281static tree member_declared_type (const_tree); 3282#if 0 3283static const char *decl_start_label (tree); 3284#endif 3285static void gen_array_type_die (tree, dw_die_ref); 3286static void gen_descr_array_type_die (tree, struct array_descr_info *, dw_die_ref); 3287#if 0 3288static void gen_entry_point_die (tree, dw_die_ref); 3289#endif 3290static dw_die_ref gen_enumeration_type_die (tree, dw_die_ref); 3291static dw_die_ref gen_formal_parameter_die (tree, tree, bool, dw_die_ref); 3292static dw_die_ref gen_formal_parameter_pack_die (tree, tree, dw_die_ref, tree*); 3293static void gen_unspecified_parameters_die (tree, dw_die_ref); 3294static void gen_formal_types_die (tree, dw_die_ref); 3295static void gen_subprogram_die (tree, dw_die_ref); 3296static void gen_variable_die (tree, tree, dw_die_ref); 3297static void gen_const_die (tree, dw_die_ref); 3298static void gen_label_die (tree, dw_die_ref); 3299static void gen_lexical_block_die (tree, dw_die_ref); 3300static void gen_inlined_subroutine_die (tree, dw_die_ref); 3301static void gen_field_die (tree, dw_die_ref); 3302static void gen_ptr_to_mbr_type_die (tree, dw_die_ref); 3303static dw_die_ref gen_compile_unit_die (const char *); 3304static void gen_inheritance_die (tree, tree, dw_die_ref); 3305static void gen_member_die (tree, dw_die_ref); 3306static void gen_struct_or_union_type_die (tree, dw_die_ref, 3307 enum debug_info_usage); 3308static void gen_subroutine_type_die (tree, dw_die_ref); 3309static void gen_typedef_die (tree, dw_die_ref); 3310static void gen_type_die (tree, dw_die_ref); 3311static void gen_block_die (tree, dw_die_ref); 3312static void decls_for_scope (tree, dw_die_ref); 3313static inline int is_redundant_typedef (const_tree); 3314static bool is_naming_typedef_decl (const_tree); 3315static inline dw_die_ref get_context_die (tree); 3316static void gen_namespace_die (tree, dw_die_ref); 3317static dw_die_ref gen_namelist_decl (tree, dw_die_ref, tree); 3318static dw_die_ref gen_decl_die (tree, tree, dw_die_ref); 3319static dw_die_ref force_decl_die (tree); 3320static dw_die_ref force_type_die (tree); 3321static dw_die_ref setup_namespace_context (tree, dw_die_ref); 3322static dw_die_ref declare_in_namespace (tree, dw_die_ref); 3323static struct dwarf_file_data * lookup_filename (const char *); 3324static void retry_incomplete_types (void); 3325static void gen_type_die_for_member (tree, tree, dw_die_ref); 3326static void gen_generic_params_dies (tree); 3327static void gen_tagged_type_die (tree, dw_die_ref, enum debug_info_usage); 3328static void gen_type_die_with_usage (tree, dw_die_ref, enum debug_info_usage); 3329static void splice_child_die (dw_die_ref, dw_die_ref); 3330static int file_info_cmp (const void *, const void *); 3331static dw_loc_list_ref new_loc_list (dw_loc_descr_ref, const char *, 3332 const char *, const char *); 3333static void output_loc_list (dw_loc_list_ref); 3334static char *gen_internal_sym (const char *); 3335static bool want_pubnames (void); 3336 3337static void prune_unmark_dies (dw_die_ref); 3338static void prune_unused_types_mark_generic_parms_dies (dw_die_ref); 3339static void prune_unused_types_mark (dw_die_ref, int); 3340static void prune_unused_types_walk (dw_die_ref); 3341static void prune_unused_types_walk_attribs (dw_die_ref); 3342static void prune_unused_types_prune (dw_die_ref); 3343static void prune_unused_types (void); 3344static int maybe_emit_file (struct dwarf_file_data *fd); 3345static inline const char *AT_vms_delta1 (dw_attr_ref); 3346static inline const char *AT_vms_delta2 (dw_attr_ref); 3347static inline void add_AT_vms_delta (dw_die_ref, enum dwarf_attribute, 3348 const char *, const char *); 3349static void append_entry_to_tmpl_value_parm_die_table (dw_die_ref, tree); 3350static void gen_remaining_tmpl_value_param_die_attribute (void); 3351static bool generic_type_p (tree); 3352static void schedule_generic_params_dies_gen (tree t); 3353static void gen_scheduled_generic_parms_dies (void); 3354 3355static const char *comp_dir_string (void); 3356 3357static void hash_loc_operands (dw_loc_descr_ref, inchash::hash &); 3358 3359/* enum for tracking thread-local variables whose address is really an offset 3360 relative to the TLS pointer, which will need link-time relocation, but will 3361 not need relocation by the DWARF consumer. */ 3362 3363enum dtprel_bool 3364{ 3365 dtprel_false = 0, 3366 dtprel_true = 1 3367}; 3368 3369/* Return the operator to use for an address of a variable. For dtprel_true, we 3370 use DW_OP_const*. For regular variables, which need both link-time 3371 relocation and consumer-level relocation (e.g., to account for shared objects 3372 loaded at a random address), we use DW_OP_addr*. */ 3373 3374static inline enum dwarf_location_atom 3375dw_addr_op (enum dtprel_bool dtprel) 3376{ 3377 if (dtprel == dtprel_true) 3378 return (dwarf_split_debug_info ? DW_OP_GNU_const_index 3379 : (DWARF2_ADDR_SIZE == 4 ? DW_OP_const4u : DW_OP_const8u)); 3380 else 3381 return dwarf_split_debug_info ? DW_OP_GNU_addr_index : DW_OP_addr; 3382} 3383 3384/* Return a pointer to a newly allocated address location description. If 3385 dwarf_split_debug_info is true, then record the address with the appropriate 3386 relocation. */ 3387static inline dw_loc_descr_ref 3388new_addr_loc_descr (rtx addr, enum dtprel_bool dtprel) 3389{ 3390 dw_loc_descr_ref ref = new_loc_descr (dw_addr_op (dtprel), 0, 0); 3391 3392 ref->dw_loc_oprnd1.val_class = dw_val_class_addr; 3393 ref->dw_loc_oprnd1.v.val_addr = addr; 3394 ref->dtprel = dtprel; 3395 if (dwarf_split_debug_info) 3396 ref->dw_loc_oprnd1.val_entry 3397 = add_addr_table_entry (addr, 3398 dtprel ? ate_kind_rtx_dtprel : ate_kind_rtx); 3399 else 3400 ref->dw_loc_oprnd1.val_entry = NULL; 3401 3402 return ref; 3403} 3404 3405/* Section names used to hold DWARF debugging information. */ 3406 3407#ifndef DEBUG_INFO_SECTION 3408#define DEBUG_INFO_SECTION ".debug_info" 3409#endif 3410#ifndef DEBUG_DWO_INFO_SECTION 3411#define DEBUG_DWO_INFO_SECTION ".debug_info.dwo" 3412#endif 3413#ifndef DEBUG_ABBREV_SECTION 3414#define DEBUG_ABBREV_SECTION ".debug_abbrev" 3415#endif 3416#ifndef DEBUG_DWO_ABBREV_SECTION 3417#define DEBUG_DWO_ABBREV_SECTION ".debug_abbrev.dwo" 3418#endif 3419#ifndef DEBUG_ARANGES_SECTION 3420#define DEBUG_ARANGES_SECTION ".debug_aranges" 3421#endif 3422#ifndef DEBUG_ADDR_SECTION 3423#define DEBUG_ADDR_SECTION ".debug_addr" 3424#endif 3425#ifndef DEBUG_NORM_MACINFO_SECTION 3426#define DEBUG_NORM_MACINFO_SECTION ".debug_macinfo" 3427#endif 3428#ifndef DEBUG_DWO_MACINFO_SECTION 3429#define DEBUG_DWO_MACINFO_SECTION ".debug_macinfo.dwo" 3430#endif 3431#ifndef DEBUG_MACINFO_SECTION 3432#define DEBUG_MACINFO_SECTION \ 3433 (!dwarf_split_debug_info \ 3434 ? (DEBUG_NORM_MACINFO_SECTION) : (DEBUG_DWO_MACINFO_SECTION)) 3435#endif 3436#ifndef DEBUG_NORM_MACRO_SECTION 3437#define DEBUG_NORM_MACRO_SECTION ".debug_macro" 3438#endif 3439#ifndef DEBUG_DWO_MACRO_SECTION 3440#define DEBUG_DWO_MACRO_SECTION ".debug_macro.dwo" 3441#endif 3442#ifndef DEBUG_MACRO_SECTION 3443#define DEBUG_MACRO_SECTION \ 3444 (!dwarf_split_debug_info \ 3445 ? (DEBUG_NORM_MACRO_SECTION) : (DEBUG_DWO_MACRO_SECTION)) 3446#endif 3447#ifndef DEBUG_LINE_SECTION 3448#define DEBUG_LINE_SECTION ".debug_line" 3449#endif 3450#ifndef DEBUG_DWO_LINE_SECTION 3451#define DEBUG_DWO_LINE_SECTION ".debug_line.dwo" 3452#endif 3453#ifndef DEBUG_LOC_SECTION 3454#define DEBUG_LOC_SECTION ".debug_loc" 3455#endif 3456#ifndef DEBUG_DWO_LOC_SECTION 3457#define DEBUG_DWO_LOC_SECTION ".debug_loc.dwo" 3458#endif 3459#ifndef DEBUG_PUBNAMES_SECTION 3460#define DEBUG_PUBNAMES_SECTION \ 3461 ((debug_generate_pub_sections == 2) \ 3462 ? ".debug_gnu_pubnames" : ".debug_pubnames") 3463#endif 3464#ifndef DEBUG_PUBTYPES_SECTION 3465#define DEBUG_PUBTYPES_SECTION \ 3466 ((debug_generate_pub_sections == 2) \ 3467 ? ".debug_gnu_pubtypes" : ".debug_pubtypes") 3468#endif 3469#define DEBUG_NORM_STR_OFFSETS_SECTION ".debug_str_offsets" 3470#define DEBUG_DWO_STR_OFFSETS_SECTION ".debug_str_offsets.dwo" 3471#ifndef DEBUG_STR_OFFSETS_SECTION 3472#define DEBUG_STR_OFFSETS_SECTION \ 3473 (!dwarf_split_debug_info \ 3474 ? (DEBUG_NORM_STR_OFFSETS_SECTION) : (DEBUG_DWO_STR_OFFSETS_SECTION)) 3475#endif 3476#ifndef DEBUG_STR_DWO_SECTION 3477#define DEBUG_STR_DWO_SECTION ".debug_str.dwo" 3478#endif 3479#ifndef DEBUG_STR_SECTION 3480#define DEBUG_STR_SECTION ".debug_str" 3481#endif 3482#ifndef DEBUG_RANGES_SECTION 3483#define DEBUG_RANGES_SECTION ".debug_ranges" 3484#endif 3485 3486/* Standard ELF section names for compiled code and data. */ 3487#ifndef TEXT_SECTION_NAME 3488#define TEXT_SECTION_NAME ".text" 3489#endif 3490 3491/* Section flags for .debug_macinfo/.debug_macro section. */ 3492#define DEBUG_MACRO_SECTION_FLAGS \ 3493 (dwarf_split_debug_info ? SECTION_DEBUG | SECTION_EXCLUDE : SECTION_DEBUG) 3494 3495/* Section flags for .debug_str section. */ 3496#define DEBUG_STR_SECTION_FLAGS \ 3497 (HAVE_GAS_SHF_MERGE && flag_merge_debug_strings \ 3498 ? SECTION_DEBUG | SECTION_MERGE | SECTION_STRINGS | 1 \ 3499 : SECTION_DEBUG) 3500 3501/* Section flags for .debug_str.dwo section. */ 3502#define DEBUG_STR_DWO_SECTION_FLAGS (SECTION_DEBUG | SECTION_EXCLUDE) 3503 3504/* Labels we insert at beginning sections we can reference instead of 3505 the section names themselves. */ 3506 3507#ifndef TEXT_SECTION_LABEL 3508#define TEXT_SECTION_LABEL "Ltext" 3509#endif 3510#ifndef COLD_TEXT_SECTION_LABEL 3511#define COLD_TEXT_SECTION_LABEL "Ltext_cold" 3512#endif 3513#ifndef DEBUG_LINE_SECTION_LABEL 3514#define DEBUG_LINE_SECTION_LABEL "Ldebug_line" 3515#endif 3516#ifndef DEBUG_SKELETON_LINE_SECTION_LABEL 3517#define DEBUG_SKELETON_LINE_SECTION_LABEL "Lskeleton_debug_line" 3518#endif 3519#ifndef DEBUG_INFO_SECTION_LABEL 3520#define DEBUG_INFO_SECTION_LABEL "Ldebug_info" 3521#endif 3522#ifndef DEBUG_SKELETON_INFO_SECTION_LABEL 3523#define DEBUG_SKELETON_INFO_SECTION_LABEL "Lskeleton_debug_info" 3524#endif 3525#ifndef DEBUG_ABBREV_SECTION_LABEL 3526#define DEBUG_ABBREV_SECTION_LABEL "Ldebug_abbrev" 3527#endif 3528#ifndef DEBUG_SKELETON_ABBREV_SECTION_LABEL 3529#define DEBUG_SKELETON_ABBREV_SECTION_LABEL "Lskeleton_debug_abbrev" 3530#endif 3531#ifndef DEBUG_ADDR_SECTION_LABEL 3532#define DEBUG_ADDR_SECTION_LABEL "Ldebug_addr" 3533#endif 3534#ifndef DEBUG_LOC_SECTION_LABEL 3535#define DEBUG_LOC_SECTION_LABEL "Ldebug_loc" 3536#endif 3537#ifndef DEBUG_RANGES_SECTION_LABEL 3538#define DEBUG_RANGES_SECTION_LABEL "Ldebug_ranges" 3539#endif 3540#ifndef DEBUG_MACINFO_SECTION_LABEL 3541#define DEBUG_MACINFO_SECTION_LABEL "Ldebug_macinfo" 3542#endif 3543#ifndef DEBUG_MACRO_SECTION_LABEL 3544#define DEBUG_MACRO_SECTION_LABEL "Ldebug_macro" 3545#endif 3546#define SKELETON_COMP_DIE_ABBREV 1 3547#define SKELETON_TYPE_DIE_ABBREV 2 3548 3549/* Definitions of defaults for formats and names of various special 3550 (artificial) labels which may be generated within this file (when the -g 3551 options is used and DWARF2_DEBUGGING_INFO is in effect. 3552 If necessary, these may be overridden from within the tm.h file, but 3553 typically, overriding these defaults is unnecessary. */ 3554 3555static char text_end_label[MAX_ARTIFICIAL_LABEL_BYTES]; 3556static char text_section_label[MAX_ARTIFICIAL_LABEL_BYTES]; 3557static char cold_text_section_label[MAX_ARTIFICIAL_LABEL_BYTES]; 3558static char cold_end_label[MAX_ARTIFICIAL_LABEL_BYTES]; 3559static char abbrev_section_label[MAX_ARTIFICIAL_LABEL_BYTES]; 3560static char debug_info_section_label[MAX_ARTIFICIAL_LABEL_BYTES]; 3561static char debug_skeleton_info_section_label[MAX_ARTIFICIAL_LABEL_BYTES]; 3562static char debug_skeleton_abbrev_section_label[MAX_ARTIFICIAL_LABEL_BYTES]; 3563static char debug_line_section_label[MAX_ARTIFICIAL_LABEL_BYTES]; 3564static char debug_addr_section_label[MAX_ARTIFICIAL_LABEL_BYTES]; 3565static char debug_skeleton_line_section_label[MAX_ARTIFICIAL_LABEL_BYTES]; 3566static char macinfo_section_label[MAX_ARTIFICIAL_LABEL_BYTES]; 3567static char loc_section_label[MAX_ARTIFICIAL_LABEL_BYTES]; 3568static char ranges_section_label[2 * MAX_ARTIFICIAL_LABEL_BYTES]; 3569 3570#ifndef TEXT_END_LABEL 3571#define TEXT_END_LABEL "Letext" 3572#endif 3573#ifndef COLD_END_LABEL 3574#define COLD_END_LABEL "Letext_cold" 3575#endif 3576#ifndef BLOCK_BEGIN_LABEL 3577#define BLOCK_BEGIN_LABEL "LBB" 3578#endif 3579#ifndef BLOCK_END_LABEL 3580#define BLOCK_END_LABEL "LBE" 3581#endif 3582#ifndef LINE_CODE_LABEL 3583#define LINE_CODE_LABEL "LM" 3584#endif 3585 3586 3587/* Return the root of the DIE's built for the current compilation unit. */ 3588static dw_die_ref 3589comp_unit_die (void) 3590{ 3591 if (!single_comp_unit_die) 3592 single_comp_unit_die = gen_compile_unit_die (NULL); 3593 return single_comp_unit_die; 3594} 3595 3596/* We allow a language front-end to designate a function that is to be 3597 called to "demangle" any name before it is put into a DIE. */ 3598 3599static const char *(*demangle_name_func) (const char *); 3600 3601void 3602dwarf2out_set_demangle_name_func (const char *(*func) (const char *)) 3603{ 3604 demangle_name_func = func; 3605} 3606 3607/* Test if rtl node points to a pseudo register. */ 3608 3609static inline int 3610is_pseudo_reg (const_rtx rtl) 3611{ 3612 return ((REG_P (rtl) && REGNO (rtl) >= FIRST_PSEUDO_REGISTER) 3613 || (GET_CODE (rtl) == SUBREG 3614 && REGNO (SUBREG_REG (rtl)) >= FIRST_PSEUDO_REGISTER)); 3615} 3616 3617/* Return a reference to a type, with its const and volatile qualifiers 3618 removed. */ 3619 3620static inline tree 3621type_main_variant (tree type) 3622{ 3623 type = TYPE_MAIN_VARIANT (type); 3624 3625 /* ??? There really should be only one main variant among any group of 3626 variants of a given type (and all of the MAIN_VARIANT values for all 3627 members of the group should point to that one type) but sometimes the C 3628 front-end messes this up for array types, so we work around that bug 3629 here. */ 3630 if (TREE_CODE (type) == ARRAY_TYPE) 3631 while (type != TYPE_MAIN_VARIANT (type)) 3632 type = TYPE_MAIN_VARIANT (type); 3633 3634 return type; 3635} 3636 3637/* Return nonzero if the given type node represents a tagged type. */ 3638 3639static inline int 3640is_tagged_type (const_tree type) 3641{ 3642 enum tree_code code = TREE_CODE (type); 3643 3644 return (code == RECORD_TYPE || code == UNION_TYPE 3645 || code == QUAL_UNION_TYPE || code == ENUMERAL_TYPE); 3646} 3647 3648/* Set label to debug_info_section_label + die_offset of a DIE reference. */ 3649 3650static void 3651get_ref_die_offset_label (char *label, dw_die_ref ref) 3652{ 3653 sprintf (label, "%s+%ld", debug_info_section_label, ref->die_offset); 3654} 3655 3656/* Return die_offset of a DIE reference to a base type. */ 3657 3658static unsigned long int 3659get_base_type_offset (dw_die_ref ref) 3660{ 3661 if (ref->die_offset) 3662 return ref->die_offset; 3663 if (comp_unit_die ()->die_abbrev) 3664 { 3665 calc_base_type_die_sizes (); 3666 gcc_assert (ref->die_offset); 3667 } 3668 return ref->die_offset; 3669} 3670 3671/* Return die_offset of a DIE reference other than base type. */ 3672 3673static unsigned long int 3674get_ref_die_offset (dw_die_ref ref) 3675{ 3676 gcc_assert (ref->die_offset); 3677 return ref->die_offset; 3678} 3679 3680/* Convert a DIE tag into its string name. */ 3681 3682static const char * 3683dwarf_tag_name (unsigned int tag) 3684{ 3685 const char *name = get_DW_TAG_name (tag); 3686 3687 if (name != NULL) 3688 return name; 3689 3690 return "DW_TAG_<unknown>"; 3691} 3692 3693/* Convert a DWARF attribute code into its string name. */ 3694 3695static const char * 3696dwarf_attr_name (unsigned int attr) 3697{ 3698 const char *name; 3699 3700 switch (attr) 3701 { 3702#if VMS_DEBUGGING_INFO 3703 case DW_AT_HP_prologue: 3704 return "DW_AT_HP_prologue"; 3705#else 3706 case DW_AT_MIPS_loop_unroll_factor: 3707 return "DW_AT_MIPS_loop_unroll_factor"; 3708#endif 3709 3710#if VMS_DEBUGGING_INFO 3711 case DW_AT_HP_epilogue: 3712 return "DW_AT_HP_epilogue"; 3713#else 3714 case DW_AT_MIPS_stride: 3715 return "DW_AT_MIPS_stride"; 3716#endif 3717 } 3718 3719 name = get_DW_AT_name (attr); 3720 3721 if (name != NULL) 3722 return name; 3723 3724 return "DW_AT_<unknown>"; 3725} 3726 3727/* Convert a DWARF value form code into its string name. */ 3728 3729static const char * 3730dwarf_form_name (unsigned int form) 3731{ 3732 const char *name = get_DW_FORM_name (form); 3733 3734 if (name != NULL) 3735 return name; 3736 3737 return "DW_FORM_<unknown>"; 3738} 3739 3740/* Determine the "ultimate origin" of a decl. The decl may be an inlined 3741 instance of an inlined instance of a decl which is local to an inline 3742 function, so we have to trace all of the way back through the origin chain 3743 to find out what sort of node actually served as the original seed for the 3744 given block. */ 3745 3746static tree 3747decl_ultimate_origin (const_tree decl) 3748{ 3749 if (!CODE_CONTAINS_STRUCT (TREE_CODE (decl), TS_DECL_COMMON)) 3750 return NULL_TREE; 3751 3752 /* DECL_ABSTRACT_ORIGIN can point to itself; ignore that if 3753 we're trying to output the abstract instance of this function. */ 3754 if (DECL_ABSTRACT_P (decl) && DECL_ABSTRACT_ORIGIN (decl) == decl) 3755 return NULL_TREE; 3756 3757 /* Since the DECL_ABSTRACT_ORIGIN for a DECL is supposed to be the 3758 most distant ancestor, this should never happen. */ 3759 gcc_assert (!DECL_FROM_INLINE (DECL_ORIGIN (decl))); 3760 3761 return DECL_ABSTRACT_ORIGIN (decl); 3762} 3763 3764/* Get the class to which DECL belongs, if any. In g++, the DECL_CONTEXT 3765 of a virtual function may refer to a base class, so we check the 'this' 3766 parameter. */ 3767 3768static tree 3769decl_class_context (tree decl) 3770{ 3771 tree context = NULL_TREE; 3772 3773 if (TREE_CODE (decl) != FUNCTION_DECL || ! DECL_VINDEX (decl)) 3774 context = DECL_CONTEXT (decl); 3775 else 3776 context = TYPE_MAIN_VARIANT 3777 (TREE_TYPE (TREE_VALUE (TYPE_ARG_TYPES (TREE_TYPE (decl))))); 3778 3779 if (context && !TYPE_P (context)) 3780 context = NULL_TREE; 3781 3782 return context; 3783} 3784 3785/* Add an attribute/value pair to a DIE. */ 3786 3787static inline void 3788add_dwarf_attr (dw_die_ref die, dw_attr_ref attr) 3789{ 3790 /* Maybe this should be an assert? */ 3791 if (die == NULL) 3792 return; 3793 3794 vec_safe_reserve (die->die_attr, 1); 3795 vec_safe_push (die->die_attr, *attr); 3796} 3797 3798static inline enum dw_val_class 3799AT_class (dw_attr_ref a) 3800{ 3801 return a->dw_attr_val.val_class; 3802} 3803 3804/* Return the index for any attribute that will be referenced with a 3805 DW_FORM_GNU_addr_index or DW_FORM_GNU_str_index. String indices 3806 are stored in dw_attr_val.v.val_str for reference counting 3807 pruning. */ 3808 3809static inline unsigned int 3810AT_index (dw_attr_ref a) 3811{ 3812 if (AT_class (a) == dw_val_class_str) 3813 return a->dw_attr_val.v.val_str->index; 3814 else if (a->dw_attr_val.val_entry != NULL) 3815 return a->dw_attr_val.val_entry->index; 3816 return NOT_INDEXED; 3817} 3818 3819/* Add a flag value attribute to a DIE. */ 3820 3821static inline void 3822add_AT_flag (dw_die_ref die, enum dwarf_attribute attr_kind, unsigned int flag) 3823{ 3824 dw_attr_node attr; 3825 3826 attr.dw_attr = attr_kind; 3827 attr.dw_attr_val.val_class = dw_val_class_flag; 3828 attr.dw_attr_val.val_entry = NULL; 3829 attr.dw_attr_val.v.val_flag = flag; 3830 add_dwarf_attr (die, &attr); 3831} 3832 3833static inline unsigned 3834AT_flag (dw_attr_ref a) 3835{ 3836 gcc_assert (a && AT_class (a) == dw_val_class_flag); 3837 return a->dw_attr_val.v.val_flag; 3838} 3839 3840/* Add a signed integer attribute value to a DIE. */ 3841 3842static inline void 3843add_AT_int (dw_die_ref die, enum dwarf_attribute attr_kind, HOST_WIDE_INT int_val) 3844{ 3845 dw_attr_node attr; 3846 3847 attr.dw_attr = attr_kind; 3848 attr.dw_attr_val.val_class = dw_val_class_const; 3849 attr.dw_attr_val.val_entry = NULL; 3850 attr.dw_attr_val.v.val_int = int_val; 3851 add_dwarf_attr (die, &attr); 3852} 3853 3854static inline HOST_WIDE_INT 3855AT_int (dw_attr_ref a) 3856{ 3857 gcc_assert (a && AT_class (a) == dw_val_class_const); 3858 return a->dw_attr_val.v.val_int; 3859} 3860 3861/* Add an unsigned integer attribute value to a DIE. */ 3862 3863static inline void 3864add_AT_unsigned (dw_die_ref die, enum dwarf_attribute attr_kind, 3865 unsigned HOST_WIDE_INT unsigned_val) 3866{ 3867 dw_attr_node attr; 3868 3869 attr.dw_attr = attr_kind; 3870 attr.dw_attr_val.val_class = dw_val_class_unsigned_const; 3871 attr.dw_attr_val.val_entry = NULL; 3872 attr.dw_attr_val.v.val_unsigned = unsigned_val; 3873 add_dwarf_attr (die, &attr); 3874} 3875 3876static inline unsigned HOST_WIDE_INT 3877AT_unsigned (dw_attr_ref a) 3878{ 3879 gcc_assert (a && AT_class (a) == dw_val_class_unsigned_const); 3880 return a->dw_attr_val.v.val_unsigned; 3881} 3882 3883/* Add an unsigned wide integer attribute value to a DIE. */ 3884 3885static inline void 3886add_AT_wide (dw_die_ref die, enum dwarf_attribute attr_kind, 3887 const wide_int& w) 3888{ 3889 dw_attr_node attr; 3890 3891 attr.dw_attr = attr_kind; 3892 attr.dw_attr_val.val_class = dw_val_class_wide_int; 3893 attr.dw_attr_val.val_entry = NULL; 3894 attr.dw_attr_val.v.val_wide = ggc_alloc<wide_int> (); 3895 *attr.dw_attr_val.v.val_wide = w; 3896 add_dwarf_attr (die, &attr); 3897} 3898 3899/* Add an unsigned double integer attribute value to a DIE. */ 3900 3901static inline void 3902add_AT_double (dw_die_ref die, enum dwarf_attribute attr_kind, 3903 HOST_WIDE_INT high, unsigned HOST_WIDE_INT low) 3904{ 3905 dw_attr_node attr; 3906 3907 attr.dw_attr = attr_kind; 3908 attr.dw_attr_val.val_class = dw_val_class_const_double; 3909 attr.dw_attr_val.val_entry = NULL; 3910 attr.dw_attr_val.v.val_double.high = high; 3911 attr.dw_attr_val.v.val_double.low = low; 3912 add_dwarf_attr (die, &attr); 3913} 3914 3915/* Add a floating point attribute value to a DIE and return it. */ 3916 3917static inline void 3918add_AT_vec (dw_die_ref die, enum dwarf_attribute attr_kind, 3919 unsigned int length, unsigned int elt_size, unsigned char *array) 3920{ 3921 dw_attr_node attr; 3922 3923 attr.dw_attr = attr_kind; 3924 attr.dw_attr_val.val_class = dw_val_class_vec; 3925 attr.dw_attr_val.val_entry = NULL; 3926 attr.dw_attr_val.v.val_vec.length = length; 3927 attr.dw_attr_val.v.val_vec.elt_size = elt_size; 3928 attr.dw_attr_val.v.val_vec.array = array; 3929 add_dwarf_attr (die, &attr); 3930} 3931 3932/* Add an 8-byte data attribute value to a DIE. */ 3933 3934static inline void 3935add_AT_data8 (dw_die_ref die, enum dwarf_attribute attr_kind, 3936 unsigned char data8[8]) 3937{ 3938 dw_attr_node attr; 3939 3940 attr.dw_attr = attr_kind; 3941 attr.dw_attr_val.val_class = dw_val_class_data8; 3942 attr.dw_attr_val.val_entry = NULL; 3943 memcpy (attr.dw_attr_val.v.val_data8, data8, 8); 3944 add_dwarf_attr (die, &attr); 3945} 3946 3947/* Add DW_AT_low_pc and DW_AT_high_pc to a DIE. When using 3948 dwarf_split_debug_info, address attributes in dies destined for the 3949 final executable have force_direct set to avoid using indexed 3950 references. */ 3951 3952static inline void 3953add_AT_low_high_pc (dw_die_ref die, const char *lbl_low, const char *lbl_high, 3954 bool force_direct) 3955{ 3956 dw_attr_node attr; 3957 char * lbl_id; 3958 3959 lbl_id = xstrdup (lbl_low); 3960 attr.dw_attr = DW_AT_low_pc; 3961 attr.dw_attr_val.val_class = dw_val_class_lbl_id; 3962 attr.dw_attr_val.v.val_lbl_id = lbl_id; 3963 if (dwarf_split_debug_info && !force_direct) 3964 attr.dw_attr_val.val_entry 3965 = add_addr_table_entry (lbl_id, ate_kind_label); 3966 else 3967 attr.dw_attr_val.val_entry = NULL; 3968 add_dwarf_attr (die, &attr); 3969 3970 attr.dw_attr = DW_AT_high_pc; 3971 if (dwarf_version < 4) 3972 attr.dw_attr_val.val_class = dw_val_class_lbl_id; 3973 else 3974 attr.dw_attr_val.val_class = dw_val_class_high_pc; 3975 lbl_id = xstrdup (lbl_high); 3976 attr.dw_attr_val.v.val_lbl_id = lbl_id; 3977 if (attr.dw_attr_val.val_class == dw_val_class_lbl_id 3978 && dwarf_split_debug_info && !force_direct) 3979 attr.dw_attr_val.val_entry 3980 = add_addr_table_entry (lbl_id, ate_kind_label); 3981 else 3982 attr.dw_attr_val.val_entry = NULL; 3983 add_dwarf_attr (die, &attr); 3984} 3985 3986/* Hash and equality functions for debug_str_hash. */ 3987 3988hashval_t 3989indirect_string_hasher::hash (indirect_string_node *x) 3990{ 3991 return htab_hash_string (x->str); 3992} 3993 3994bool 3995indirect_string_hasher::equal (indirect_string_node *x1, const char *x2) 3996{ 3997 return strcmp (x1->str, x2) == 0; 3998} 3999 4000/* Add STR to the given string hash table. */ 4001 4002static struct indirect_string_node * 4003find_AT_string_in_table (const char *str, 4004 hash_table<indirect_string_hasher> *table) 4005{ 4006 struct indirect_string_node *node; 4007 4008 indirect_string_node **slot 4009 = table->find_slot_with_hash (str, htab_hash_string (str), INSERT); 4010 if (*slot == NULL) 4011 { 4012 node = ggc_cleared_alloc<indirect_string_node> (); 4013 node->str = ggc_strdup (str); 4014 *slot = node; 4015 } 4016 else 4017 node = *slot; 4018 4019 node->refcount++; 4020 return node; 4021} 4022 4023/* Add STR to the indirect string hash table. */ 4024 4025static struct indirect_string_node * 4026find_AT_string (const char *str) 4027{ 4028 if (! debug_str_hash) 4029 debug_str_hash = hash_table<indirect_string_hasher>::create_ggc (10); 4030 4031 return find_AT_string_in_table (str, debug_str_hash); 4032} 4033 4034/* Add a string attribute value to a DIE. */ 4035 4036static inline void 4037add_AT_string (dw_die_ref die, enum dwarf_attribute attr_kind, const char *str) 4038{ 4039 dw_attr_node attr; 4040 struct indirect_string_node *node; 4041 4042 node = find_AT_string (str); 4043 4044 attr.dw_attr = attr_kind; 4045 attr.dw_attr_val.val_class = dw_val_class_str; 4046 attr.dw_attr_val.val_entry = NULL; 4047 attr.dw_attr_val.v.val_str = node; 4048 add_dwarf_attr (die, &attr); 4049} 4050 4051static inline const char * 4052AT_string (dw_attr_ref a) 4053{ 4054 gcc_assert (a && AT_class (a) == dw_val_class_str); 4055 return a->dw_attr_val.v.val_str->str; 4056} 4057 4058/* Call this function directly to bypass AT_string_form's logic to put 4059 the string inline in the die. */ 4060 4061static void 4062set_indirect_string (struct indirect_string_node *node) 4063{ 4064 char label[32]; 4065 /* Already indirect is a no op. */ 4066 if (node->form == DW_FORM_strp || node->form == DW_FORM_GNU_str_index) 4067 { 4068 gcc_assert (node->label); 4069 return; 4070 } 4071 ASM_GENERATE_INTERNAL_LABEL (label, "LASF", dw2_string_counter); 4072 ++dw2_string_counter; 4073 node->label = xstrdup (label); 4074 4075 if (!dwarf_split_debug_info) 4076 { 4077 node->form = DW_FORM_strp; 4078 node->index = NOT_INDEXED; 4079 } 4080 else 4081 { 4082 node->form = DW_FORM_GNU_str_index; 4083 node->index = NO_INDEX_ASSIGNED; 4084 } 4085} 4086 4087/* Find out whether a string should be output inline in DIE 4088 or out-of-line in .debug_str section. */ 4089 4090static enum dwarf_form 4091find_string_form (struct indirect_string_node *node) 4092{ 4093 unsigned int len; 4094 4095 if (node->form) 4096 return node->form; 4097 4098 len = strlen (node->str) + 1; 4099 4100 /* If the string is shorter or equal to the size of the reference, it is 4101 always better to put it inline. */ 4102 if (len <= DWARF_OFFSET_SIZE || node->refcount == 0) 4103 return node->form = DW_FORM_string; 4104 4105 /* If we cannot expect the linker to merge strings in .debug_str 4106 section, only put it into .debug_str if it is worth even in this 4107 single module. */ 4108 if (DWARF2_INDIRECT_STRING_SUPPORT_MISSING_ON_TARGET 4109 || ((debug_str_section->common.flags & SECTION_MERGE) == 0 4110 && (len - DWARF_OFFSET_SIZE) * node->refcount <= len)) 4111 return node->form = DW_FORM_string; 4112 4113 set_indirect_string (node); 4114 4115 return node->form; 4116} 4117 4118/* Find out whether the string referenced from the attribute should be 4119 output inline in DIE or out-of-line in .debug_str section. */ 4120 4121static enum dwarf_form 4122AT_string_form (dw_attr_ref a) 4123{ 4124 gcc_assert (a && AT_class (a) == dw_val_class_str); 4125 return find_string_form (a->dw_attr_val.v.val_str); 4126} 4127 4128/* Add a DIE reference attribute value to a DIE. */ 4129 4130static inline void 4131add_AT_die_ref (dw_die_ref die, enum dwarf_attribute attr_kind, dw_die_ref targ_die) 4132{ 4133 dw_attr_node attr; 4134 4135#ifdef ENABLE_CHECKING 4136 gcc_assert (targ_die != NULL); 4137#else 4138 /* With LTO we can end up trying to reference something we didn't create 4139 a DIE for. Avoid crashing later on a NULL referenced DIE. */ 4140 if (targ_die == NULL) 4141 return; 4142#endif 4143 4144 attr.dw_attr = attr_kind; 4145 attr.dw_attr_val.val_class = dw_val_class_die_ref; 4146 attr.dw_attr_val.val_entry = NULL; 4147 attr.dw_attr_val.v.val_die_ref.die = targ_die; 4148 attr.dw_attr_val.v.val_die_ref.external = 0; 4149 add_dwarf_attr (die, &attr); 4150} 4151 4152/* Change DIE reference REF to point to NEW_DIE instead. */ 4153 4154static inline void 4155change_AT_die_ref (dw_attr_ref ref, dw_die_ref new_die) 4156{ 4157 gcc_assert (ref->dw_attr_val.val_class == dw_val_class_die_ref); 4158 ref->dw_attr_val.v.val_die_ref.die = new_die; 4159 ref->dw_attr_val.v.val_die_ref.external = 0; 4160} 4161 4162/* Add an AT_specification attribute to a DIE, and also make the back 4163 pointer from the specification to the definition. */ 4164 4165static inline void 4166add_AT_specification (dw_die_ref die, dw_die_ref targ_die) 4167{ 4168 add_AT_die_ref (die, DW_AT_specification, targ_die); 4169 gcc_assert (!targ_die->die_definition); 4170 targ_die->die_definition = die; 4171} 4172 4173static inline dw_die_ref 4174AT_ref (dw_attr_ref a) 4175{ 4176 gcc_assert (a && AT_class (a) == dw_val_class_die_ref); 4177 return a->dw_attr_val.v.val_die_ref.die; 4178} 4179 4180static inline int 4181AT_ref_external (dw_attr_ref a) 4182{ 4183 if (a && AT_class (a) == dw_val_class_die_ref) 4184 return a->dw_attr_val.v.val_die_ref.external; 4185 4186 return 0; 4187} 4188 4189static inline void 4190set_AT_ref_external (dw_attr_ref a, int i) 4191{ 4192 gcc_assert (a && AT_class (a) == dw_val_class_die_ref); 4193 a->dw_attr_val.v.val_die_ref.external = i; 4194} 4195 4196/* Add an FDE reference attribute value to a DIE. */ 4197 4198static inline void 4199add_AT_fde_ref (dw_die_ref die, enum dwarf_attribute attr_kind, unsigned int targ_fde) 4200{ 4201 dw_attr_node attr; 4202 4203 attr.dw_attr = attr_kind; 4204 attr.dw_attr_val.val_class = dw_val_class_fde_ref; 4205 attr.dw_attr_val.val_entry = NULL; 4206 attr.dw_attr_val.v.val_fde_index = targ_fde; 4207 add_dwarf_attr (die, &attr); 4208} 4209 4210/* Add a location description attribute value to a DIE. */ 4211 4212static inline void 4213add_AT_loc (dw_die_ref die, enum dwarf_attribute attr_kind, dw_loc_descr_ref loc) 4214{ 4215 dw_attr_node attr; 4216 4217 attr.dw_attr = attr_kind; 4218 attr.dw_attr_val.val_class = dw_val_class_loc; 4219 attr.dw_attr_val.val_entry = NULL; 4220 attr.dw_attr_val.v.val_loc = loc; 4221 add_dwarf_attr (die, &attr); 4222} 4223 4224static inline dw_loc_descr_ref 4225AT_loc (dw_attr_ref a) 4226{ 4227 gcc_assert (a && AT_class (a) == dw_val_class_loc); 4228 return a->dw_attr_val.v.val_loc; 4229} 4230 4231static inline void 4232add_AT_loc_list (dw_die_ref die, enum dwarf_attribute attr_kind, dw_loc_list_ref loc_list) 4233{ 4234 dw_attr_node attr; 4235 4236 attr.dw_attr = attr_kind; 4237 attr.dw_attr_val.val_class = dw_val_class_loc_list; 4238 attr.dw_attr_val.val_entry = NULL; 4239 attr.dw_attr_val.v.val_loc_list = loc_list; 4240 add_dwarf_attr (die, &attr); 4241 have_location_lists = true; 4242} 4243 4244static inline dw_loc_list_ref 4245AT_loc_list (dw_attr_ref a) 4246{ 4247 gcc_assert (a && AT_class (a) == dw_val_class_loc_list); 4248 return a->dw_attr_val.v.val_loc_list; 4249} 4250 4251static inline dw_loc_list_ref * 4252AT_loc_list_ptr (dw_attr_ref a) 4253{ 4254 gcc_assert (a && AT_class (a) == dw_val_class_loc_list); 4255 return &a->dw_attr_val.v.val_loc_list; 4256} 4257 4258struct addr_hasher : ggc_hasher<addr_table_entry *> 4259{ 4260 static hashval_t hash (addr_table_entry *); 4261 static bool equal (addr_table_entry *, addr_table_entry *); 4262}; 4263 4264/* Table of entries into the .debug_addr section. */ 4265 4266static GTY (()) hash_table<addr_hasher> *addr_index_table; 4267 4268/* Hash an address_table_entry. */ 4269 4270hashval_t 4271addr_hasher::hash (addr_table_entry *a) 4272{ 4273 inchash::hash hstate; 4274 switch (a->kind) 4275 { 4276 case ate_kind_rtx: 4277 hstate.add_int (0); 4278 break; 4279 case ate_kind_rtx_dtprel: 4280 hstate.add_int (1); 4281 break; 4282 case ate_kind_label: 4283 return htab_hash_string (a->addr.label); 4284 default: 4285 gcc_unreachable (); 4286 } 4287 inchash::add_rtx (a->addr.rtl, hstate); 4288 return hstate.end (); 4289} 4290 4291/* Determine equality for two address_table_entries. */ 4292 4293bool 4294addr_hasher::equal (addr_table_entry *a1, addr_table_entry *a2) 4295{ 4296 if (a1->kind != a2->kind) 4297 return 0; 4298 switch (a1->kind) 4299 { 4300 case ate_kind_rtx: 4301 case ate_kind_rtx_dtprel: 4302 return rtx_equal_p (a1->addr.rtl, a2->addr.rtl); 4303 case ate_kind_label: 4304 return strcmp (a1->addr.label, a2->addr.label) == 0; 4305 default: 4306 gcc_unreachable (); 4307 } 4308} 4309 4310/* Initialize an addr_table_entry. */ 4311 4312void 4313init_addr_table_entry (addr_table_entry *e, enum ate_kind kind, void *addr) 4314{ 4315 e->kind = kind; 4316 switch (kind) 4317 { 4318 case ate_kind_rtx: 4319 case ate_kind_rtx_dtprel: 4320 e->addr.rtl = (rtx) addr; 4321 break; 4322 case ate_kind_label: 4323 e->addr.label = (char *) addr; 4324 break; 4325 } 4326 e->refcount = 0; 4327 e->index = NO_INDEX_ASSIGNED; 4328} 4329 4330/* Add attr to the address table entry to the table. Defer setting an 4331 index until output time. */ 4332 4333static addr_table_entry * 4334add_addr_table_entry (void *addr, enum ate_kind kind) 4335{ 4336 addr_table_entry *node; 4337 addr_table_entry finder; 4338 4339 gcc_assert (dwarf_split_debug_info); 4340 if (! addr_index_table) 4341 addr_index_table = hash_table<addr_hasher>::create_ggc (10); 4342 init_addr_table_entry (&finder, kind, addr); 4343 addr_table_entry **slot = addr_index_table->find_slot (&finder, INSERT); 4344 4345 if (*slot == HTAB_EMPTY_ENTRY) 4346 { 4347 node = ggc_cleared_alloc<addr_table_entry> (); 4348 init_addr_table_entry (node, kind, addr); 4349 *slot = node; 4350 } 4351 else 4352 node = *slot; 4353 4354 node->refcount++; 4355 return node; 4356} 4357 4358/* Remove an entry from the addr table by decrementing its refcount. 4359 Strictly, decrementing the refcount would be enough, but the 4360 assertion that the entry is actually in the table has found 4361 bugs. */ 4362 4363static void 4364remove_addr_table_entry (addr_table_entry *entry) 4365{ 4366 gcc_assert (dwarf_split_debug_info && addr_index_table); 4367 /* After an index is assigned, the table is frozen. */ 4368 gcc_assert (entry->refcount > 0 && entry->index == NO_INDEX_ASSIGNED); 4369 entry->refcount--; 4370} 4371 4372/* Given a location list, remove all addresses it refers to from the 4373 address_table. */ 4374 4375static void 4376remove_loc_list_addr_table_entries (dw_loc_descr_ref descr) 4377{ 4378 for (; descr; descr = descr->dw_loc_next) 4379 if (descr->dw_loc_oprnd1.val_entry != NULL) 4380 { 4381 gcc_assert (descr->dw_loc_oprnd1.val_entry->index == NO_INDEX_ASSIGNED); 4382 remove_addr_table_entry (descr->dw_loc_oprnd1.val_entry); 4383 } 4384} 4385 4386/* A helper function for dwarf2out_finish called through 4387 htab_traverse. Assign an addr_table_entry its index. All entries 4388 must be collected into the table when this function is called, 4389 because the indexing code relies on htab_traverse to traverse nodes 4390 in the same order for each run. */ 4391 4392int 4393index_addr_table_entry (addr_table_entry **h, unsigned int *index) 4394{ 4395 addr_table_entry *node = *h; 4396 4397 /* Don't index unreferenced nodes. */ 4398 if (node->refcount == 0) 4399 return 1; 4400 4401 gcc_assert (node->index == NO_INDEX_ASSIGNED); 4402 node->index = *index; 4403 *index += 1; 4404 4405 return 1; 4406} 4407 4408/* Add an address constant attribute value to a DIE. When using 4409 dwarf_split_debug_info, address attributes in dies destined for the 4410 final executable should be direct references--setting the parameter 4411 force_direct ensures this behavior. */ 4412 4413static inline void 4414add_AT_addr (dw_die_ref die, enum dwarf_attribute attr_kind, rtx addr, 4415 bool force_direct) 4416{ 4417 dw_attr_node attr; 4418 4419 attr.dw_attr = attr_kind; 4420 attr.dw_attr_val.val_class = dw_val_class_addr; 4421 attr.dw_attr_val.v.val_addr = addr; 4422 if (dwarf_split_debug_info && !force_direct) 4423 attr.dw_attr_val.val_entry = add_addr_table_entry (addr, ate_kind_rtx); 4424 else 4425 attr.dw_attr_val.val_entry = NULL; 4426 add_dwarf_attr (die, &attr); 4427} 4428 4429/* Get the RTX from to an address DIE attribute. */ 4430 4431static inline rtx 4432AT_addr (dw_attr_ref a) 4433{ 4434 gcc_assert (a && AT_class (a) == dw_val_class_addr); 4435 return a->dw_attr_val.v.val_addr; 4436} 4437 4438/* Add a file attribute value to a DIE. */ 4439 4440static inline void 4441add_AT_file (dw_die_ref die, enum dwarf_attribute attr_kind, 4442 struct dwarf_file_data *fd) 4443{ 4444 dw_attr_node attr; 4445 4446 attr.dw_attr = attr_kind; 4447 attr.dw_attr_val.val_class = dw_val_class_file; 4448 attr.dw_attr_val.val_entry = NULL; 4449 attr.dw_attr_val.v.val_file = fd; 4450 add_dwarf_attr (die, &attr); 4451} 4452 4453/* Get the dwarf_file_data from a file DIE attribute. */ 4454 4455static inline struct dwarf_file_data * 4456AT_file (dw_attr_ref a) 4457{ 4458 gcc_assert (a && AT_class (a) == dw_val_class_file); 4459 return a->dw_attr_val.v.val_file; 4460} 4461 4462/* Add a vms delta attribute value to a DIE. */ 4463 4464static inline void 4465add_AT_vms_delta (dw_die_ref die, enum dwarf_attribute attr_kind, 4466 const char *lbl1, const char *lbl2) 4467{ 4468 dw_attr_node attr; 4469 4470 attr.dw_attr = attr_kind; 4471 attr.dw_attr_val.val_class = dw_val_class_vms_delta; 4472 attr.dw_attr_val.val_entry = NULL; 4473 attr.dw_attr_val.v.val_vms_delta.lbl1 = xstrdup (lbl1); 4474 attr.dw_attr_val.v.val_vms_delta.lbl2 = xstrdup (lbl2); 4475 add_dwarf_attr (die, &attr); 4476} 4477 4478/* Add a label identifier attribute value to a DIE. */ 4479 4480static inline void 4481add_AT_lbl_id (dw_die_ref die, enum dwarf_attribute attr_kind, 4482 const char *lbl_id) 4483{ 4484 dw_attr_node attr; 4485 4486 attr.dw_attr = attr_kind; 4487 attr.dw_attr_val.val_class = dw_val_class_lbl_id; 4488 attr.dw_attr_val.val_entry = NULL; 4489 attr.dw_attr_val.v.val_lbl_id = xstrdup (lbl_id); 4490 if (dwarf_split_debug_info) 4491 attr.dw_attr_val.val_entry 4492 = add_addr_table_entry (attr.dw_attr_val.v.val_lbl_id, 4493 ate_kind_label); 4494 add_dwarf_attr (die, &attr); 4495} 4496 4497/* Add a section offset attribute value to a DIE, an offset into the 4498 debug_line section. */ 4499 4500static inline void 4501add_AT_lineptr (dw_die_ref die, enum dwarf_attribute attr_kind, 4502 const char *label) 4503{ 4504 dw_attr_node attr; 4505 4506 attr.dw_attr = attr_kind; 4507 attr.dw_attr_val.val_class = dw_val_class_lineptr; 4508 attr.dw_attr_val.val_entry = NULL; 4509 attr.dw_attr_val.v.val_lbl_id = xstrdup (label); 4510 add_dwarf_attr (die, &attr); 4511} 4512 4513/* Add a section offset attribute value to a DIE, an offset into the 4514 debug_macinfo section. */ 4515 4516static inline void 4517add_AT_macptr (dw_die_ref die, enum dwarf_attribute attr_kind, 4518 const char *label) 4519{ 4520 dw_attr_node attr; 4521 4522 attr.dw_attr = attr_kind; 4523 attr.dw_attr_val.val_class = dw_val_class_macptr; 4524 attr.dw_attr_val.val_entry = NULL; 4525 attr.dw_attr_val.v.val_lbl_id = xstrdup (label); 4526 add_dwarf_attr (die, &attr); 4527} 4528 4529/* Add an offset attribute value to a DIE. */ 4530 4531static inline void 4532add_AT_offset (dw_die_ref die, enum dwarf_attribute attr_kind, 4533 unsigned HOST_WIDE_INT offset) 4534{ 4535 dw_attr_node attr; 4536 4537 attr.dw_attr = attr_kind; 4538 attr.dw_attr_val.val_class = dw_val_class_offset; 4539 attr.dw_attr_val.val_entry = NULL; 4540 attr.dw_attr_val.v.val_offset = offset; 4541 add_dwarf_attr (die, &attr); 4542} 4543 4544/* Add a range_list attribute value to a DIE. When using 4545 dwarf_split_debug_info, address attributes in dies destined for the 4546 final executable should be direct references--setting the parameter 4547 force_direct ensures this behavior. */ 4548 4549#define UNRELOCATED_OFFSET ((addr_table_entry *) 1) 4550#define RELOCATED_OFFSET (NULL) 4551 4552static void 4553add_AT_range_list (dw_die_ref die, enum dwarf_attribute attr_kind, 4554 long unsigned int offset, bool force_direct) 4555{ 4556 dw_attr_node attr; 4557 4558 attr.dw_attr = attr_kind; 4559 attr.dw_attr_val.val_class = dw_val_class_range_list; 4560 /* For the range_list attribute, use val_entry to store whether the 4561 offset should follow split-debug-info or normal semantics. This 4562 value is read in output_range_list_offset. */ 4563 if (dwarf_split_debug_info && !force_direct) 4564 attr.dw_attr_val.val_entry = UNRELOCATED_OFFSET; 4565 else 4566 attr.dw_attr_val.val_entry = RELOCATED_OFFSET; 4567 attr.dw_attr_val.v.val_offset = offset; 4568 add_dwarf_attr (die, &attr); 4569} 4570 4571/* Return the start label of a delta attribute. */ 4572 4573static inline const char * 4574AT_vms_delta1 (dw_attr_ref a) 4575{ 4576 gcc_assert (a && (AT_class (a) == dw_val_class_vms_delta)); 4577 return a->dw_attr_val.v.val_vms_delta.lbl1; 4578} 4579 4580/* Return the end label of a delta attribute. */ 4581 4582static inline const char * 4583AT_vms_delta2 (dw_attr_ref a) 4584{ 4585 gcc_assert (a && (AT_class (a) == dw_val_class_vms_delta)); 4586 return a->dw_attr_val.v.val_vms_delta.lbl2; 4587} 4588 4589static inline const char * 4590AT_lbl (dw_attr_ref a) 4591{ 4592 gcc_assert (a && (AT_class (a) == dw_val_class_lbl_id 4593 || AT_class (a) == dw_val_class_lineptr 4594 || AT_class (a) == dw_val_class_macptr 4595 || AT_class (a) == dw_val_class_high_pc)); 4596 return a->dw_attr_val.v.val_lbl_id; 4597} 4598 4599/* Get the attribute of type attr_kind. */ 4600 4601static dw_attr_ref 4602get_AT (dw_die_ref die, enum dwarf_attribute attr_kind) 4603{ 4604 dw_attr_ref a; 4605 unsigned ix; 4606 dw_die_ref spec = NULL; 4607 4608 if (! die) 4609 return NULL; 4610 4611 FOR_EACH_VEC_SAFE_ELT (die->die_attr, ix, a) 4612 if (a->dw_attr == attr_kind) 4613 return a; 4614 else if (a->dw_attr == DW_AT_specification 4615 || a->dw_attr == DW_AT_abstract_origin) 4616 spec = AT_ref (a); 4617 4618 if (spec) 4619 return get_AT (spec, attr_kind); 4620 4621 return NULL; 4622} 4623 4624/* Returns the parent of the declaration of DIE. */ 4625 4626static dw_die_ref 4627get_die_parent (dw_die_ref die) 4628{ 4629 dw_die_ref t; 4630 4631 if (!die) 4632 return NULL; 4633 4634 if ((t = get_AT_ref (die, DW_AT_abstract_origin)) 4635 || (t = get_AT_ref (die, DW_AT_specification))) 4636 die = t; 4637 4638 return die->die_parent; 4639} 4640 4641/* Return the "low pc" attribute value, typically associated with a subprogram 4642 DIE. Return null if the "low pc" attribute is either not present, or if it 4643 cannot be represented as an assembler label identifier. */ 4644 4645static inline const char * 4646get_AT_low_pc (dw_die_ref die) 4647{ 4648 dw_attr_ref a = get_AT (die, DW_AT_low_pc); 4649 4650 return a ? AT_lbl (a) : NULL; 4651} 4652 4653/* Return the "high pc" attribute value, typically associated with a subprogram 4654 DIE. Return null if the "high pc" attribute is either not present, or if it 4655 cannot be represented as an assembler label identifier. */ 4656 4657static inline const char * 4658get_AT_hi_pc (dw_die_ref die) 4659{ 4660 dw_attr_ref a = get_AT (die, DW_AT_high_pc); 4661 4662 return a ? AT_lbl (a) : NULL; 4663} 4664 4665/* Return the value of the string attribute designated by ATTR_KIND, or 4666 NULL if it is not present. */ 4667 4668static inline const char * 4669get_AT_string (dw_die_ref die, enum dwarf_attribute attr_kind) 4670{ 4671 dw_attr_ref a = get_AT (die, attr_kind); 4672 4673 return a ? AT_string (a) : NULL; 4674} 4675 4676/* Return the value of the flag attribute designated by ATTR_KIND, or -1 4677 if it is not present. */ 4678 4679static inline int 4680get_AT_flag (dw_die_ref die, enum dwarf_attribute attr_kind) 4681{ 4682 dw_attr_ref a = get_AT (die, attr_kind); 4683 4684 return a ? AT_flag (a) : 0; 4685} 4686 4687/* Return the value of the unsigned attribute designated by ATTR_KIND, or 0 4688 if it is not present. */ 4689 4690static inline unsigned 4691get_AT_unsigned (dw_die_ref die, enum dwarf_attribute attr_kind) 4692{ 4693 dw_attr_ref a = get_AT (die, attr_kind); 4694 4695 return a ? AT_unsigned (a) : 0; 4696} 4697 4698static inline dw_die_ref 4699get_AT_ref (dw_die_ref die, enum dwarf_attribute attr_kind) 4700{ 4701 dw_attr_ref a = get_AT (die, attr_kind); 4702 4703 return a ? AT_ref (a) : NULL; 4704} 4705 4706static inline struct dwarf_file_data * 4707get_AT_file (dw_die_ref die, enum dwarf_attribute attr_kind) 4708{ 4709 dw_attr_ref a = get_AT (die, attr_kind); 4710 4711 return a ? AT_file (a) : NULL; 4712} 4713 4714/* Return TRUE if the language is C++. */ 4715 4716static inline bool 4717is_cxx (void) 4718{ 4719 unsigned int lang = get_AT_unsigned (comp_unit_die (), DW_AT_language); 4720 4721 return (lang == DW_LANG_C_plus_plus || lang == DW_LANG_ObjC_plus_plus 4722 || lang == DW_LANG_C_plus_plus_11 || lang == DW_LANG_C_plus_plus_14); 4723} 4724 4725/* Return TRUE if the language is Java. */ 4726 4727static inline bool 4728is_java (void) 4729{ 4730 unsigned int lang = get_AT_unsigned (comp_unit_die (), DW_AT_language); 4731 4732 return lang == DW_LANG_Java; 4733} 4734 4735/* Return TRUE if the language is Fortran. */ 4736 4737static inline bool 4738is_fortran (void) 4739{ 4740 unsigned int lang = get_AT_unsigned (comp_unit_die (), DW_AT_language); 4741 4742 return (lang == DW_LANG_Fortran77 4743 || lang == DW_LANG_Fortran90 4744 || lang == DW_LANG_Fortran95 4745 || lang == DW_LANG_Fortran03 4746 || lang == DW_LANG_Fortran08); 4747} 4748 4749/* Return TRUE if the language is Ada. */ 4750 4751static inline bool 4752is_ada (void) 4753{ 4754 unsigned int lang = get_AT_unsigned (comp_unit_die (), DW_AT_language); 4755 4756 return lang == DW_LANG_Ada95 || lang == DW_LANG_Ada83; 4757} 4758 4759/* Remove the specified attribute if present. */ 4760 4761static void 4762remove_AT (dw_die_ref die, enum dwarf_attribute attr_kind) 4763{ 4764 dw_attr_ref a; 4765 unsigned ix; 4766 4767 if (! die) 4768 return; 4769 4770 FOR_EACH_VEC_SAFE_ELT (die->die_attr, ix, a) 4771 if (a->dw_attr == attr_kind) 4772 { 4773 if (AT_class (a) == dw_val_class_str) 4774 if (a->dw_attr_val.v.val_str->refcount) 4775 a->dw_attr_val.v.val_str->refcount--; 4776 4777 /* vec::ordered_remove should help reduce the number of abbrevs 4778 that are needed. */ 4779 die->die_attr->ordered_remove (ix); 4780 return; 4781 } 4782} 4783 4784/* Remove CHILD from its parent. PREV must have the property that 4785 PREV->DIE_SIB == CHILD. Does not alter CHILD. */ 4786 4787static void 4788remove_child_with_prev (dw_die_ref child, dw_die_ref prev) 4789{ 4790 gcc_assert (child->die_parent == prev->die_parent); 4791 gcc_assert (prev->die_sib == child); 4792 if (prev == child) 4793 { 4794 gcc_assert (child->die_parent->die_child == child); 4795 prev = NULL; 4796 } 4797 else 4798 prev->die_sib = child->die_sib; 4799 if (child->die_parent->die_child == child) 4800 child->die_parent->die_child = prev; 4801} 4802 4803/* Replace OLD_CHILD with NEW_CHILD. PREV must have the property that 4804 PREV->DIE_SIB == OLD_CHILD. Does not alter OLD_CHILD. */ 4805 4806static void 4807replace_child (dw_die_ref old_child, dw_die_ref new_child, dw_die_ref prev) 4808{ 4809 dw_die_ref parent = old_child->die_parent; 4810 4811 gcc_assert (parent == prev->die_parent); 4812 gcc_assert (prev->die_sib == old_child); 4813 4814 new_child->die_parent = parent; 4815 if (prev == old_child) 4816 { 4817 gcc_assert (parent->die_child == old_child); 4818 new_child->die_sib = new_child; 4819 } 4820 else 4821 { 4822 prev->die_sib = new_child; 4823 new_child->die_sib = old_child->die_sib; 4824 } 4825 if (old_child->die_parent->die_child == old_child) 4826 old_child->die_parent->die_child = new_child; 4827} 4828 4829/* Move all children from OLD_PARENT to NEW_PARENT. */ 4830 4831static void 4832move_all_children (dw_die_ref old_parent, dw_die_ref new_parent) 4833{ 4834 dw_die_ref c; 4835 new_parent->die_child = old_parent->die_child; 4836 old_parent->die_child = NULL; 4837 FOR_EACH_CHILD (new_parent, c, c->die_parent = new_parent); 4838} 4839 4840/* Remove child DIE whose die_tag is TAG. Do nothing if no child 4841 matches TAG. */ 4842 4843static void 4844remove_child_TAG (dw_die_ref die, enum dwarf_tag tag) 4845{ 4846 dw_die_ref c; 4847 4848 c = die->die_child; 4849 if (c) do { 4850 dw_die_ref prev = c; 4851 c = c->die_sib; 4852 while (c->die_tag == tag) 4853 { 4854 remove_child_with_prev (c, prev); 4855 /* Might have removed every child. */ 4856 if (c == c->die_sib) 4857 return; 4858 c = c->die_sib; 4859 } 4860 } while (c != die->die_child); 4861} 4862 4863/* Add a CHILD_DIE as the last child of DIE. */ 4864 4865static void 4866add_child_die (dw_die_ref die, dw_die_ref child_die) 4867{ 4868 /* FIXME this should probably be an assert. */ 4869 if (! die || ! child_die) 4870 return; 4871 gcc_assert (die != child_die); 4872 4873 child_die->die_parent = die; 4874 if (die->die_child) 4875 { 4876 child_die->die_sib = die->die_child->die_sib; 4877 die->die_child->die_sib = child_die; 4878 } 4879 else 4880 child_die->die_sib = child_die; 4881 die->die_child = child_die; 4882} 4883 4884/* Move CHILD, which must be a child of PARENT or the DIE for which PARENT 4885 is the specification, to the end of PARENT's list of children. 4886 This is done by removing and re-adding it. */ 4887 4888static void 4889splice_child_die (dw_die_ref parent, dw_die_ref child) 4890{ 4891 dw_die_ref p; 4892 4893 /* We want the declaration DIE from inside the class, not the 4894 specification DIE at toplevel. */ 4895 if (child->die_parent != parent) 4896 { 4897 dw_die_ref tmp = get_AT_ref (child, DW_AT_specification); 4898 4899 if (tmp) 4900 child = tmp; 4901 } 4902 4903 gcc_assert (child->die_parent == parent 4904 || (child->die_parent 4905 == get_AT_ref (parent, DW_AT_specification))); 4906 4907 for (p = child->die_parent->die_child; ; p = p->die_sib) 4908 if (p->die_sib == child) 4909 { 4910 remove_child_with_prev (child, p); 4911 break; 4912 } 4913 4914 add_child_die (parent, child); 4915} 4916 4917/* Return a pointer to a newly created DIE node. */ 4918 4919static inline dw_die_ref 4920new_die (enum dwarf_tag tag_value, dw_die_ref parent_die, tree t) 4921{ 4922 dw_die_ref die = ggc_cleared_alloc<die_node> (); 4923 4924 die->die_tag = tag_value; 4925 4926 if (parent_die != NULL) 4927 add_child_die (parent_die, die); 4928 else 4929 { 4930 limbo_die_node *limbo_node; 4931 4932 limbo_node = ggc_cleared_alloc<limbo_die_node> (); 4933 limbo_node->die = die; 4934 limbo_node->created_for = t; 4935 limbo_node->next = limbo_die_list; 4936 limbo_die_list = limbo_node; 4937 } 4938 4939 return die; 4940} 4941 4942/* Return the DIE associated with the given type specifier. */ 4943 4944static inline dw_die_ref 4945lookup_type_die (tree type) 4946{ 4947 return TYPE_SYMTAB_DIE (type); 4948} 4949 4950/* Given a TYPE_DIE representing the type TYPE, if TYPE is an 4951 anonymous type named by the typedef TYPE_DIE, return the DIE of the 4952 anonymous type instead the one of the naming typedef. */ 4953 4954static inline dw_die_ref 4955strip_naming_typedef (tree type, dw_die_ref type_die) 4956{ 4957 if (type 4958 && TREE_CODE (type) == RECORD_TYPE 4959 && type_die 4960 && type_die->die_tag == DW_TAG_typedef 4961 && is_naming_typedef_decl (TYPE_NAME (type))) 4962 type_die = get_AT_ref (type_die, DW_AT_type); 4963 return type_die; 4964} 4965 4966/* Like lookup_type_die, but if type is an anonymous type named by a 4967 typedef[1], return the DIE of the anonymous type instead the one of 4968 the naming typedef. This is because in gen_typedef_die, we did 4969 equate the anonymous struct named by the typedef with the DIE of 4970 the naming typedef. So by default, lookup_type_die on an anonymous 4971 struct yields the DIE of the naming typedef. 4972 4973 [1]: Read the comment of is_naming_typedef_decl to learn about what 4974 a naming typedef is. */ 4975 4976static inline dw_die_ref 4977lookup_type_die_strip_naming_typedef (tree type) 4978{ 4979 dw_die_ref die = lookup_type_die (type); 4980 return strip_naming_typedef (type, die); 4981} 4982 4983/* Equate a DIE to a given type specifier. */ 4984 4985static inline void 4986equate_type_number_to_die (tree type, dw_die_ref type_die) 4987{ 4988 TYPE_SYMTAB_DIE (type) = type_die; 4989} 4990 4991/* Returns a hash value for X (which really is a die_struct). */ 4992 4993inline hashval_t 4994decl_die_hasher::hash (die_node *x) 4995{ 4996 return (hashval_t) x->decl_id; 4997} 4998 4999/* Return nonzero if decl_id of die_struct X is the same as UID of decl *Y. */ 5000 5001inline bool 5002decl_die_hasher::equal (die_node *x, tree y) 5003{ 5004 return (x->decl_id == DECL_UID (y)); 5005} 5006 5007/* Return the DIE associated with a given declaration. */ 5008 5009static inline dw_die_ref 5010lookup_decl_die (tree decl) 5011{ 5012 return decl_die_table->find_with_hash (decl, DECL_UID (decl)); 5013} 5014 5015/* Returns a hash value for X (which really is a var_loc_list). */ 5016 5017inline hashval_t 5018decl_loc_hasher::hash (var_loc_list *x) 5019{ 5020 return (hashval_t) x->decl_id; 5021} 5022 5023/* Return nonzero if decl_id of var_loc_list X is the same as 5024 UID of decl *Y. */ 5025 5026inline bool 5027decl_loc_hasher::equal (var_loc_list *x, const_tree y) 5028{ 5029 return (x->decl_id == DECL_UID (y)); 5030} 5031 5032/* Return the var_loc list associated with a given declaration. */ 5033 5034static inline var_loc_list * 5035lookup_decl_loc (const_tree decl) 5036{ 5037 if (!decl_loc_table) 5038 return NULL; 5039 return decl_loc_table->find_with_hash (decl, DECL_UID (decl)); 5040} 5041 5042/* Returns a hash value for X (which really is a cached_dw_loc_list_list). */ 5043 5044inline hashval_t 5045dw_loc_list_hasher::hash (cached_dw_loc_list *x) 5046{ 5047 return (hashval_t) x->decl_id; 5048} 5049 5050/* Return nonzero if decl_id of cached_dw_loc_list X is the same as 5051 UID of decl *Y. */ 5052 5053inline bool 5054dw_loc_list_hasher::equal (cached_dw_loc_list *x, const_tree y) 5055{ 5056 return (x->decl_id == DECL_UID (y)); 5057} 5058 5059/* Equate a DIE to a particular declaration. */ 5060 5061static void 5062equate_decl_number_to_die (tree decl, dw_die_ref decl_die) 5063{ 5064 unsigned int decl_id = DECL_UID (decl); 5065 5066 *decl_die_table->find_slot_with_hash (decl, decl_id, INSERT) = decl_die; 5067 decl_die->decl_id = decl_id; 5068} 5069 5070/* Return how many bits covers PIECE EXPR_LIST. */ 5071 5072static HOST_WIDE_INT 5073decl_piece_bitsize (rtx piece) 5074{ 5075 int ret = (int) GET_MODE (piece); 5076 if (ret) 5077 return ret; 5078 gcc_assert (GET_CODE (XEXP (piece, 0)) == CONCAT 5079 && CONST_INT_P (XEXP (XEXP (piece, 0), 0))); 5080 return INTVAL (XEXP (XEXP (piece, 0), 0)); 5081} 5082 5083/* Return pointer to the location of location note in PIECE EXPR_LIST. */ 5084 5085static rtx * 5086decl_piece_varloc_ptr (rtx piece) 5087{ 5088 if ((int) GET_MODE (piece)) 5089 return &XEXP (piece, 0); 5090 else 5091 return &XEXP (XEXP (piece, 0), 1); 5092} 5093 5094/* Create an EXPR_LIST for location note LOC_NOTE covering BITSIZE bits. 5095 Next is the chain of following piece nodes. */ 5096 5097static rtx_expr_list * 5098decl_piece_node (rtx loc_note, HOST_WIDE_INT bitsize, rtx next) 5099{ 5100 if (bitsize > 0 && bitsize <= (int) MAX_MACHINE_MODE) 5101 return alloc_EXPR_LIST (bitsize, loc_note, next); 5102 else 5103 return alloc_EXPR_LIST (0, gen_rtx_CONCAT (VOIDmode, 5104 GEN_INT (bitsize), 5105 loc_note), next); 5106} 5107 5108/* Return rtx that should be stored into loc field for 5109 LOC_NOTE and BITPOS/BITSIZE. */ 5110 5111static rtx 5112construct_piece_list (rtx loc_note, HOST_WIDE_INT bitpos, 5113 HOST_WIDE_INT bitsize) 5114{ 5115 if (bitsize != -1) 5116 { 5117 loc_note = decl_piece_node (loc_note, bitsize, NULL_RTX); 5118 if (bitpos != 0) 5119 loc_note = decl_piece_node (NULL_RTX, bitpos, loc_note); 5120 } 5121 return loc_note; 5122} 5123 5124/* This function either modifies location piece list *DEST in 5125 place (if SRC and INNER is NULL), or copies location piece list 5126 *SRC to *DEST while modifying it. Location BITPOS is modified 5127 to contain LOC_NOTE, any pieces overlapping it are removed resp. 5128 not copied and if needed some padding around it is added. 5129 When modifying in place, DEST should point to EXPR_LIST where 5130 earlier pieces cover PIECE_BITPOS bits, when copying SRC points 5131 to the start of the whole list and INNER points to the EXPR_LIST 5132 where earlier pieces cover PIECE_BITPOS bits. */ 5133 5134static void 5135adjust_piece_list (rtx *dest, rtx *src, rtx *inner, 5136 HOST_WIDE_INT bitpos, HOST_WIDE_INT piece_bitpos, 5137 HOST_WIDE_INT bitsize, rtx loc_note) 5138{ 5139 HOST_WIDE_INT diff; 5140 bool copy = inner != NULL; 5141 5142 if (copy) 5143 { 5144 /* First copy all nodes preceding the current bitpos. */ 5145 while (src != inner) 5146 { 5147 *dest = decl_piece_node (*decl_piece_varloc_ptr (*src), 5148 decl_piece_bitsize (*src), NULL_RTX); 5149 dest = &XEXP (*dest, 1); 5150 src = &XEXP (*src, 1); 5151 } 5152 } 5153 /* Add padding if needed. */ 5154 if (bitpos != piece_bitpos) 5155 { 5156 *dest = decl_piece_node (NULL_RTX, bitpos - piece_bitpos, 5157 copy ? NULL_RTX : *dest); 5158 dest = &XEXP (*dest, 1); 5159 } 5160 else if (*dest && decl_piece_bitsize (*dest) == bitsize) 5161 { 5162 gcc_assert (!copy); 5163 /* A piece with correct bitpos and bitsize already exist, 5164 just update the location for it and return. */ 5165 *decl_piece_varloc_ptr (*dest) = loc_note; 5166 return; 5167 } 5168 /* Add the piece that changed. */ 5169 *dest = decl_piece_node (loc_note, bitsize, copy ? NULL_RTX : *dest); 5170 dest = &XEXP (*dest, 1); 5171 /* Skip over pieces that overlap it. */ 5172 diff = bitpos - piece_bitpos + bitsize; 5173 if (!copy) 5174 src = dest; 5175 while (diff > 0 && *src) 5176 { 5177 rtx piece = *src; 5178 diff -= decl_piece_bitsize (piece); 5179 if (copy) 5180 src = &XEXP (piece, 1); 5181 else 5182 { 5183 *src = XEXP (piece, 1); 5184 free_EXPR_LIST_node (piece); 5185 } 5186 } 5187 /* Add padding if needed. */ 5188 if (diff < 0 && *src) 5189 { 5190 if (!copy) 5191 dest = src; 5192 *dest = decl_piece_node (NULL_RTX, -diff, copy ? NULL_RTX : *dest); 5193 dest = &XEXP (*dest, 1); 5194 } 5195 if (!copy) 5196 return; 5197 /* Finally copy all nodes following it. */ 5198 while (*src) 5199 { 5200 *dest = decl_piece_node (*decl_piece_varloc_ptr (*src), 5201 decl_piece_bitsize (*src), NULL_RTX); 5202 dest = &XEXP (*dest, 1); 5203 src = &XEXP (*src, 1); 5204 } 5205} 5206 5207/* Add a variable location node to the linked list for DECL. */ 5208 5209static struct var_loc_node * 5210add_var_loc_to_decl (tree decl, rtx loc_note, const char *label) 5211{ 5212 unsigned int decl_id; 5213 var_loc_list *temp; 5214 struct var_loc_node *loc = NULL; 5215 HOST_WIDE_INT bitsize = -1, bitpos = -1; 5216 5217 if (TREE_CODE (decl) == VAR_DECL 5218 && DECL_HAS_DEBUG_EXPR_P (decl)) 5219 { 5220 tree realdecl = DECL_DEBUG_EXPR (decl); 5221 if (handled_component_p (realdecl) 5222 || (TREE_CODE (realdecl) == MEM_REF 5223 && TREE_CODE (TREE_OPERAND (realdecl, 0)) == ADDR_EXPR)) 5224 { 5225 HOST_WIDE_INT maxsize; 5226 tree innerdecl; 5227 innerdecl 5228 = get_ref_base_and_extent (realdecl, &bitpos, &bitsize, &maxsize); 5229 if (!DECL_P (innerdecl) 5230 || DECL_IGNORED_P (innerdecl) 5231 || TREE_STATIC (innerdecl) 5232 || bitsize <= 0 5233 || bitpos + bitsize > 256 5234 || bitsize != maxsize) 5235 return NULL; 5236 decl = innerdecl; 5237 } 5238 } 5239 5240 decl_id = DECL_UID (decl); 5241 var_loc_list **slot 5242 = decl_loc_table->find_slot_with_hash (decl, decl_id, INSERT); 5243 if (*slot == NULL) 5244 { 5245 temp = ggc_cleared_alloc<var_loc_list> (); 5246 temp->decl_id = decl_id; 5247 *slot = temp; 5248 } 5249 else 5250 temp = *slot; 5251 5252 /* For PARM_DECLs try to keep around the original incoming value, 5253 even if that means we'll emit a zero-range .debug_loc entry. */ 5254 if (temp->last 5255 && temp->first == temp->last 5256 && TREE_CODE (decl) == PARM_DECL 5257 && NOTE_P (temp->first->loc) 5258 && NOTE_VAR_LOCATION_DECL (temp->first->loc) == decl 5259 && DECL_INCOMING_RTL (decl) 5260 && NOTE_VAR_LOCATION_LOC (temp->first->loc) 5261 && GET_CODE (NOTE_VAR_LOCATION_LOC (temp->first->loc)) 5262 == GET_CODE (DECL_INCOMING_RTL (decl)) 5263 && prev_real_insn (temp->first->loc) == NULL_RTX 5264 && (bitsize != -1 5265 || !rtx_equal_p (NOTE_VAR_LOCATION_LOC (temp->first->loc), 5266 NOTE_VAR_LOCATION_LOC (loc_note)) 5267 || (NOTE_VAR_LOCATION_STATUS (temp->first->loc) 5268 != NOTE_VAR_LOCATION_STATUS (loc_note)))) 5269 { 5270 loc = ggc_cleared_alloc<var_loc_node> (); 5271 temp->first->next = loc; 5272 temp->last = loc; 5273 loc->loc = construct_piece_list (loc_note, bitpos, bitsize); 5274 } 5275 else if (temp->last) 5276 { 5277 struct var_loc_node *last = temp->last, *unused = NULL; 5278 rtx *piece_loc = NULL, last_loc_note; 5279 HOST_WIDE_INT piece_bitpos = 0; 5280 if (last->next) 5281 { 5282 last = last->next; 5283 gcc_assert (last->next == NULL); 5284 } 5285 if (bitsize != -1 && GET_CODE (last->loc) == EXPR_LIST) 5286 { 5287 piece_loc = &last->loc; 5288 do 5289 { 5290 HOST_WIDE_INT cur_bitsize = decl_piece_bitsize (*piece_loc); 5291 if (piece_bitpos + cur_bitsize > bitpos) 5292 break; 5293 piece_bitpos += cur_bitsize; 5294 piece_loc = &XEXP (*piece_loc, 1); 5295 } 5296 while (*piece_loc); 5297 } 5298 /* TEMP->LAST here is either pointer to the last but one or 5299 last element in the chained list, LAST is pointer to the 5300 last element. */ 5301 if (label && strcmp (last->label, label) == 0) 5302 { 5303 /* For SRA optimized variables if there weren't any real 5304 insns since last note, just modify the last node. */ 5305 if (piece_loc != NULL) 5306 { 5307 adjust_piece_list (piece_loc, NULL, NULL, 5308 bitpos, piece_bitpos, bitsize, loc_note); 5309 return NULL; 5310 } 5311 /* If the last note doesn't cover any instructions, remove it. */ 5312 if (temp->last != last) 5313 { 5314 temp->last->next = NULL; 5315 unused = last; 5316 last = temp->last; 5317 gcc_assert (strcmp (last->label, label) != 0); 5318 } 5319 else 5320 { 5321 gcc_assert (temp->first == temp->last 5322 || (temp->first->next == temp->last 5323 && TREE_CODE (decl) == PARM_DECL)); 5324 memset (temp->last, '\0', sizeof (*temp->last)); 5325 temp->last->loc = construct_piece_list (loc_note, bitpos, bitsize); 5326 return temp->last; 5327 } 5328 } 5329 if (bitsize == -1 && NOTE_P (last->loc)) 5330 last_loc_note = last->loc; 5331 else if (piece_loc != NULL 5332 && *piece_loc != NULL_RTX 5333 && piece_bitpos == bitpos 5334 && decl_piece_bitsize (*piece_loc) == bitsize) 5335 last_loc_note = *decl_piece_varloc_ptr (*piece_loc); 5336 else 5337 last_loc_note = NULL_RTX; 5338 /* If the current location is the same as the end of the list, 5339 and either both or neither of the locations is uninitialized, 5340 we have nothing to do. */ 5341 if (last_loc_note == NULL_RTX 5342 || (!rtx_equal_p (NOTE_VAR_LOCATION_LOC (last_loc_note), 5343 NOTE_VAR_LOCATION_LOC (loc_note))) 5344 || ((NOTE_VAR_LOCATION_STATUS (last_loc_note) 5345 != NOTE_VAR_LOCATION_STATUS (loc_note)) 5346 && ((NOTE_VAR_LOCATION_STATUS (last_loc_note) 5347 == VAR_INIT_STATUS_UNINITIALIZED) 5348 || (NOTE_VAR_LOCATION_STATUS (loc_note) 5349 == VAR_INIT_STATUS_UNINITIALIZED)))) 5350 { 5351 /* Add LOC to the end of list and update LAST. If the last 5352 element of the list has been removed above, reuse its 5353 memory for the new node, otherwise allocate a new one. */ 5354 if (unused) 5355 { 5356 loc = unused; 5357 memset (loc, '\0', sizeof (*loc)); 5358 } 5359 else 5360 loc = ggc_cleared_alloc<var_loc_node> (); 5361 if (bitsize == -1 || piece_loc == NULL) 5362 loc->loc = construct_piece_list (loc_note, bitpos, bitsize); 5363 else 5364 adjust_piece_list (&loc->loc, &last->loc, piece_loc, 5365 bitpos, piece_bitpos, bitsize, loc_note); 5366 last->next = loc; 5367 /* Ensure TEMP->LAST will point either to the new last but one 5368 element of the chain, or to the last element in it. */ 5369 if (last != temp->last) 5370 temp->last = last; 5371 } 5372 else if (unused) 5373 ggc_free (unused); 5374 } 5375 else 5376 { 5377 loc = ggc_cleared_alloc<var_loc_node> (); 5378 temp->first = loc; 5379 temp->last = loc; 5380 loc->loc = construct_piece_list (loc_note, bitpos, bitsize); 5381 } 5382 return loc; 5383} 5384 5385/* Keep track of the number of spaces used to indent the 5386 output of the debugging routines that print the structure of 5387 the DIE internal representation. */ 5388static int print_indent; 5389 5390/* Indent the line the number of spaces given by print_indent. */ 5391 5392static inline void 5393print_spaces (FILE *outfile) 5394{ 5395 fprintf (outfile, "%*s", print_indent, ""); 5396} 5397 5398/* Print a type signature in hex. */ 5399 5400static inline void 5401print_signature (FILE *outfile, char *sig) 5402{ 5403 int i; 5404 5405 for (i = 0; i < DWARF_TYPE_SIGNATURE_SIZE; i++) 5406 fprintf (outfile, "%02x", sig[i] & 0xff); 5407} 5408 5409static void print_loc_descr (dw_loc_descr_ref, FILE *); 5410 5411/* Print the value associated to the VAL DWARF value node to OUTFILE. If 5412 RECURSE, output location descriptor operations. */ 5413 5414static void 5415print_dw_val (dw_val_node *val, bool recurse, FILE *outfile) 5416{ 5417 switch (val->val_class) 5418 { 5419 case dw_val_class_addr: 5420 fprintf (outfile, "address"); 5421 break; 5422 case dw_val_class_offset: 5423 fprintf (outfile, "offset"); 5424 break; 5425 case dw_val_class_loc: 5426 fprintf (outfile, "location descriptor"); 5427 if (val->v.val_loc == NULL) 5428 fprintf (outfile, " -> <null>\n"); 5429 else if (recurse) 5430 { 5431 fprintf (outfile, ":\n"); 5432 print_indent += 4; 5433 print_loc_descr (val->v.val_loc, outfile); 5434 print_indent -= 4; 5435 } 5436 else 5437 fprintf (outfile, " (%p)\n", (void *) val->v.val_loc); 5438 break; 5439 case dw_val_class_loc_list: 5440 fprintf (outfile, "location list -> label:%s", 5441 val->v.val_loc_list->ll_symbol); 5442 break; 5443 case dw_val_class_range_list: 5444 fprintf (outfile, "range list"); 5445 break; 5446 case dw_val_class_const: 5447 fprintf (outfile, HOST_WIDE_INT_PRINT_DEC, val->v.val_int); 5448 break; 5449 case dw_val_class_unsigned_const: 5450 fprintf (outfile, HOST_WIDE_INT_PRINT_UNSIGNED, val->v.val_unsigned); 5451 break; 5452 case dw_val_class_const_double: 5453 fprintf (outfile, "constant ("HOST_WIDE_INT_PRINT_DEC","\ 5454 HOST_WIDE_INT_PRINT_UNSIGNED")", 5455 val->v.val_double.high, 5456 val->v.val_double.low); 5457 break; 5458 case dw_val_class_wide_int: 5459 { 5460 int i = val->v.val_wide->get_len (); 5461 fprintf (outfile, "constant ("); 5462 gcc_assert (i > 0); 5463 if (val->v.val_wide->elt (i - 1) == 0) 5464 fprintf (outfile, "0x"); 5465 fprintf (outfile, HOST_WIDE_INT_PRINT_HEX, 5466 val->v.val_wide->elt (--i)); 5467 while (--i >= 0) 5468 fprintf (outfile, HOST_WIDE_INT_PRINT_PADDED_HEX, 5469 val->v.val_wide->elt (i)); 5470 fprintf (outfile, ")"); 5471 break; 5472 } 5473 case dw_val_class_vec: 5474 fprintf (outfile, "floating-point or vector constant"); 5475 break; 5476 case dw_val_class_flag: 5477 fprintf (outfile, "%u", val->v.val_flag); 5478 break; 5479 case dw_val_class_die_ref: 5480 if (val->v.val_die_ref.die != NULL) 5481 { 5482 dw_die_ref die = val->v.val_die_ref.die; 5483 5484 if (die->comdat_type_p) 5485 { 5486 fprintf (outfile, "die -> signature: "); 5487 print_signature (outfile, 5488 die->die_id.die_type_node->signature); 5489 } 5490 else if (die->die_id.die_symbol) 5491 fprintf (outfile, "die -> label: %s", die->die_id.die_symbol); 5492 else 5493 fprintf (outfile, "die -> %ld", die->die_offset); 5494 fprintf (outfile, " (%p)", (void *) die); 5495 } 5496 else 5497 fprintf (outfile, "die -> <null>"); 5498 break; 5499 case dw_val_class_vms_delta: 5500 fprintf (outfile, "delta: @slotcount(%s-%s)", 5501 val->v.val_vms_delta.lbl2, val->v.val_vms_delta.lbl1); 5502 break; 5503 case dw_val_class_lbl_id: 5504 case dw_val_class_lineptr: 5505 case dw_val_class_macptr: 5506 case dw_val_class_high_pc: 5507 fprintf (outfile, "label: %s", val->v.val_lbl_id); 5508 break; 5509 case dw_val_class_str: 5510 if (val->v.val_str->str != NULL) 5511 fprintf (outfile, "\"%s\"", val->v.val_str->str); 5512 else 5513 fprintf (outfile, "<null>"); 5514 break; 5515 case dw_val_class_file: 5516 fprintf (outfile, "\"%s\" (%d)", val->v.val_file->filename, 5517 val->v.val_file->emitted_number); 5518 break; 5519 case dw_val_class_data8: 5520 { 5521 int i; 5522 5523 for (i = 0; i < 8; i++) 5524 fprintf (outfile, "%02x", val->v.val_data8[i]); 5525 break; 5526 } 5527 default: 5528 break; 5529 } 5530} 5531 5532/* Likewise, for a DIE attribute. */ 5533 5534static void 5535print_attribute (dw_attr_ref a, bool recurse, FILE *outfile) 5536{ 5537 print_dw_val (&a->dw_attr_val, recurse, outfile); 5538} 5539 5540 5541/* Print the list of operands in the LOC location description to OUTFILE. This 5542 routine is a debugging aid only. */ 5543 5544static void 5545print_loc_descr (dw_loc_descr_ref loc, FILE *outfile) 5546{ 5547 dw_loc_descr_ref l = loc; 5548 5549 if (loc == NULL) 5550 { 5551 print_spaces (outfile); 5552 fprintf (outfile, "<null>\n"); 5553 return; 5554 } 5555 5556 for (l = loc; l != NULL; l = l->dw_loc_next) 5557 { 5558 print_spaces (outfile); 5559 fprintf (outfile, "(%p) %s", 5560 (void *) l, 5561 dwarf_stack_op_name (l->dw_loc_opc)); 5562 if (l->dw_loc_oprnd1.val_class != dw_val_class_none) 5563 { 5564 fprintf (outfile, " "); 5565 print_dw_val (&l->dw_loc_oprnd1, false, outfile); 5566 } 5567 if (l->dw_loc_oprnd2.val_class != dw_val_class_none) 5568 { 5569 fprintf (outfile, ", "); 5570 print_dw_val (&l->dw_loc_oprnd2, false, outfile); 5571 } 5572 fprintf (outfile, "\n"); 5573 } 5574} 5575 5576/* Print the information associated with a given DIE, and its children. 5577 This routine is a debugging aid only. */ 5578 5579static void 5580print_die (dw_die_ref die, FILE *outfile) 5581{ 5582 dw_attr_ref a; 5583 dw_die_ref c; 5584 unsigned ix; 5585 5586 print_spaces (outfile); 5587 fprintf (outfile, "DIE %4ld: %s (%p)\n", 5588 die->die_offset, dwarf_tag_name (die->die_tag), 5589 (void*) die); 5590 print_spaces (outfile); 5591 fprintf (outfile, " abbrev id: %lu", die->die_abbrev); 5592 fprintf (outfile, " offset: %ld", die->die_offset); 5593 fprintf (outfile, " mark: %d\n", die->die_mark); 5594 5595 if (die->comdat_type_p) 5596 { 5597 print_spaces (outfile); 5598 fprintf (outfile, " signature: "); 5599 print_signature (outfile, die->die_id.die_type_node->signature); 5600 fprintf (outfile, "\n"); 5601 } 5602 5603 FOR_EACH_VEC_SAFE_ELT (die->die_attr, ix, a) 5604 { 5605 print_spaces (outfile); 5606 fprintf (outfile, " %s: ", dwarf_attr_name (a->dw_attr)); 5607 5608 print_attribute (a, true, outfile); 5609 fprintf (outfile, "\n"); 5610 } 5611 5612 if (die->die_child != NULL) 5613 { 5614 print_indent += 4; 5615 FOR_EACH_CHILD (die, c, print_die (c, outfile)); 5616 print_indent -= 4; 5617 } 5618 if (print_indent == 0) 5619 fprintf (outfile, "\n"); 5620} 5621 5622/* Print the list of operations in the LOC location description. */ 5623 5624DEBUG_FUNCTION void 5625debug_dwarf_loc_descr (dw_loc_descr_ref loc) 5626{ 5627 print_loc_descr (loc, stderr); 5628} 5629 5630/* Print the information collected for a given DIE. */ 5631 5632DEBUG_FUNCTION void 5633debug_dwarf_die (dw_die_ref die) 5634{ 5635 print_die (die, stderr); 5636} 5637 5638DEBUG_FUNCTION void 5639debug (die_struct &ref) 5640{ 5641 print_die (&ref, stderr); 5642} 5643 5644DEBUG_FUNCTION void 5645debug (die_struct *ptr) 5646{ 5647 if (ptr) 5648 debug (*ptr); 5649 else 5650 fprintf (stderr, "<nil>\n"); 5651} 5652 5653 5654/* Print all DWARF information collected for the compilation unit. 5655 This routine is a debugging aid only. */ 5656 5657DEBUG_FUNCTION void 5658debug_dwarf (void) 5659{ 5660 print_indent = 0; 5661 print_die (comp_unit_die (), stderr); 5662} 5663 5664/* Start a new compilation unit DIE for an include file. OLD_UNIT is the CU 5665 for the enclosing include file, if any. BINCL_DIE is the DW_TAG_GNU_BINCL 5666 DIE that marks the start of the DIEs for this include file. */ 5667 5668static dw_die_ref 5669push_new_compile_unit (dw_die_ref old_unit, dw_die_ref bincl_die) 5670{ 5671 const char *filename = get_AT_string (bincl_die, DW_AT_name); 5672 dw_die_ref new_unit = gen_compile_unit_die (filename); 5673 5674 new_unit->die_sib = old_unit; 5675 return new_unit; 5676} 5677 5678/* Close an include-file CU and reopen the enclosing one. */ 5679 5680static dw_die_ref 5681pop_compile_unit (dw_die_ref old_unit) 5682{ 5683 dw_die_ref new_unit = old_unit->die_sib; 5684 5685 old_unit->die_sib = NULL; 5686 return new_unit; 5687} 5688 5689#define CHECKSUM(FOO) md5_process_bytes (&(FOO), sizeof (FOO), ctx) 5690#define CHECKSUM_BLOCK(FOO, SIZE) md5_process_bytes ((FOO), (SIZE), ctx) 5691#define CHECKSUM_STRING(FOO) md5_process_bytes ((FOO), strlen (FOO), ctx) 5692 5693/* Calculate the checksum of a location expression. */ 5694 5695static inline void 5696loc_checksum (dw_loc_descr_ref loc, struct md5_ctx *ctx) 5697{ 5698 int tem; 5699 inchash::hash hstate; 5700 hashval_t hash; 5701 5702 tem = (loc->dtprel << 8) | ((unsigned int) loc->dw_loc_opc); 5703 CHECKSUM (tem); 5704 hash_loc_operands (loc, hstate); 5705 hash = hstate.end(); 5706 CHECKSUM (hash); 5707} 5708 5709/* Calculate the checksum of an attribute. */ 5710 5711static void 5712attr_checksum (dw_attr_ref at, struct md5_ctx *ctx, int *mark) 5713{ 5714 dw_loc_descr_ref loc; 5715 rtx r; 5716 5717 CHECKSUM (at->dw_attr); 5718 5719 /* We don't care that this was compiled with a different compiler 5720 snapshot; if the output is the same, that's what matters. */ 5721 if (at->dw_attr == DW_AT_producer) 5722 return; 5723 5724 switch (AT_class (at)) 5725 { 5726 case dw_val_class_const: 5727 CHECKSUM (at->dw_attr_val.v.val_int); 5728 break; 5729 case dw_val_class_unsigned_const: 5730 CHECKSUM (at->dw_attr_val.v.val_unsigned); 5731 break; 5732 case dw_val_class_const_double: 5733 CHECKSUM (at->dw_attr_val.v.val_double); 5734 break; 5735 case dw_val_class_wide_int: 5736 CHECKSUM_BLOCK (at->dw_attr_val.v.val_wide->get_val (), 5737 get_full_len (*at->dw_attr_val.v.val_wide) 5738 * HOST_BITS_PER_WIDE_INT / HOST_BITS_PER_CHAR); 5739 break; 5740 case dw_val_class_vec: 5741 CHECKSUM_BLOCK (at->dw_attr_val.v.val_vec.array, 5742 (at->dw_attr_val.v.val_vec.length 5743 * at->dw_attr_val.v.val_vec.elt_size)); 5744 break; 5745 case dw_val_class_flag: 5746 CHECKSUM (at->dw_attr_val.v.val_flag); 5747 break; 5748 case dw_val_class_str: 5749 CHECKSUM_STRING (AT_string (at)); 5750 break; 5751 5752 case dw_val_class_addr: 5753 r = AT_addr (at); 5754 gcc_assert (GET_CODE (r) == SYMBOL_REF); 5755 CHECKSUM_STRING (XSTR (r, 0)); 5756 break; 5757 5758 case dw_val_class_offset: 5759 CHECKSUM (at->dw_attr_val.v.val_offset); 5760 break; 5761 5762 case dw_val_class_loc: 5763 for (loc = AT_loc (at); loc; loc = loc->dw_loc_next) 5764 loc_checksum (loc, ctx); 5765 break; 5766 5767 case dw_val_class_die_ref: 5768 die_checksum (AT_ref (at), ctx, mark); 5769 break; 5770 5771 case dw_val_class_fde_ref: 5772 case dw_val_class_vms_delta: 5773 case dw_val_class_lbl_id: 5774 case dw_val_class_lineptr: 5775 case dw_val_class_macptr: 5776 case dw_val_class_high_pc: 5777 break; 5778 5779 case dw_val_class_file: 5780 CHECKSUM_STRING (AT_file (at)->filename); 5781 break; 5782 5783 case dw_val_class_data8: 5784 CHECKSUM (at->dw_attr_val.v.val_data8); 5785 break; 5786 5787 default: 5788 break; 5789 } 5790} 5791 5792/* Calculate the checksum of a DIE. */ 5793 5794static void 5795die_checksum (dw_die_ref die, struct md5_ctx *ctx, int *mark) 5796{ 5797 dw_die_ref c; 5798 dw_attr_ref a; 5799 unsigned ix; 5800 5801 /* To avoid infinite recursion. */ 5802 if (die->die_mark) 5803 { 5804 CHECKSUM (die->die_mark); 5805 return; 5806 } 5807 die->die_mark = ++(*mark); 5808 5809 CHECKSUM (die->die_tag); 5810 5811 FOR_EACH_VEC_SAFE_ELT (die->die_attr, ix, a) 5812 attr_checksum (a, ctx, mark); 5813 5814 FOR_EACH_CHILD (die, c, die_checksum (c, ctx, mark)); 5815} 5816 5817#undef CHECKSUM 5818#undef CHECKSUM_BLOCK 5819#undef CHECKSUM_STRING 5820 5821/* For DWARF-4 types, include the trailing NULL when checksumming strings. */ 5822#define CHECKSUM(FOO) md5_process_bytes (&(FOO), sizeof (FOO), ctx) 5823#define CHECKSUM_BLOCK(FOO, SIZE) md5_process_bytes ((FOO), (SIZE), ctx) 5824#define CHECKSUM_STRING(FOO) md5_process_bytes ((FOO), strlen (FOO) + 1, ctx) 5825#define CHECKSUM_SLEB128(FOO) checksum_sleb128 ((FOO), ctx) 5826#define CHECKSUM_ULEB128(FOO) checksum_uleb128 ((FOO), ctx) 5827#define CHECKSUM_ATTR(FOO) \ 5828 if (FOO) attr_checksum_ordered (die->die_tag, (FOO), ctx, mark) 5829 5830/* Calculate the checksum of a number in signed LEB128 format. */ 5831 5832static void 5833checksum_sleb128 (HOST_WIDE_INT value, struct md5_ctx *ctx) 5834{ 5835 unsigned char byte; 5836 bool more; 5837 5838 while (1) 5839 { 5840 byte = (value & 0x7f); 5841 value >>= 7; 5842 more = !((value == 0 && (byte & 0x40) == 0) 5843 || (value == -1 && (byte & 0x40) != 0)); 5844 if (more) 5845 byte |= 0x80; 5846 CHECKSUM (byte); 5847 if (!more) 5848 break; 5849 } 5850} 5851 5852/* Calculate the checksum of a number in unsigned LEB128 format. */ 5853 5854static void 5855checksum_uleb128 (unsigned HOST_WIDE_INT value, struct md5_ctx *ctx) 5856{ 5857 while (1) 5858 { 5859 unsigned char byte = (value & 0x7f); 5860 value >>= 7; 5861 if (value != 0) 5862 /* More bytes to follow. */ 5863 byte |= 0x80; 5864 CHECKSUM (byte); 5865 if (value == 0) 5866 break; 5867 } 5868} 5869 5870/* Checksum the context of the DIE. This adds the names of any 5871 surrounding namespaces or structures to the checksum. */ 5872 5873static void 5874checksum_die_context (dw_die_ref die, struct md5_ctx *ctx) 5875{ 5876 const char *name; 5877 dw_die_ref spec; 5878 int tag = die->die_tag; 5879 5880 if (tag != DW_TAG_namespace 5881 && tag != DW_TAG_structure_type 5882 && tag != DW_TAG_class_type) 5883 return; 5884 5885 name = get_AT_string (die, DW_AT_name); 5886 5887 spec = get_AT_ref (die, DW_AT_specification); 5888 if (spec != NULL) 5889 die = spec; 5890 5891 if (die->die_parent != NULL) 5892 checksum_die_context (die->die_parent, ctx); 5893 5894 CHECKSUM_ULEB128 ('C'); 5895 CHECKSUM_ULEB128 (tag); 5896 if (name != NULL) 5897 CHECKSUM_STRING (name); 5898} 5899 5900/* Calculate the checksum of a location expression. */ 5901 5902static inline void 5903loc_checksum_ordered (dw_loc_descr_ref loc, struct md5_ctx *ctx) 5904{ 5905 /* Special case for lone DW_OP_plus_uconst: checksum as if the location 5906 were emitted as a DW_FORM_sdata instead of a location expression. */ 5907 if (loc->dw_loc_opc == DW_OP_plus_uconst && loc->dw_loc_next == NULL) 5908 { 5909 CHECKSUM_ULEB128 (DW_FORM_sdata); 5910 CHECKSUM_SLEB128 ((HOST_WIDE_INT) loc->dw_loc_oprnd1.v.val_unsigned); 5911 return; 5912 } 5913 5914 /* Otherwise, just checksum the raw location expression. */ 5915 while (loc != NULL) 5916 { 5917 inchash::hash hstate; 5918 hashval_t hash; 5919 5920 CHECKSUM_ULEB128 (loc->dtprel); 5921 CHECKSUM_ULEB128 (loc->dw_loc_opc); 5922 hash_loc_operands (loc, hstate); 5923 hash = hstate.end (); 5924 CHECKSUM (hash); 5925 loc = loc->dw_loc_next; 5926 } 5927} 5928 5929/* Calculate the checksum of an attribute. */ 5930 5931static void 5932attr_checksum_ordered (enum dwarf_tag tag, dw_attr_ref at, 5933 struct md5_ctx *ctx, int *mark) 5934{ 5935 dw_loc_descr_ref loc; 5936 rtx r; 5937 5938 if (AT_class (at) == dw_val_class_die_ref) 5939 { 5940 dw_die_ref target_die = AT_ref (at); 5941 5942 /* For pointer and reference types, we checksum only the (qualified) 5943 name of the target type (if there is a name). For friend entries, 5944 we checksum only the (qualified) name of the target type or function. 5945 This allows the checksum to remain the same whether the target type 5946 is complete or not. */ 5947 if ((at->dw_attr == DW_AT_type 5948 && (tag == DW_TAG_pointer_type 5949 || tag == DW_TAG_reference_type 5950 || tag == DW_TAG_rvalue_reference_type 5951 || tag == DW_TAG_ptr_to_member_type)) 5952 || (at->dw_attr == DW_AT_friend 5953 && tag == DW_TAG_friend)) 5954 { 5955 dw_attr_ref name_attr = get_AT (target_die, DW_AT_name); 5956 5957 if (name_attr != NULL) 5958 { 5959 dw_die_ref decl = get_AT_ref (target_die, DW_AT_specification); 5960 5961 if (decl == NULL) 5962 decl = target_die; 5963 CHECKSUM_ULEB128 ('N'); 5964 CHECKSUM_ULEB128 (at->dw_attr); 5965 if (decl->die_parent != NULL) 5966 checksum_die_context (decl->die_parent, ctx); 5967 CHECKSUM_ULEB128 ('E'); 5968 CHECKSUM_STRING (AT_string (name_attr)); 5969 return; 5970 } 5971 } 5972 5973 /* For all other references to another DIE, we check to see if the 5974 target DIE has already been visited. If it has, we emit a 5975 backward reference; if not, we descend recursively. */ 5976 if (target_die->die_mark > 0) 5977 { 5978 CHECKSUM_ULEB128 ('R'); 5979 CHECKSUM_ULEB128 (at->dw_attr); 5980 CHECKSUM_ULEB128 (target_die->die_mark); 5981 } 5982 else 5983 { 5984 dw_die_ref decl = get_AT_ref (target_die, DW_AT_specification); 5985 5986 if (decl == NULL) 5987 decl = target_die; 5988 target_die->die_mark = ++(*mark); 5989 CHECKSUM_ULEB128 ('T'); 5990 CHECKSUM_ULEB128 (at->dw_attr); 5991 if (decl->die_parent != NULL) 5992 checksum_die_context (decl->die_parent, ctx); 5993 die_checksum_ordered (target_die, ctx, mark); 5994 } 5995 return; 5996 } 5997 5998 CHECKSUM_ULEB128 ('A'); 5999 CHECKSUM_ULEB128 (at->dw_attr); 6000 6001 switch (AT_class (at)) 6002 { 6003 case dw_val_class_const: 6004 CHECKSUM_ULEB128 (DW_FORM_sdata); 6005 CHECKSUM_SLEB128 (at->dw_attr_val.v.val_int); 6006 break; 6007 6008 case dw_val_class_unsigned_const: 6009 CHECKSUM_ULEB128 (DW_FORM_sdata); 6010 CHECKSUM_SLEB128 ((int) at->dw_attr_val.v.val_unsigned); 6011 break; 6012 6013 case dw_val_class_const_double: 6014 CHECKSUM_ULEB128 (DW_FORM_block); 6015 CHECKSUM_ULEB128 (sizeof (at->dw_attr_val.v.val_double)); 6016 CHECKSUM (at->dw_attr_val.v.val_double); 6017 break; 6018 6019 case dw_val_class_wide_int: 6020 CHECKSUM_ULEB128 (DW_FORM_block); 6021 CHECKSUM_ULEB128 (get_full_len (*at->dw_attr_val.v.val_wide) 6022 * HOST_BITS_PER_WIDE_INT / BITS_PER_UNIT); 6023 CHECKSUM_BLOCK (at->dw_attr_val.v.val_wide->get_val (), 6024 get_full_len (*at->dw_attr_val.v.val_wide) 6025 * HOST_BITS_PER_WIDE_INT / HOST_BITS_PER_CHAR); 6026 break; 6027 6028 case dw_val_class_vec: 6029 CHECKSUM_ULEB128 (DW_FORM_block); 6030 CHECKSUM_ULEB128 (at->dw_attr_val.v.val_vec.length 6031 * at->dw_attr_val.v.val_vec.elt_size); 6032 CHECKSUM_BLOCK (at->dw_attr_val.v.val_vec.array, 6033 (at->dw_attr_val.v.val_vec.length 6034 * at->dw_attr_val.v.val_vec.elt_size)); 6035 break; 6036 6037 case dw_val_class_flag: 6038 CHECKSUM_ULEB128 (DW_FORM_flag); 6039 CHECKSUM_ULEB128 (at->dw_attr_val.v.val_flag ? 1 : 0); 6040 break; 6041 6042 case dw_val_class_str: 6043 CHECKSUM_ULEB128 (DW_FORM_string); 6044 CHECKSUM_STRING (AT_string (at)); 6045 break; 6046 6047 case dw_val_class_addr: 6048 r = AT_addr (at); 6049 gcc_assert (GET_CODE (r) == SYMBOL_REF); 6050 CHECKSUM_ULEB128 (DW_FORM_string); 6051 CHECKSUM_STRING (XSTR (r, 0)); 6052 break; 6053 6054 case dw_val_class_offset: 6055 CHECKSUM_ULEB128 (DW_FORM_sdata); 6056 CHECKSUM_ULEB128 (at->dw_attr_val.v.val_offset); 6057 break; 6058 6059 case dw_val_class_loc: 6060 for (loc = AT_loc (at); loc; loc = loc->dw_loc_next) 6061 loc_checksum_ordered (loc, ctx); 6062 break; 6063 6064 case dw_val_class_fde_ref: 6065 case dw_val_class_lbl_id: 6066 case dw_val_class_lineptr: 6067 case dw_val_class_macptr: 6068 case dw_val_class_high_pc: 6069 break; 6070 6071 case dw_val_class_file: 6072 CHECKSUM_ULEB128 (DW_FORM_string); 6073 CHECKSUM_STRING (AT_file (at)->filename); 6074 break; 6075 6076 case dw_val_class_data8: 6077 CHECKSUM (at->dw_attr_val.v.val_data8); 6078 break; 6079 6080 default: 6081 break; 6082 } 6083} 6084 6085struct checksum_attributes 6086{ 6087 dw_attr_ref at_name; 6088 dw_attr_ref at_type; 6089 dw_attr_ref at_friend; 6090 dw_attr_ref at_accessibility; 6091 dw_attr_ref at_address_class; 6092 dw_attr_ref at_allocated; 6093 dw_attr_ref at_artificial; 6094 dw_attr_ref at_associated; 6095 dw_attr_ref at_binary_scale; 6096 dw_attr_ref at_bit_offset; 6097 dw_attr_ref at_bit_size; 6098 dw_attr_ref at_bit_stride; 6099 dw_attr_ref at_byte_size; 6100 dw_attr_ref at_byte_stride; 6101 dw_attr_ref at_const_value; 6102 dw_attr_ref at_containing_type; 6103 dw_attr_ref at_count; 6104 dw_attr_ref at_data_location; 6105 dw_attr_ref at_data_member_location; 6106 dw_attr_ref at_decimal_scale; 6107 dw_attr_ref at_decimal_sign; 6108 dw_attr_ref at_default_value; 6109 dw_attr_ref at_digit_count; 6110 dw_attr_ref at_discr; 6111 dw_attr_ref at_discr_list; 6112 dw_attr_ref at_discr_value; 6113 dw_attr_ref at_encoding; 6114 dw_attr_ref at_endianity; 6115 dw_attr_ref at_explicit; 6116 dw_attr_ref at_is_optional; 6117 dw_attr_ref at_location; 6118 dw_attr_ref at_lower_bound; 6119 dw_attr_ref at_mutable; 6120 dw_attr_ref at_ordering; 6121 dw_attr_ref at_picture_string; 6122 dw_attr_ref at_prototyped; 6123 dw_attr_ref at_small; 6124 dw_attr_ref at_segment; 6125 dw_attr_ref at_string_length; 6126 dw_attr_ref at_threads_scaled; 6127 dw_attr_ref at_upper_bound; 6128 dw_attr_ref at_use_location; 6129 dw_attr_ref at_use_UTF8; 6130 dw_attr_ref at_variable_parameter; 6131 dw_attr_ref at_virtuality; 6132 dw_attr_ref at_visibility; 6133 dw_attr_ref at_vtable_elem_location; 6134}; 6135 6136/* Collect the attributes that we will want to use for the checksum. */ 6137 6138static void 6139collect_checksum_attributes (struct checksum_attributes *attrs, dw_die_ref die) 6140{ 6141 dw_attr_ref a; 6142 unsigned ix; 6143 6144 FOR_EACH_VEC_SAFE_ELT (die->die_attr, ix, a) 6145 { 6146 switch (a->dw_attr) 6147 { 6148 case DW_AT_name: 6149 attrs->at_name = a; 6150 break; 6151 case DW_AT_type: 6152 attrs->at_type = a; 6153 break; 6154 case DW_AT_friend: 6155 attrs->at_friend = a; 6156 break; 6157 case DW_AT_accessibility: 6158 attrs->at_accessibility = a; 6159 break; 6160 case DW_AT_address_class: 6161 attrs->at_address_class = a; 6162 break; 6163 case DW_AT_allocated: 6164 attrs->at_allocated = a; 6165 break; 6166 case DW_AT_artificial: 6167 attrs->at_artificial = a; 6168 break; 6169 case DW_AT_associated: 6170 attrs->at_associated = a; 6171 break; 6172 case DW_AT_binary_scale: 6173 attrs->at_binary_scale = a; 6174 break; 6175 case DW_AT_bit_offset: 6176 attrs->at_bit_offset = a; 6177 break; 6178 case DW_AT_bit_size: 6179 attrs->at_bit_size = a; 6180 break; 6181 case DW_AT_bit_stride: 6182 attrs->at_bit_stride = a; 6183 break; 6184 case DW_AT_byte_size: 6185 attrs->at_byte_size = a; 6186 break; 6187 case DW_AT_byte_stride: 6188 attrs->at_byte_stride = a; 6189 break; 6190 case DW_AT_const_value: 6191 attrs->at_const_value = a; 6192 break; 6193 case DW_AT_containing_type: 6194 attrs->at_containing_type = a; 6195 break; 6196 case DW_AT_count: 6197 attrs->at_count = a; 6198 break; 6199 case DW_AT_data_location: 6200 attrs->at_data_location = a; 6201 break; 6202 case DW_AT_data_member_location: 6203 attrs->at_data_member_location = a; 6204 break; 6205 case DW_AT_decimal_scale: 6206 attrs->at_decimal_scale = a; 6207 break; 6208 case DW_AT_decimal_sign: 6209 attrs->at_decimal_sign = a; 6210 break; 6211 case DW_AT_default_value: 6212 attrs->at_default_value = a; 6213 break; 6214 case DW_AT_digit_count: 6215 attrs->at_digit_count = a; 6216 break; 6217 case DW_AT_discr: 6218 attrs->at_discr = a; 6219 break; 6220 case DW_AT_discr_list: 6221 attrs->at_discr_list = a; 6222 break; 6223 case DW_AT_discr_value: 6224 attrs->at_discr_value = a; 6225 break; 6226 case DW_AT_encoding: 6227 attrs->at_encoding = a; 6228 break; 6229 case DW_AT_endianity: 6230 attrs->at_endianity = a; 6231 break; 6232 case DW_AT_explicit: 6233 attrs->at_explicit = a; 6234 break; 6235 case DW_AT_is_optional: 6236 attrs->at_is_optional = a; 6237 break; 6238 case DW_AT_location: 6239 attrs->at_location = a; 6240 break; 6241 case DW_AT_lower_bound: 6242 attrs->at_lower_bound = a; 6243 break; 6244 case DW_AT_mutable: 6245 attrs->at_mutable = a; 6246 break; 6247 case DW_AT_ordering: 6248 attrs->at_ordering = a; 6249 break; 6250 case DW_AT_picture_string: 6251 attrs->at_picture_string = a; 6252 break; 6253 case DW_AT_prototyped: 6254 attrs->at_prototyped = a; 6255 break; 6256 case DW_AT_small: 6257 attrs->at_small = a; 6258 break; 6259 case DW_AT_segment: 6260 attrs->at_segment = a; 6261 break; 6262 case DW_AT_string_length: 6263 attrs->at_string_length = a; 6264 break; 6265 case DW_AT_threads_scaled: 6266 attrs->at_threads_scaled = a; 6267 break; 6268 case DW_AT_upper_bound: 6269 attrs->at_upper_bound = a; 6270 break; 6271 case DW_AT_use_location: 6272 attrs->at_use_location = a; 6273 break; 6274 case DW_AT_use_UTF8: 6275 attrs->at_use_UTF8 = a; 6276 break; 6277 case DW_AT_variable_parameter: 6278 attrs->at_variable_parameter = a; 6279 break; 6280 case DW_AT_virtuality: 6281 attrs->at_virtuality = a; 6282 break; 6283 case DW_AT_visibility: 6284 attrs->at_visibility = a; 6285 break; 6286 case DW_AT_vtable_elem_location: 6287 attrs->at_vtable_elem_location = a; 6288 break; 6289 default: 6290 break; 6291 } 6292 } 6293} 6294 6295/* Calculate the checksum of a DIE, using an ordered subset of attributes. */ 6296 6297static void 6298die_checksum_ordered (dw_die_ref die, struct md5_ctx *ctx, int *mark) 6299{ 6300 dw_die_ref c; 6301 dw_die_ref decl; 6302 struct checksum_attributes attrs; 6303 6304 CHECKSUM_ULEB128 ('D'); 6305 CHECKSUM_ULEB128 (die->die_tag); 6306 6307 memset (&attrs, 0, sizeof (attrs)); 6308 6309 decl = get_AT_ref (die, DW_AT_specification); 6310 if (decl != NULL) 6311 collect_checksum_attributes (&attrs, decl); 6312 collect_checksum_attributes (&attrs, die); 6313 6314 CHECKSUM_ATTR (attrs.at_name); 6315 CHECKSUM_ATTR (attrs.at_accessibility); 6316 CHECKSUM_ATTR (attrs.at_address_class); 6317 CHECKSUM_ATTR (attrs.at_allocated); 6318 CHECKSUM_ATTR (attrs.at_artificial); 6319 CHECKSUM_ATTR (attrs.at_associated); 6320 CHECKSUM_ATTR (attrs.at_binary_scale); 6321 CHECKSUM_ATTR (attrs.at_bit_offset); 6322 CHECKSUM_ATTR (attrs.at_bit_size); 6323 CHECKSUM_ATTR (attrs.at_bit_stride); 6324 CHECKSUM_ATTR (attrs.at_byte_size); 6325 CHECKSUM_ATTR (attrs.at_byte_stride); 6326 CHECKSUM_ATTR (attrs.at_const_value); 6327 CHECKSUM_ATTR (attrs.at_containing_type); 6328 CHECKSUM_ATTR (attrs.at_count); 6329 CHECKSUM_ATTR (attrs.at_data_location); 6330 CHECKSUM_ATTR (attrs.at_data_member_location); 6331 CHECKSUM_ATTR (attrs.at_decimal_scale); 6332 CHECKSUM_ATTR (attrs.at_decimal_sign); 6333 CHECKSUM_ATTR (attrs.at_default_value); 6334 CHECKSUM_ATTR (attrs.at_digit_count); 6335 CHECKSUM_ATTR (attrs.at_discr); 6336 CHECKSUM_ATTR (attrs.at_discr_list); 6337 CHECKSUM_ATTR (attrs.at_discr_value); 6338 CHECKSUM_ATTR (attrs.at_encoding); 6339 CHECKSUM_ATTR (attrs.at_endianity); 6340 CHECKSUM_ATTR (attrs.at_explicit); 6341 CHECKSUM_ATTR (attrs.at_is_optional); 6342 CHECKSUM_ATTR (attrs.at_location); 6343 CHECKSUM_ATTR (attrs.at_lower_bound); 6344 CHECKSUM_ATTR (attrs.at_mutable); 6345 CHECKSUM_ATTR (attrs.at_ordering); 6346 CHECKSUM_ATTR (attrs.at_picture_string); 6347 CHECKSUM_ATTR (attrs.at_prototyped); 6348 CHECKSUM_ATTR (attrs.at_small); 6349 CHECKSUM_ATTR (attrs.at_segment); 6350 CHECKSUM_ATTR (attrs.at_string_length); 6351 CHECKSUM_ATTR (attrs.at_threads_scaled); 6352 CHECKSUM_ATTR (attrs.at_upper_bound); 6353 CHECKSUM_ATTR (attrs.at_use_location); 6354 CHECKSUM_ATTR (attrs.at_use_UTF8); 6355 CHECKSUM_ATTR (attrs.at_variable_parameter); 6356 CHECKSUM_ATTR (attrs.at_virtuality); 6357 CHECKSUM_ATTR (attrs.at_visibility); 6358 CHECKSUM_ATTR (attrs.at_vtable_elem_location); 6359 CHECKSUM_ATTR (attrs.at_type); 6360 CHECKSUM_ATTR (attrs.at_friend); 6361 6362 /* Checksum the child DIEs. */ 6363 c = die->die_child; 6364 if (c) do { 6365 dw_attr_ref name_attr; 6366 6367 c = c->die_sib; 6368 name_attr = get_AT (c, DW_AT_name); 6369 if (is_template_instantiation (c)) 6370 { 6371 /* Ignore instantiations of member type and function templates. */ 6372 } 6373 else if (name_attr != NULL 6374 && (is_type_die (c) || c->die_tag == DW_TAG_subprogram)) 6375 { 6376 /* Use a shallow checksum for named nested types and member 6377 functions. */ 6378 CHECKSUM_ULEB128 ('S'); 6379 CHECKSUM_ULEB128 (c->die_tag); 6380 CHECKSUM_STRING (AT_string (name_attr)); 6381 } 6382 else 6383 { 6384 /* Use a deep checksum for other children. */ 6385 /* Mark this DIE so it gets processed when unmarking. */ 6386 if (c->die_mark == 0) 6387 c->die_mark = -1; 6388 die_checksum_ordered (c, ctx, mark); 6389 } 6390 } while (c != die->die_child); 6391 6392 CHECKSUM_ULEB128 (0); 6393} 6394 6395/* Add a type name and tag to a hash. */ 6396static void 6397die_odr_checksum (int tag, const char *name, md5_ctx *ctx) 6398{ 6399 CHECKSUM_ULEB128 (tag); 6400 CHECKSUM_STRING (name); 6401} 6402 6403#undef CHECKSUM 6404#undef CHECKSUM_STRING 6405#undef CHECKSUM_ATTR 6406#undef CHECKSUM_LEB128 6407#undef CHECKSUM_ULEB128 6408 6409/* Generate the type signature for DIE. This is computed by generating an 6410 MD5 checksum over the DIE's tag, its relevant attributes, and its 6411 children. Attributes that are references to other DIEs are processed 6412 by recursion, using the MARK field to prevent infinite recursion. 6413 If the DIE is nested inside a namespace or another type, we also 6414 need to include that context in the signature. The lower 64 bits 6415 of the resulting MD5 checksum comprise the signature. */ 6416 6417static void 6418generate_type_signature (dw_die_ref die, comdat_type_node *type_node) 6419{ 6420 int mark; 6421 const char *name; 6422 unsigned char checksum[16]; 6423 struct md5_ctx ctx; 6424 dw_die_ref decl; 6425 dw_die_ref parent; 6426 6427 name = get_AT_string (die, DW_AT_name); 6428 decl = get_AT_ref (die, DW_AT_specification); 6429 parent = get_die_parent (die); 6430 6431 /* First, compute a signature for just the type name (and its surrounding 6432 context, if any. This is stored in the type unit DIE for link-time 6433 ODR (one-definition rule) checking. */ 6434 6435 if (is_cxx () && name != NULL) 6436 { 6437 md5_init_ctx (&ctx); 6438 6439 /* Checksum the names of surrounding namespaces and structures. */ 6440 if (parent != NULL) 6441 checksum_die_context (parent, &ctx); 6442 6443 /* Checksum the current DIE. */ 6444 die_odr_checksum (die->die_tag, name, &ctx); 6445 md5_finish_ctx (&ctx, checksum); 6446 6447 add_AT_data8 (type_node->root_die, DW_AT_GNU_odr_signature, &checksum[8]); 6448 } 6449 6450 /* Next, compute the complete type signature. */ 6451 6452 md5_init_ctx (&ctx); 6453 mark = 1; 6454 die->die_mark = mark; 6455 6456 /* Checksum the names of surrounding namespaces and structures. */ 6457 if (parent != NULL) 6458 checksum_die_context (parent, &ctx); 6459 6460 /* Checksum the DIE and its children. */ 6461 die_checksum_ordered (die, &ctx, &mark); 6462 unmark_all_dies (die); 6463 md5_finish_ctx (&ctx, checksum); 6464 6465 /* Store the signature in the type node and link the type DIE and the 6466 type node together. */ 6467 memcpy (type_node->signature, &checksum[16 - DWARF_TYPE_SIGNATURE_SIZE], 6468 DWARF_TYPE_SIGNATURE_SIZE); 6469 die->comdat_type_p = true; 6470 die->die_id.die_type_node = type_node; 6471 type_node->type_die = die; 6472 6473 /* If the DIE is a specification, link its declaration to the type node 6474 as well. */ 6475 if (decl != NULL) 6476 { 6477 decl->comdat_type_p = true; 6478 decl->die_id.die_type_node = type_node; 6479 } 6480} 6481 6482/* Do the location expressions look same? */ 6483static inline int 6484same_loc_p (dw_loc_descr_ref loc1, dw_loc_descr_ref loc2, int *mark) 6485{ 6486 return loc1->dw_loc_opc == loc2->dw_loc_opc 6487 && same_dw_val_p (&loc1->dw_loc_oprnd1, &loc2->dw_loc_oprnd1, mark) 6488 && same_dw_val_p (&loc1->dw_loc_oprnd2, &loc2->dw_loc_oprnd2, mark); 6489} 6490 6491/* Do the values look the same? */ 6492static int 6493same_dw_val_p (const dw_val_node *v1, const dw_val_node *v2, int *mark) 6494{ 6495 dw_loc_descr_ref loc1, loc2; 6496 rtx r1, r2; 6497 6498 if (v1->val_class != v2->val_class) 6499 return 0; 6500 6501 switch (v1->val_class) 6502 { 6503 case dw_val_class_const: 6504 return v1->v.val_int == v2->v.val_int; 6505 case dw_val_class_unsigned_const: 6506 return v1->v.val_unsigned == v2->v.val_unsigned; 6507 case dw_val_class_const_double: 6508 return v1->v.val_double.high == v2->v.val_double.high 6509 && v1->v.val_double.low == v2->v.val_double.low; 6510 case dw_val_class_wide_int: 6511 return *v1->v.val_wide == *v2->v.val_wide; 6512 case dw_val_class_vec: 6513 if (v1->v.val_vec.length != v2->v.val_vec.length 6514 || v1->v.val_vec.elt_size != v2->v.val_vec.elt_size) 6515 return 0; 6516 if (memcmp (v1->v.val_vec.array, v2->v.val_vec.array, 6517 v1->v.val_vec.length * v1->v.val_vec.elt_size)) 6518 return 0; 6519 return 1; 6520 case dw_val_class_flag: 6521 return v1->v.val_flag == v2->v.val_flag; 6522 case dw_val_class_str: 6523 return !strcmp (v1->v.val_str->str, v2->v.val_str->str); 6524 6525 case dw_val_class_addr: 6526 r1 = v1->v.val_addr; 6527 r2 = v2->v.val_addr; 6528 if (GET_CODE (r1) != GET_CODE (r2)) 6529 return 0; 6530 return !rtx_equal_p (r1, r2); 6531 6532 case dw_val_class_offset: 6533 return v1->v.val_offset == v2->v.val_offset; 6534 6535 case dw_val_class_loc: 6536 for (loc1 = v1->v.val_loc, loc2 = v2->v.val_loc; 6537 loc1 && loc2; 6538 loc1 = loc1->dw_loc_next, loc2 = loc2->dw_loc_next) 6539 if (!same_loc_p (loc1, loc2, mark)) 6540 return 0; 6541 return !loc1 && !loc2; 6542 6543 case dw_val_class_die_ref: 6544 return same_die_p (v1->v.val_die_ref.die, v2->v.val_die_ref.die, mark); 6545 6546 case dw_val_class_fde_ref: 6547 case dw_val_class_vms_delta: 6548 case dw_val_class_lbl_id: 6549 case dw_val_class_lineptr: 6550 case dw_val_class_macptr: 6551 case dw_val_class_high_pc: 6552 return 1; 6553 6554 case dw_val_class_file: 6555 return v1->v.val_file == v2->v.val_file; 6556 6557 case dw_val_class_data8: 6558 return !memcmp (v1->v.val_data8, v2->v.val_data8, 8); 6559 6560 default: 6561 return 1; 6562 } 6563} 6564 6565/* Do the attributes look the same? */ 6566 6567static int 6568same_attr_p (dw_attr_ref at1, dw_attr_ref at2, int *mark) 6569{ 6570 if (at1->dw_attr != at2->dw_attr) 6571 return 0; 6572 6573 /* We don't care that this was compiled with a different compiler 6574 snapshot; if the output is the same, that's what matters. */ 6575 if (at1->dw_attr == DW_AT_producer) 6576 return 1; 6577 6578 return same_dw_val_p (&at1->dw_attr_val, &at2->dw_attr_val, mark); 6579} 6580 6581/* Do the dies look the same? */ 6582 6583static int 6584same_die_p (dw_die_ref die1, dw_die_ref die2, int *mark) 6585{ 6586 dw_die_ref c1, c2; 6587 dw_attr_ref a1; 6588 unsigned ix; 6589 6590 /* To avoid infinite recursion. */ 6591 if (die1->die_mark) 6592 return die1->die_mark == die2->die_mark; 6593 die1->die_mark = die2->die_mark = ++(*mark); 6594 6595 if (die1->die_tag != die2->die_tag) 6596 return 0; 6597 6598 if (vec_safe_length (die1->die_attr) != vec_safe_length (die2->die_attr)) 6599 return 0; 6600 6601 FOR_EACH_VEC_SAFE_ELT (die1->die_attr, ix, a1) 6602 if (!same_attr_p (a1, &(*die2->die_attr)[ix], mark)) 6603 return 0; 6604 6605 c1 = die1->die_child; 6606 c2 = die2->die_child; 6607 if (! c1) 6608 { 6609 if (c2) 6610 return 0; 6611 } 6612 else 6613 for (;;) 6614 { 6615 if (!same_die_p (c1, c2, mark)) 6616 return 0; 6617 c1 = c1->die_sib; 6618 c2 = c2->die_sib; 6619 if (c1 == die1->die_child) 6620 { 6621 if (c2 == die2->die_child) 6622 break; 6623 else 6624 return 0; 6625 } 6626 } 6627 6628 return 1; 6629} 6630 6631/* Do the dies look the same? Wrapper around same_die_p. */ 6632 6633static int 6634same_die_p_wrap (dw_die_ref die1, dw_die_ref die2) 6635{ 6636 int mark = 0; 6637 int ret = same_die_p (die1, die2, &mark); 6638 6639 unmark_all_dies (die1); 6640 unmark_all_dies (die2); 6641 6642 return ret; 6643} 6644 6645/* The prefix to attach to symbols on DIEs in the current comdat debug 6646 info section. */ 6647static const char *comdat_symbol_id; 6648 6649/* The index of the current symbol within the current comdat CU. */ 6650static unsigned int comdat_symbol_number; 6651 6652/* Calculate the MD5 checksum of the compilation unit DIE UNIT_DIE and its 6653 children, and set comdat_symbol_id accordingly. */ 6654 6655static void 6656compute_section_prefix (dw_die_ref unit_die) 6657{ 6658 const char *die_name = get_AT_string (unit_die, DW_AT_name); 6659 const char *base = die_name ? lbasename (die_name) : "anonymous"; 6660 char *name = XALLOCAVEC (char, strlen (base) + 64); 6661 char *p; 6662 int i, mark; 6663 unsigned char checksum[16]; 6664 struct md5_ctx ctx; 6665 6666 /* Compute the checksum of the DIE, then append part of it as hex digits to 6667 the name filename of the unit. */ 6668 6669 md5_init_ctx (&ctx); 6670 mark = 0; 6671 die_checksum (unit_die, &ctx, &mark); 6672 unmark_all_dies (unit_die); 6673 md5_finish_ctx (&ctx, checksum); 6674 6675 sprintf (name, "%s.", base); 6676 clean_symbol_name (name); 6677 6678 p = name + strlen (name); 6679 for (i = 0; i < 4; i++) 6680 { 6681 sprintf (p, "%.2x", checksum[i]); 6682 p += 2; 6683 } 6684 6685 comdat_symbol_id = unit_die->die_id.die_symbol = xstrdup (name); 6686 comdat_symbol_number = 0; 6687} 6688 6689/* Returns nonzero if DIE represents a type, in the sense of TYPE_P. */ 6690 6691static int 6692is_type_die (dw_die_ref die) 6693{ 6694 switch (die->die_tag) 6695 { 6696 case DW_TAG_array_type: 6697 case DW_TAG_class_type: 6698 case DW_TAG_interface_type: 6699 case DW_TAG_enumeration_type: 6700 case DW_TAG_pointer_type: 6701 case DW_TAG_reference_type: 6702 case DW_TAG_rvalue_reference_type: 6703 case DW_TAG_string_type: 6704 case DW_TAG_structure_type: 6705 case DW_TAG_subroutine_type: 6706 case DW_TAG_union_type: 6707 case DW_TAG_ptr_to_member_type: 6708 case DW_TAG_set_type: 6709 case DW_TAG_subrange_type: 6710 case DW_TAG_base_type: 6711 case DW_TAG_const_type: 6712 case DW_TAG_file_type: 6713 case DW_TAG_packed_type: 6714 case DW_TAG_volatile_type: 6715 case DW_TAG_typedef: 6716 return 1; 6717 default: 6718 return 0; 6719 } 6720} 6721 6722/* Returns 1 iff C is the sort of DIE that should go into a COMDAT CU. 6723 Basically, we want to choose the bits that are likely to be shared between 6724 compilations (types) and leave out the bits that are specific to individual 6725 compilations (functions). */ 6726 6727static int 6728is_comdat_die (dw_die_ref c) 6729{ 6730 /* I think we want to leave base types and __vtbl_ptr_type in the main CU, as 6731 we do for stabs. The advantage is a greater likelihood of sharing between 6732 objects that don't include headers in the same order (and therefore would 6733 put the base types in a different comdat). jason 8/28/00 */ 6734 6735 if (c->die_tag == DW_TAG_base_type) 6736 return 0; 6737 6738 if (c->die_tag == DW_TAG_pointer_type 6739 || c->die_tag == DW_TAG_reference_type 6740 || c->die_tag == DW_TAG_rvalue_reference_type 6741 || c->die_tag == DW_TAG_const_type 6742 || c->die_tag == DW_TAG_volatile_type) 6743 { 6744 dw_die_ref t = get_AT_ref (c, DW_AT_type); 6745 6746 return t ? is_comdat_die (t) : 0; 6747 } 6748 6749 return is_type_die (c); 6750} 6751 6752/* Returns 1 iff C is the sort of DIE that might be referred to from another 6753 compilation unit. */ 6754 6755static int 6756is_symbol_die (dw_die_ref c) 6757{ 6758 return (is_type_die (c) 6759 || is_declaration_die (c) 6760 || c->die_tag == DW_TAG_namespace 6761 || c->die_tag == DW_TAG_module); 6762} 6763 6764/* Returns true iff C is a compile-unit DIE. */ 6765 6766static inline bool 6767is_cu_die (dw_die_ref c) 6768{ 6769 return c && c->die_tag == DW_TAG_compile_unit; 6770} 6771 6772/* Returns true iff C is a unit DIE of some sort. */ 6773 6774static inline bool 6775is_unit_die (dw_die_ref c) 6776{ 6777 return c && (c->die_tag == DW_TAG_compile_unit 6778 || c->die_tag == DW_TAG_partial_unit 6779 || c->die_tag == DW_TAG_type_unit); 6780} 6781 6782/* Returns true iff C is a namespace DIE. */ 6783 6784static inline bool 6785is_namespace_die (dw_die_ref c) 6786{ 6787 return c && c->die_tag == DW_TAG_namespace; 6788} 6789 6790/* Returns true iff C is a class or structure DIE. */ 6791 6792static inline bool 6793is_class_die (dw_die_ref c) 6794{ 6795 return c && (c->die_tag == DW_TAG_class_type 6796 || c->die_tag == DW_TAG_structure_type); 6797} 6798 6799/* Return non-zero if this DIE is a template parameter. */ 6800 6801static inline bool 6802is_template_parameter (dw_die_ref die) 6803{ 6804 switch (die->die_tag) 6805 { 6806 case DW_TAG_template_type_param: 6807 case DW_TAG_template_value_param: 6808 case DW_TAG_GNU_template_template_param: 6809 case DW_TAG_GNU_template_parameter_pack: 6810 return true; 6811 default: 6812 return false; 6813 } 6814} 6815 6816/* Return non-zero if this DIE represents a template instantiation. */ 6817 6818static inline bool 6819is_template_instantiation (dw_die_ref die) 6820{ 6821 dw_die_ref c; 6822 6823 if (!is_type_die (die) && die->die_tag != DW_TAG_subprogram) 6824 return false; 6825 FOR_EACH_CHILD (die, c, if (is_template_parameter (c)) return true); 6826 return false; 6827} 6828 6829static char * 6830gen_internal_sym (const char *prefix) 6831{ 6832 char buf[256]; 6833 6834 ASM_GENERATE_INTERNAL_LABEL (buf, prefix, label_num++); 6835 return xstrdup (buf); 6836} 6837 6838/* Assign symbols to all worthy DIEs under DIE. */ 6839 6840static void 6841assign_symbol_names (dw_die_ref die) 6842{ 6843 dw_die_ref c; 6844 6845 if (is_symbol_die (die) && !die->comdat_type_p) 6846 { 6847 if (comdat_symbol_id) 6848 { 6849 char *p = XALLOCAVEC (char, strlen (comdat_symbol_id) + 64); 6850 6851 sprintf (p, "%s.%s.%x", DIE_LABEL_PREFIX, 6852 comdat_symbol_id, comdat_symbol_number++); 6853 die->die_id.die_symbol = xstrdup (p); 6854 } 6855 else 6856 die->die_id.die_symbol = gen_internal_sym ("LDIE"); 6857 } 6858 6859 FOR_EACH_CHILD (die, c, assign_symbol_names (c)); 6860} 6861 6862struct cu_hash_table_entry 6863{ 6864 dw_die_ref cu; 6865 unsigned min_comdat_num, max_comdat_num; 6866 struct cu_hash_table_entry *next; 6867}; 6868 6869/* Helpers to manipulate hash table of CUs. */ 6870 6871struct cu_hash_table_entry_hasher 6872{ 6873 typedef cu_hash_table_entry value_type; 6874 typedef die_struct compare_type; 6875 static inline hashval_t hash (const value_type *); 6876 static inline bool equal (const value_type *, const compare_type *); 6877 static inline void remove (value_type *); 6878}; 6879 6880inline hashval_t 6881cu_hash_table_entry_hasher::hash (const value_type *entry) 6882{ 6883 return htab_hash_string (entry->cu->die_id.die_symbol); 6884} 6885 6886inline bool 6887cu_hash_table_entry_hasher::equal (const value_type *entry1, 6888 const compare_type *entry2) 6889{ 6890 return !strcmp (entry1->cu->die_id.die_symbol, entry2->die_id.die_symbol); 6891} 6892 6893inline void 6894cu_hash_table_entry_hasher::remove (value_type *entry) 6895{ 6896 struct cu_hash_table_entry *next; 6897 6898 while (entry) 6899 { 6900 next = entry->next; 6901 free (entry); 6902 entry = next; 6903 } 6904} 6905 6906typedef hash_table<cu_hash_table_entry_hasher> cu_hash_type; 6907 6908/* Check whether we have already seen this CU and set up SYM_NUM 6909 accordingly. */ 6910static int 6911check_duplicate_cu (dw_die_ref cu, cu_hash_type *htable, unsigned int *sym_num) 6912{ 6913 struct cu_hash_table_entry dummy; 6914 struct cu_hash_table_entry **slot, *entry, *last = &dummy; 6915 6916 dummy.max_comdat_num = 0; 6917 6918 slot = htable->find_slot_with_hash (cu, 6919 htab_hash_string (cu->die_id.die_symbol), 6920 INSERT); 6921 entry = *slot; 6922 6923 for (; entry; last = entry, entry = entry->next) 6924 { 6925 if (same_die_p_wrap (cu, entry->cu)) 6926 break; 6927 } 6928 6929 if (entry) 6930 { 6931 *sym_num = entry->min_comdat_num; 6932 return 1; 6933 } 6934 6935 entry = XCNEW (struct cu_hash_table_entry); 6936 entry->cu = cu; 6937 entry->min_comdat_num = *sym_num = last->max_comdat_num; 6938 entry->next = *slot; 6939 *slot = entry; 6940 6941 return 0; 6942} 6943 6944/* Record SYM_NUM to record of CU in HTABLE. */ 6945static void 6946record_comdat_symbol_number (dw_die_ref cu, cu_hash_type *htable, 6947 unsigned int sym_num) 6948{ 6949 struct cu_hash_table_entry **slot, *entry; 6950 6951 slot = htable->find_slot_with_hash (cu, 6952 htab_hash_string (cu->die_id.die_symbol), 6953 NO_INSERT); 6954 entry = *slot; 6955 6956 entry->max_comdat_num = sym_num; 6957} 6958 6959/* Traverse the DIE (which is always comp_unit_die), and set up 6960 additional compilation units for each of the include files we see 6961 bracketed by BINCL/EINCL. */ 6962 6963static void 6964break_out_includes (dw_die_ref die) 6965{ 6966 dw_die_ref c; 6967 dw_die_ref unit = NULL; 6968 limbo_die_node *node, **pnode; 6969 6970 c = die->die_child; 6971 if (c) do { 6972 dw_die_ref prev = c; 6973 c = c->die_sib; 6974 while (c->die_tag == DW_TAG_GNU_BINCL || c->die_tag == DW_TAG_GNU_EINCL 6975 || (unit && is_comdat_die (c))) 6976 { 6977 dw_die_ref next = c->die_sib; 6978 6979 /* This DIE is for a secondary CU; remove it from the main one. */ 6980 remove_child_with_prev (c, prev); 6981 6982 if (c->die_tag == DW_TAG_GNU_BINCL) 6983 unit = push_new_compile_unit (unit, c); 6984 else if (c->die_tag == DW_TAG_GNU_EINCL) 6985 unit = pop_compile_unit (unit); 6986 else 6987 add_child_die (unit, c); 6988 c = next; 6989 if (c == die->die_child) 6990 break; 6991 } 6992 } while (c != die->die_child); 6993 6994#if 0 6995 /* We can only use this in debugging, since the frontend doesn't check 6996 to make sure that we leave every include file we enter. */ 6997 gcc_assert (!unit); 6998#endif 6999 7000 assign_symbol_names (die); 7001 cu_hash_type cu_hash_table (10); 7002 for (node = limbo_die_list, pnode = &limbo_die_list; 7003 node; 7004 node = node->next) 7005 { 7006 int is_dupl; 7007 7008 compute_section_prefix (node->die); 7009 is_dupl = check_duplicate_cu (node->die, &cu_hash_table, 7010 &comdat_symbol_number); 7011 assign_symbol_names (node->die); 7012 if (is_dupl) 7013 *pnode = node->next; 7014 else 7015 { 7016 pnode = &node->next; 7017 record_comdat_symbol_number (node->die, &cu_hash_table, 7018 comdat_symbol_number); 7019 } 7020 } 7021} 7022 7023/* Return non-zero if this DIE is a declaration. */ 7024 7025static int 7026is_declaration_die (dw_die_ref die) 7027{ 7028 dw_attr_ref a; 7029 unsigned ix; 7030 7031 FOR_EACH_VEC_SAFE_ELT (die->die_attr, ix, a) 7032 if (a->dw_attr == DW_AT_declaration) 7033 return 1; 7034 7035 return 0; 7036} 7037 7038/* Return non-zero if this DIE is nested inside a subprogram. */ 7039 7040static int 7041is_nested_in_subprogram (dw_die_ref die) 7042{ 7043 dw_die_ref decl = get_AT_ref (die, DW_AT_specification); 7044 7045 if (decl == NULL) 7046 decl = die; 7047 return local_scope_p (decl); 7048} 7049 7050/* Return non-zero if this DIE contains a defining declaration of a 7051 subprogram. */ 7052 7053static int 7054contains_subprogram_definition (dw_die_ref die) 7055{ 7056 dw_die_ref c; 7057 7058 if (die->die_tag == DW_TAG_subprogram && ! is_declaration_die (die)) 7059 return 1; 7060 FOR_EACH_CHILD (die, c, if (contains_subprogram_definition (c)) return 1); 7061 return 0; 7062} 7063 7064/* Return non-zero if this is a type DIE that should be moved to a 7065 COMDAT .debug_types section. */ 7066 7067static int 7068should_move_die_to_comdat (dw_die_ref die) 7069{ 7070 switch (die->die_tag) 7071 { 7072 case DW_TAG_class_type: 7073 case DW_TAG_structure_type: 7074 case DW_TAG_enumeration_type: 7075 case DW_TAG_union_type: 7076 /* Don't move declarations, inlined instances, types nested in a 7077 subprogram, or types that contain subprogram definitions. */ 7078 if (is_declaration_die (die) 7079 || get_AT (die, DW_AT_abstract_origin) 7080 || is_nested_in_subprogram (die) 7081 || contains_subprogram_definition (die)) 7082 return 0; 7083 return 1; 7084 case DW_TAG_array_type: 7085 case DW_TAG_interface_type: 7086 case DW_TAG_pointer_type: 7087 case DW_TAG_reference_type: 7088 case DW_TAG_rvalue_reference_type: 7089 case DW_TAG_string_type: 7090 case DW_TAG_subroutine_type: 7091 case DW_TAG_ptr_to_member_type: 7092 case DW_TAG_set_type: 7093 case DW_TAG_subrange_type: 7094 case DW_TAG_base_type: 7095 case DW_TAG_const_type: 7096 case DW_TAG_file_type: 7097 case DW_TAG_packed_type: 7098 case DW_TAG_volatile_type: 7099 case DW_TAG_typedef: 7100 default: 7101 return 0; 7102 } 7103} 7104 7105/* Make a clone of DIE. */ 7106 7107static dw_die_ref 7108clone_die (dw_die_ref die) 7109{ 7110 dw_die_ref clone; 7111 dw_attr_ref a; 7112 unsigned ix; 7113 7114 clone = ggc_cleared_alloc<die_node> (); 7115 clone->die_tag = die->die_tag; 7116 7117 FOR_EACH_VEC_SAFE_ELT (die->die_attr, ix, a) 7118 add_dwarf_attr (clone, a); 7119 7120 return clone; 7121} 7122 7123/* Make a clone of the tree rooted at DIE. */ 7124 7125static dw_die_ref 7126clone_tree (dw_die_ref die) 7127{ 7128 dw_die_ref c; 7129 dw_die_ref clone = clone_die (die); 7130 7131 FOR_EACH_CHILD (die, c, add_child_die (clone, clone_tree (c))); 7132 7133 return clone; 7134} 7135 7136/* Make a clone of DIE as a declaration. */ 7137 7138static dw_die_ref 7139clone_as_declaration (dw_die_ref die) 7140{ 7141 dw_die_ref clone; 7142 dw_die_ref decl; 7143 dw_attr_ref a; 7144 unsigned ix; 7145 7146 /* If the DIE is already a declaration, just clone it. */ 7147 if (is_declaration_die (die)) 7148 return clone_die (die); 7149 7150 /* If the DIE is a specification, just clone its declaration DIE. */ 7151 decl = get_AT_ref (die, DW_AT_specification); 7152 if (decl != NULL) 7153 { 7154 clone = clone_die (decl); 7155 if (die->comdat_type_p) 7156 add_AT_die_ref (clone, DW_AT_signature, die); 7157 return clone; 7158 } 7159 7160 clone = ggc_cleared_alloc<die_node> (); 7161 clone->die_tag = die->die_tag; 7162 7163 FOR_EACH_VEC_SAFE_ELT (die->die_attr, ix, a) 7164 { 7165 /* We don't want to copy over all attributes. 7166 For example we don't want DW_AT_byte_size because otherwise we will no 7167 longer have a declaration and GDB will treat it as a definition. */ 7168 7169 switch (a->dw_attr) 7170 { 7171 case DW_AT_abstract_origin: 7172 case DW_AT_artificial: 7173 case DW_AT_containing_type: 7174 case DW_AT_external: 7175 case DW_AT_name: 7176 case DW_AT_type: 7177 case DW_AT_virtuality: 7178 case DW_AT_linkage_name: 7179 case DW_AT_MIPS_linkage_name: 7180 add_dwarf_attr (clone, a); 7181 break; 7182 case DW_AT_byte_size: 7183 default: 7184 break; 7185 } 7186 } 7187 7188 if (die->comdat_type_p) 7189 add_AT_die_ref (clone, DW_AT_signature, die); 7190 7191 add_AT_flag (clone, DW_AT_declaration, 1); 7192 return clone; 7193} 7194 7195 7196/* Structure to map a DIE in one CU to its copy in a comdat type unit. */ 7197 7198struct decl_table_entry 7199{ 7200 dw_die_ref orig; 7201 dw_die_ref copy; 7202}; 7203 7204/* Helpers to manipulate hash table of copied declarations. */ 7205 7206/* Hashtable helpers. */ 7207 7208struct decl_table_entry_hasher : typed_free_remove <decl_table_entry> 7209{ 7210 typedef decl_table_entry value_type; 7211 typedef die_struct compare_type; 7212 static inline hashval_t hash (const value_type *); 7213 static inline bool equal (const value_type *, const compare_type *); 7214}; 7215 7216inline hashval_t 7217decl_table_entry_hasher::hash (const value_type *entry) 7218{ 7219 return htab_hash_pointer (entry->orig); 7220} 7221 7222inline bool 7223decl_table_entry_hasher::equal (const value_type *entry1, 7224 const compare_type *entry2) 7225{ 7226 return entry1->orig == entry2; 7227} 7228 7229typedef hash_table<decl_table_entry_hasher> decl_hash_type; 7230 7231/* Copy DIE and its ancestors, up to, but not including, the compile unit 7232 or type unit entry, to a new tree. Adds the new tree to UNIT and returns 7233 a pointer to the copy of DIE. If DECL_TABLE is provided, it is used 7234 to check if the ancestor has already been copied into UNIT. */ 7235 7236static dw_die_ref 7237copy_ancestor_tree (dw_die_ref unit, dw_die_ref die, 7238 decl_hash_type *decl_table) 7239{ 7240 dw_die_ref parent = die->die_parent; 7241 dw_die_ref new_parent = unit; 7242 dw_die_ref copy; 7243 decl_table_entry **slot = NULL; 7244 struct decl_table_entry *entry = NULL; 7245 7246 if (decl_table) 7247 { 7248 /* Check if the entry has already been copied to UNIT. */ 7249 slot = decl_table->find_slot_with_hash (die, htab_hash_pointer (die), 7250 INSERT); 7251 if (*slot != HTAB_EMPTY_ENTRY) 7252 { 7253 entry = *slot; 7254 return entry->copy; 7255 } 7256 7257 /* Record in DECL_TABLE that DIE has been copied to UNIT. */ 7258 entry = XCNEW (struct decl_table_entry); 7259 entry->orig = die; 7260 entry->copy = NULL; 7261 *slot = entry; 7262 } 7263 7264 if (parent != NULL) 7265 { 7266 dw_die_ref spec = get_AT_ref (parent, DW_AT_specification); 7267 if (spec != NULL) 7268 parent = spec; 7269 if (!is_unit_die (parent)) 7270 new_parent = copy_ancestor_tree (unit, parent, decl_table); 7271 } 7272 7273 copy = clone_as_declaration (die); 7274 add_child_die (new_parent, copy); 7275 7276 if (decl_table) 7277 { 7278 /* Record the pointer to the copy. */ 7279 entry->copy = copy; 7280 } 7281 7282 return copy; 7283} 7284/* Copy the declaration context to the new type unit DIE. This includes 7285 any surrounding namespace or type declarations. If the DIE has an 7286 AT_specification attribute, it also includes attributes and children 7287 attached to the specification, and returns a pointer to the original 7288 parent of the declaration DIE. Returns NULL otherwise. */ 7289 7290static dw_die_ref 7291copy_declaration_context (dw_die_ref unit, dw_die_ref die) 7292{ 7293 dw_die_ref decl; 7294 dw_die_ref new_decl; 7295 dw_die_ref orig_parent = NULL; 7296 7297 decl = get_AT_ref (die, DW_AT_specification); 7298 if (decl == NULL) 7299 decl = die; 7300 else 7301 { 7302 unsigned ix; 7303 dw_die_ref c; 7304 dw_attr_ref a; 7305 7306 /* The original DIE will be changed to a declaration, and must 7307 be moved to be a child of the original declaration DIE. */ 7308 orig_parent = decl->die_parent; 7309 7310 /* Copy the type node pointer from the new DIE to the original 7311 declaration DIE so we can forward references later. */ 7312 decl->comdat_type_p = true; 7313 decl->die_id.die_type_node = die->die_id.die_type_node; 7314 7315 remove_AT (die, DW_AT_specification); 7316 7317 FOR_EACH_VEC_SAFE_ELT (decl->die_attr, ix, a) 7318 { 7319 if (a->dw_attr != DW_AT_name 7320 && a->dw_attr != DW_AT_declaration 7321 && a->dw_attr != DW_AT_external) 7322 add_dwarf_attr (die, a); 7323 } 7324 7325 FOR_EACH_CHILD (decl, c, add_child_die (die, clone_tree (c))); 7326 } 7327 7328 if (decl->die_parent != NULL 7329 && !is_unit_die (decl->die_parent)) 7330 { 7331 new_decl = copy_ancestor_tree (unit, decl, NULL); 7332 if (new_decl != NULL) 7333 { 7334 remove_AT (new_decl, DW_AT_signature); 7335 add_AT_specification (die, new_decl); 7336 } 7337 } 7338 7339 return orig_parent; 7340} 7341 7342/* Generate the skeleton ancestor tree for the given NODE, then clone 7343 the DIE and add the clone into the tree. */ 7344 7345static void 7346generate_skeleton_ancestor_tree (skeleton_chain_node *node) 7347{ 7348 if (node->new_die != NULL) 7349 return; 7350 7351 node->new_die = clone_as_declaration (node->old_die); 7352 7353 if (node->parent != NULL) 7354 { 7355 generate_skeleton_ancestor_tree (node->parent); 7356 add_child_die (node->parent->new_die, node->new_die); 7357 } 7358} 7359 7360/* Generate a skeleton tree of DIEs containing any declarations that are 7361 found in the original tree. We traverse the tree looking for declaration 7362 DIEs, and construct the skeleton from the bottom up whenever we find one. */ 7363 7364static void 7365generate_skeleton_bottom_up (skeleton_chain_node *parent) 7366{ 7367 skeleton_chain_node node; 7368 dw_die_ref c; 7369 dw_die_ref first; 7370 dw_die_ref prev = NULL; 7371 dw_die_ref next = NULL; 7372 7373 node.parent = parent; 7374 7375 first = c = parent->old_die->die_child; 7376 if (c) 7377 next = c->die_sib; 7378 if (c) do { 7379 if (prev == NULL || prev->die_sib == c) 7380 prev = c; 7381 c = next; 7382 next = (c == first ? NULL : c->die_sib); 7383 node.old_die = c; 7384 node.new_die = NULL; 7385 if (is_declaration_die (c)) 7386 { 7387 if (is_template_instantiation (c)) 7388 { 7389 /* Instantiated templates do not need to be cloned into the 7390 type unit. Just move the DIE and its children back to 7391 the skeleton tree (in the main CU). */ 7392 remove_child_with_prev (c, prev); 7393 add_child_die (parent->new_die, c); 7394 c = prev; 7395 } 7396 else 7397 { 7398 /* Clone the existing DIE, move the original to the skeleton 7399 tree (which is in the main CU), and put the clone, with 7400 all the original's children, where the original came from 7401 (which is about to be moved to the type unit). */ 7402 dw_die_ref clone = clone_die (c); 7403 move_all_children (c, clone); 7404 7405 /* If the original has a DW_AT_object_pointer attribute, 7406 it would now point to a child DIE just moved to the 7407 cloned tree, so we need to remove that attribute from 7408 the original. */ 7409 remove_AT (c, DW_AT_object_pointer); 7410 7411 replace_child (c, clone, prev); 7412 generate_skeleton_ancestor_tree (parent); 7413 add_child_die (parent->new_die, c); 7414 node.new_die = c; 7415 c = clone; 7416 } 7417 } 7418 generate_skeleton_bottom_up (&node); 7419 } while (next != NULL); 7420} 7421 7422/* Wrapper function for generate_skeleton_bottom_up. */ 7423 7424static dw_die_ref 7425generate_skeleton (dw_die_ref die) 7426{ 7427 skeleton_chain_node node; 7428 7429 node.old_die = die; 7430 node.new_die = NULL; 7431 node.parent = NULL; 7432 7433 /* If this type definition is nested inside another type, 7434 and is not an instantiation of a template, always leave 7435 at least a declaration in its place. */ 7436 if (die->die_parent != NULL 7437 && is_type_die (die->die_parent) 7438 && !is_template_instantiation (die)) 7439 node.new_die = clone_as_declaration (die); 7440 7441 generate_skeleton_bottom_up (&node); 7442 return node.new_die; 7443} 7444 7445/* Remove the CHILD DIE from its parent, possibly replacing it with a cloned 7446 declaration. The original DIE is moved to a new compile unit so that 7447 existing references to it follow it to the new location. If any of the 7448 original DIE's descendants is a declaration, we need to replace the 7449 original DIE with a skeleton tree and move the declarations back into the 7450 skeleton tree. */ 7451 7452static dw_die_ref 7453remove_child_or_replace_with_skeleton (dw_die_ref unit, dw_die_ref child, 7454 dw_die_ref prev) 7455{ 7456 dw_die_ref skeleton, orig_parent; 7457 7458 /* Copy the declaration context to the type unit DIE. If the returned 7459 ORIG_PARENT is not NULL, the skeleton needs to be added as a child of 7460 that DIE. */ 7461 orig_parent = copy_declaration_context (unit, child); 7462 7463 skeleton = generate_skeleton (child); 7464 if (skeleton == NULL) 7465 remove_child_with_prev (child, prev); 7466 else 7467 { 7468 skeleton->comdat_type_p = true; 7469 skeleton->die_id.die_type_node = child->die_id.die_type_node; 7470 7471 /* If the original DIE was a specification, we need to put 7472 the skeleton under the parent DIE of the declaration. 7473 This leaves the original declaration in the tree, but 7474 it will be pruned later since there are no longer any 7475 references to it. */ 7476 if (orig_parent != NULL) 7477 { 7478 remove_child_with_prev (child, prev); 7479 add_child_die (orig_parent, skeleton); 7480 } 7481 else 7482 replace_child (child, skeleton, prev); 7483 } 7484 7485 return skeleton; 7486} 7487 7488/* Traverse the DIE and set up additional .debug_types sections for each 7489 type worthy of being placed in a COMDAT section. */ 7490 7491static void 7492break_out_comdat_types (dw_die_ref die) 7493{ 7494 dw_die_ref c; 7495 dw_die_ref first; 7496 dw_die_ref prev = NULL; 7497 dw_die_ref next = NULL; 7498 dw_die_ref unit = NULL; 7499 7500 first = c = die->die_child; 7501 if (c) 7502 next = c->die_sib; 7503 if (c) do { 7504 if (prev == NULL || prev->die_sib == c) 7505 prev = c; 7506 c = next; 7507 next = (c == first ? NULL : c->die_sib); 7508 if (should_move_die_to_comdat (c)) 7509 { 7510 dw_die_ref replacement; 7511 comdat_type_node_ref type_node; 7512 7513 /* Break out nested types into their own type units. */ 7514 break_out_comdat_types (c); 7515 7516 /* Create a new type unit DIE as the root for the new tree, and 7517 add it to the list of comdat types. */ 7518 unit = new_die (DW_TAG_type_unit, NULL, NULL); 7519 add_AT_unsigned (unit, DW_AT_language, 7520 get_AT_unsigned (comp_unit_die (), DW_AT_language)); 7521 type_node = ggc_cleared_alloc<comdat_type_node> (); 7522 type_node->root_die = unit; 7523 type_node->next = comdat_type_list; 7524 comdat_type_list = type_node; 7525 7526 /* Generate the type signature. */ 7527 generate_type_signature (c, type_node); 7528 7529 /* Copy the declaration context, attributes, and children of the 7530 declaration into the new type unit DIE, then remove this DIE 7531 from the main CU (or replace it with a skeleton if necessary). */ 7532 replacement = remove_child_or_replace_with_skeleton (unit, c, prev); 7533 type_node->skeleton_die = replacement; 7534 7535 /* Add the DIE to the new compunit. */ 7536 add_child_die (unit, c); 7537 7538 if (replacement != NULL) 7539 c = replacement; 7540 } 7541 else if (c->die_tag == DW_TAG_namespace 7542 || c->die_tag == DW_TAG_class_type 7543 || c->die_tag == DW_TAG_structure_type 7544 || c->die_tag == DW_TAG_union_type) 7545 { 7546 /* Look for nested types that can be broken out. */ 7547 break_out_comdat_types (c); 7548 } 7549 } while (next != NULL); 7550} 7551 7552/* Like clone_tree, but copy DW_TAG_subprogram DIEs as declarations. 7553 Enter all the cloned children into the hash table decl_table. */ 7554 7555static dw_die_ref 7556clone_tree_partial (dw_die_ref die, decl_hash_type *decl_table) 7557{ 7558 dw_die_ref c; 7559 dw_die_ref clone; 7560 struct decl_table_entry *entry; 7561 decl_table_entry **slot; 7562 7563 if (die->die_tag == DW_TAG_subprogram) 7564 clone = clone_as_declaration (die); 7565 else 7566 clone = clone_die (die); 7567 7568 slot = decl_table->find_slot_with_hash (die, 7569 htab_hash_pointer (die), INSERT); 7570 7571 /* Assert that DIE isn't in the hash table yet. If it would be there 7572 before, the ancestors would be necessarily there as well, therefore 7573 clone_tree_partial wouldn't be called. */ 7574 gcc_assert (*slot == HTAB_EMPTY_ENTRY); 7575 7576 entry = XCNEW (struct decl_table_entry); 7577 entry->orig = die; 7578 entry->copy = clone; 7579 *slot = entry; 7580 7581 if (die->die_tag != DW_TAG_subprogram) 7582 FOR_EACH_CHILD (die, c, 7583 add_child_die (clone, clone_tree_partial (c, decl_table))); 7584 7585 return clone; 7586} 7587 7588/* Walk the DIE and its children, looking for references to incomplete 7589 or trivial types that are unmarked (i.e., that are not in the current 7590 type_unit). */ 7591 7592static void 7593copy_decls_walk (dw_die_ref unit, dw_die_ref die, decl_hash_type *decl_table) 7594{ 7595 dw_die_ref c; 7596 dw_attr_ref a; 7597 unsigned ix; 7598 7599 FOR_EACH_VEC_SAFE_ELT (die->die_attr, ix, a) 7600 { 7601 if (AT_class (a) == dw_val_class_die_ref) 7602 { 7603 dw_die_ref targ = AT_ref (a); 7604 decl_table_entry **slot; 7605 struct decl_table_entry *entry; 7606 7607 if (targ->die_mark != 0 || targ->comdat_type_p) 7608 continue; 7609 7610 slot = decl_table->find_slot_with_hash (targ, 7611 htab_hash_pointer (targ), 7612 INSERT); 7613 7614 if (*slot != HTAB_EMPTY_ENTRY) 7615 { 7616 /* TARG has already been copied, so we just need to 7617 modify the reference to point to the copy. */ 7618 entry = *slot; 7619 a->dw_attr_val.v.val_die_ref.die = entry->copy; 7620 } 7621 else 7622 { 7623 dw_die_ref parent = unit; 7624 dw_die_ref copy = clone_die (targ); 7625 7626 /* Record in DECL_TABLE that TARG has been copied. 7627 Need to do this now, before the recursive call, 7628 because DECL_TABLE may be expanded and SLOT 7629 would no longer be a valid pointer. */ 7630 entry = XCNEW (struct decl_table_entry); 7631 entry->orig = targ; 7632 entry->copy = copy; 7633 *slot = entry; 7634 7635 /* If TARG is not a declaration DIE, we need to copy its 7636 children. */ 7637 if (!is_declaration_die (targ)) 7638 { 7639 FOR_EACH_CHILD ( 7640 targ, c, 7641 add_child_die (copy, 7642 clone_tree_partial (c, decl_table))); 7643 } 7644 7645 /* Make sure the cloned tree is marked as part of the 7646 type unit. */ 7647 mark_dies (copy); 7648 7649 /* If TARG has surrounding context, copy its ancestor tree 7650 into the new type unit. */ 7651 if (targ->die_parent != NULL 7652 && !is_unit_die (targ->die_parent)) 7653 parent = copy_ancestor_tree (unit, targ->die_parent, 7654 decl_table); 7655 7656 add_child_die (parent, copy); 7657 a->dw_attr_val.v.val_die_ref.die = copy; 7658 7659 /* Make sure the newly-copied DIE is walked. If it was 7660 installed in a previously-added context, it won't 7661 get visited otherwise. */ 7662 if (parent != unit) 7663 { 7664 /* Find the highest point of the newly-added tree, 7665 mark each node along the way, and walk from there. */ 7666 parent->die_mark = 1; 7667 while (parent->die_parent 7668 && parent->die_parent->die_mark == 0) 7669 { 7670 parent = parent->die_parent; 7671 parent->die_mark = 1; 7672 } 7673 copy_decls_walk (unit, parent, decl_table); 7674 } 7675 } 7676 } 7677 } 7678 7679 FOR_EACH_CHILD (die, c, copy_decls_walk (unit, c, decl_table)); 7680} 7681 7682/* Copy declarations for "unworthy" types into the new comdat section. 7683 Incomplete types, modified types, and certain other types aren't broken 7684 out into comdat sections of their own, so they don't have a signature, 7685 and we need to copy the declaration into the same section so that we 7686 don't have an external reference. */ 7687 7688static void 7689copy_decls_for_unworthy_types (dw_die_ref unit) 7690{ 7691 mark_dies (unit); 7692 decl_hash_type decl_table (10); 7693 copy_decls_walk (unit, unit, &decl_table); 7694 unmark_dies (unit); 7695} 7696 7697/* Traverse the DIE and add a sibling attribute if it may have the 7698 effect of speeding up access to siblings. To save some space, 7699 avoid generating sibling attributes for DIE's without children. */ 7700 7701static void 7702add_sibling_attributes (dw_die_ref die) 7703{ 7704 dw_die_ref c; 7705 7706 if (! die->die_child) 7707 return; 7708 7709 if (die->die_parent && die != die->die_parent->die_child) 7710 add_AT_die_ref (die, DW_AT_sibling, die->die_sib); 7711 7712 FOR_EACH_CHILD (die, c, add_sibling_attributes (c)); 7713} 7714 7715/* Output all location lists for the DIE and its children. */ 7716 7717static void 7718output_location_lists (dw_die_ref die) 7719{ 7720 dw_die_ref c; 7721 dw_attr_ref a; 7722 unsigned ix; 7723 7724 FOR_EACH_VEC_SAFE_ELT (die->die_attr, ix, a) 7725 if (AT_class (a) == dw_val_class_loc_list) 7726 output_loc_list (AT_loc_list (a)); 7727 7728 FOR_EACH_CHILD (die, c, output_location_lists (c)); 7729} 7730 7731/* We want to limit the number of external references, because they are 7732 larger than local references: a relocation takes multiple words, and 7733 even a sig8 reference is always eight bytes, whereas a local reference 7734 can be as small as one byte (though DW_FORM_ref is usually 4 in GCC). 7735 So if we encounter multiple external references to the same type DIE, we 7736 make a local typedef stub for it and redirect all references there. 7737 7738 This is the element of the hash table for keeping track of these 7739 references. */ 7740 7741struct external_ref 7742{ 7743 dw_die_ref type; 7744 dw_die_ref stub; 7745 unsigned n_refs; 7746}; 7747 7748/* Hashtable helpers. */ 7749 7750struct external_ref_hasher : typed_free_remove <external_ref> 7751{ 7752 typedef external_ref value_type; 7753 typedef external_ref compare_type; 7754 static inline hashval_t hash (const value_type *); 7755 static inline bool equal (const value_type *, const compare_type *); 7756}; 7757 7758inline hashval_t 7759external_ref_hasher::hash (const value_type *r) 7760{ 7761 dw_die_ref die = r->type; 7762 hashval_t h = 0; 7763 7764 /* We can't use the address of the DIE for hashing, because 7765 that will make the order of the stub DIEs non-deterministic. */ 7766 if (! die->comdat_type_p) 7767 /* We have a symbol; use it to compute a hash. */ 7768 h = htab_hash_string (die->die_id.die_symbol); 7769 else 7770 { 7771 /* We have a type signature; use a subset of the bits as the hash. 7772 The 8-byte signature is at least as large as hashval_t. */ 7773 comdat_type_node_ref type_node = die->die_id.die_type_node; 7774 memcpy (&h, type_node->signature, sizeof (h)); 7775 } 7776 return h; 7777} 7778 7779inline bool 7780external_ref_hasher::equal (const value_type *r1, const compare_type *r2) 7781{ 7782 return r1->type == r2->type; 7783} 7784 7785typedef hash_table<external_ref_hasher> external_ref_hash_type; 7786 7787/* Return a pointer to the external_ref for references to DIE. */ 7788 7789static struct external_ref * 7790lookup_external_ref (external_ref_hash_type *map, dw_die_ref die) 7791{ 7792 struct external_ref ref, *ref_p; 7793 external_ref **slot; 7794 7795 ref.type = die; 7796 slot = map->find_slot (&ref, INSERT); 7797 if (*slot != HTAB_EMPTY_ENTRY) 7798 return *slot; 7799 7800 ref_p = XCNEW (struct external_ref); 7801 ref_p->type = die; 7802 *slot = ref_p; 7803 return ref_p; 7804} 7805 7806/* Subroutine of optimize_external_refs, below. 7807 7808 If we see a type skeleton, record it as our stub. If we see external 7809 references, remember how many we've seen. */ 7810 7811static void 7812optimize_external_refs_1 (dw_die_ref die, external_ref_hash_type *map) 7813{ 7814 dw_die_ref c; 7815 dw_attr_ref a; 7816 unsigned ix; 7817 struct external_ref *ref_p; 7818 7819 if (is_type_die (die) 7820 && (c = get_AT_ref (die, DW_AT_signature))) 7821 { 7822 /* This is a local skeleton; use it for local references. */ 7823 ref_p = lookup_external_ref (map, c); 7824 ref_p->stub = die; 7825 } 7826 7827 /* Scan the DIE references, and remember any that refer to DIEs from 7828 other CUs (i.e. those which are not marked). */ 7829 FOR_EACH_VEC_SAFE_ELT (die->die_attr, ix, a) 7830 if (AT_class (a) == dw_val_class_die_ref 7831 && (c = AT_ref (a))->die_mark == 0 7832 && is_type_die (c)) 7833 { 7834 ref_p = lookup_external_ref (map, c); 7835 ref_p->n_refs++; 7836 } 7837 7838 FOR_EACH_CHILD (die, c, optimize_external_refs_1 (c, map)); 7839} 7840 7841/* htab_traverse callback function for optimize_external_refs, below. SLOT 7842 points to an external_ref, DATA is the CU we're processing. If we don't 7843 already have a local stub, and we have multiple refs, build a stub. */ 7844 7845int 7846dwarf2_build_local_stub (external_ref **slot, dw_die_ref data) 7847{ 7848 struct external_ref *ref_p = *slot; 7849 7850 if (ref_p->stub == NULL && ref_p->n_refs > 1 && !dwarf_strict) 7851 { 7852 /* We have multiple references to this type, so build a small stub. 7853 Both of these forms are a bit dodgy from the perspective of the 7854 DWARF standard, since technically they should have names. */ 7855 dw_die_ref cu = data; 7856 dw_die_ref type = ref_p->type; 7857 dw_die_ref stub = NULL; 7858 7859 if (type->comdat_type_p) 7860 { 7861 /* If we refer to this type via sig8, use AT_signature. */ 7862 stub = new_die (type->die_tag, cu, NULL_TREE); 7863 add_AT_die_ref (stub, DW_AT_signature, type); 7864 } 7865 else 7866 { 7867 /* Otherwise, use a typedef with no name. */ 7868 stub = new_die (DW_TAG_typedef, cu, NULL_TREE); 7869 add_AT_die_ref (stub, DW_AT_type, type); 7870 } 7871 7872 stub->die_mark++; 7873 ref_p->stub = stub; 7874 } 7875 return 1; 7876} 7877 7878/* DIE is a unit; look through all the DIE references to see if there are 7879 any external references to types, and if so, create local stubs for 7880 them which will be applied in build_abbrev_table. This is useful because 7881 references to local DIEs are smaller. */ 7882 7883static external_ref_hash_type * 7884optimize_external_refs (dw_die_ref die) 7885{ 7886 external_ref_hash_type *map = new external_ref_hash_type (10); 7887 optimize_external_refs_1 (die, map); 7888 map->traverse <dw_die_ref, dwarf2_build_local_stub> (die); 7889 return map; 7890} 7891 7892/* The format of each DIE (and its attribute value pairs) is encoded in an 7893 abbreviation table. This routine builds the abbreviation table and assigns 7894 a unique abbreviation id for each abbreviation entry. The children of each 7895 die are visited recursively. */ 7896 7897static void 7898build_abbrev_table (dw_die_ref die, external_ref_hash_type *extern_map) 7899{ 7900 unsigned long abbrev_id; 7901 unsigned int n_alloc; 7902 dw_die_ref c; 7903 dw_attr_ref a; 7904 unsigned ix; 7905 7906 /* Scan the DIE references, and replace any that refer to 7907 DIEs from other CUs (i.e. those which are not marked) with 7908 the local stubs we built in optimize_external_refs. */ 7909 FOR_EACH_VEC_SAFE_ELT (die->die_attr, ix, a) 7910 if (AT_class (a) == dw_val_class_die_ref 7911 && (c = AT_ref (a))->die_mark == 0) 7912 { 7913 struct external_ref *ref_p; 7914 gcc_assert (AT_ref (a)->comdat_type_p || AT_ref (a)->die_id.die_symbol); 7915 7916 ref_p = lookup_external_ref (extern_map, c); 7917 if (ref_p->stub && ref_p->stub != die) 7918 change_AT_die_ref (a, ref_p->stub); 7919 else 7920 /* We aren't changing this reference, so mark it external. */ 7921 set_AT_ref_external (a, 1); 7922 } 7923 7924 for (abbrev_id = 1; abbrev_id < abbrev_die_table_in_use; ++abbrev_id) 7925 { 7926 dw_die_ref abbrev = abbrev_die_table[abbrev_id]; 7927 dw_attr_ref die_a, abbrev_a; 7928 unsigned ix; 7929 bool ok = true; 7930 7931 if (abbrev->die_tag != die->die_tag) 7932 continue; 7933 if ((abbrev->die_child != NULL) != (die->die_child != NULL)) 7934 continue; 7935 7936 if (vec_safe_length (abbrev->die_attr) != vec_safe_length (die->die_attr)) 7937 continue; 7938 7939 FOR_EACH_VEC_SAFE_ELT (die->die_attr, ix, die_a) 7940 { 7941 abbrev_a = &(*abbrev->die_attr)[ix]; 7942 if ((abbrev_a->dw_attr != die_a->dw_attr) 7943 || (value_format (abbrev_a) != value_format (die_a))) 7944 { 7945 ok = false; 7946 break; 7947 } 7948 } 7949 if (ok) 7950 break; 7951 } 7952 7953 if (abbrev_id >= abbrev_die_table_in_use) 7954 { 7955 if (abbrev_die_table_in_use >= abbrev_die_table_allocated) 7956 { 7957 n_alloc = abbrev_die_table_allocated + ABBREV_DIE_TABLE_INCREMENT; 7958 abbrev_die_table = GGC_RESIZEVEC (dw_die_ref, abbrev_die_table, 7959 n_alloc); 7960 7961 memset (&abbrev_die_table[abbrev_die_table_allocated], 0, 7962 (n_alloc - abbrev_die_table_allocated) * sizeof (dw_die_ref)); 7963 abbrev_die_table_allocated = n_alloc; 7964 } 7965 7966 ++abbrev_die_table_in_use; 7967 abbrev_die_table[abbrev_id] = die; 7968 } 7969 7970 die->die_abbrev = abbrev_id; 7971 FOR_EACH_CHILD (die, c, build_abbrev_table (c, extern_map)); 7972} 7973 7974/* Return the power-of-two number of bytes necessary to represent VALUE. */ 7975 7976static int 7977constant_size (unsigned HOST_WIDE_INT value) 7978{ 7979 int log; 7980 7981 if (value == 0) 7982 log = 0; 7983 else 7984 log = floor_log2 (value); 7985 7986 log = log / 8; 7987 log = 1 << (floor_log2 (log) + 1); 7988 7989 return log; 7990} 7991 7992/* Return the size of a DIE as it is represented in the 7993 .debug_info section. */ 7994 7995static unsigned long 7996size_of_die (dw_die_ref die) 7997{ 7998 unsigned long size = 0; 7999 dw_attr_ref a; 8000 unsigned ix; 8001 enum dwarf_form form; 8002 8003 size += size_of_uleb128 (die->die_abbrev); 8004 FOR_EACH_VEC_SAFE_ELT (die->die_attr, ix, a) 8005 { 8006 switch (AT_class (a)) 8007 { 8008 case dw_val_class_addr: 8009 if (dwarf_split_debug_info && AT_index (a) != NOT_INDEXED) 8010 { 8011 gcc_assert (AT_index (a) != NO_INDEX_ASSIGNED); 8012 size += size_of_uleb128 (AT_index (a)); 8013 } 8014 else 8015 size += DWARF2_ADDR_SIZE; 8016 break; 8017 case dw_val_class_offset: 8018 size += DWARF_OFFSET_SIZE; 8019 break; 8020 case dw_val_class_loc: 8021 { 8022 unsigned long lsize = size_of_locs (AT_loc (a)); 8023 8024 /* Block length. */ 8025 if (dwarf_version >= 4) 8026 size += size_of_uleb128 (lsize); 8027 else 8028 size += constant_size (lsize); 8029 size += lsize; 8030 } 8031 break; 8032 case dw_val_class_loc_list: 8033 if (dwarf_split_debug_info && AT_index (a) != NOT_INDEXED) 8034 { 8035 gcc_assert (AT_index (a) != NO_INDEX_ASSIGNED); 8036 size += size_of_uleb128 (AT_index (a)); 8037 } 8038 else 8039 size += DWARF_OFFSET_SIZE; 8040 break; 8041 case dw_val_class_range_list: 8042 size += DWARF_OFFSET_SIZE; 8043 break; 8044 case dw_val_class_const: 8045 size += size_of_sleb128 (AT_int (a)); 8046 break; 8047 case dw_val_class_unsigned_const: 8048 { 8049 int csize = constant_size (AT_unsigned (a)); 8050 if (dwarf_version == 3 8051 && a->dw_attr == DW_AT_data_member_location 8052 && csize >= 4) 8053 size += size_of_uleb128 (AT_unsigned (a)); 8054 else 8055 size += csize; 8056 } 8057 break; 8058 case dw_val_class_const_double: 8059 size += HOST_BITS_PER_DOUBLE_INT / HOST_BITS_PER_CHAR; 8060 if (HOST_BITS_PER_WIDE_INT >= 64) 8061 size++; /* block */ 8062 break; 8063 case dw_val_class_wide_int: 8064 size += (get_full_len (*a->dw_attr_val.v.val_wide) 8065 * HOST_BITS_PER_WIDE_INT / HOST_BITS_PER_CHAR); 8066 if (get_full_len (*a->dw_attr_val.v.val_wide) * HOST_BITS_PER_WIDE_INT 8067 > 64) 8068 size++; /* block */ 8069 break; 8070 case dw_val_class_vec: 8071 size += constant_size (a->dw_attr_val.v.val_vec.length 8072 * a->dw_attr_val.v.val_vec.elt_size) 8073 + a->dw_attr_val.v.val_vec.length 8074 * a->dw_attr_val.v.val_vec.elt_size; /* block */ 8075 break; 8076 case dw_val_class_flag: 8077 if (dwarf_version >= 4) 8078 /* Currently all add_AT_flag calls pass in 1 as last argument, 8079 so DW_FORM_flag_present can be used. If that ever changes, 8080 we'll need to use DW_FORM_flag and have some optimization 8081 in build_abbrev_table that will change those to 8082 DW_FORM_flag_present if it is set to 1 in all DIEs using 8083 the same abbrev entry. */ 8084 gcc_assert (a->dw_attr_val.v.val_flag == 1); 8085 else 8086 size += 1; 8087 break; 8088 case dw_val_class_die_ref: 8089 if (AT_ref_external (a)) 8090 { 8091 /* In DWARF4, we use DW_FORM_ref_sig8; for earlier versions 8092 we use DW_FORM_ref_addr. In DWARF2, DW_FORM_ref_addr 8093 is sized by target address length, whereas in DWARF3 8094 it's always sized as an offset. */ 8095 if (use_debug_types) 8096 size += DWARF_TYPE_SIGNATURE_SIZE; 8097 else if (dwarf_version == 2) 8098 size += DWARF2_ADDR_SIZE; 8099 else 8100 size += DWARF_OFFSET_SIZE; 8101 } 8102 else 8103 size += DWARF_OFFSET_SIZE; 8104 break; 8105 case dw_val_class_fde_ref: 8106 size += DWARF_OFFSET_SIZE; 8107 break; 8108 case dw_val_class_lbl_id: 8109 if (dwarf_split_debug_info && AT_index (a) != NOT_INDEXED) 8110 { 8111 gcc_assert (AT_index (a) != NO_INDEX_ASSIGNED); 8112 size += size_of_uleb128 (AT_index (a)); 8113 } 8114 else 8115 size += DWARF2_ADDR_SIZE; 8116 break; 8117 case dw_val_class_lineptr: 8118 case dw_val_class_macptr: 8119 size += DWARF_OFFSET_SIZE; 8120 break; 8121 case dw_val_class_str: 8122 form = AT_string_form (a); 8123 if (form == DW_FORM_strp) 8124 size += DWARF_OFFSET_SIZE; 8125 else if (form == DW_FORM_GNU_str_index) 8126 size += size_of_uleb128 (AT_index (a)); 8127 else 8128 size += strlen (a->dw_attr_val.v.val_str->str) + 1; 8129 break; 8130 case dw_val_class_file: 8131 size += constant_size (maybe_emit_file (a->dw_attr_val.v.val_file)); 8132 break; 8133 case dw_val_class_data8: 8134 size += 8; 8135 break; 8136 case dw_val_class_vms_delta: 8137 size += DWARF_OFFSET_SIZE; 8138 break; 8139 case dw_val_class_high_pc: 8140 size += DWARF2_ADDR_SIZE; 8141 break; 8142 default: 8143 gcc_unreachable (); 8144 } 8145 } 8146 8147 return size; 8148} 8149 8150/* Size the debugging information associated with a given DIE. Visits the 8151 DIE's children recursively. Updates the global variable next_die_offset, on 8152 each time through. Uses the current value of next_die_offset to update the 8153 die_offset field in each DIE. */ 8154 8155static void 8156calc_die_sizes (dw_die_ref die) 8157{ 8158 dw_die_ref c; 8159 8160 gcc_assert (die->die_offset == 0 8161 || (unsigned long int) die->die_offset == next_die_offset); 8162 die->die_offset = next_die_offset; 8163 next_die_offset += size_of_die (die); 8164 8165 FOR_EACH_CHILD (die, c, calc_die_sizes (c)); 8166 8167 if (die->die_child != NULL) 8168 /* Count the null byte used to terminate sibling lists. */ 8169 next_die_offset += 1; 8170} 8171 8172/* Size just the base type children at the start of the CU. 8173 This is needed because build_abbrev needs to size locs 8174 and sizing of type based stack ops needs to know die_offset 8175 values for the base types. */ 8176 8177static void 8178calc_base_type_die_sizes (void) 8179{ 8180 unsigned long die_offset = DWARF_COMPILE_UNIT_HEADER_SIZE; 8181 unsigned int i; 8182 dw_die_ref base_type; 8183#if ENABLE_ASSERT_CHECKING 8184 dw_die_ref prev = comp_unit_die ()->die_child; 8185#endif 8186 8187 die_offset += size_of_die (comp_unit_die ()); 8188 for (i = 0; base_types.iterate (i, &base_type); i++) 8189 { 8190#if ENABLE_ASSERT_CHECKING 8191 gcc_assert (base_type->die_offset == 0 8192 && prev->die_sib == base_type 8193 && base_type->die_child == NULL 8194 && base_type->die_abbrev); 8195 prev = base_type; 8196#endif 8197 base_type->die_offset = die_offset; 8198 die_offset += size_of_die (base_type); 8199 } 8200} 8201 8202/* Set the marks for a die and its children. We do this so 8203 that we know whether or not a reference needs to use FORM_ref_addr; only 8204 DIEs in the same CU will be marked. We used to clear out the offset 8205 and use that as the flag, but ran into ordering problems. */ 8206 8207static void 8208mark_dies (dw_die_ref die) 8209{ 8210 dw_die_ref c; 8211 8212 gcc_assert (!die->die_mark); 8213 8214 die->die_mark = 1; 8215 FOR_EACH_CHILD (die, c, mark_dies (c)); 8216} 8217 8218/* Clear the marks for a die and its children. */ 8219 8220static void 8221unmark_dies (dw_die_ref die) 8222{ 8223 dw_die_ref c; 8224 8225 if (! use_debug_types) 8226 gcc_assert (die->die_mark); 8227 8228 die->die_mark = 0; 8229 FOR_EACH_CHILD (die, c, unmark_dies (c)); 8230} 8231 8232/* Clear the marks for a die, its children and referred dies. */ 8233 8234static void 8235unmark_all_dies (dw_die_ref die) 8236{ 8237 dw_die_ref c; 8238 dw_attr_ref a; 8239 unsigned ix; 8240 8241 if (!die->die_mark) 8242 return; 8243 die->die_mark = 0; 8244 8245 FOR_EACH_CHILD (die, c, unmark_all_dies (c)); 8246 8247 FOR_EACH_VEC_SAFE_ELT (die->die_attr, ix, a) 8248 if (AT_class (a) == dw_val_class_die_ref) 8249 unmark_all_dies (AT_ref (a)); 8250} 8251 8252/* Calculate if the entry should appear in the final output file. It may be 8253 from a pruned a type. */ 8254 8255static bool 8256include_pubname_in_output (vec<pubname_entry, va_gc> *table, pubname_entry *p) 8257{ 8258 /* By limiting gnu pubnames to definitions only, gold can generate a 8259 gdb index without entries for declarations, which don't include 8260 enough information to be useful. */ 8261 if (debug_generate_pub_sections == 2 && is_declaration_die (p->die)) 8262 return false; 8263 8264 if (table == pubname_table) 8265 { 8266 /* Enumerator names are part of the pubname table, but the 8267 parent DW_TAG_enumeration_type die may have been pruned. 8268 Don't output them if that is the case. */ 8269 if (p->die->die_tag == DW_TAG_enumerator && 8270 (p->die->die_parent == NULL 8271 || !p->die->die_parent->die_perennial_p)) 8272 return false; 8273 8274 /* Everything else in the pubname table is included. */ 8275 return true; 8276 } 8277 8278 /* The pubtypes table shouldn't include types that have been 8279 pruned. */ 8280 return (p->die->die_offset != 0 8281 || !flag_eliminate_unused_debug_types); 8282} 8283 8284/* Return the size of the .debug_pubnames or .debug_pubtypes table 8285 generated for the compilation unit. */ 8286 8287static unsigned long 8288size_of_pubnames (vec<pubname_entry, va_gc> *names) 8289{ 8290 unsigned long size; 8291 unsigned i; 8292 pubname_ref p; 8293 int space_for_flags = (debug_generate_pub_sections == 2) ? 1 : 0; 8294 8295 size = DWARF_PUBNAMES_HEADER_SIZE; 8296 FOR_EACH_VEC_ELT (*names, i, p) 8297 if (include_pubname_in_output (names, p)) 8298 size += strlen (p->name) + DWARF_OFFSET_SIZE + 1 + space_for_flags; 8299 8300 size += DWARF_OFFSET_SIZE; 8301 return size; 8302} 8303 8304/* Return the size of the information in the .debug_aranges section. */ 8305 8306static unsigned long 8307size_of_aranges (void) 8308{ 8309 unsigned long size; 8310 8311 size = DWARF_ARANGES_HEADER_SIZE; 8312 8313 /* Count the address/length pair for this compilation unit. */ 8314 if (text_section_used) 8315 size += 2 * DWARF2_ADDR_SIZE; 8316 if (cold_text_section_used) 8317 size += 2 * DWARF2_ADDR_SIZE; 8318 if (have_multiple_function_sections) 8319 { 8320 unsigned fde_idx; 8321 dw_fde_ref fde; 8322 8323 FOR_EACH_VEC_ELT (*fde_vec, fde_idx, fde) 8324 { 8325 if (DECL_IGNORED_P (fde->decl)) 8326 continue; 8327 if (!fde->in_std_section) 8328 size += 2 * DWARF2_ADDR_SIZE; 8329 if (fde->dw_fde_second_begin && !fde->second_in_std_section) 8330 size += 2 * DWARF2_ADDR_SIZE; 8331 } 8332 } 8333 8334 /* Count the two zero words used to terminated the address range table. */ 8335 size += 2 * DWARF2_ADDR_SIZE; 8336 return size; 8337} 8338 8339/* Select the encoding of an attribute value. */ 8340 8341static enum dwarf_form 8342value_format (dw_attr_ref a) 8343{ 8344 switch (AT_class (a)) 8345 { 8346 case dw_val_class_addr: 8347 /* Only very few attributes allow DW_FORM_addr. */ 8348 switch (a->dw_attr) 8349 { 8350 case DW_AT_low_pc: 8351 case DW_AT_high_pc: 8352 case DW_AT_entry_pc: 8353 case DW_AT_trampoline: 8354 return (AT_index (a) == NOT_INDEXED 8355 ? DW_FORM_addr : DW_FORM_GNU_addr_index); 8356 default: 8357 break; 8358 } 8359 switch (DWARF2_ADDR_SIZE) 8360 { 8361 case 1: 8362 return DW_FORM_data1; 8363 case 2: 8364 return DW_FORM_data2; 8365 case 4: 8366 return DW_FORM_data4; 8367 case 8: 8368 return DW_FORM_data8; 8369 default: 8370 gcc_unreachable (); 8371 } 8372 case dw_val_class_range_list: 8373 case dw_val_class_loc_list: 8374 if (dwarf_version >= 4) 8375 return DW_FORM_sec_offset; 8376 /* FALLTHRU */ 8377 case dw_val_class_vms_delta: 8378 case dw_val_class_offset: 8379 switch (DWARF_OFFSET_SIZE) 8380 { 8381 case 4: 8382 return DW_FORM_data4; 8383 case 8: 8384 return DW_FORM_data8; 8385 default: 8386 gcc_unreachable (); 8387 } 8388 case dw_val_class_loc: 8389 if (dwarf_version >= 4) 8390 return DW_FORM_exprloc; 8391 switch (constant_size (size_of_locs (AT_loc (a)))) 8392 { 8393 case 1: 8394 return DW_FORM_block1; 8395 case 2: 8396 return DW_FORM_block2; 8397 case 4: 8398 return DW_FORM_block4; 8399 default: 8400 gcc_unreachable (); 8401 } 8402 case dw_val_class_const: 8403 return DW_FORM_sdata; 8404 case dw_val_class_unsigned_const: 8405 switch (constant_size (AT_unsigned (a))) 8406 { 8407 case 1: 8408 return DW_FORM_data1; 8409 case 2: 8410 return DW_FORM_data2; 8411 case 4: 8412 /* In DWARF3 DW_AT_data_member_location with 8413 DW_FORM_data4 or DW_FORM_data8 is a loclistptr, not 8414 constant, so we need to use DW_FORM_udata if we need 8415 a large constant. */ 8416 if (dwarf_version == 3 && a->dw_attr == DW_AT_data_member_location) 8417 return DW_FORM_udata; 8418 return DW_FORM_data4; 8419 case 8: 8420 if (dwarf_version == 3 && a->dw_attr == DW_AT_data_member_location) 8421 return DW_FORM_udata; 8422 return DW_FORM_data8; 8423 default: 8424 gcc_unreachable (); 8425 } 8426 case dw_val_class_const_double: 8427 switch (HOST_BITS_PER_WIDE_INT) 8428 { 8429 case 8: 8430 return DW_FORM_data2; 8431 case 16: 8432 return DW_FORM_data4; 8433 case 32: 8434 return DW_FORM_data8; 8435 case 64: 8436 default: 8437 return DW_FORM_block1; 8438 } 8439 case dw_val_class_wide_int: 8440 switch (get_full_len (*a->dw_attr_val.v.val_wide) * HOST_BITS_PER_WIDE_INT) 8441 { 8442 case 8: 8443 return DW_FORM_data1; 8444 case 16: 8445 return DW_FORM_data2; 8446 case 32: 8447 return DW_FORM_data4; 8448 case 64: 8449 return DW_FORM_data8; 8450 default: 8451 return DW_FORM_block1; 8452 } 8453 case dw_val_class_vec: 8454 switch (constant_size (a->dw_attr_val.v.val_vec.length 8455 * a->dw_attr_val.v.val_vec.elt_size)) 8456 { 8457 case 1: 8458 return DW_FORM_block1; 8459 case 2: 8460 return DW_FORM_block2; 8461 case 4: 8462 return DW_FORM_block4; 8463 default: 8464 gcc_unreachable (); 8465 } 8466 case dw_val_class_flag: 8467 if (dwarf_version >= 4) 8468 { 8469 /* Currently all add_AT_flag calls pass in 1 as last argument, 8470 so DW_FORM_flag_present can be used. If that ever changes, 8471 we'll need to use DW_FORM_flag and have some optimization 8472 in build_abbrev_table that will change those to 8473 DW_FORM_flag_present if it is set to 1 in all DIEs using 8474 the same abbrev entry. */ 8475 gcc_assert (a->dw_attr_val.v.val_flag == 1); 8476 return DW_FORM_flag_present; 8477 } 8478 return DW_FORM_flag; 8479 case dw_val_class_die_ref: 8480 if (AT_ref_external (a)) 8481 return use_debug_types ? DW_FORM_ref_sig8 : DW_FORM_ref_addr; 8482 else 8483 return DW_FORM_ref; 8484 case dw_val_class_fde_ref: 8485 return DW_FORM_data; 8486 case dw_val_class_lbl_id: 8487 return (AT_index (a) == NOT_INDEXED 8488 ? DW_FORM_addr : DW_FORM_GNU_addr_index); 8489 case dw_val_class_lineptr: 8490 case dw_val_class_macptr: 8491 return dwarf_version >= 4 ? DW_FORM_sec_offset : DW_FORM_data; 8492 case dw_val_class_str: 8493 return AT_string_form (a); 8494 case dw_val_class_file: 8495 switch (constant_size (maybe_emit_file (a->dw_attr_val.v.val_file))) 8496 { 8497 case 1: 8498 return DW_FORM_data1; 8499 case 2: 8500 return DW_FORM_data2; 8501 case 4: 8502 return DW_FORM_data4; 8503 default: 8504 gcc_unreachable (); 8505 } 8506 8507 case dw_val_class_data8: 8508 return DW_FORM_data8; 8509 8510 case dw_val_class_high_pc: 8511 switch (DWARF2_ADDR_SIZE) 8512 { 8513 case 1: 8514 return DW_FORM_data1; 8515 case 2: 8516 return DW_FORM_data2; 8517 case 4: 8518 return DW_FORM_data4; 8519 case 8: 8520 return DW_FORM_data8; 8521 default: 8522 gcc_unreachable (); 8523 } 8524 8525 default: 8526 gcc_unreachable (); 8527 } 8528} 8529 8530/* Output the encoding of an attribute value. */ 8531 8532static void 8533output_value_format (dw_attr_ref a) 8534{ 8535 enum dwarf_form form = value_format (a); 8536 8537 dw2_asm_output_data_uleb128 (form, "(%s)", dwarf_form_name (form)); 8538} 8539 8540/* Given a die and id, produce the appropriate abbreviations. */ 8541 8542static void 8543output_die_abbrevs (unsigned long abbrev_id, dw_die_ref abbrev) 8544{ 8545 unsigned ix; 8546 dw_attr_ref a_attr; 8547 8548 dw2_asm_output_data_uleb128 (abbrev_id, "(abbrev code)"); 8549 dw2_asm_output_data_uleb128 (abbrev->die_tag, "(TAG: %s)", 8550 dwarf_tag_name (abbrev->die_tag)); 8551 8552 if (abbrev->die_child != NULL) 8553 dw2_asm_output_data (1, DW_children_yes, "DW_children_yes"); 8554 else 8555 dw2_asm_output_data (1, DW_children_no, "DW_children_no"); 8556 8557 for (ix = 0; vec_safe_iterate (abbrev->die_attr, ix, &a_attr); ix++) 8558 { 8559 dw2_asm_output_data_uleb128 (a_attr->dw_attr, "(%s)", 8560 dwarf_attr_name (a_attr->dw_attr)); 8561 output_value_format (a_attr); 8562 } 8563 8564 dw2_asm_output_data (1, 0, NULL); 8565 dw2_asm_output_data (1, 0, NULL); 8566} 8567 8568 8569/* Output the .debug_abbrev section which defines the DIE abbreviation 8570 table. */ 8571 8572static void 8573output_abbrev_section (void) 8574{ 8575 unsigned long abbrev_id; 8576 8577 for (abbrev_id = 1; abbrev_id < abbrev_die_table_in_use; ++abbrev_id) 8578 output_die_abbrevs (abbrev_id, abbrev_die_table[abbrev_id]); 8579 8580 /* Terminate the table. */ 8581 dw2_asm_output_data (1, 0, NULL); 8582} 8583 8584/* Output a symbol we can use to refer to this DIE from another CU. */ 8585 8586static inline void 8587output_die_symbol (dw_die_ref die) 8588{ 8589 const char *sym = die->die_id.die_symbol; 8590 8591 gcc_assert (!die->comdat_type_p); 8592 8593 if (sym == 0) 8594 return; 8595 8596 if (strncmp (sym, DIE_LABEL_PREFIX, sizeof (DIE_LABEL_PREFIX) - 1) == 0) 8597 /* We make these global, not weak; if the target doesn't support 8598 .linkonce, it doesn't support combining the sections, so debugging 8599 will break. */ 8600 targetm.asm_out.globalize_label (asm_out_file, sym); 8601 8602 ASM_OUTPUT_LABEL (asm_out_file, sym); 8603} 8604 8605/* Return a new location list, given the begin and end range, and the 8606 expression. */ 8607 8608static inline dw_loc_list_ref 8609new_loc_list (dw_loc_descr_ref expr, const char *begin, const char *end, 8610 const char *section) 8611{ 8612 dw_loc_list_ref retlist = ggc_cleared_alloc<dw_loc_list_node> (); 8613 8614 retlist->begin = begin; 8615 retlist->begin_entry = NULL; 8616 retlist->end = end; 8617 retlist->expr = expr; 8618 retlist->section = section; 8619 8620 return retlist; 8621} 8622 8623/* Generate a new internal symbol for this location list node, if it 8624 hasn't got one yet. */ 8625 8626static inline void 8627gen_llsym (dw_loc_list_ref list) 8628{ 8629 gcc_assert (!list->ll_symbol); 8630 list->ll_symbol = gen_internal_sym ("LLST"); 8631} 8632 8633/* Output the location list given to us. */ 8634 8635static void 8636output_loc_list (dw_loc_list_ref list_head) 8637{ 8638 dw_loc_list_ref curr = list_head; 8639 8640 if (list_head->emitted) 8641 return; 8642 list_head->emitted = true; 8643 8644 ASM_OUTPUT_LABEL (asm_out_file, list_head->ll_symbol); 8645 8646 /* Walk the location list, and output each range + expression. */ 8647 for (curr = list_head; curr != NULL; curr = curr->dw_loc_next) 8648 { 8649 unsigned long size; 8650 /* Don't output an entry that starts and ends at the same address. */ 8651 if (strcmp (curr->begin, curr->end) == 0 && !curr->force) 8652 continue; 8653 size = size_of_locs (curr->expr); 8654 /* If the expression is too large, drop it on the floor. We could 8655 perhaps put it into DW_TAG_dwarf_procedure and refer to that 8656 in the expression, but >= 64KB expressions for a single value 8657 in a single range are unlikely very useful. */ 8658 if (size > 0xffff) 8659 continue; 8660 if (dwarf_split_debug_info) 8661 { 8662 dw2_asm_output_data (1, DW_LLE_GNU_start_length_entry, 8663 "Location list start/length entry (%s)", 8664 list_head->ll_symbol); 8665 dw2_asm_output_data_uleb128 (curr->begin_entry->index, 8666 "Location list range start index (%s)", 8667 curr->begin); 8668 /* The length field is 4 bytes. If we ever need to support 8669 an 8-byte length, we can add a new DW_LLE code or fall back 8670 to DW_LLE_GNU_start_end_entry. */ 8671 dw2_asm_output_delta (4, curr->end, curr->begin, 8672 "Location list range length (%s)", 8673 list_head->ll_symbol); 8674 } 8675 else if (!have_multiple_function_sections) 8676 { 8677 dw2_asm_output_delta (DWARF2_ADDR_SIZE, curr->begin, curr->section, 8678 "Location list begin address (%s)", 8679 list_head->ll_symbol); 8680 dw2_asm_output_delta (DWARF2_ADDR_SIZE, curr->end, curr->section, 8681 "Location list end address (%s)", 8682 list_head->ll_symbol); 8683 } 8684 else 8685 { 8686 dw2_asm_output_addr (DWARF2_ADDR_SIZE, curr->begin, 8687 "Location list begin address (%s)", 8688 list_head->ll_symbol); 8689 dw2_asm_output_addr (DWARF2_ADDR_SIZE, curr->end, 8690 "Location list end address (%s)", 8691 list_head->ll_symbol); 8692 } 8693 8694 /* Output the block length for this list of location operations. */ 8695 gcc_assert (size <= 0xffff); 8696 dw2_asm_output_data (2, size, "%s", "Location expression size"); 8697 8698 output_loc_sequence (curr->expr, -1); 8699 } 8700 8701 if (dwarf_split_debug_info) 8702 dw2_asm_output_data (1, DW_LLE_GNU_end_of_list_entry, 8703 "Location list terminator (%s)", 8704 list_head->ll_symbol); 8705 else 8706 { 8707 dw2_asm_output_data (DWARF2_ADDR_SIZE, 0, 8708 "Location list terminator begin (%s)", 8709 list_head->ll_symbol); 8710 dw2_asm_output_data (DWARF2_ADDR_SIZE, 0, 8711 "Location list terminator end (%s)", 8712 list_head->ll_symbol); 8713 } 8714} 8715 8716/* Output a range_list offset into the debug_range section. Emit a 8717 relocated reference if val_entry is NULL, otherwise, emit an 8718 indirect reference. */ 8719 8720static void 8721output_range_list_offset (dw_attr_ref a) 8722{ 8723 const char *name = dwarf_attr_name (a->dw_attr); 8724 8725 if (a->dw_attr_val.val_entry == RELOCATED_OFFSET) 8726 { 8727 char *p = strchr (ranges_section_label, '\0'); 8728 sprintf (p, "+" HOST_WIDE_INT_PRINT_HEX, a->dw_attr_val.v.val_offset); 8729 dw2_asm_output_offset (DWARF_OFFSET_SIZE, ranges_section_label, 8730 debug_ranges_section, "%s", name); 8731 *p = '\0'; 8732 } 8733 else 8734 dw2_asm_output_data (DWARF_OFFSET_SIZE, a->dw_attr_val.v.val_offset, 8735 "%s (offset from %s)", name, ranges_section_label); 8736} 8737 8738/* Output the offset into the debug_loc section. */ 8739 8740static void 8741output_loc_list_offset (dw_attr_ref a) 8742{ 8743 char *sym = AT_loc_list (a)->ll_symbol; 8744 8745 gcc_assert (sym); 8746 if (dwarf_split_debug_info) 8747 dw2_asm_output_delta (DWARF_OFFSET_SIZE, sym, loc_section_label, 8748 "%s", dwarf_attr_name (a->dw_attr)); 8749 else 8750 dw2_asm_output_offset (DWARF_OFFSET_SIZE, sym, debug_loc_section, 8751 "%s", dwarf_attr_name (a->dw_attr)); 8752} 8753 8754/* Output an attribute's index or value appropriately. */ 8755 8756static void 8757output_attr_index_or_value (dw_attr_ref a) 8758{ 8759 const char *name = dwarf_attr_name (a->dw_attr); 8760 8761 if (dwarf_split_debug_info && AT_index (a) != NOT_INDEXED) 8762 { 8763 dw2_asm_output_data_uleb128 (AT_index (a), "%s", name); 8764 return; 8765 } 8766 switch (AT_class (a)) 8767 { 8768 case dw_val_class_addr: 8769 dw2_asm_output_addr_rtx (DWARF2_ADDR_SIZE, AT_addr (a), "%s", name); 8770 break; 8771 case dw_val_class_high_pc: 8772 case dw_val_class_lbl_id: 8773 dw2_asm_output_addr (DWARF2_ADDR_SIZE, AT_lbl (a), "%s", name); 8774 break; 8775 case dw_val_class_loc_list: 8776 output_loc_list_offset (a); 8777 break; 8778 default: 8779 gcc_unreachable (); 8780 } 8781} 8782 8783/* Output a type signature. */ 8784 8785static inline void 8786output_signature (const char *sig, const char *name) 8787{ 8788 int i; 8789 8790 for (i = 0; i < DWARF_TYPE_SIGNATURE_SIZE; i++) 8791 dw2_asm_output_data (1, sig[i], i == 0 ? "%s" : NULL, name); 8792} 8793 8794/* Output the DIE and its attributes. Called recursively to generate 8795 the definitions of each child DIE. */ 8796 8797static void 8798output_die (dw_die_ref die) 8799{ 8800 dw_attr_ref a; 8801 dw_die_ref c; 8802 unsigned long size; 8803 unsigned ix; 8804 8805 /* If someone in another CU might refer to us, set up a symbol for 8806 them to point to. */ 8807 if (! die->comdat_type_p && die->die_id.die_symbol) 8808 output_die_symbol (die); 8809 8810 dw2_asm_output_data_uleb128 (die->die_abbrev, "(DIE (%#lx) %s)", 8811 (unsigned long)die->die_offset, 8812 dwarf_tag_name (die->die_tag)); 8813 8814 FOR_EACH_VEC_SAFE_ELT (die->die_attr, ix, a) 8815 { 8816 const char *name = dwarf_attr_name (a->dw_attr); 8817 8818 switch (AT_class (a)) 8819 { 8820 case dw_val_class_addr: 8821 output_attr_index_or_value (a); 8822 break; 8823 8824 case dw_val_class_offset: 8825 dw2_asm_output_data (DWARF_OFFSET_SIZE, a->dw_attr_val.v.val_offset, 8826 "%s", name); 8827 break; 8828 8829 case dw_val_class_range_list: 8830 output_range_list_offset (a); 8831 break; 8832 8833 case dw_val_class_loc: 8834 size = size_of_locs (AT_loc (a)); 8835 8836 /* Output the block length for this list of location operations. */ 8837 if (dwarf_version >= 4) 8838 dw2_asm_output_data_uleb128 (size, "%s", name); 8839 else 8840 dw2_asm_output_data (constant_size (size), size, "%s", name); 8841 8842 output_loc_sequence (AT_loc (a), -1); 8843 break; 8844 8845 case dw_val_class_const: 8846 /* ??? It would be slightly more efficient to use a scheme like is 8847 used for unsigned constants below, but gdb 4.x does not sign 8848 extend. Gdb 5.x does sign extend. */ 8849 dw2_asm_output_data_sleb128 (AT_int (a), "%s", name); 8850 break; 8851 8852 case dw_val_class_unsigned_const: 8853 { 8854 int csize = constant_size (AT_unsigned (a)); 8855 if (dwarf_version == 3 8856 && a->dw_attr == DW_AT_data_member_location 8857 && csize >= 4) 8858 dw2_asm_output_data_uleb128 (AT_unsigned (a), "%s", name); 8859 else 8860 dw2_asm_output_data (csize, AT_unsigned (a), "%s", name); 8861 } 8862 break; 8863 8864 case dw_val_class_const_double: 8865 { 8866 unsigned HOST_WIDE_INT first, second; 8867 8868 if (HOST_BITS_PER_WIDE_INT >= 64) 8869 dw2_asm_output_data (1, 8870 HOST_BITS_PER_DOUBLE_INT 8871 / HOST_BITS_PER_CHAR, 8872 NULL); 8873 8874 if (WORDS_BIG_ENDIAN) 8875 { 8876 first = a->dw_attr_val.v.val_double.high; 8877 second = a->dw_attr_val.v.val_double.low; 8878 } 8879 else 8880 { 8881 first = a->dw_attr_val.v.val_double.low; 8882 second = a->dw_attr_val.v.val_double.high; 8883 } 8884 8885 dw2_asm_output_data (HOST_BITS_PER_WIDE_INT / HOST_BITS_PER_CHAR, 8886 first, "%s", name); 8887 dw2_asm_output_data (HOST_BITS_PER_WIDE_INT / HOST_BITS_PER_CHAR, 8888 second, NULL); 8889 } 8890 break; 8891 8892 case dw_val_class_wide_int: 8893 { 8894 int i; 8895 int len = get_full_len (*a->dw_attr_val.v.val_wide); 8896 int l = HOST_BITS_PER_WIDE_INT / HOST_BITS_PER_CHAR; 8897 if (len * HOST_BITS_PER_WIDE_INT > 64) 8898 dw2_asm_output_data (1, get_full_len (*a->dw_attr_val.v.val_wide) * l, 8899 NULL); 8900 8901 if (WORDS_BIG_ENDIAN) 8902 for (i = len - 1; i >= 0; --i) 8903 { 8904 dw2_asm_output_data (l, a->dw_attr_val.v.val_wide->elt (i), 8905 "%s", name); 8906 name = ""; 8907 } 8908 else 8909 for (i = 0; i < len; ++i) 8910 { 8911 dw2_asm_output_data (l, a->dw_attr_val.v.val_wide->elt (i), 8912 "%s", name); 8913 name = ""; 8914 } 8915 } 8916 break; 8917 8918 case dw_val_class_vec: 8919 { 8920 unsigned int elt_size = a->dw_attr_val.v.val_vec.elt_size; 8921 unsigned int len = a->dw_attr_val.v.val_vec.length; 8922 unsigned int i; 8923 unsigned char *p; 8924 8925 dw2_asm_output_data (constant_size (len * elt_size), 8926 len * elt_size, "%s", name); 8927 if (elt_size > sizeof (HOST_WIDE_INT)) 8928 { 8929 elt_size /= 2; 8930 len *= 2; 8931 } 8932 for (i = 0, p = a->dw_attr_val.v.val_vec.array; 8933 i < len; 8934 i++, p += elt_size) 8935 dw2_asm_output_data (elt_size, extract_int (p, elt_size), 8936 "fp or vector constant word %u", i); 8937 break; 8938 } 8939 8940 case dw_val_class_flag: 8941 if (dwarf_version >= 4) 8942 { 8943 /* Currently all add_AT_flag calls pass in 1 as last argument, 8944 so DW_FORM_flag_present can be used. If that ever changes, 8945 we'll need to use DW_FORM_flag and have some optimization 8946 in build_abbrev_table that will change those to 8947 DW_FORM_flag_present if it is set to 1 in all DIEs using 8948 the same abbrev entry. */ 8949 gcc_assert (AT_flag (a) == 1); 8950 if (flag_debug_asm) 8951 fprintf (asm_out_file, "\t\t\t%s %s\n", 8952 ASM_COMMENT_START, name); 8953 break; 8954 } 8955 dw2_asm_output_data (1, AT_flag (a), "%s", name); 8956 break; 8957 8958 case dw_val_class_loc_list: 8959 output_attr_index_or_value (a); 8960 break; 8961 8962 case dw_val_class_die_ref: 8963 if (AT_ref_external (a)) 8964 { 8965 if (AT_ref (a)->comdat_type_p) 8966 { 8967 comdat_type_node_ref type_node = 8968 AT_ref (a)->die_id.die_type_node; 8969 8970 gcc_assert (type_node); 8971 output_signature (type_node->signature, name); 8972 } 8973 else 8974 { 8975 const char *sym = AT_ref (a)->die_id.die_symbol; 8976 int size; 8977 8978 gcc_assert (sym); 8979 /* In DWARF2, DW_FORM_ref_addr is sized by target address 8980 length, whereas in DWARF3 it's always sized as an 8981 offset. */ 8982 if (dwarf_version == 2) 8983 size = DWARF2_ADDR_SIZE; 8984 else 8985 size = DWARF_OFFSET_SIZE; 8986 dw2_asm_output_offset (size, sym, debug_info_section, "%s", 8987 name); 8988 } 8989 } 8990 else 8991 { 8992 gcc_assert (AT_ref (a)->die_offset); 8993 dw2_asm_output_data (DWARF_OFFSET_SIZE, AT_ref (a)->die_offset, 8994 "%s", name); 8995 } 8996 break; 8997 8998 case dw_val_class_fde_ref: 8999 { 9000 char l1[20]; 9001 9002 ASM_GENERATE_INTERNAL_LABEL (l1, FDE_LABEL, 9003 a->dw_attr_val.v.val_fde_index * 2); 9004 dw2_asm_output_offset (DWARF_OFFSET_SIZE, l1, debug_frame_section, 9005 "%s", name); 9006 } 9007 break; 9008 9009 case dw_val_class_vms_delta: 9010#ifdef ASM_OUTPUT_DWARF_VMS_DELTA 9011 dw2_asm_output_vms_delta (DWARF_OFFSET_SIZE, 9012 AT_vms_delta2 (a), AT_vms_delta1 (a), 9013 "%s", name); 9014#else 9015 dw2_asm_output_delta (DWARF_OFFSET_SIZE, 9016 AT_vms_delta2 (a), AT_vms_delta1 (a), 9017 "%s", name); 9018#endif 9019 break; 9020 9021 case dw_val_class_lbl_id: 9022 output_attr_index_or_value (a); 9023 break; 9024 9025 case dw_val_class_lineptr: 9026 dw2_asm_output_offset (DWARF_OFFSET_SIZE, AT_lbl (a), 9027 debug_line_section, "%s", name); 9028 break; 9029 9030 case dw_val_class_macptr: 9031 dw2_asm_output_offset (DWARF_OFFSET_SIZE, AT_lbl (a), 9032 debug_macinfo_section, "%s", name); 9033 break; 9034 9035 case dw_val_class_str: 9036 if (a->dw_attr_val.v.val_str->form == DW_FORM_strp) 9037 dw2_asm_output_offset (DWARF_OFFSET_SIZE, 9038 a->dw_attr_val.v.val_str->label, 9039 debug_str_section, 9040 "%s: \"%s\"", name, AT_string (a)); 9041 else if (a->dw_attr_val.v.val_str->form == DW_FORM_GNU_str_index) 9042 dw2_asm_output_data_uleb128 (AT_index (a), 9043 "%s: \"%s\"", name, AT_string (a)); 9044 else 9045 dw2_asm_output_nstring (AT_string (a), -1, "%s", name); 9046 break; 9047 9048 case dw_val_class_file: 9049 { 9050 int f = maybe_emit_file (a->dw_attr_val.v.val_file); 9051 9052 dw2_asm_output_data (constant_size (f), f, "%s (%s)", name, 9053 a->dw_attr_val.v.val_file->filename); 9054 break; 9055 } 9056 9057 case dw_val_class_data8: 9058 { 9059 int i; 9060 9061 for (i = 0; i < 8; i++) 9062 dw2_asm_output_data (1, a->dw_attr_val.v.val_data8[i], 9063 i == 0 ? "%s" : NULL, name); 9064 break; 9065 } 9066 9067 case dw_val_class_high_pc: 9068 dw2_asm_output_delta (DWARF2_ADDR_SIZE, AT_lbl (a), 9069 get_AT_low_pc (die), "DW_AT_high_pc"); 9070 break; 9071 9072 default: 9073 gcc_unreachable (); 9074 } 9075 } 9076 9077 FOR_EACH_CHILD (die, c, output_die (c)); 9078 9079 /* Add null byte to terminate sibling list. */ 9080 if (die->die_child != NULL) 9081 dw2_asm_output_data (1, 0, "end of children of DIE %#lx", 9082 (unsigned long) die->die_offset); 9083} 9084 9085/* Output the compilation unit that appears at the beginning of the 9086 .debug_info section, and precedes the DIE descriptions. */ 9087 9088static void 9089output_compilation_unit_header (void) 9090{ 9091 /* We don't support actual DWARFv5 units yet, we just use some 9092 DWARFv5 draft DIE tags in DWARFv4 format. */ 9093 int ver = dwarf_version < 5 ? dwarf_version : 4; 9094 9095 if (DWARF_INITIAL_LENGTH_SIZE - DWARF_OFFSET_SIZE == 4) 9096 dw2_asm_output_data (4, 0xffffffff, 9097 "Initial length escape value indicating 64-bit DWARF extension"); 9098 dw2_asm_output_data (DWARF_OFFSET_SIZE, 9099 next_die_offset - DWARF_INITIAL_LENGTH_SIZE, 9100 "Length of Compilation Unit Info"); 9101 dw2_asm_output_data (2, ver, "DWARF version number"); 9102 dw2_asm_output_offset (DWARF_OFFSET_SIZE, abbrev_section_label, 9103 debug_abbrev_section, 9104 "Offset Into Abbrev. Section"); 9105 dw2_asm_output_data (1, DWARF2_ADDR_SIZE, "Pointer Size (in bytes)"); 9106} 9107 9108/* Output the compilation unit DIE and its children. */ 9109 9110static void 9111output_comp_unit (dw_die_ref die, int output_if_empty) 9112{ 9113 const char *secname, *oldsym; 9114 char *tmp; 9115 9116 /* Unless we are outputting main CU, we may throw away empty ones. */ 9117 if (!output_if_empty && die->die_child == NULL) 9118 return; 9119 9120 /* Even if there are no children of this DIE, we must output the information 9121 about the compilation unit. Otherwise, on an empty translation unit, we 9122 will generate a present, but empty, .debug_info section. IRIX 6.5 `nm' 9123 will then complain when examining the file. First mark all the DIEs in 9124 this CU so we know which get local refs. */ 9125 mark_dies (die); 9126 9127 external_ref_hash_type *extern_map = optimize_external_refs (die); 9128 9129 build_abbrev_table (die, extern_map); 9130 9131 delete extern_map; 9132 9133 /* Initialize the beginning DIE offset - and calculate sizes/offsets. */ 9134 next_die_offset = DWARF_COMPILE_UNIT_HEADER_SIZE; 9135 calc_die_sizes (die); 9136 9137 oldsym = die->die_id.die_symbol; 9138 if (oldsym) 9139 { 9140 tmp = XALLOCAVEC (char, strlen (oldsym) + 24); 9141 9142 sprintf (tmp, ".gnu.linkonce.wi.%s", oldsym); 9143 secname = tmp; 9144 die->die_id.die_symbol = NULL; 9145 switch_to_section (get_section (secname, SECTION_DEBUG, NULL)); 9146 } 9147 else 9148 { 9149 switch_to_section (debug_info_section); 9150 ASM_OUTPUT_LABEL (asm_out_file, debug_info_section_label); 9151 info_section_emitted = true; 9152 } 9153 9154 /* Output debugging information. */ 9155 output_compilation_unit_header (); 9156 output_die (die); 9157 9158 /* Leave the marks on the main CU, so we can check them in 9159 output_pubnames. */ 9160 if (oldsym) 9161 { 9162 unmark_dies (die); 9163 die->die_id.die_symbol = oldsym; 9164 } 9165} 9166 9167/* Whether to generate the DWARF accelerator tables in .debug_pubnames 9168 and .debug_pubtypes. This is configured per-target, but can be 9169 overridden by the -gpubnames or -gno-pubnames options. */ 9170 9171static inline bool 9172want_pubnames (void) 9173{ 9174 if (debug_info_level <= DINFO_LEVEL_TERSE) 9175 return false; 9176 if (debug_generate_pub_sections != -1) 9177 return debug_generate_pub_sections; 9178 return targetm.want_debug_pub_sections; 9179} 9180 9181/* Add the DW_AT_GNU_pubnames and DW_AT_GNU_pubtypes attributes. */ 9182 9183static void 9184add_AT_pubnames (dw_die_ref die) 9185{ 9186 if (want_pubnames ()) 9187 add_AT_flag (die, DW_AT_GNU_pubnames, 1); 9188} 9189 9190/* Add a string attribute value to a skeleton DIE. */ 9191 9192static inline void 9193add_skeleton_AT_string (dw_die_ref die, enum dwarf_attribute attr_kind, 9194 const char *str) 9195{ 9196 dw_attr_node attr; 9197 struct indirect_string_node *node; 9198 9199 if (! skeleton_debug_str_hash) 9200 skeleton_debug_str_hash 9201 = hash_table<indirect_string_hasher>::create_ggc (10); 9202 9203 node = find_AT_string_in_table (str, skeleton_debug_str_hash); 9204 find_string_form (node); 9205 if (node->form == DW_FORM_GNU_str_index) 9206 node->form = DW_FORM_strp; 9207 9208 attr.dw_attr = attr_kind; 9209 attr.dw_attr_val.val_class = dw_val_class_str; 9210 attr.dw_attr_val.val_entry = NULL; 9211 attr.dw_attr_val.v.val_str = node; 9212 add_dwarf_attr (die, &attr); 9213} 9214 9215/* Helper function to generate top-level dies for skeleton debug_info and 9216 debug_types. */ 9217 9218static void 9219add_top_level_skeleton_die_attrs (dw_die_ref die) 9220{ 9221 const char *dwo_file_name = concat (aux_base_name, ".dwo", NULL); 9222 const char *comp_dir = comp_dir_string (); 9223 9224 add_skeleton_AT_string (die, DW_AT_GNU_dwo_name, dwo_file_name); 9225 if (comp_dir != NULL) 9226 add_skeleton_AT_string (die, DW_AT_comp_dir, comp_dir); 9227 add_AT_pubnames (die); 9228 add_AT_lineptr (die, DW_AT_GNU_addr_base, debug_addr_section_label); 9229} 9230 9231/* Output skeleton debug sections that point to the dwo file. */ 9232 9233static void 9234output_skeleton_debug_sections (dw_die_ref comp_unit) 9235{ 9236 /* We don't support actual DWARFv5 units yet, we just use some 9237 DWARFv5 draft DIE tags in DWARFv4 format. */ 9238 int ver = dwarf_version < 5 ? dwarf_version : 4; 9239 9240 /* These attributes will be found in the full debug_info section. */ 9241 remove_AT (comp_unit, DW_AT_producer); 9242 remove_AT (comp_unit, DW_AT_language); 9243 9244 switch_to_section (debug_skeleton_info_section); 9245 ASM_OUTPUT_LABEL (asm_out_file, debug_skeleton_info_section_label); 9246 9247 /* Produce the skeleton compilation-unit header. This one differs enough from 9248 a normal CU header that it's better not to call output_compilation_unit 9249 header. */ 9250 if (DWARF_INITIAL_LENGTH_SIZE - DWARF_OFFSET_SIZE == 4) 9251 dw2_asm_output_data (4, 0xffffffff, 9252 "Initial length escape value indicating 64-bit DWARF extension"); 9253 9254 dw2_asm_output_data (DWARF_OFFSET_SIZE, 9255 DWARF_COMPILE_UNIT_HEADER_SIZE 9256 - DWARF_INITIAL_LENGTH_SIZE 9257 + size_of_die (comp_unit), 9258 "Length of Compilation Unit Info"); 9259 dw2_asm_output_data (2, ver, "DWARF version number"); 9260 dw2_asm_output_offset (DWARF_OFFSET_SIZE, debug_skeleton_abbrev_section_label, 9261 debug_abbrev_section, 9262 "Offset Into Abbrev. Section"); 9263 dw2_asm_output_data (1, DWARF2_ADDR_SIZE, "Pointer Size (in bytes)"); 9264 9265 comp_unit->die_abbrev = SKELETON_COMP_DIE_ABBREV; 9266 output_die (comp_unit); 9267 9268 /* Build the skeleton debug_abbrev section. */ 9269 switch_to_section (debug_skeleton_abbrev_section); 9270 ASM_OUTPUT_LABEL (asm_out_file, debug_skeleton_abbrev_section_label); 9271 9272 output_die_abbrevs (SKELETON_COMP_DIE_ABBREV, comp_unit); 9273 9274 dw2_asm_output_data (1, 0, "end of skeleton .debug_abbrev"); 9275} 9276 9277/* Output a comdat type unit DIE and its children. */ 9278 9279static void 9280output_comdat_type_unit (comdat_type_node *node) 9281{ 9282 const char *secname; 9283 char *tmp; 9284 int i; 9285#if defined (OBJECT_FORMAT_ELF) 9286 tree comdat_key; 9287#endif 9288 9289 /* First mark all the DIEs in this CU so we know which get local refs. */ 9290 mark_dies (node->root_die); 9291 9292 external_ref_hash_type *extern_map = optimize_external_refs (node->root_die); 9293 9294 build_abbrev_table (node->root_die, extern_map); 9295 9296 delete extern_map; 9297 extern_map = NULL; 9298 9299 /* Initialize the beginning DIE offset - and calculate sizes/offsets. */ 9300 next_die_offset = DWARF_COMDAT_TYPE_UNIT_HEADER_SIZE; 9301 calc_die_sizes (node->root_die); 9302 9303#if defined (OBJECT_FORMAT_ELF) 9304 if (!dwarf_split_debug_info) 9305 secname = ".debug_types"; 9306 else 9307 secname = ".debug_types.dwo"; 9308 9309 tmp = XALLOCAVEC (char, 4 + DWARF_TYPE_SIGNATURE_SIZE * 2); 9310 sprintf (tmp, "wt."); 9311 for (i = 0; i < DWARF_TYPE_SIGNATURE_SIZE; i++) 9312 sprintf (tmp + 3 + i * 2, "%02x", node->signature[i] & 0xff); 9313 comdat_key = get_identifier (tmp); 9314 targetm.asm_out.named_section (secname, 9315 SECTION_DEBUG | SECTION_LINKONCE, 9316 comdat_key); 9317#else 9318 tmp = XALLOCAVEC (char, 18 + DWARF_TYPE_SIGNATURE_SIZE * 2); 9319 sprintf (tmp, ".gnu.linkonce.wt."); 9320 for (i = 0; i < DWARF_TYPE_SIGNATURE_SIZE; i++) 9321 sprintf (tmp + 17 + i * 2, "%02x", node->signature[i] & 0xff); 9322 secname = tmp; 9323 switch_to_section (get_section (secname, SECTION_DEBUG, NULL)); 9324#endif 9325 9326 /* Output debugging information. */ 9327 output_compilation_unit_header (); 9328 output_signature (node->signature, "Type Signature"); 9329 dw2_asm_output_data (DWARF_OFFSET_SIZE, node->type_die->die_offset, 9330 "Offset to Type DIE"); 9331 output_die (node->root_die); 9332 9333 unmark_dies (node->root_die); 9334} 9335 9336/* Return the DWARF2/3 pubname associated with a decl. */ 9337 9338static const char * 9339dwarf2_name (tree decl, int scope) 9340{ 9341 if (DECL_NAMELESS (decl)) 9342 return NULL; 9343 return lang_hooks.dwarf_name (decl, scope ? 1 : 0); 9344} 9345 9346/* Add a new entry to .debug_pubnames if appropriate. */ 9347 9348static void 9349add_pubname_string (const char *str, dw_die_ref die) 9350{ 9351 pubname_entry e; 9352 9353 e.die = die; 9354 e.name = xstrdup (str); 9355 vec_safe_push (pubname_table, e); 9356} 9357 9358static void 9359add_pubname (tree decl, dw_die_ref die) 9360{ 9361 if (!want_pubnames ()) 9362 return; 9363 9364 /* Don't add items to the table when we expect that the consumer will have 9365 just read the enclosing die. For example, if the consumer is looking at a 9366 class_member, it will either be inside the class already, or will have just 9367 looked up the class to find the member. Either way, searching the class is 9368 faster than searching the index. */ 9369 if ((TREE_PUBLIC (decl) && !class_scope_p (die->die_parent)) 9370 || is_cu_die (die->die_parent) || is_namespace_die (die->die_parent)) 9371 { 9372 const char *name = dwarf2_name (decl, 1); 9373 9374 if (name) 9375 add_pubname_string (name, die); 9376 } 9377} 9378 9379/* Add an enumerator to the pubnames section. */ 9380 9381static void 9382add_enumerator_pubname (const char *scope_name, dw_die_ref die) 9383{ 9384 pubname_entry e; 9385 9386 gcc_assert (scope_name); 9387 e.name = concat (scope_name, get_AT_string (die, DW_AT_name), NULL); 9388 e.die = die; 9389 vec_safe_push (pubname_table, e); 9390} 9391 9392/* Add a new entry to .debug_pubtypes if appropriate. */ 9393 9394static void 9395add_pubtype (tree decl, dw_die_ref die) 9396{ 9397 pubname_entry e; 9398 9399 if (!want_pubnames ()) 9400 return; 9401 9402 if ((TREE_PUBLIC (decl) 9403 || is_cu_die (die->die_parent) || is_namespace_die (die->die_parent)) 9404 && (die->die_tag == DW_TAG_typedef || COMPLETE_TYPE_P (decl))) 9405 { 9406 tree scope = NULL; 9407 const char *scope_name = ""; 9408 const char *sep = is_cxx () ? "::" : "."; 9409 const char *name; 9410 9411 scope = TYPE_P (decl) ? TYPE_CONTEXT (decl) : NULL; 9412 if (scope && TREE_CODE (scope) == NAMESPACE_DECL) 9413 { 9414 scope_name = lang_hooks.dwarf_name (scope, 1); 9415 if (scope_name != NULL && scope_name[0] != '\0') 9416 scope_name = concat (scope_name, sep, NULL); 9417 else 9418 scope_name = ""; 9419 } 9420 9421 if (TYPE_P (decl)) 9422 name = type_tag (decl); 9423 else 9424 name = lang_hooks.dwarf_name (decl, 1); 9425 9426 /* If we don't have a name for the type, there's no point in adding 9427 it to the table. */ 9428 if (name != NULL && name[0] != '\0') 9429 { 9430 e.die = die; 9431 e.name = concat (scope_name, name, NULL); 9432 vec_safe_push (pubtype_table, e); 9433 } 9434 9435 /* Although it might be more consistent to add the pubinfo for the 9436 enumerators as their dies are created, they should only be added if the 9437 enum type meets the criteria above. So rather than re-check the parent 9438 enum type whenever an enumerator die is created, just output them all 9439 here. This isn't protected by the name conditional because anonymous 9440 enums don't have names. */ 9441 if (die->die_tag == DW_TAG_enumeration_type) 9442 { 9443 dw_die_ref c; 9444 9445 FOR_EACH_CHILD (die, c, add_enumerator_pubname (scope_name, c)); 9446 } 9447 } 9448} 9449 9450/* Output a single entry in the pubnames table. */ 9451 9452static void 9453output_pubname (dw_offset die_offset, pubname_entry *entry) 9454{ 9455 dw_die_ref die = entry->die; 9456 int is_static = get_AT_flag (die, DW_AT_external) ? 0 : 1; 9457 9458 dw2_asm_output_data (DWARF_OFFSET_SIZE, die_offset, "DIE offset"); 9459 9460 if (debug_generate_pub_sections == 2) 9461 { 9462 /* This logic follows gdb's method for determining the value of the flag 9463 byte. */ 9464 uint32_t flags = GDB_INDEX_SYMBOL_KIND_NONE; 9465 switch (die->die_tag) 9466 { 9467 case DW_TAG_typedef: 9468 case DW_TAG_base_type: 9469 case DW_TAG_subrange_type: 9470 GDB_INDEX_SYMBOL_KIND_SET_VALUE(flags, GDB_INDEX_SYMBOL_KIND_TYPE); 9471 GDB_INDEX_SYMBOL_STATIC_SET_VALUE(flags, 1); 9472 break; 9473 case DW_TAG_enumerator: 9474 GDB_INDEX_SYMBOL_KIND_SET_VALUE(flags, 9475 GDB_INDEX_SYMBOL_KIND_VARIABLE); 9476 if (!is_cxx () && !is_java ()) 9477 GDB_INDEX_SYMBOL_STATIC_SET_VALUE(flags, 1); 9478 break; 9479 case DW_TAG_subprogram: 9480 GDB_INDEX_SYMBOL_KIND_SET_VALUE(flags, 9481 GDB_INDEX_SYMBOL_KIND_FUNCTION); 9482 if (!is_ada ()) 9483 GDB_INDEX_SYMBOL_STATIC_SET_VALUE(flags, is_static); 9484 break; 9485 case DW_TAG_constant: 9486 GDB_INDEX_SYMBOL_KIND_SET_VALUE(flags, 9487 GDB_INDEX_SYMBOL_KIND_VARIABLE); 9488 GDB_INDEX_SYMBOL_STATIC_SET_VALUE(flags, is_static); 9489 break; 9490 case DW_TAG_variable: 9491 GDB_INDEX_SYMBOL_KIND_SET_VALUE(flags, 9492 GDB_INDEX_SYMBOL_KIND_VARIABLE); 9493 GDB_INDEX_SYMBOL_STATIC_SET_VALUE(flags, is_static); 9494 break; 9495 case DW_TAG_namespace: 9496 case DW_TAG_imported_declaration: 9497 GDB_INDEX_SYMBOL_KIND_SET_VALUE(flags, GDB_INDEX_SYMBOL_KIND_TYPE); 9498 break; 9499 case DW_TAG_class_type: 9500 case DW_TAG_interface_type: 9501 case DW_TAG_structure_type: 9502 case DW_TAG_union_type: 9503 case DW_TAG_enumeration_type: 9504 GDB_INDEX_SYMBOL_KIND_SET_VALUE(flags, GDB_INDEX_SYMBOL_KIND_TYPE); 9505 if (!is_cxx () && !is_java ()) 9506 GDB_INDEX_SYMBOL_STATIC_SET_VALUE(flags, 1); 9507 break; 9508 default: 9509 /* An unusual tag. Leave the flag-byte empty. */ 9510 break; 9511 } 9512 dw2_asm_output_data (1, flags >> GDB_INDEX_CU_BITSIZE, 9513 "GDB-index flags"); 9514 } 9515 9516 dw2_asm_output_nstring (entry->name, -1, "external name"); 9517} 9518 9519 9520/* Output the public names table used to speed up access to externally 9521 visible names; or the public types table used to find type definitions. */ 9522 9523static void 9524output_pubnames (vec<pubname_entry, va_gc> *names) 9525{ 9526 unsigned i; 9527 unsigned long pubnames_length = size_of_pubnames (names); 9528 pubname_ref pub; 9529 9530 if (DWARF_INITIAL_LENGTH_SIZE - DWARF_OFFSET_SIZE == 4) 9531 dw2_asm_output_data (4, 0xffffffff, 9532 "Initial length escape value indicating 64-bit DWARF extension"); 9533 dw2_asm_output_data (DWARF_OFFSET_SIZE, pubnames_length, "Pub Info Length"); 9534 9535 /* Version number for pubnames/pubtypes is independent of dwarf version. */ 9536 dw2_asm_output_data (2, 2, "DWARF Version"); 9537 9538 if (dwarf_split_debug_info) 9539 dw2_asm_output_offset (DWARF_OFFSET_SIZE, debug_skeleton_info_section_label, 9540 debug_skeleton_info_section, 9541 "Offset of Compilation Unit Info"); 9542 else 9543 dw2_asm_output_offset (DWARF_OFFSET_SIZE, debug_info_section_label, 9544 debug_info_section, 9545 "Offset of Compilation Unit Info"); 9546 dw2_asm_output_data (DWARF_OFFSET_SIZE, next_die_offset, 9547 "Compilation Unit Length"); 9548 9549 FOR_EACH_VEC_ELT (*names, i, pub) 9550 { 9551 if (include_pubname_in_output (names, pub)) 9552 { 9553 dw_offset die_offset = pub->die->die_offset; 9554 9555 /* We shouldn't see pubnames for DIEs outside of the main CU. */ 9556 if (names == pubname_table && pub->die->die_tag != DW_TAG_enumerator) 9557 gcc_assert (pub->die->die_mark); 9558 9559 /* If we're putting types in their own .debug_types sections, 9560 the .debug_pubtypes table will still point to the compile 9561 unit (not the type unit), so we want to use the offset of 9562 the skeleton DIE (if there is one). */ 9563 if (pub->die->comdat_type_p && names == pubtype_table) 9564 { 9565 comdat_type_node_ref type_node = pub->die->die_id.die_type_node; 9566 9567 if (type_node != NULL) 9568 die_offset = (type_node->skeleton_die != NULL 9569 ? type_node->skeleton_die->die_offset 9570 : comp_unit_die ()->die_offset); 9571 } 9572 9573 output_pubname (die_offset, pub); 9574 } 9575 } 9576 9577 dw2_asm_output_data (DWARF_OFFSET_SIZE, 0, NULL); 9578} 9579 9580/* Output public names and types tables if necessary. */ 9581 9582static void 9583output_pubtables (void) 9584{ 9585 if (!want_pubnames () || !info_section_emitted) 9586 return; 9587 9588 switch_to_section (debug_pubnames_section); 9589 output_pubnames (pubname_table); 9590 /* ??? Only defined by DWARF3, but emitted by Darwin for DWARF2. 9591 It shouldn't hurt to emit it always, since pure DWARF2 consumers 9592 simply won't look for the section. */ 9593 switch_to_section (debug_pubtypes_section); 9594 output_pubnames (pubtype_table); 9595} 9596 9597 9598/* Output the information that goes into the .debug_aranges table. 9599 Namely, define the beginning and ending address range of the 9600 text section generated for this compilation unit. */ 9601 9602static void 9603output_aranges (unsigned long aranges_length) 9604{ 9605 unsigned i; 9606 9607 if (DWARF_INITIAL_LENGTH_SIZE - DWARF_OFFSET_SIZE == 4) 9608 dw2_asm_output_data (4, 0xffffffff, 9609 "Initial length escape value indicating 64-bit DWARF extension"); 9610 dw2_asm_output_data (DWARF_OFFSET_SIZE, aranges_length, 9611 "Length of Address Ranges Info"); 9612 /* Version number for aranges is still 2, even up to DWARF5. */ 9613 dw2_asm_output_data (2, 2, "DWARF Version"); 9614 if (dwarf_split_debug_info) 9615 dw2_asm_output_offset (DWARF_OFFSET_SIZE, debug_skeleton_info_section_label, 9616 debug_skeleton_info_section, 9617 "Offset of Compilation Unit Info"); 9618 else 9619 dw2_asm_output_offset (DWARF_OFFSET_SIZE, debug_info_section_label, 9620 debug_info_section, 9621 "Offset of Compilation Unit Info"); 9622 dw2_asm_output_data (1, DWARF2_ADDR_SIZE, "Size of Address"); 9623 dw2_asm_output_data (1, 0, "Size of Segment Descriptor"); 9624 9625 /* We need to align to twice the pointer size here. */ 9626 if (DWARF_ARANGES_PAD_SIZE) 9627 { 9628 /* Pad using a 2 byte words so that padding is correct for any 9629 pointer size. */ 9630 dw2_asm_output_data (2, 0, "Pad to %d byte boundary", 9631 2 * DWARF2_ADDR_SIZE); 9632 for (i = 2; i < (unsigned) DWARF_ARANGES_PAD_SIZE; i += 2) 9633 dw2_asm_output_data (2, 0, NULL); 9634 } 9635 9636 /* It is necessary not to output these entries if the sections were 9637 not used; if the sections were not used, the length will be 0 and 9638 the address may end up as 0 if the section is discarded by ld 9639 --gc-sections, leaving an invalid (0, 0) entry that can be 9640 confused with the terminator. */ 9641 if (text_section_used) 9642 { 9643 dw2_asm_output_addr (DWARF2_ADDR_SIZE, text_section_label, "Address"); 9644 dw2_asm_output_delta (DWARF2_ADDR_SIZE, text_end_label, 9645 text_section_label, "Length"); 9646 } 9647 if (cold_text_section_used) 9648 { 9649 dw2_asm_output_addr (DWARF2_ADDR_SIZE, cold_text_section_label, 9650 "Address"); 9651 dw2_asm_output_delta (DWARF2_ADDR_SIZE, cold_end_label, 9652 cold_text_section_label, "Length"); 9653 } 9654 9655 if (have_multiple_function_sections) 9656 { 9657 unsigned fde_idx; 9658 dw_fde_ref fde; 9659 9660 FOR_EACH_VEC_ELT (*fde_vec, fde_idx, fde) 9661 { 9662 if (DECL_IGNORED_P (fde->decl)) 9663 continue; 9664 if (!fde->in_std_section) 9665 { 9666 dw2_asm_output_addr (DWARF2_ADDR_SIZE, fde->dw_fde_begin, 9667 "Address"); 9668 dw2_asm_output_delta (DWARF2_ADDR_SIZE, fde->dw_fde_end, 9669 fde->dw_fde_begin, "Length"); 9670 } 9671 if (fde->dw_fde_second_begin && !fde->second_in_std_section) 9672 { 9673 dw2_asm_output_addr (DWARF2_ADDR_SIZE, fde->dw_fde_second_begin, 9674 "Address"); 9675 dw2_asm_output_delta (DWARF2_ADDR_SIZE, fde->dw_fde_second_end, 9676 fde->dw_fde_second_begin, "Length"); 9677 } 9678 } 9679 } 9680 9681 /* Output the terminator words. */ 9682 dw2_asm_output_data (DWARF2_ADDR_SIZE, 0, NULL); 9683 dw2_asm_output_data (DWARF2_ADDR_SIZE, 0, NULL); 9684} 9685 9686/* Add a new entry to .debug_ranges. Return the offset at which it 9687 was placed. */ 9688 9689static unsigned int 9690add_ranges_num (int num) 9691{ 9692 unsigned int in_use = ranges_table_in_use; 9693 9694 if (in_use == ranges_table_allocated) 9695 { 9696 ranges_table_allocated += RANGES_TABLE_INCREMENT; 9697 ranges_table = GGC_RESIZEVEC (struct dw_ranges_struct, ranges_table, 9698 ranges_table_allocated); 9699 memset (ranges_table + ranges_table_in_use, 0, 9700 RANGES_TABLE_INCREMENT * sizeof (struct dw_ranges_struct)); 9701 } 9702 9703 ranges_table[in_use].num = num; 9704 ranges_table_in_use = in_use + 1; 9705 9706 return in_use * 2 * DWARF2_ADDR_SIZE; 9707} 9708 9709/* Add a new entry to .debug_ranges corresponding to a block, or a 9710 range terminator if BLOCK is NULL. */ 9711 9712static unsigned int 9713add_ranges (const_tree block) 9714{ 9715 return add_ranges_num (block ? BLOCK_NUMBER (block) : 0); 9716} 9717 9718/* Add a new entry to .debug_ranges corresponding to a pair of labels. 9719 When using dwarf_split_debug_info, address attributes in dies destined 9720 for the final executable should be direct references--setting the 9721 parameter force_direct ensures this behavior. */ 9722 9723static void 9724add_ranges_by_labels (dw_die_ref die, const char *begin, const char *end, 9725 bool *added, bool force_direct) 9726{ 9727 unsigned int in_use = ranges_by_label_in_use; 9728 unsigned int offset; 9729 9730 if (in_use == ranges_by_label_allocated) 9731 { 9732 ranges_by_label_allocated += RANGES_TABLE_INCREMENT; 9733 ranges_by_label = GGC_RESIZEVEC (struct dw_ranges_by_label_struct, 9734 ranges_by_label, 9735 ranges_by_label_allocated); 9736 memset (ranges_by_label + ranges_by_label_in_use, 0, 9737 RANGES_TABLE_INCREMENT 9738 * sizeof (struct dw_ranges_by_label_struct)); 9739 } 9740 9741 ranges_by_label[in_use].begin = begin; 9742 ranges_by_label[in_use].end = end; 9743 ranges_by_label_in_use = in_use + 1; 9744 9745 offset = add_ranges_num (-(int)in_use - 1); 9746 if (!*added) 9747 { 9748 add_AT_range_list (die, DW_AT_ranges, offset, force_direct); 9749 *added = true; 9750 } 9751} 9752 9753static void 9754output_ranges (void) 9755{ 9756 unsigned i; 9757 static const char *const start_fmt = "Offset %#x"; 9758 const char *fmt = start_fmt; 9759 9760 for (i = 0; i < ranges_table_in_use; i++) 9761 { 9762 int block_num = ranges_table[i].num; 9763 9764 if (block_num > 0) 9765 { 9766 char blabel[MAX_ARTIFICIAL_LABEL_BYTES]; 9767 char elabel[MAX_ARTIFICIAL_LABEL_BYTES]; 9768 9769 ASM_GENERATE_INTERNAL_LABEL (blabel, BLOCK_BEGIN_LABEL, block_num); 9770 ASM_GENERATE_INTERNAL_LABEL (elabel, BLOCK_END_LABEL, block_num); 9771 9772 /* If all code is in the text section, then the compilation 9773 unit base address defaults to DW_AT_low_pc, which is the 9774 base of the text section. */ 9775 if (!have_multiple_function_sections) 9776 { 9777 dw2_asm_output_delta (DWARF2_ADDR_SIZE, blabel, 9778 text_section_label, 9779 fmt, i * 2 * DWARF2_ADDR_SIZE); 9780 dw2_asm_output_delta (DWARF2_ADDR_SIZE, elabel, 9781 text_section_label, NULL); 9782 } 9783 9784 /* Otherwise, the compilation unit base address is zero, 9785 which allows us to use absolute addresses, and not worry 9786 about whether the target supports cross-section 9787 arithmetic. */ 9788 else 9789 { 9790 dw2_asm_output_addr (DWARF2_ADDR_SIZE, blabel, 9791 fmt, i * 2 * DWARF2_ADDR_SIZE); 9792 dw2_asm_output_addr (DWARF2_ADDR_SIZE, elabel, NULL); 9793 } 9794 9795 fmt = NULL; 9796 } 9797 9798 /* Negative block_num stands for an index into ranges_by_label. */ 9799 else if (block_num < 0) 9800 { 9801 int lab_idx = - block_num - 1; 9802 9803 if (!have_multiple_function_sections) 9804 { 9805 gcc_unreachable (); 9806#if 0 9807 /* If we ever use add_ranges_by_labels () for a single 9808 function section, all we have to do is to take out 9809 the #if 0 above. */ 9810 dw2_asm_output_delta (DWARF2_ADDR_SIZE, 9811 ranges_by_label[lab_idx].begin, 9812 text_section_label, 9813 fmt, i * 2 * DWARF2_ADDR_SIZE); 9814 dw2_asm_output_delta (DWARF2_ADDR_SIZE, 9815 ranges_by_label[lab_idx].end, 9816 text_section_label, NULL); 9817#endif 9818 } 9819 else 9820 { 9821 dw2_asm_output_addr (DWARF2_ADDR_SIZE, 9822 ranges_by_label[lab_idx].begin, 9823 fmt, i * 2 * DWARF2_ADDR_SIZE); 9824 dw2_asm_output_addr (DWARF2_ADDR_SIZE, 9825 ranges_by_label[lab_idx].end, 9826 NULL); 9827 } 9828 } 9829 else 9830 { 9831 dw2_asm_output_data (DWARF2_ADDR_SIZE, 0, NULL); 9832 dw2_asm_output_data (DWARF2_ADDR_SIZE, 0, NULL); 9833 fmt = start_fmt; 9834 } 9835 } 9836} 9837 9838/* Data structure containing information about input files. */ 9839struct file_info 9840{ 9841 const char *path; /* Complete file name. */ 9842 const char *fname; /* File name part. */ 9843 int length; /* Length of entire string. */ 9844 struct dwarf_file_data * file_idx; /* Index in input file table. */ 9845 int dir_idx; /* Index in directory table. */ 9846}; 9847 9848/* Data structure containing information about directories with source 9849 files. */ 9850struct dir_info 9851{ 9852 const char *path; /* Path including directory name. */ 9853 int length; /* Path length. */ 9854 int prefix; /* Index of directory entry which is a prefix. */ 9855 int count; /* Number of files in this directory. */ 9856 int dir_idx; /* Index of directory used as base. */ 9857}; 9858 9859/* Callback function for file_info comparison. We sort by looking at 9860 the directories in the path. */ 9861 9862static int 9863file_info_cmp (const void *p1, const void *p2) 9864{ 9865 const struct file_info *const s1 = (const struct file_info *) p1; 9866 const struct file_info *const s2 = (const struct file_info *) p2; 9867 const unsigned char *cp1; 9868 const unsigned char *cp2; 9869 9870 /* Take care of file names without directories. We need to make sure that 9871 we return consistent values to qsort since some will get confused if 9872 we return the same value when identical operands are passed in opposite 9873 orders. So if neither has a directory, return 0 and otherwise return 9874 1 or -1 depending on which one has the directory. */ 9875 if ((s1->path == s1->fname || s2->path == s2->fname)) 9876 return (s2->path == s2->fname) - (s1->path == s1->fname); 9877 9878 cp1 = (const unsigned char *) s1->path; 9879 cp2 = (const unsigned char *) s2->path; 9880 9881 while (1) 9882 { 9883 ++cp1; 9884 ++cp2; 9885 /* Reached the end of the first path? If so, handle like above. */ 9886 if ((cp1 == (const unsigned char *) s1->fname) 9887 || (cp2 == (const unsigned char *) s2->fname)) 9888 return ((cp2 == (const unsigned char *) s2->fname) 9889 - (cp1 == (const unsigned char *) s1->fname)); 9890 9891 /* Character of current path component the same? */ 9892 else if (*cp1 != *cp2) 9893 return *cp1 - *cp2; 9894 } 9895} 9896 9897struct file_name_acquire_data 9898{ 9899 struct file_info *files; 9900 int used_files; 9901 int max_files; 9902}; 9903 9904/* Traversal function for the hash table. */ 9905 9906int 9907file_name_acquire (dwarf_file_data **slot, file_name_acquire_data *fnad) 9908{ 9909 struct dwarf_file_data *d = *slot; 9910 struct file_info *fi; 9911 const char *f; 9912 9913 gcc_assert (fnad->max_files >= d->emitted_number); 9914 9915 if (! d->emitted_number) 9916 return 1; 9917 9918 gcc_assert (fnad->max_files != fnad->used_files); 9919 9920 fi = fnad->files + fnad->used_files++; 9921 9922 /* Skip all leading "./". */ 9923 f = d->filename; 9924 while (f[0] == '.' && IS_DIR_SEPARATOR (f[1])) 9925 f += 2; 9926 9927 /* Create a new array entry. */ 9928 fi->path = f; 9929 fi->length = strlen (f); 9930 fi->file_idx = d; 9931 9932 /* Search for the file name part. */ 9933 f = strrchr (f, DIR_SEPARATOR); 9934#if defined (DIR_SEPARATOR_2) 9935 { 9936 char *g = strrchr (fi->path, DIR_SEPARATOR_2); 9937 9938 if (g != NULL) 9939 { 9940 if (f == NULL || f < g) 9941 f = g; 9942 } 9943 } 9944#endif 9945 9946 fi->fname = f == NULL ? fi->path : f + 1; 9947 return 1; 9948} 9949 9950/* Output the directory table and the file name table. We try to minimize 9951 the total amount of memory needed. A heuristic is used to avoid large 9952 slowdowns with many input files. */ 9953 9954static void 9955output_file_names (void) 9956{ 9957 struct file_name_acquire_data fnad; 9958 int numfiles; 9959 struct file_info *files; 9960 struct dir_info *dirs; 9961 int *saved; 9962 int *savehere; 9963 int *backmap; 9964 int ndirs; 9965 int idx_offset; 9966 int i; 9967 9968 if (!last_emitted_file) 9969 { 9970 dw2_asm_output_data (1, 0, "End directory table"); 9971 dw2_asm_output_data (1, 0, "End file name table"); 9972 return; 9973 } 9974 9975 numfiles = last_emitted_file->emitted_number; 9976 9977 /* Allocate the various arrays we need. */ 9978 files = XALLOCAVEC (struct file_info, numfiles); 9979 dirs = XALLOCAVEC (struct dir_info, numfiles); 9980 9981 fnad.files = files; 9982 fnad.used_files = 0; 9983 fnad.max_files = numfiles; 9984 file_table->traverse<file_name_acquire_data *, file_name_acquire> (&fnad); 9985 gcc_assert (fnad.used_files == fnad.max_files); 9986 9987 qsort (files, numfiles, sizeof (files[0]), file_info_cmp); 9988 9989 /* Find all the different directories used. */ 9990 dirs[0].path = files[0].path; 9991 dirs[0].length = files[0].fname - files[0].path; 9992 dirs[0].prefix = -1; 9993 dirs[0].count = 1; 9994 dirs[0].dir_idx = 0; 9995 files[0].dir_idx = 0; 9996 ndirs = 1; 9997 9998 for (i = 1; i < numfiles; i++) 9999 if (files[i].fname - files[i].path == dirs[ndirs - 1].length 10000 && memcmp (dirs[ndirs - 1].path, files[i].path, 10001 dirs[ndirs - 1].length) == 0) 10002 { 10003 /* Same directory as last entry. */ 10004 files[i].dir_idx = ndirs - 1; 10005 ++dirs[ndirs - 1].count; 10006 } 10007 else 10008 { 10009 int j; 10010 10011 /* This is a new directory. */ 10012 dirs[ndirs].path = files[i].path; 10013 dirs[ndirs].length = files[i].fname - files[i].path; 10014 dirs[ndirs].count = 1; 10015 dirs[ndirs].dir_idx = ndirs; 10016 files[i].dir_idx = ndirs; 10017 10018 /* Search for a prefix. */ 10019 dirs[ndirs].prefix = -1; 10020 for (j = 0; j < ndirs; j++) 10021 if (dirs[j].length < dirs[ndirs].length 10022 && dirs[j].length > 1 10023 && (dirs[ndirs].prefix == -1 10024 || dirs[j].length > dirs[dirs[ndirs].prefix].length) 10025 && memcmp (dirs[j].path, dirs[ndirs].path, dirs[j].length) == 0) 10026 dirs[ndirs].prefix = j; 10027 10028 ++ndirs; 10029 } 10030 10031 /* Now to the actual work. We have to find a subset of the directories which 10032 allow expressing the file name using references to the directory table 10033 with the least amount of characters. We do not do an exhaustive search 10034 where we would have to check out every combination of every single 10035 possible prefix. Instead we use a heuristic which provides nearly optimal 10036 results in most cases and never is much off. */ 10037 saved = XALLOCAVEC (int, ndirs); 10038 savehere = XALLOCAVEC (int, ndirs); 10039 10040 memset (saved, '\0', ndirs * sizeof (saved[0])); 10041 for (i = 0; i < ndirs; i++) 10042 { 10043 int j; 10044 int total; 10045 10046 /* We can always save some space for the current directory. But this 10047 does not mean it will be enough to justify adding the directory. */ 10048 savehere[i] = dirs[i].length; 10049 total = (savehere[i] - saved[i]) * dirs[i].count; 10050 10051 for (j = i + 1; j < ndirs; j++) 10052 { 10053 savehere[j] = 0; 10054 if (saved[j] < dirs[i].length) 10055 { 10056 /* Determine whether the dirs[i] path is a prefix of the 10057 dirs[j] path. */ 10058 int k; 10059 10060 k = dirs[j].prefix; 10061 while (k != -1 && k != (int) i) 10062 k = dirs[k].prefix; 10063 10064 if (k == (int) i) 10065 { 10066 /* Yes it is. We can possibly save some memory by 10067 writing the filenames in dirs[j] relative to 10068 dirs[i]. */ 10069 savehere[j] = dirs[i].length; 10070 total += (savehere[j] - saved[j]) * dirs[j].count; 10071 } 10072 } 10073 } 10074 10075 /* Check whether we can save enough to justify adding the dirs[i] 10076 directory. */ 10077 if (total > dirs[i].length + 1) 10078 { 10079 /* It's worthwhile adding. */ 10080 for (j = i; j < ndirs; j++) 10081 if (savehere[j] > 0) 10082 { 10083 /* Remember how much we saved for this directory so far. */ 10084 saved[j] = savehere[j]; 10085 10086 /* Remember the prefix directory. */ 10087 dirs[j].dir_idx = i; 10088 } 10089 } 10090 } 10091 10092 /* Emit the directory name table. */ 10093 idx_offset = dirs[0].length > 0 ? 1 : 0; 10094 for (i = 1 - idx_offset; i < ndirs; i++) 10095 dw2_asm_output_nstring (dirs[i].path, 10096 dirs[i].length 10097 - !DWARF2_DIR_SHOULD_END_WITH_SEPARATOR, 10098 "Directory Entry: %#x", i + idx_offset); 10099 10100 dw2_asm_output_data (1, 0, "End directory table"); 10101 10102 /* We have to emit them in the order of emitted_number since that's 10103 used in the debug info generation. To do this efficiently we 10104 generate a back-mapping of the indices first. */ 10105 backmap = XALLOCAVEC (int, numfiles); 10106 for (i = 0; i < numfiles; i++) 10107 backmap[files[i].file_idx->emitted_number - 1] = i; 10108 10109 /* Now write all the file names. */ 10110 for (i = 0; i < numfiles; i++) 10111 { 10112 int file_idx = backmap[i]; 10113 int dir_idx = dirs[files[file_idx].dir_idx].dir_idx; 10114 10115#ifdef VMS_DEBUGGING_INFO 10116#define MAX_VMS_VERSION_LEN 6 /* ";32768" */ 10117 10118 /* Setting these fields can lead to debugger miscomparisons, 10119 but VMS Debug requires them to be set correctly. */ 10120 10121 int ver; 10122 long long cdt; 10123 long siz; 10124 int maxfilelen = strlen (files[file_idx].path) 10125 + dirs[dir_idx].length 10126 + MAX_VMS_VERSION_LEN + 1; 10127 char *filebuf = XALLOCAVEC (char, maxfilelen); 10128 10129 vms_file_stats_name (files[file_idx].path, 0, 0, 0, &ver); 10130 snprintf (filebuf, maxfilelen, "%s;%d", 10131 files[file_idx].path + dirs[dir_idx].length, ver); 10132 10133 dw2_asm_output_nstring 10134 (filebuf, -1, "File Entry: %#x", (unsigned) i + 1); 10135 10136 /* Include directory index. */ 10137 dw2_asm_output_data_uleb128 (dir_idx + idx_offset, NULL); 10138 10139 /* Modification time. */ 10140 dw2_asm_output_data_uleb128 10141 ((vms_file_stats_name (files[file_idx].path, &cdt, 0, 0, 0) == 0) 10142 ? cdt : 0, 10143 NULL); 10144 10145 /* File length in bytes. */ 10146 dw2_asm_output_data_uleb128 10147 ((vms_file_stats_name (files[file_idx].path, 0, &siz, 0, 0) == 0) 10148 ? siz : 0, 10149 NULL); 10150#else 10151 dw2_asm_output_nstring (files[file_idx].path + dirs[dir_idx].length, -1, 10152 "File Entry: %#x", (unsigned) i + 1); 10153 10154 /* Include directory index. */ 10155 dw2_asm_output_data_uleb128 (dir_idx + idx_offset, NULL); 10156 10157 /* Modification time. */ 10158 dw2_asm_output_data_uleb128 (0, NULL); 10159 10160 /* File length in bytes. */ 10161 dw2_asm_output_data_uleb128 (0, NULL); 10162#endif /* VMS_DEBUGGING_INFO */ 10163 } 10164 10165 dw2_asm_output_data (1, 0, "End file name table"); 10166} 10167 10168 10169/* Output one line number table into the .debug_line section. */ 10170 10171static void 10172output_one_line_info_table (dw_line_info_table *table) 10173{ 10174 char line_label[MAX_ARTIFICIAL_LABEL_BYTES]; 10175 unsigned int current_line = 1; 10176 bool current_is_stmt = DWARF_LINE_DEFAULT_IS_STMT_START; 10177 dw_line_info_entry *ent; 10178 size_t i; 10179 10180 FOR_EACH_VEC_SAFE_ELT (table->entries, i, ent) 10181 { 10182 switch (ent->opcode) 10183 { 10184 case LI_set_address: 10185 /* ??? Unfortunately, we have little choice here currently, and 10186 must always use the most general form. GCC does not know the 10187 address delta itself, so we can't use DW_LNS_advance_pc. Many 10188 ports do have length attributes which will give an upper bound 10189 on the address range. We could perhaps use length attributes 10190 to determine when it is safe to use DW_LNS_fixed_advance_pc. */ 10191 ASM_GENERATE_INTERNAL_LABEL (line_label, LINE_CODE_LABEL, ent->val); 10192 10193 /* This can handle any delta. This takes 10194 4+DWARF2_ADDR_SIZE bytes. */ 10195 dw2_asm_output_data (1, 0, "set address %s", line_label); 10196 dw2_asm_output_data_uleb128 (1 + DWARF2_ADDR_SIZE, NULL); 10197 dw2_asm_output_data (1, DW_LNE_set_address, NULL); 10198 dw2_asm_output_addr (DWARF2_ADDR_SIZE, line_label, NULL); 10199 break; 10200 10201 case LI_set_line: 10202 if (ent->val == current_line) 10203 { 10204 /* We still need to start a new row, so output a copy insn. */ 10205 dw2_asm_output_data (1, DW_LNS_copy, 10206 "copy line %u", current_line); 10207 } 10208 else 10209 { 10210 int line_offset = ent->val - current_line; 10211 int line_delta = line_offset - DWARF_LINE_BASE; 10212 10213 current_line = ent->val; 10214 if (line_delta >= 0 && line_delta < (DWARF_LINE_RANGE - 1)) 10215 { 10216 /* This can handle deltas from -10 to 234, using the current 10217 definitions of DWARF_LINE_BASE and DWARF_LINE_RANGE. 10218 This takes 1 byte. */ 10219 dw2_asm_output_data (1, DWARF_LINE_OPCODE_BASE + line_delta, 10220 "line %u", current_line); 10221 } 10222 else 10223 { 10224 /* This can handle any delta. This takes at least 4 bytes, 10225 depending on the value being encoded. */ 10226 dw2_asm_output_data (1, DW_LNS_advance_line, 10227 "advance to line %u", current_line); 10228 dw2_asm_output_data_sleb128 (line_offset, NULL); 10229 dw2_asm_output_data (1, DW_LNS_copy, NULL); 10230 } 10231 } 10232 break; 10233 10234 case LI_set_file: 10235 dw2_asm_output_data (1, DW_LNS_set_file, "set file %u", ent->val); 10236 dw2_asm_output_data_uleb128 (ent->val, "%u", ent->val); 10237 break; 10238 10239 case LI_set_column: 10240 dw2_asm_output_data (1, DW_LNS_set_column, "column %u", ent->val); 10241 dw2_asm_output_data_uleb128 (ent->val, "%u", ent->val); 10242 break; 10243 10244 case LI_negate_stmt: 10245 current_is_stmt = !current_is_stmt; 10246 dw2_asm_output_data (1, DW_LNS_negate_stmt, 10247 "is_stmt %d", current_is_stmt); 10248 break; 10249 10250 case LI_set_prologue_end: 10251 dw2_asm_output_data (1, DW_LNS_set_prologue_end, 10252 "set prologue end"); 10253 break; 10254 10255 case LI_set_epilogue_begin: 10256 dw2_asm_output_data (1, DW_LNS_set_epilogue_begin, 10257 "set epilogue begin"); 10258 break; 10259 10260 case LI_set_discriminator: 10261 dw2_asm_output_data (1, 0, "discriminator %u", ent->val); 10262 dw2_asm_output_data_uleb128 (1 + size_of_uleb128 (ent->val), NULL); 10263 dw2_asm_output_data (1, DW_LNE_set_discriminator, NULL); 10264 dw2_asm_output_data_uleb128 (ent->val, NULL); 10265 break; 10266 } 10267 } 10268 10269 /* Emit debug info for the address of the end of the table. */ 10270 dw2_asm_output_data (1, 0, "set address %s", table->end_label); 10271 dw2_asm_output_data_uleb128 (1 + DWARF2_ADDR_SIZE, NULL); 10272 dw2_asm_output_data (1, DW_LNE_set_address, NULL); 10273 dw2_asm_output_addr (DWARF2_ADDR_SIZE, table->end_label, NULL); 10274 10275 dw2_asm_output_data (1, 0, "end sequence"); 10276 dw2_asm_output_data_uleb128 (1, NULL); 10277 dw2_asm_output_data (1, DW_LNE_end_sequence, NULL); 10278} 10279 10280/* Output the source line number correspondence information. This 10281 information goes into the .debug_line section. */ 10282 10283static void 10284output_line_info (bool prologue_only) 10285{ 10286 char l1[20], l2[20], p1[20], p2[20]; 10287 /* We don't support DWARFv5 line tables yet. */ 10288 int ver = dwarf_version < 5 ? dwarf_version : 4; 10289 bool saw_one = false; 10290 int opc; 10291 10292 ASM_GENERATE_INTERNAL_LABEL (l1, LINE_NUMBER_BEGIN_LABEL, 0); 10293 ASM_GENERATE_INTERNAL_LABEL (l2, LINE_NUMBER_END_LABEL, 0); 10294 ASM_GENERATE_INTERNAL_LABEL (p1, LN_PROLOG_AS_LABEL, 0); 10295 ASM_GENERATE_INTERNAL_LABEL (p2, LN_PROLOG_END_LABEL, 0); 10296 10297 if (DWARF_INITIAL_LENGTH_SIZE - DWARF_OFFSET_SIZE == 4) 10298 dw2_asm_output_data (4, 0xffffffff, 10299 "Initial length escape value indicating 64-bit DWARF extension"); 10300 dw2_asm_output_delta (DWARF_OFFSET_SIZE, l2, l1, 10301 "Length of Source Line Info"); 10302 ASM_OUTPUT_LABEL (asm_out_file, l1); 10303 10304 dw2_asm_output_data (2, ver, "DWARF Version"); 10305 dw2_asm_output_delta (DWARF_OFFSET_SIZE, p2, p1, "Prolog Length"); 10306 ASM_OUTPUT_LABEL (asm_out_file, p1); 10307 10308 /* Define the architecture-dependent minimum instruction length (in bytes). 10309 In this implementation of DWARF, this field is used for information 10310 purposes only. Since GCC generates assembly language, we have no 10311 a priori knowledge of how many instruction bytes are generated for each 10312 source line, and therefore can use only the DW_LNE_set_address and 10313 DW_LNS_fixed_advance_pc line information commands. Accordingly, we fix 10314 this as '1', which is "correct enough" for all architectures, 10315 and don't let the target override. */ 10316 dw2_asm_output_data (1, 1, "Minimum Instruction Length"); 10317 10318 if (ver >= 4) 10319 dw2_asm_output_data (1, DWARF_LINE_DEFAULT_MAX_OPS_PER_INSN, 10320 "Maximum Operations Per Instruction"); 10321 dw2_asm_output_data (1, DWARF_LINE_DEFAULT_IS_STMT_START, 10322 "Default is_stmt_start flag"); 10323 dw2_asm_output_data (1, DWARF_LINE_BASE, 10324 "Line Base Value (Special Opcodes)"); 10325 dw2_asm_output_data (1, DWARF_LINE_RANGE, 10326 "Line Range Value (Special Opcodes)"); 10327 dw2_asm_output_data (1, DWARF_LINE_OPCODE_BASE, 10328 "Special Opcode Base"); 10329 10330 for (opc = 1; opc < DWARF_LINE_OPCODE_BASE; opc++) 10331 { 10332 int n_op_args; 10333 switch (opc) 10334 { 10335 case DW_LNS_advance_pc: 10336 case DW_LNS_advance_line: 10337 case DW_LNS_set_file: 10338 case DW_LNS_set_column: 10339 case DW_LNS_fixed_advance_pc: 10340 case DW_LNS_set_isa: 10341 n_op_args = 1; 10342 break; 10343 default: 10344 n_op_args = 0; 10345 break; 10346 } 10347 10348 dw2_asm_output_data (1, n_op_args, "opcode: %#x has %d args", 10349 opc, n_op_args); 10350 } 10351 10352 /* Write out the information about the files we use. */ 10353 output_file_names (); 10354 ASM_OUTPUT_LABEL (asm_out_file, p2); 10355 if (prologue_only) 10356 { 10357 /* Output the marker for the end of the line number info. */ 10358 ASM_OUTPUT_LABEL (asm_out_file, l2); 10359 return; 10360 } 10361 10362 if (separate_line_info) 10363 { 10364 dw_line_info_table *table; 10365 size_t i; 10366 10367 FOR_EACH_VEC_ELT (*separate_line_info, i, table) 10368 if (table->in_use) 10369 { 10370 output_one_line_info_table (table); 10371 saw_one = true; 10372 } 10373 } 10374 if (cold_text_section_line_info && cold_text_section_line_info->in_use) 10375 { 10376 output_one_line_info_table (cold_text_section_line_info); 10377 saw_one = true; 10378 } 10379 10380 /* ??? Some Darwin linkers crash on a .debug_line section with no 10381 sequences. Further, merely a DW_LNE_end_sequence entry is not 10382 sufficient -- the address column must also be initialized. 10383 Make sure to output at least one set_address/end_sequence pair, 10384 choosing .text since that section is always present. */ 10385 if (text_section_line_info->in_use || !saw_one) 10386 output_one_line_info_table (text_section_line_info); 10387 10388 /* Output the marker for the end of the line number info. */ 10389 ASM_OUTPUT_LABEL (asm_out_file, l2); 10390} 10391 10392/* Given a pointer to a tree node for some base type, return a pointer to 10393 a DIE that describes the given type. 10394 10395 This routine must only be called for GCC type nodes that correspond to 10396 Dwarf base (fundamental) types. */ 10397 10398static dw_die_ref 10399base_type_die (tree type) 10400{ 10401 dw_die_ref base_type_result; 10402 enum dwarf_type encoding; 10403 10404 if (TREE_CODE (type) == ERROR_MARK || TREE_CODE (type) == VOID_TYPE) 10405 return 0; 10406 10407 /* If this is a subtype that should not be emitted as a subrange type, 10408 use the base type. See subrange_type_for_debug_p. */ 10409 if (TREE_CODE (type) == INTEGER_TYPE && TREE_TYPE (type) != NULL_TREE) 10410 type = TREE_TYPE (type); 10411 10412 switch (TREE_CODE (type)) 10413 { 10414 case INTEGER_TYPE: 10415 if ((dwarf_version >= 4 || !dwarf_strict) 10416 && TYPE_NAME (type) 10417 && TREE_CODE (TYPE_NAME (type)) == TYPE_DECL 10418 && DECL_IS_BUILTIN (TYPE_NAME (type)) 10419 && DECL_NAME (TYPE_NAME (type))) 10420 { 10421 const char *name = IDENTIFIER_POINTER (DECL_NAME (TYPE_NAME (type))); 10422 if (strcmp (name, "char16_t") == 0 10423 || strcmp (name, "char32_t") == 0) 10424 { 10425 encoding = DW_ATE_UTF; 10426 break; 10427 } 10428 } 10429 if (TYPE_STRING_FLAG (type)) 10430 { 10431 if (TYPE_UNSIGNED (type)) 10432 encoding = DW_ATE_unsigned_char; 10433 else 10434 encoding = DW_ATE_signed_char; 10435 } 10436 else if (TYPE_UNSIGNED (type)) 10437 encoding = DW_ATE_unsigned; 10438 else 10439 encoding = DW_ATE_signed; 10440 break; 10441 10442 case REAL_TYPE: 10443 if (DECIMAL_FLOAT_MODE_P (TYPE_MODE (type))) 10444 { 10445 if (dwarf_version >= 3 || !dwarf_strict) 10446 encoding = DW_ATE_decimal_float; 10447 else 10448 encoding = DW_ATE_lo_user; 10449 } 10450 else 10451 encoding = DW_ATE_float; 10452 break; 10453 10454 case FIXED_POINT_TYPE: 10455 if (!(dwarf_version >= 3 || !dwarf_strict)) 10456 encoding = DW_ATE_lo_user; 10457 else if (TYPE_UNSIGNED (type)) 10458 encoding = DW_ATE_unsigned_fixed; 10459 else 10460 encoding = DW_ATE_signed_fixed; 10461 break; 10462 10463 /* Dwarf2 doesn't know anything about complex ints, so use 10464 a user defined type for it. */ 10465 case COMPLEX_TYPE: 10466 if (TREE_CODE (TREE_TYPE (type)) == REAL_TYPE) 10467 encoding = DW_ATE_complex_float; 10468 else 10469 encoding = DW_ATE_lo_user; 10470 break; 10471 10472 case BOOLEAN_TYPE: 10473 /* GNU FORTRAN/Ada/C++ BOOLEAN type. */ 10474 encoding = DW_ATE_boolean; 10475 break; 10476 10477 default: 10478 /* No other TREE_CODEs are Dwarf fundamental types. */ 10479 gcc_unreachable (); 10480 } 10481 10482 base_type_result = new_die (DW_TAG_base_type, comp_unit_die (), type); 10483 10484 add_AT_unsigned (base_type_result, DW_AT_byte_size, 10485 int_size_in_bytes (type)); 10486 add_AT_unsigned (base_type_result, DW_AT_encoding, encoding); 10487 add_pubtype (type, base_type_result); 10488 10489 return base_type_result; 10490} 10491 10492/* A C++ function with deduced return type can have a TEMPLATE_TYPE_PARM 10493 named 'auto' in its type: return true for it, false otherwise. */ 10494 10495static inline bool 10496is_cxx_auto (tree type) 10497{ 10498 if (is_cxx ()) 10499 { 10500 tree name = TYPE_IDENTIFIER (type); 10501 if (name == get_identifier ("auto") 10502 || name == get_identifier ("decltype(auto)")) 10503 return true; 10504 } 10505 return false; 10506} 10507 10508/* Given a pointer to an arbitrary ..._TYPE tree node, return nonzero if the 10509 given input type is a Dwarf "fundamental" type. Otherwise return null. */ 10510 10511static inline int 10512is_base_type (tree type) 10513{ 10514 switch (TREE_CODE (type)) 10515 { 10516 case ERROR_MARK: 10517 case VOID_TYPE: 10518 case INTEGER_TYPE: 10519 case REAL_TYPE: 10520 case FIXED_POINT_TYPE: 10521 case COMPLEX_TYPE: 10522 case BOOLEAN_TYPE: 10523 case POINTER_BOUNDS_TYPE: 10524 return 1; 10525 10526 case ARRAY_TYPE: 10527 case RECORD_TYPE: 10528 case UNION_TYPE: 10529 case QUAL_UNION_TYPE: 10530 case ENUMERAL_TYPE: 10531 case FUNCTION_TYPE: 10532 case METHOD_TYPE: 10533 case POINTER_TYPE: 10534 case REFERENCE_TYPE: 10535 case NULLPTR_TYPE: 10536 case OFFSET_TYPE: 10537 case LANG_TYPE: 10538 case VECTOR_TYPE: 10539 return 0; 10540 10541 default: 10542 if (is_cxx_auto (type)) 10543 return 0; 10544 gcc_unreachable (); 10545 } 10546 10547 return 0; 10548} 10549 10550/* Given a pointer to a tree node, assumed to be some kind of a ..._TYPE 10551 node, return the size in bits for the type if it is a constant, or else 10552 return the alignment for the type if the type's size is not constant, or 10553 else return BITS_PER_WORD if the type actually turns out to be an 10554 ERROR_MARK node. */ 10555 10556static inline unsigned HOST_WIDE_INT 10557simple_type_size_in_bits (const_tree type) 10558{ 10559 if (TREE_CODE (type) == ERROR_MARK) 10560 return BITS_PER_WORD; 10561 else if (TYPE_SIZE (type) == NULL_TREE) 10562 return 0; 10563 else if (tree_fits_uhwi_p (TYPE_SIZE (type))) 10564 return tree_to_uhwi (TYPE_SIZE (type)); 10565 else 10566 return TYPE_ALIGN (type); 10567} 10568 10569/* Similarly, but return an offset_int instead of UHWI. */ 10570 10571static inline offset_int 10572offset_int_type_size_in_bits (const_tree type) 10573{ 10574 if (TREE_CODE (type) == ERROR_MARK) 10575 return BITS_PER_WORD; 10576 else if (TYPE_SIZE (type) == NULL_TREE) 10577 return 0; 10578 else if (TREE_CODE (TYPE_SIZE (type)) == INTEGER_CST) 10579 return wi::to_offset (TYPE_SIZE (type)); 10580 else 10581 return TYPE_ALIGN (type); 10582} 10583 10584/* Given a pointer to a tree node for a subrange type, return a pointer 10585 to a DIE that describes the given type. */ 10586 10587static dw_die_ref 10588subrange_type_die (tree type, tree low, tree high, dw_die_ref context_die) 10589{ 10590 dw_die_ref subrange_die; 10591 const HOST_WIDE_INT size_in_bytes = int_size_in_bytes (type); 10592 10593 if (context_die == NULL) 10594 context_die = comp_unit_die (); 10595 10596 subrange_die = new_die (DW_TAG_subrange_type, context_die, type); 10597 10598 if (int_size_in_bytes (TREE_TYPE (type)) != size_in_bytes) 10599 { 10600 /* The size of the subrange type and its base type do not match, 10601 so we need to generate a size attribute for the subrange type. */ 10602 add_AT_unsigned (subrange_die, DW_AT_byte_size, size_in_bytes); 10603 } 10604 10605 if (low) 10606 add_bound_info (subrange_die, DW_AT_lower_bound, low, NULL); 10607 if (high) 10608 add_bound_info (subrange_die, DW_AT_upper_bound, high, NULL); 10609 10610 return subrange_die; 10611} 10612 10613/* Returns the (const and/or volatile) cv_qualifiers associated with 10614 the decl node. This will normally be augmented with the 10615 cv_qualifiers of the underlying type in add_type_attribute. */ 10616 10617static int 10618decl_quals (const_tree decl) 10619{ 10620 return ((TREE_READONLY (decl) 10621 ? TYPE_QUAL_CONST : TYPE_UNQUALIFIED) 10622 | (TREE_THIS_VOLATILE (decl) 10623 ? TYPE_QUAL_VOLATILE : TYPE_UNQUALIFIED)); 10624} 10625 10626/* Determine the TYPE whose qualifiers match the largest strict subset 10627 of the given TYPE_QUALS, and return its qualifiers. Ignore all 10628 qualifiers outside QUAL_MASK. */ 10629 10630static int 10631get_nearest_type_subqualifiers (tree type, int type_quals, int qual_mask) 10632{ 10633 tree t; 10634 int best_rank = 0, best_qual = 0, max_rank; 10635 10636 type_quals &= qual_mask; 10637 max_rank = popcount_hwi (type_quals) - 1; 10638 10639 for (t = TYPE_MAIN_VARIANT (type); t && best_rank < max_rank; 10640 t = TYPE_NEXT_VARIANT (t)) 10641 { 10642 int q = TYPE_QUALS (t) & qual_mask; 10643 10644 if ((q & type_quals) == q && q != type_quals 10645 && check_base_type (t, type)) 10646 { 10647 int rank = popcount_hwi (q); 10648 10649 if (rank > best_rank) 10650 { 10651 best_rank = rank; 10652 best_qual = q; 10653 } 10654 } 10655 } 10656 10657 return best_qual; 10658} 10659 10660/* Given a pointer to an arbitrary ..._TYPE tree node, return a debugging 10661 entry that chains various modifiers in front of the given type. */ 10662 10663static dw_die_ref 10664modified_type_die (tree type, int cv_quals, dw_die_ref context_die) 10665{ 10666 enum tree_code code = TREE_CODE (type); 10667 dw_die_ref mod_type_die; 10668 dw_die_ref sub_die = NULL; 10669 tree item_type = NULL; 10670 tree qualified_type; 10671 tree name, low, high; 10672 dw_die_ref mod_scope; 10673 /* Only these cv-qualifiers are currently handled. */ 10674 const int cv_qual_mask = (TYPE_QUAL_CONST | TYPE_QUAL_VOLATILE 10675 | TYPE_QUAL_RESTRICT | TYPE_QUAL_ATOMIC); 10676 10677 if (code == ERROR_MARK) 10678 return NULL; 10679 10680 cv_quals &= cv_qual_mask; 10681 10682 /* Don't emit DW_TAG_restrict_type for DWARFv2, since it is a type 10683 tag modifier (and not an attribute) old consumers won't be able 10684 to handle it. */ 10685 if (dwarf_version < 3) 10686 cv_quals &= ~TYPE_QUAL_RESTRICT; 10687 10688 /* Likewise for DW_TAG_atomic_type for DWARFv5. */ 10689 if (dwarf_version < 5) 10690 cv_quals &= ~TYPE_QUAL_ATOMIC; 10691 10692 /* See if we already have the appropriately qualified variant of 10693 this type. */ 10694 qualified_type = get_qualified_type (type, cv_quals); 10695 10696 if (qualified_type == sizetype 10697 && TYPE_NAME (qualified_type) 10698 && TREE_CODE (TYPE_NAME (qualified_type)) == TYPE_DECL) 10699 { 10700 tree t = TREE_TYPE (TYPE_NAME (qualified_type)); 10701 10702 gcc_checking_assert (TREE_CODE (t) == INTEGER_TYPE 10703 && TYPE_PRECISION (t) 10704 == TYPE_PRECISION (qualified_type) 10705 && TYPE_UNSIGNED (t) 10706 == TYPE_UNSIGNED (qualified_type)); 10707 qualified_type = t; 10708 } 10709 10710 /* If we do, then we can just use its DIE, if it exists. */ 10711 if (qualified_type) 10712 { 10713 mod_type_die = lookup_type_die (qualified_type); 10714 if (mod_type_die) 10715 return mod_type_die; 10716 } 10717 10718 name = qualified_type ? TYPE_NAME (qualified_type) : NULL; 10719 10720 /* Handle C typedef types. */ 10721 if (name && TREE_CODE (name) == TYPE_DECL && DECL_ORIGINAL_TYPE (name) 10722 && !DECL_ARTIFICIAL (name)) 10723 { 10724 tree dtype = TREE_TYPE (name); 10725 10726 if (qualified_type == dtype) 10727 { 10728 /* For a named type, use the typedef. */ 10729 gen_type_die (qualified_type, context_die); 10730 return lookup_type_die (qualified_type); 10731 } 10732 else 10733 { 10734 int dquals = TYPE_QUALS_NO_ADDR_SPACE (dtype); 10735 dquals &= cv_qual_mask; 10736 if ((dquals & ~cv_quals) != TYPE_UNQUALIFIED 10737 || (cv_quals == dquals && DECL_ORIGINAL_TYPE (name) != type)) 10738 /* cv-unqualified version of named type. Just use 10739 the unnamed type to which it refers. */ 10740 return modified_type_die (DECL_ORIGINAL_TYPE (name), 10741 cv_quals, context_die); 10742 /* Else cv-qualified version of named type; fall through. */ 10743 } 10744 } 10745 10746 mod_scope = scope_die_for (type, context_die); 10747 10748 if (cv_quals) 10749 { 10750 struct qual_info { int q; enum dwarf_tag t; }; 10751 static const struct qual_info qual_info[] = 10752 { 10753 { TYPE_QUAL_ATOMIC, DW_TAG_atomic_type }, 10754 { TYPE_QUAL_RESTRICT, DW_TAG_restrict_type }, 10755 { TYPE_QUAL_VOLATILE, DW_TAG_volatile_type }, 10756 { TYPE_QUAL_CONST, DW_TAG_const_type }, 10757 }; 10758 int sub_quals; 10759 unsigned i; 10760 10761 /* Determine a lesser qualified type that most closely matches 10762 this one. Then generate DW_TAG_* entries for the remaining 10763 qualifiers. */ 10764 sub_quals = get_nearest_type_subqualifiers (type, cv_quals, 10765 cv_qual_mask); 10766 mod_type_die = modified_type_die (type, sub_quals, context_die); 10767 10768 for (i = 0; i < sizeof (qual_info) / sizeof (qual_info[0]); i++) 10769 if (qual_info[i].q & cv_quals & ~sub_quals) 10770 { 10771 dw_die_ref d = new_die (qual_info[i].t, mod_scope, type); 10772 if (mod_type_die) 10773 add_AT_die_ref (d, DW_AT_type, mod_type_die); 10774 mod_type_die = d; 10775 } 10776 } 10777 else if (code == POINTER_TYPE) 10778 { 10779 mod_type_die = new_die (DW_TAG_pointer_type, mod_scope, type); 10780 add_AT_unsigned (mod_type_die, DW_AT_byte_size, 10781 simple_type_size_in_bits (type) / BITS_PER_UNIT); 10782 item_type = TREE_TYPE (type); 10783 if (!ADDR_SPACE_GENERIC_P (TYPE_ADDR_SPACE (item_type))) 10784 add_AT_unsigned (mod_type_die, DW_AT_address_class, 10785 TYPE_ADDR_SPACE (item_type)); 10786 } 10787 else if (code == REFERENCE_TYPE) 10788 { 10789 if (TYPE_REF_IS_RVALUE (type) && dwarf_version >= 4) 10790 mod_type_die = new_die (DW_TAG_rvalue_reference_type, mod_scope, 10791 type); 10792 else 10793 mod_type_die = new_die (DW_TAG_reference_type, mod_scope, type); 10794 add_AT_unsigned (mod_type_die, DW_AT_byte_size, 10795 simple_type_size_in_bits (type) / BITS_PER_UNIT); 10796 item_type = TREE_TYPE (type); 10797 if (!ADDR_SPACE_GENERIC_P (TYPE_ADDR_SPACE (item_type))) 10798 add_AT_unsigned (mod_type_die, DW_AT_address_class, 10799 TYPE_ADDR_SPACE (item_type)); 10800 } 10801 else if (code == INTEGER_TYPE 10802 && TREE_TYPE (type) != NULL_TREE 10803 && subrange_type_for_debug_p (type, &low, &high)) 10804 { 10805 mod_type_die = subrange_type_die (type, low, high, context_die); 10806 item_type = TREE_TYPE (type); 10807 } 10808 else if (is_base_type (type)) 10809 mod_type_die = base_type_die (type); 10810 else 10811 { 10812 gen_type_die (type, context_die); 10813 10814 /* We have to get the type_main_variant here (and pass that to the 10815 `lookup_type_die' routine) because the ..._TYPE node we have 10816 might simply be a *copy* of some original type node (where the 10817 copy was created to help us keep track of typedef names) and 10818 that copy might have a different TYPE_UID from the original 10819 ..._TYPE node. */ 10820 if (TREE_CODE (type) != VECTOR_TYPE) 10821 return lookup_type_die (type_main_variant (type)); 10822 else 10823 /* Vectors have the debugging information in the type, 10824 not the main variant. */ 10825 return lookup_type_die (type); 10826 } 10827 10828 /* Builtin types don't have a DECL_ORIGINAL_TYPE. For those, 10829 don't output a DW_TAG_typedef, since there isn't one in the 10830 user's program; just attach a DW_AT_name to the type. 10831 Don't attach a DW_AT_name to DW_TAG_const_type or DW_TAG_volatile_type 10832 if the base type already has the same name. */ 10833 if (name 10834 && ((TREE_CODE (name) != TYPE_DECL 10835 && (qualified_type == TYPE_MAIN_VARIANT (type) 10836 || (cv_quals == TYPE_UNQUALIFIED))) 10837 || (TREE_CODE (name) == TYPE_DECL 10838 && TREE_TYPE (name) == qualified_type 10839 && DECL_NAME (name)))) 10840 { 10841 if (TREE_CODE (name) == TYPE_DECL) 10842 /* Could just call add_name_and_src_coords_attributes here, 10843 but since this is a builtin type it doesn't have any 10844 useful source coordinates anyway. */ 10845 name = DECL_NAME (name); 10846 add_name_attribute (mod_type_die, IDENTIFIER_POINTER (name)); 10847 } 10848 /* This probably indicates a bug. */ 10849 else if (mod_type_die && mod_type_die->die_tag == DW_TAG_base_type) 10850 { 10851 name = TYPE_IDENTIFIER (type); 10852 add_name_attribute (mod_type_die, 10853 name ? IDENTIFIER_POINTER (name) : "__unknown__"); 10854 } 10855 10856 if (qualified_type) 10857 equate_type_number_to_die (qualified_type, mod_type_die); 10858 10859 if (item_type) 10860 /* We must do this after the equate_type_number_to_die call, in case 10861 this is a recursive type. This ensures that the modified_type_die 10862 recursion will terminate even if the type is recursive. Recursive 10863 types are possible in Ada. */ 10864 sub_die = modified_type_die (item_type, 10865 TYPE_QUALS_NO_ADDR_SPACE (item_type), 10866 context_die); 10867 10868 if (sub_die != NULL) 10869 add_AT_die_ref (mod_type_die, DW_AT_type, sub_die); 10870 10871 add_gnat_descriptive_type_attribute (mod_type_die, type, context_die); 10872 if (TYPE_ARTIFICIAL (type)) 10873 add_AT_flag (mod_type_die, DW_AT_artificial, 1); 10874 10875 return mod_type_die; 10876} 10877 10878/* Generate DIEs for the generic parameters of T. 10879 T must be either a generic type or a generic function. 10880 See http://gcc.gnu.org/wiki/TemplateParmsDwarf for more. */ 10881 10882static void 10883gen_generic_params_dies (tree t) 10884{ 10885 tree parms, args; 10886 int parms_num, i; 10887 dw_die_ref die = NULL; 10888 int non_default; 10889 10890 if (!t || (TYPE_P (t) && !COMPLETE_TYPE_P (t))) 10891 return; 10892 10893 if (TYPE_P (t)) 10894 die = lookup_type_die (t); 10895 else if (DECL_P (t)) 10896 die = lookup_decl_die (t); 10897 10898 gcc_assert (die); 10899 10900 parms = lang_hooks.get_innermost_generic_parms (t); 10901 if (!parms) 10902 /* T has no generic parameter. It means T is neither a generic type 10903 or function. End of story. */ 10904 return; 10905 10906 parms_num = TREE_VEC_LENGTH (parms); 10907 args = lang_hooks.get_innermost_generic_args (t); 10908 if (TREE_CHAIN (args) && TREE_CODE (TREE_CHAIN (args)) == INTEGER_CST) 10909 non_default = int_cst_value (TREE_CHAIN (args)); 10910 else 10911 non_default = TREE_VEC_LENGTH (args); 10912 for (i = 0; i < parms_num; i++) 10913 { 10914 tree parm, arg, arg_pack_elems; 10915 dw_die_ref parm_die; 10916 10917 parm = TREE_VEC_ELT (parms, i); 10918 arg = TREE_VEC_ELT (args, i); 10919 arg_pack_elems = lang_hooks.types.get_argument_pack_elems (arg); 10920 gcc_assert (parm && TREE_VALUE (parm) && arg); 10921 10922 if (parm && TREE_VALUE (parm) && arg) 10923 { 10924 /* If PARM represents a template parameter pack, 10925 emit a DW_TAG_GNU_template_parameter_pack DIE, followed 10926 by DW_TAG_template_*_parameter DIEs for the argument 10927 pack elements of ARG. Note that ARG would then be 10928 an argument pack. */ 10929 if (arg_pack_elems) 10930 parm_die = template_parameter_pack_die (TREE_VALUE (parm), 10931 arg_pack_elems, 10932 die); 10933 else 10934 parm_die = generic_parameter_die (TREE_VALUE (parm), arg, 10935 true /* emit name */, die); 10936 if (i >= non_default) 10937 add_AT_flag (parm_die, DW_AT_default_value, 1); 10938 } 10939 } 10940} 10941 10942/* Create and return a DIE for PARM which should be 10943 the representation of a generic type parameter. 10944 For instance, in the C++ front end, PARM would be a template parameter. 10945 ARG is the argument to PARM. 10946 EMIT_NAME_P if tree, the DIE will have DW_AT_name attribute set to the 10947 name of the PARM. 10948 PARENT_DIE is the parent DIE which the new created DIE should be added to, 10949 as a child node. */ 10950 10951static dw_die_ref 10952generic_parameter_die (tree parm, tree arg, 10953 bool emit_name_p, 10954 dw_die_ref parent_die) 10955{ 10956 dw_die_ref tmpl_die = NULL; 10957 const char *name = NULL; 10958 10959 if (!parm || !DECL_NAME (parm) || !arg) 10960 return NULL; 10961 10962 /* We support non-type generic parameters and arguments, 10963 type generic parameters and arguments, as well as 10964 generic generic parameters (a.k.a. template template parameters in C++) 10965 and arguments. */ 10966 if (TREE_CODE (parm) == PARM_DECL) 10967 /* PARM is a nontype generic parameter */ 10968 tmpl_die = new_die (DW_TAG_template_value_param, parent_die, parm); 10969 else if (TREE_CODE (parm) == TYPE_DECL) 10970 /* PARM is a type generic parameter. */ 10971 tmpl_die = new_die (DW_TAG_template_type_param, parent_die, parm); 10972 else if (lang_hooks.decls.generic_generic_parameter_decl_p (parm)) 10973 /* PARM is a generic generic parameter. 10974 Its DIE is a GNU extension. It shall have a 10975 DW_AT_name attribute to represent the name of the template template 10976 parameter, and a DW_AT_GNU_template_name attribute to represent the 10977 name of the template template argument. */ 10978 tmpl_die = new_die (DW_TAG_GNU_template_template_param, 10979 parent_die, parm); 10980 else 10981 gcc_unreachable (); 10982 10983 if (tmpl_die) 10984 { 10985 tree tmpl_type; 10986 10987 /* If PARM is a generic parameter pack, it means we are 10988 emitting debug info for a template argument pack element. 10989 In other terms, ARG is a template argument pack element. 10990 In that case, we don't emit any DW_AT_name attribute for 10991 the die. */ 10992 if (emit_name_p) 10993 { 10994 name = IDENTIFIER_POINTER (DECL_NAME (parm)); 10995 gcc_assert (name); 10996 add_AT_string (tmpl_die, DW_AT_name, name); 10997 } 10998 10999 if (!lang_hooks.decls.generic_generic_parameter_decl_p (parm)) 11000 { 11001 /* DWARF3, 5.6.8 says if PARM is a non-type generic parameter 11002 TMPL_DIE should have a child DW_AT_type attribute that is set 11003 to the type of the argument to PARM, which is ARG. 11004 If PARM is a type generic parameter, TMPL_DIE should have a 11005 child DW_AT_type that is set to ARG. */ 11006 tmpl_type = TYPE_P (arg) ? arg : TREE_TYPE (arg); 11007 add_type_attribute (tmpl_die, tmpl_type, 11008 (TREE_THIS_VOLATILE (tmpl_type) 11009 ? TYPE_QUAL_VOLATILE : TYPE_UNQUALIFIED), 11010 parent_die); 11011 } 11012 else 11013 { 11014 /* So TMPL_DIE is a DIE representing a 11015 a generic generic template parameter, a.k.a template template 11016 parameter in C++ and arg is a template. */ 11017 11018 /* The DW_AT_GNU_template_name attribute of the DIE must be set 11019 to the name of the argument. */ 11020 name = dwarf2_name (TYPE_P (arg) ? TYPE_NAME (arg) : arg, 1); 11021 if (name) 11022 add_AT_string (tmpl_die, DW_AT_GNU_template_name, name); 11023 } 11024 11025 if (TREE_CODE (parm) == PARM_DECL) 11026 /* So PARM is a non-type generic parameter. 11027 DWARF3 5.6.8 says we must set a DW_AT_const_value child 11028 attribute of TMPL_DIE which value represents the value 11029 of ARG. 11030 We must be careful here: 11031 The value of ARG might reference some function decls. 11032 We might currently be emitting debug info for a generic 11033 type and types are emitted before function decls, we don't 11034 know if the function decls referenced by ARG will actually be 11035 emitted after cgraph computations. 11036 So must defer the generation of the DW_AT_const_value to 11037 after cgraph is ready. */ 11038 append_entry_to_tmpl_value_parm_die_table (tmpl_die, arg); 11039 } 11040 11041 return tmpl_die; 11042} 11043 11044/* Generate and return a DW_TAG_GNU_template_parameter_pack DIE representing. 11045 PARM_PACK must be a template parameter pack. The returned DIE 11046 will be child DIE of PARENT_DIE. */ 11047 11048static dw_die_ref 11049template_parameter_pack_die (tree parm_pack, 11050 tree parm_pack_args, 11051 dw_die_ref parent_die) 11052{ 11053 dw_die_ref die; 11054 int j; 11055 11056 gcc_assert (parent_die && parm_pack); 11057 11058 die = new_die (DW_TAG_GNU_template_parameter_pack, parent_die, parm_pack); 11059 add_name_and_src_coords_attributes (die, parm_pack); 11060 for (j = 0; j < TREE_VEC_LENGTH (parm_pack_args); j++) 11061 generic_parameter_die (parm_pack, 11062 TREE_VEC_ELT (parm_pack_args, j), 11063 false /* Don't emit DW_AT_name */, 11064 die); 11065 return die; 11066} 11067 11068/* Given a pointer to an arbitrary ..._TYPE tree node, return true if it is 11069 an enumerated type. */ 11070 11071static inline int 11072type_is_enum (const_tree type) 11073{ 11074 return TREE_CODE (type) == ENUMERAL_TYPE; 11075} 11076 11077/* Return the DBX register number described by a given RTL node. */ 11078 11079static unsigned int 11080dbx_reg_number (const_rtx rtl) 11081{ 11082 unsigned regno = REGNO (rtl); 11083 11084 gcc_assert (regno < FIRST_PSEUDO_REGISTER); 11085 11086#ifdef LEAF_REG_REMAP 11087 if (crtl->uses_only_leaf_regs) 11088 { 11089 int leaf_reg = LEAF_REG_REMAP (regno); 11090 if (leaf_reg != -1) 11091 regno = (unsigned) leaf_reg; 11092 } 11093#endif 11094 11095 regno = DBX_REGISTER_NUMBER (regno); 11096 gcc_assert (regno != INVALID_REGNUM); 11097 return regno; 11098} 11099 11100/* Optionally add a DW_OP_piece term to a location description expression. 11101 DW_OP_piece is only added if the location description expression already 11102 doesn't end with DW_OP_piece. */ 11103 11104static void 11105add_loc_descr_op_piece (dw_loc_descr_ref *list_head, int size) 11106{ 11107 dw_loc_descr_ref loc; 11108 11109 if (*list_head != NULL) 11110 { 11111 /* Find the end of the chain. */ 11112 for (loc = *list_head; loc->dw_loc_next != NULL; loc = loc->dw_loc_next) 11113 ; 11114 11115 if (loc->dw_loc_opc != DW_OP_piece) 11116 loc->dw_loc_next = new_loc_descr (DW_OP_piece, size, 0); 11117 } 11118} 11119 11120/* Return a location descriptor that designates a machine register or 11121 zero if there is none. */ 11122 11123static dw_loc_descr_ref 11124reg_loc_descriptor (rtx rtl, enum var_init_status initialized) 11125{ 11126 rtx regs; 11127 11128 if (REGNO (rtl) >= FIRST_PSEUDO_REGISTER) 11129 return 0; 11130 11131 /* We only use "frame base" when we're sure we're talking about the 11132 post-prologue local stack frame. We do this by *not* running 11133 register elimination until this point, and recognizing the special 11134 argument pointer and soft frame pointer rtx's. 11135 Use DW_OP_fbreg offset DW_OP_stack_value in this case. */ 11136 if ((rtl == arg_pointer_rtx || rtl == frame_pointer_rtx) 11137 && eliminate_regs (rtl, VOIDmode, NULL_RTX) != rtl) 11138 { 11139 dw_loc_descr_ref result = NULL; 11140 11141 if (dwarf_version >= 4 || !dwarf_strict) 11142 { 11143 result = mem_loc_descriptor (rtl, GET_MODE (rtl), VOIDmode, 11144 initialized); 11145 if (result) 11146 add_loc_descr (&result, 11147 new_loc_descr (DW_OP_stack_value, 0, 0)); 11148 } 11149 return result; 11150 } 11151 11152 regs = targetm.dwarf_register_span (rtl); 11153 11154 if (hard_regno_nregs[REGNO (rtl)][GET_MODE (rtl)] > 1 || regs) 11155 return multiple_reg_loc_descriptor (rtl, regs, initialized); 11156 else 11157 { 11158 unsigned int dbx_regnum = dbx_reg_number (rtl); 11159 if (dbx_regnum == IGNORED_DWARF_REGNUM) 11160 return 0; 11161 return one_reg_loc_descriptor (dbx_regnum, initialized); 11162 } 11163} 11164 11165/* Return a location descriptor that designates a machine register for 11166 a given hard register number. */ 11167 11168static dw_loc_descr_ref 11169one_reg_loc_descriptor (unsigned int regno, enum var_init_status initialized) 11170{ 11171 dw_loc_descr_ref reg_loc_descr; 11172 11173 if (regno <= 31) 11174 reg_loc_descr 11175 = new_loc_descr ((enum dwarf_location_atom) (DW_OP_reg0 + regno), 0, 0); 11176 else 11177 reg_loc_descr = new_loc_descr (DW_OP_regx, regno, 0); 11178 11179 if (initialized == VAR_INIT_STATUS_UNINITIALIZED) 11180 add_loc_descr (®_loc_descr, new_loc_descr (DW_OP_GNU_uninit, 0, 0)); 11181 11182 return reg_loc_descr; 11183} 11184 11185/* Given an RTL of a register, return a location descriptor that 11186 designates a value that spans more than one register. */ 11187 11188static dw_loc_descr_ref 11189multiple_reg_loc_descriptor (rtx rtl, rtx regs, 11190 enum var_init_status initialized) 11191{ 11192 int size, i; 11193 dw_loc_descr_ref loc_result = NULL; 11194 11195 /* Simple, contiguous registers. */ 11196 if (regs == NULL_RTX) 11197 { 11198 unsigned reg = REGNO (rtl); 11199 int nregs; 11200 11201#ifdef LEAF_REG_REMAP 11202 if (crtl->uses_only_leaf_regs) 11203 { 11204 int leaf_reg = LEAF_REG_REMAP (reg); 11205 if (leaf_reg != -1) 11206 reg = (unsigned) leaf_reg; 11207 } 11208#endif 11209 11210 gcc_assert ((unsigned) DBX_REGISTER_NUMBER (reg) == dbx_reg_number (rtl)); 11211 nregs = hard_regno_nregs[REGNO (rtl)][GET_MODE (rtl)]; 11212 11213 size = GET_MODE_SIZE (GET_MODE (rtl)) / nregs; 11214 11215 loc_result = NULL; 11216 while (nregs--) 11217 { 11218 dw_loc_descr_ref t; 11219 11220 t = one_reg_loc_descriptor (DBX_REGISTER_NUMBER (reg), 11221 VAR_INIT_STATUS_INITIALIZED); 11222 add_loc_descr (&loc_result, t); 11223 add_loc_descr_op_piece (&loc_result, size); 11224 ++reg; 11225 } 11226 return loc_result; 11227 } 11228 11229 /* Now onto stupid register sets in non contiguous locations. */ 11230 11231 gcc_assert (GET_CODE (regs) == PARALLEL); 11232 11233 size = GET_MODE_SIZE (GET_MODE (XVECEXP (regs, 0, 0))); 11234 loc_result = NULL; 11235 11236 for (i = 0; i < XVECLEN (regs, 0); ++i) 11237 { 11238 dw_loc_descr_ref t; 11239 11240 t = one_reg_loc_descriptor (dbx_reg_number (XVECEXP (regs, 0, i)), 11241 VAR_INIT_STATUS_INITIALIZED); 11242 add_loc_descr (&loc_result, t); 11243 add_loc_descr_op_piece (&loc_result, size); 11244 } 11245 11246 if (loc_result && initialized == VAR_INIT_STATUS_UNINITIALIZED) 11247 add_loc_descr (&loc_result, new_loc_descr (DW_OP_GNU_uninit, 0, 0)); 11248 return loc_result; 11249} 11250 11251static unsigned long size_of_int_loc_descriptor (HOST_WIDE_INT); 11252 11253/* Return a location descriptor that designates a constant i, 11254 as a compound operation from constant (i >> shift), constant shift 11255 and DW_OP_shl. */ 11256 11257static dw_loc_descr_ref 11258int_shift_loc_descriptor (HOST_WIDE_INT i, int shift) 11259{ 11260 dw_loc_descr_ref ret = int_loc_descriptor (i >> shift); 11261 add_loc_descr (&ret, int_loc_descriptor (shift)); 11262 add_loc_descr (&ret, new_loc_descr (DW_OP_shl, 0, 0)); 11263 return ret; 11264} 11265 11266/* Return a location descriptor that designates a constant. */ 11267 11268static dw_loc_descr_ref 11269int_loc_descriptor (HOST_WIDE_INT i) 11270{ 11271 enum dwarf_location_atom op; 11272 11273 /* Pick the smallest representation of a constant, rather than just 11274 defaulting to the LEB encoding. */ 11275 if (i >= 0) 11276 { 11277 int clz = clz_hwi (i); 11278 int ctz = ctz_hwi (i); 11279 if (i <= 31) 11280 op = (enum dwarf_location_atom) (DW_OP_lit0 + i); 11281 else if (i <= 0xff) 11282 op = DW_OP_const1u; 11283 else if (i <= 0xffff) 11284 op = DW_OP_const2u; 11285 else if (clz + ctz >= HOST_BITS_PER_WIDE_INT - 5 11286 && clz + 5 + 255 >= HOST_BITS_PER_WIDE_INT) 11287 /* DW_OP_litX DW_OP_litY DW_OP_shl takes just 3 bytes and 11288 DW_OP_litX DW_OP_const1u Y DW_OP_shl takes just 4 bytes, 11289 while DW_OP_const4u is 5 bytes. */ 11290 return int_shift_loc_descriptor (i, HOST_BITS_PER_WIDE_INT - clz - 5); 11291 else if (clz + ctz >= HOST_BITS_PER_WIDE_INT - 8 11292 && clz + 8 + 31 >= HOST_BITS_PER_WIDE_INT) 11293 /* DW_OP_const1u X DW_OP_litY DW_OP_shl takes just 4 bytes, 11294 while DW_OP_const4u is 5 bytes. */ 11295 return int_shift_loc_descriptor (i, HOST_BITS_PER_WIDE_INT - clz - 8); 11296 else if (HOST_BITS_PER_WIDE_INT == 32 || i <= 0xffffffff) 11297 op = DW_OP_const4u; 11298 else if (clz + ctz >= HOST_BITS_PER_WIDE_INT - 8 11299 && clz + 8 + 255 >= HOST_BITS_PER_WIDE_INT) 11300 /* DW_OP_const1u X DW_OP_const1u Y DW_OP_shl takes just 5 bytes, 11301 while DW_OP_constu of constant >= 0x100000000 takes at least 11302 6 bytes. */ 11303 return int_shift_loc_descriptor (i, HOST_BITS_PER_WIDE_INT - clz - 8); 11304 else if (clz + ctz >= HOST_BITS_PER_WIDE_INT - 16 11305 && clz + 16 + (size_of_uleb128 (i) > 5 ? 255 : 31) 11306 >= HOST_BITS_PER_WIDE_INT) 11307 /* DW_OP_const2u X DW_OP_litY DW_OP_shl takes just 5 bytes, 11308 DW_OP_const2u X DW_OP_const1u Y DW_OP_shl takes 6 bytes, 11309 while DW_OP_constu takes in this case at least 6 bytes. */ 11310 return int_shift_loc_descriptor (i, HOST_BITS_PER_WIDE_INT - clz - 16); 11311 else if (clz + ctz >= HOST_BITS_PER_WIDE_INT - 32 11312 && clz + 32 + 31 >= HOST_BITS_PER_WIDE_INT 11313 && size_of_uleb128 (i) > 6) 11314 /* DW_OP_const4u X DW_OP_litY DW_OP_shl takes just 7 bytes. */ 11315 return int_shift_loc_descriptor (i, HOST_BITS_PER_WIDE_INT - clz - 32); 11316 else 11317 op = DW_OP_constu; 11318 } 11319 else 11320 { 11321 if (i >= -0x80) 11322 op = DW_OP_const1s; 11323 else if (i >= -0x8000) 11324 op = DW_OP_const2s; 11325 else if (HOST_BITS_PER_WIDE_INT == 32 || i >= -0x80000000) 11326 { 11327 if (size_of_int_loc_descriptor (i) < 5) 11328 { 11329 dw_loc_descr_ref ret = int_loc_descriptor (-i); 11330 add_loc_descr (&ret, new_loc_descr (DW_OP_neg, 0, 0)); 11331 return ret; 11332 } 11333 op = DW_OP_const4s; 11334 } 11335 else 11336 { 11337 if (size_of_int_loc_descriptor (i) 11338 < (unsigned long) 1 + size_of_sleb128 (i)) 11339 { 11340 dw_loc_descr_ref ret = int_loc_descriptor (-i); 11341 add_loc_descr (&ret, new_loc_descr (DW_OP_neg, 0, 0)); 11342 return ret; 11343 } 11344 op = DW_OP_consts; 11345 } 11346 } 11347 11348 return new_loc_descr (op, i, 0); 11349} 11350 11351/* Return size_of_locs (int_shift_loc_descriptor (i, shift)) 11352 without actually allocating it. */ 11353 11354static unsigned long 11355size_of_int_shift_loc_descriptor (HOST_WIDE_INT i, int shift) 11356{ 11357 return size_of_int_loc_descriptor (i >> shift) 11358 + size_of_int_loc_descriptor (shift) 11359 + 1; 11360} 11361 11362/* Return size_of_locs (int_loc_descriptor (i)) without 11363 actually allocating it. */ 11364 11365static unsigned long 11366size_of_int_loc_descriptor (HOST_WIDE_INT i) 11367{ 11368 unsigned long s; 11369 11370 if (i >= 0) 11371 { 11372 int clz, ctz; 11373 if (i <= 31) 11374 return 1; 11375 else if (i <= 0xff) 11376 return 2; 11377 else if (i <= 0xffff) 11378 return 3; 11379 clz = clz_hwi (i); 11380 ctz = ctz_hwi (i); 11381 if (clz + ctz >= HOST_BITS_PER_WIDE_INT - 5 11382 && clz + 5 + 255 >= HOST_BITS_PER_WIDE_INT) 11383 return size_of_int_shift_loc_descriptor (i, HOST_BITS_PER_WIDE_INT 11384 - clz - 5); 11385 else if (clz + ctz >= HOST_BITS_PER_WIDE_INT - 8 11386 && clz + 8 + 31 >= HOST_BITS_PER_WIDE_INT) 11387 return size_of_int_shift_loc_descriptor (i, HOST_BITS_PER_WIDE_INT 11388 - clz - 8); 11389 else if (HOST_BITS_PER_WIDE_INT == 32 || i <= 0xffffffff) 11390 return 5; 11391 s = size_of_uleb128 ((unsigned HOST_WIDE_INT) i); 11392 if (clz + ctz >= HOST_BITS_PER_WIDE_INT - 8 11393 && clz + 8 + 255 >= HOST_BITS_PER_WIDE_INT) 11394 return size_of_int_shift_loc_descriptor (i, HOST_BITS_PER_WIDE_INT 11395 - clz - 8); 11396 else if (clz + ctz >= HOST_BITS_PER_WIDE_INT - 16 11397 && clz + 16 + (s > 5 ? 255 : 31) >= HOST_BITS_PER_WIDE_INT) 11398 return size_of_int_shift_loc_descriptor (i, HOST_BITS_PER_WIDE_INT 11399 - clz - 16); 11400 else if (clz + ctz >= HOST_BITS_PER_WIDE_INT - 32 11401 && clz + 32 + 31 >= HOST_BITS_PER_WIDE_INT 11402 && s > 6) 11403 return size_of_int_shift_loc_descriptor (i, HOST_BITS_PER_WIDE_INT 11404 - clz - 32); 11405 else 11406 return 1 + s; 11407 } 11408 else 11409 { 11410 if (i >= -0x80) 11411 return 2; 11412 else if (i >= -0x8000) 11413 return 3; 11414 else if (HOST_BITS_PER_WIDE_INT == 32 || i >= -0x80000000) 11415 { 11416 if (-(unsigned HOST_WIDE_INT) i != (unsigned HOST_WIDE_INT) i) 11417 { 11418 s = size_of_int_loc_descriptor (-i) + 1; 11419 if (s < 5) 11420 return s; 11421 } 11422 return 5; 11423 } 11424 else 11425 { 11426 unsigned long r = 1 + size_of_sleb128 (i); 11427 if (-(unsigned HOST_WIDE_INT) i != (unsigned HOST_WIDE_INT) i) 11428 { 11429 s = size_of_int_loc_descriptor (-i) + 1; 11430 if (s < r) 11431 return s; 11432 } 11433 return r; 11434 } 11435 } 11436} 11437 11438/* Return loc description representing "address" of integer value. 11439 This can appear only as toplevel expression. */ 11440 11441static dw_loc_descr_ref 11442address_of_int_loc_descriptor (int size, HOST_WIDE_INT i) 11443{ 11444 int litsize; 11445 dw_loc_descr_ref loc_result = NULL; 11446 11447 if (!(dwarf_version >= 4 || !dwarf_strict)) 11448 return NULL; 11449 11450 litsize = size_of_int_loc_descriptor (i); 11451 /* Determine if DW_OP_stack_value or DW_OP_implicit_value 11452 is more compact. For DW_OP_stack_value we need: 11453 litsize + 1 (DW_OP_stack_value) 11454 and for DW_OP_implicit_value: 11455 1 (DW_OP_implicit_value) + 1 (length) + size. */ 11456 if ((int) DWARF2_ADDR_SIZE >= size && litsize + 1 <= 1 + 1 + size) 11457 { 11458 loc_result = int_loc_descriptor (i); 11459 add_loc_descr (&loc_result, 11460 new_loc_descr (DW_OP_stack_value, 0, 0)); 11461 return loc_result; 11462 } 11463 11464 loc_result = new_loc_descr (DW_OP_implicit_value, 11465 size, 0); 11466 loc_result->dw_loc_oprnd2.val_class = dw_val_class_const; 11467 loc_result->dw_loc_oprnd2.v.val_int = i; 11468 return loc_result; 11469} 11470 11471/* Return a location descriptor that designates a base+offset location. */ 11472 11473static dw_loc_descr_ref 11474based_loc_descr (rtx reg, HOST_WIDE_INT offset, 11475 enum var_init_status initialized) 11476{ 11477 unsigned int regno; 11478 dw_loc_descr_ref result; 11479 dw_fde_ref fde = cfun->fde; 11480 11481 /* We only use "frame base" when we're sure we're talking about the 11482 post-prologue local stack frame. We do this by *not* running 11483 register elimination until this point, and recognizing the special 11484 argument pointer and soft frame pointer rtx's. */ 11485 if (reg == arg_pointer_rtx || reg == frame_pointer_rtx) 11486 { 11487 rtx elim = (ira_use_lra_p 11488 ? lra_eliminate_regs (reg, VOIDmode, NULL_RTX) 11489 : eliminate_regs (reg, VOIDmode, NULL_RTX)); 11490 11491 if (elim != reg) 11492 { 11493 if (GET_CODE (elim) == PLUS) 11494 { 11495 offset += INTVAL (XEXP (elim, 1)); 11496 elim = XEXP (elim, 0); 11497 } 11498 gcc_assert ((SUPPORTS_STACK_ALIGNMENT 11499 && (elim == hard_frame_pointer_rtx 11500 || elim == stack_pointer_rtx)) 11501 || elim == (frame_pointer_needed 11502 ? hard_frame_pointer_rtx 11503 : stack_pointer_rtx)); 11504 11505 /* If drap register is used to align stack, use frame 11506 pointer + offset to access stack variables. If stack 11507 is aligned without drap, use stack pointer + offset to 11508 access stack variables. */ 11509 if (crtl->stack_realign_tried 11510 && reg == frame_pointer_rtx) 11511 { 11512 int base_reg 11513 = DWARF_FRAME_REGNUM ((fde && fde->drap_reg != INVALID_REGNUM) 11514 ? HARD_FRAME_POINTER_REGNUM 11515 : REGNO (elim)); 11516 return new_reg_loc_descr (base_reg, offset); 11517 } 11518 11519 gcc_assert (frame_pointer_fb_offset_valid); 11520 offset += frame_pointer_fb_offset; 11521 return new_loc_descr (DW_OP_fbreg, offset, 0); 11522 } 11523 } 11524 11525 regno = REGNO (reg); 11526#ifdef LEAF_REG_REMAP 11527 if (crtl->uses_only_leaf_regs) 11528 { 11529 int leaf_reg = LEAF_REG_REMAP (regno); 11530 if (leaf_reg != -1) 11531 regno = (unsigned) leaf_reg; 11532 } 11533#endif 11534 regno = DWARF_FRAME_REGNUM (regno); 11535 11536 if (!optimize && fde 11537 && (fde->drap_reg == regno || fde->vdrap_reg == regno)) 11538 { 11539 /* Use cfa+offset to represent the location of arguments passed 11540 on the stack when drap is used to align stack. 11541 Only do this when not optimizing, for optimized code var-tracking 11542 is supposed to track where the arguments live and the register 11543 used as vdrap or drap in some spot might be used for something 11544 else in other part of the routine. */ 11545 return new_loc_descr (DW_OP_fbreg, offset, 0); 11546 } 11547 11548 if (regno <= 31) 11549 result = new_loc_descr ((enum dwarf_location_atom) (DW_OP_breg0 + regno), 11550 offset, 0); 11551 else 11552 result = new_loc_descr (DW_OP_bregx, regno, offset); 11553 11554 if (initialized == VAR_INIT_STATUS_UNINITIALIZED) 11555 add_loc_descr (&result, new_loc_descr (DW_OP_GNU_uninit, 0, 0)); 11556 11557 return result; 11558} 11559 11560/* Return true if this RTL expression describes a base+offset calculation. */ 11561 11562static inline int 11563is_based_loc (const_rtx rtl) 11564{ 11565 return (GET_CODE (rtl) == PLUS 11566 && ((REG_P (XEXP (rtl, 0)) 11567 && REGNO (XEXP (rtl, 0)) < FIRST_PSEUDO_REGISTER 11568 && CONST_INT_P (XEXP (rtl, 1))))); 11569} 11570 11571/* Try to handle TLS MEMs, for which mem_loc_descriptor on XEXP (mem, 0) 11572 failed. */ 11573 11574static dw_loc_descr_ref 11575tls_mem_loc_descriptor (rtx mem) 11576{ 11577 tree base; 11578 dw_loc_descr_ref loc_result; 11579 11580 if (MEM_EXPR (mem) == NULL_TREE || !MEM_OFFSET_KNOWN_P (mem)) 11581 return NULL; 11582 11583 base = get_base_address (MEM_EXPR (mem)); 11584 if (base == NULL 11585 || TREE_CODE (base) != VAR_DECL 11586 || !DECL_THREAD_LOCAL_P (base)) 11587 return NULL; 11588 11589 loc_result = loc_descriptor_from_tree (MEM_EXPR (mem), 1, NULL); 11590 if (loc_result == NULL) 11591 return NULL; 11592 11593 if (MEM_OFFSET (mem)) 11594 loc_descr_plus_const (&loc_result, MEM_OFFSET (mem)); 11595 11596 return loc_result; 11597} 11598 11599/* Output debug info about reason why we failed to expand expression as dwarf 11600 expression. */ 11601 11602static void 11603expansion_failed (tree expr, rtx rtl, char const *reason) 11604{ 11605 if (dump_file && (dump_flags & TDF_DETAILS)) 11606 { 11607 fprintf (dump_file, "Failed to expand as dwarf: "); 11608 if (expr) 11609 print_generic_expr (dump_file, expr, dump_flags); 11610 if (rtl) 11611 { 11612 fprintf (dump_file, "\n"); 11613 print_rtl (dump_file, rtl); 11614 } 11615 fprintf (dump_file, "\nReason: %s\n", reason); 11616 } 11617} 11618 11619/* Helper function for const_ok_for_output. */ 11620 11621static bool 11622const_ok_for_output_1 (rtx rtl) 11623{ 11624 if (GET_CODE (rtl) == UNSPEC) 11625 { 11626 /* If delegitimize_address couldn't do anything with the UNSPEC, assume 11627 we can't express it in the debug info. */ 11628#ifdef ENABLE_CHECKING 11629 /* Don't complain about TLS UNSPECs, those are just too hard to 11630 delegitimize. Note this could be a non-decl SYMBOL_REF such as 11631 one in a constant pool entry, so testing SYMBOL_REF_TLS_MODEL 11632 rather than DECL_THREAD_LOCAL_P is not just an optimization. */ 11633 if (XVECLEN (rtl, 0) == 0 11634 || GET_CODE (XVECEXP (rtl, 0, 0)) != SYMBOL_REF 11635 || SYMBOL_REF_TLS_MODEL (XVECEXP (rtl, 0, 0)) == TLS_MODEL_NONE) 11636 inform (current_function_decl 11637 ? DECL_SOURCE_LOCATION (current_function_decl) 11638 : UNKNOWN_LOCATION, 11639#if NUM_UNSPEC_VALUES > 0 11640 "non-delegitimized UNSPEC %s (%d) found in variable location", 11641 ((XINT (rtl, 1) >= 0 && XINT (rtl, 1) < NUM_UNSPEC_VALUES) 11642 ? unspec_strings[XINT (rtl, 1)] : "unknown"), 11643 XINT (rtl, 1)); 11644#else 11645 "non-delegitimized UNSPEC %d found in variable location", 11646 XINT (rtl, 1)); 11647#endif 11648#endif 11649 expansion_failed (NULL_TREE, rtl, 11650 "UNSPEC hasn't been delegitimized.\n"); 11651 return false; 11652 } 11653 11654 if (targetm.const_not_ok_for_debug_p (rtl)) 11655 { 11656 expansion_failed (NULL_TREE, rtl, 11657 "Expression rejected for debug by the backend.\n"); 11658 return false; 11659 } 11660 11661 /* FIXME: Refer to PR60655. It is possible for simplification 11662 of rtl expressions in var tracking to produce such expressions. 11663 We should really identify / validate expressions 11664 enclosed in CONST that can be handled by assemblers on various 11665 targets and only handle legitimate cases here. */ 11666 if (GET_CODE (rtl) != SYMBOL_REF) 11667 { 11668 if (GET_CODE (rtl) == NOT) 11669 return false; 11670 return true; 11671 } 11672 11673 if (CONSTANT_POOL_ADDRESS_P (rtl)) 11674 { 11675 bool marked; 11676 get_pool_constant_mark (rtl, &marked); 11677 /* If all references to this pool constant were optimized away, 11678 it was not output and thus we can't represent it. */ 11679 if (!marked) 11680 { 11681 expansion_failed (NULL_TREE, rtl, 11682 "Constant was removed from constant pool.\n"); 11683 return false; 11684 } 11685 } 11686 11687 if (SYMBOL_REF_TLS_MODEL (rtl) != TLS_MODEL_NONE) 11688 return false; 11689 11690 /* Avoid references to external symbols in debug info, on several targets 11691 the linker might even refuse to link when linking a shared library, 11692 and in many other cases the relocations for .debug_info/.debug_loc are 11693 dropped, so the address becomes zero anyway. Hidden symbols, guaranteed 11694 to be defined within the same shared library or executable are fine. */ 11695 if (SYMBOL_REF_EXTERNAL_P (rtl)) 11696 { 11697 tree decl = SYMBOL_REF_DECL (rtl); 11698 11699 if (decl == NULL || !targetm.binds_local_p (decl)) 11700 { 11701 expansion_failed (NULL_TREE, rtl, 11702 "Symbol not defined in current TU.\n"); 11703 return false; 11704 } 11705 } 11706 11707 return true; 11708} 11709 11710/* Return true if constant RTL can be emitted in DW_OP_addr or 11711 DW_AT_const_value. TLS SYMBOL_REFs, external SYMBOL_REFs or 11712 non-marked constant pool SYMBOL_REFs can't be referenced in it. */ 11713 11714static bool 11715const_ok_for_output (rtx rtl) 11716{ 11717 if (GET_CODE (rtl) == SYMBOL_REF) 11718 return const_ok_for_output_1 (rtl); 11719 11720 if (GET_CODE (rtl) == CONST) 11721 { 11722 subrtx_var_iterator::array_type array; 11723 FOR_EACH_SUBRTX_VAR (iter, array, XEXP (rtl, 0), ALL) 11724 if (!const_ok_for_output_1 (*iter)) 11725 return false; 11726 return true; 11727 } 11728 11729 return true; 11730} 11731 11732/* Return a reference to DW_TAG_base_type corresponding to MODE and UNSIGNEDP 11733 if possible, NULL otherwise. */ 11734 11735static dw_die_ref 11736base_type_for_mode (machine_mode mode, bool unsignedp) 11737{ 11738 dw_die_ref type_die; 11739 tree type = lang_hooks.types.type_for_mode (mode, unsignedp); 11740 11741 if (type == NULL) 11742 return NULL; 11743 switch (TREE_CODE (type)) 11744 { 11745 case INTEGER_TYPE: 11746 case REAL_TYPE: 11747 break; 11748 default: 11749 return NULL; 11750 } 11751 type_die = lookup_type_die (type); 11752 if (!type_die) 11753 type_die = modified_type_die (type, TYPE_UNQUALIFIED, comp_unit_die ()); 11754 if (type_die == NULL || type_die->die_tag != DW_TAG_base_type) 11755 return NULL; 11756 return type_die; 11757} 11758 11759/* For OP descriptor assumed to be in unsigned MODE, convert it to a unsigned 11760 type matching MODE, or, if MODE is narrower than or as wide as 11761 DWARF2_ADDR_SIZE, untyped. Return NULL if the conversion is not 11762 possible. */ 11763 11764static dw_loc_descr_ref 11765convert_descriptor_to_mode (machine_mode mode, dw_loc_descr_ref op) 11766{ 11767 machine_mode outer_mode = mode; 11768 dw_die_ref type_die; 11769 dw_loc_descr_ref cvt; 11770 11771 if (GET_MODE_SIZE (mode) <= DWARF2_ADDR_SIZE) 11772 { 11773 add_loc_descr (&op, new_loc_descr (DW_OP_GNU_convert, 0, 0)); 11774 return op; 11775 } 11776 type_die = base_type_for_mode (outer_mode, 1); 11777 if (type_die == NULL) 11778 return NULL; 11779 cvt = new_loc_descr (DW_OP_GNU_convert, 0, 0); 11780 cvt->dw_loc_oprnd1.val_class = dw_val_class_die_ref; 11781 cvt->dw_loc_oprnd1.v.val_die_ref.die = type_die; 11782 cvt->dw_loc_oprnd1.v.val_die_ref.external = 0; 11783 add_loc_descr (&op, cvt); 11784 return op; 11785} 11786 11787/* Return location descriptor for comparison OP with operands OP0 and OP1. */ 11788 11789static dw_loc_descr_ref 11790compare_loc_descriptor (enum dwarf_location_atom op, dw_loc_descr_ref op0, 11791 dw_loc_descr_ref op1) 11792{ 11793 dw_loc_descr_ref ret = op0; 11794 add_loc_descr (&ret, op1); 11795 add_loc_descr (&ret, new_loc_descr (op, 0, 0)); 11796 if (STORE_FLAG_VALUE != 1) 11797 { 11798 add_loc_descr (&ret, int_loc_descriptor (STORE_FLAG_VALUE)); 11799 add_loc_descr (&ret, new_loc_descr (DW_OP_mul, 0, 0)); 11800 } 11801 return ret; 11802} 11803 11804/* Return location descriptor for signed comparison OP RTL. */ 11805 11806static dw_loc_descr_ref 11807scompare_loc_descriptor (enum dwarf_location_atom op, rtx rtl, 11808 machine_mode mem_mode) 11809{ 11810 machine_mode op_mode = GET_MODE (XEXP (rtl, 0)); 11811 dw_loc_descr_ref op0, op1; 11812 int shift; 11813 11814 if (op_mode == VOIDmode) 11815 op_mode = GET_MODE (XEXP (rtl, 1)); 11816 if (op_mode == VOIDmode) 11817 return NULL; 11818 11819 if (dwarf_strict 11820 && (GET_MODE_CLASS (op_mode) != MODE_INT 11821 || GET_MODE_SIZE (op_mode) > DWARF2_ADDR_SIZE)) 11822 return NULL; 11823 11824 op0 = mem_loc_descriptor (XEXP (rtl, 0), op_mode, mem_mode, 11825 VAR_INIT_STATUS_INITIALIZED); 11826 op1 = mem_loc_descriptor (XEXP (rtl, 1), op_mode, mem_mode, 11827 VAR_INIT_STATUS_INITIALIZED); 11828 11829 if (op0 == NULL || op1 == NULL) 11830 return NULL; 11831 11832 if (GET_MODE_CLASS (op_mode) != MODE_INT 11833 || GET_MODE_SIZE (op_mode) == DWARF2_ADDR_SIZE) 11834 return compare_loc_descriptor (op, op0, op1); 11835 11836 if (GET_MODE_SIZE (op_mode) > DWARF2_ADDR_SIZE) 11837 { 11838 dw_die_ref type_die = base_type_for_mode (op_mode, 0); 11839 dw_loc_descr_ref cvt; 11840 11841 if (type_die == NULL) 11842 return NULL; 11843 cvt = new_loc_descr (DW_OP_GNU_convert, 0, 0); 11844 cvt->dw_loc_oprnd1.val_class = dw_val_class_die_ref; 11845 cvt->dw_loc_oprnd1.v.val_die_ref.die = type_die; 11846 cvt->dw_loc_oprnd1.v.val_die_ref.external = 0; 11847 add_loc_descr (&op0, cvt); 11848 cvt = new_loc_descr (DW_OP_GNU_convert, 0, 0); 11849 cvt->dw_loc_oprnd1.val_class = dw_val_class_die_ref; 11850 cvt->dw_loc_oprnd1.v.val_die_ref.die = type_die; 11851 cvt->dw_loc_oprnd1.v.val_die_ref.external = 0; 11852 add_loc_descr (&op1, cvt); 11853 return compare_loc_descriptor (op, op0, op1); 11854 } 11855 11856 shift = (DWARF2_ADDR_SIZE - GET_MODE_SIZE (op_mode)) * BITS_PER_UNIT; 11857 /* For eq/ne, if the operands are known to be zero-extended, 11858 there is no need to do the fancy shifting up. */ 11859 if (op == DW_OP_eq || op == DW_OP_ne) 11860 { 11861 dw_loc_descr_ref last0, last1; 11862 for (last0 = op0; last0->dw_loc_next != NULL; last0 = last0->dw_loc_next) 11863 ; 11864 for (last1 = op1; last1->dw_loc_next != NULL; last1 = last1->dw_loc_next) 11865 ; 11866 /* deref_size zero extends, and for constants we can check 11867 whether they are zero extended or not. */ 11868 if (((last0->dw_loc_opc == DW_OP_deref_size 11869 && last0->dw_loc_oprnd1.v.val_int <= GET_MODE_SIZE (op_mode)) 11870 || (CONST_INT_P (XEXP (rtl, 0)) 11871 && (unsigned HOST_WIDE_INT) INTVAL (XEXP (rtl, 0)) 11872 == (INTVAL (XEXP (rtl, 0)) & GET_MODE_MASK (op_mode)))) 11873 && ((last1->dw_loc_opc == DW_OP_deref_size 11874 && last1->dw_loc_oprnd1.v.val_int <= GET_MODE_SIZE (op_mode)) 11875 || (CONST_INT_P (XEXP (rtl, 1)) 11876 && (unsigned HOST_WIDE_INT) INTVAL (XEXP (rtl, 1)) 11877 == (INTVAL (XEXP (rtl, 1)) & GET_MODE_MASK (op_mode))))) 11878 return compare_loc_descriptor (op, op0, op1); 11879 11880 /* EQ/NE comparison against constant in narrower type than 11881 DWARF2_ADDR_SIZE can be performed either as 11882 DW_OP_const1u <shift> DW_OP_shl DW_OP_const* <cst << shift> 11883 DW_OP_{eq,ne} 11884 or 11885 DW_OP_const*u <mode_mask> DW_OP_and DW_OP_const* <cst & mode_mask> 11886 DW_OP_{eq,ne}. Pick whatever is shorter. */ 11887 if (CONST_INT_P (XEXP (rtl, 1)) 11888 && GET_MODE_BITSIZE (op_mode) < HOST_BITS_PER_WIDE_INT 11889 && (size_of_int_loc_descriptor (shift) + 1 11890 + size_of_int_loc_descriptor (INTVAL (XEXP (rtl, 1)) << shift) 11891 >= size_of_int_loc_descriptor (GET_MODE_MASK (op_mode)) + 1 11892 + size_of_int_loc_descriptor (INTVAL (XEXP (rtl, 1)) 11893 & GET_MODE_MASK (op_mode)))) 11894 { 11895 add_loc_descr (&op0, int_loc_descriptor (GET_MODE_MASK (op_mode))); 11896 add_loc_descr (&op0, new_loc_descr (DW_OP_and, 0, 0)); 11897 op1 = int_loc_descriptor (INTVAL (XEXP (rtl, 1)) 11898 & GET_MODE_MASK (op_mode)); 11899 return compare_loc_descriptor (op, op0, op1); 11900 } 11901 } 11902 add_loc_descr (&op0, int_loc_descriptor (shift)); 11903 add_loc_descr (&op0, new_loc_descr (DW_OP_shl, 0, 0)); 11904 if (CONST_INT_P (XEXP (rtl, 1))) 11905 op1 = int_loc_descriptor (INTVAL (XEXP (rtl, 1)) << shift); 11906 else 11907 { 11908 add_loc_descr (&op1, int_loc_descriptor (shift)); 11909 add_loc_descr (&op1, new_loc_descr (DW_OP_shl, 0, 0)); 11910 } 11911 return compare_loc_descriptor (op, op0, op1); 11912} 11913 11914/* Return location descriptor for unsigned comparison OP RTL. */ 11915 11916static dw_loc_descr_ref 11917ucompare_loc_descriptor (enum dwarf_location_atom op, rtx rtl, 11918 machine_mode mem_mode) 11919{ 11920 machine_mode op_mode = GET_MODE (XEXP (rtl, 0)); 11921 dw_loc_descr_ref op0, op1; 11922 11923 if (op_mode == VOIDmode) 11924 op_mode = GET_MODE (XEXP (rtl, 1)); 11925 if (op_mode == VOIDmode) 11926 return NULL; 11927 if (GET_MODE_CLASS (op_mode) != MODE_INT) 11928 return NULL; 11929 11930 if (dwarf_strict && GET_MODE_SIZE (op_mode) > DWARF2_ADDR_SIZE) 11931 return NULL; 11932 11933 op0 = mem_loc_descriptor (XEXP (rtl, 0), op_mode, mem_mode, 11934 VAR_INIT_STATUS_INITIALIZED); 11935 op1 = mem_loc_descriptor (XEXP (rtl, 1), op_mode, mem_mode, 11936 VAR_INIT_STATUS_INITIALIZED); 11937 11938 if (op0 == NULL || op1 == NULL) 11939 return NULL; 11940 11941 if (GET_MODE_SIZE (op_mode) < DWARF2_ADDR_SIZE) 11942 { 11943 HOST_WIDE_INT mask = GET_MODE_MASK (op_mode); 11944 dw_loc_descr_ref last0, last1; 11945 for (last0 = op0; last0->dw_loc_next != NULL; last0 = last0->dw_loc_next) 11946 ; 11947 for (last1 = op1; last1->dw_loc_next != NULL; last1 = last1->dw_loc_next) 11948 ; 11949 if (CONST_INT_P (XEXP (rtl, 0))) 11950 op0 = int_loc_descriptor (INTVAL (XEXP (rtl, 0)) & mask); 11951 /* deref_size zero extends, so no need to mask it again. */ 11952 else if (last0->dw_loc_opc != DW_OP_deref_size 11953 || last0->dw_loc_oprnd1.v.val_int > GET_MODE_SIZE (op_mode)) 11954 { 11955 add_loc_descr (&op0, int_loc_descriptor (mask)); 11956 add_loc_descr (&op0, new_loc_descr (DW_OP_and, 0, 0)); 11957 } 11958 if (CONST_INT_P (XEXP (rtl, 1))) 11959 op1 = int_loc_descriptor (INTVAL (XEXP (rtl, 1)) & mask); 11960 /* deref_size zero extends, so no need to mask it again. */ 11961 else if (last1->dw_loc_opc != DW_OP_deref_size 11962 || last1->dw_loc_oprnd1.v.val_int > GET_MODE_SIZE (op_mode)) 11963 { 11964 add_loc_descr (&op1, int_loc_descriptor (mask)); 11965 add_loc_descr (&op1, new_loc_descr (DW_OP_and, 0, 0)); 11966 } 11967 } 11968 else if (GET_MODE_SIZE (op_mode) == DWARF2_ADDR_SIZE) 11969 { 11970 HOST_WIDE_INT bias = 1; 11971 bias <<= (DWARF2_ADDR_SIZE * BITS_PER_UNIT - 1); 11972 add_loc_descr (&op0, new_loc_descr (DW_OP_plus_uconst, bias, 0)); 11973 if (CONST_INT_P (XEXP (rtl, 1))) 11974 op1 = int_loc_descriptor ((unsigned HOST_WIDE_INT) bias 11975 + INTVAL (XEXP (rtl, 1))); 11976 else 11977 add_loc_descr (&op1, new_loc_descr (DW_OP_plus_uconst, 11978 bias, 0)); 11979 } 11980 return compare_loc_descriptor (op, op0, op1); 11981} 11982 11983/* Return location descriptor for {U,S}{MIN,MAX}. */ 11984 11985static dw_loc_descr_ref 11986minmax_loc_descriptor (rtx rtl, machine_mode mode, 11987 machine_mode mem_mode) 11988{ 11989 enum dwarf_location_atom op; 11990 dw_loc_descr_ref op0, op1, ret; 11991 dw_loc_descr_ref bra_node, drop_node; 11992 11993 if (dwarf_strict 11994 && (GET_MODE_CLASS (mode) != MODE_INT 11995 || GET_MODE_SIZE (mode) > DWARF2_ADDR_SIZE)) 11996 return NULL; 11997 11998 op0 = mem_loc_descriptor (XEXP (rtl, 0), mode, mem_mode, 11999 VAR_INIT_STATUS_INITIALIZED); 12000 op1 = mem_loc_descriptor (XEXP (rtl, 1), mode, mem_mode, 12001 VAR_INIT_STATUS_INITIALIZED); 12002 12003 if (op0 == NULL || op1 == NULL) 12004 return NULL; 12005 12006 add_loc_descr (&op0, new_loc_descr (DW_OP_dup, 0, 0)); 12007 add_loc_descr (&op1, new_loc_descr (DW_OP_swap, 0, 0)); 12008 add_loc_descr (&op1, new_loc_descr (DW_OP_over, 0, 0)); 12009 if (GET_CODE (rtl) == UMIN || GET_CODE (rtl) == UMAX) 12010 { 12011 if (GET_MODE_SIZE (mode) < DWARF2_ADDR_SIZE) 12012 { 12013 HOST_WIDE_INT mask = GET_MODE_MASK (mode); 12014 add_loc_descr (&op0, int_loc_descriptor (mask)); 12015 add_loc_descr (&op0, new_loc_descr (DW_OP_and, 0, 0)); 12016 add_loc_descr (&op1, int_loc_descriptor (mask)); 12017 add_loc_descr (&op1, new_loc_descr (DW_OP_and, 0, 0)); 12018 } 12019 else if (GET_MODE_SIZE (mode) == DWARF2_ADDR_SIZE) 12020 { 12021 HOST_WIDE_INT bias = 1; 12022 bias <<= (DWARF2_ADDR_SIZE * BITS_PER_UNIT - 1); 12023 add_loc_descr (&op0, new_loc_descr (DW_OP_plus_uconst, bias, 0)); 12024 add_loc_descr (&op1, new_loc_descr (DW_OP_plus_uconst, bias, 0)); 12025 } 12026 } 12027 else if (GET_MODE_CLASS (mode) == MODE_INT 12028 && GET_MODE_SIZE (mode) < DWARF2_ADDR_SIZE) 12029 { 12030 int shift = (DWARF2_ADDR_SIZE - GET_MODE_SIZE (mode)) * BITS_PER_UNIT; 12031 add_loc_descr (&op0, int_loc_descriptor (shift)); 12032 add_loc_descr (&op0, new_loc_descr (DW_OP_shl, 0, 0)); 12033 add_loc_descr (&op1, int_loc_descriptor (shift)); 12034 add_loc_descr (&op1, new_loc_descr (DW_OP_shl, 0, 0)); 12035 } 12036 else if (GET_MODE_CLASS (mode) == MODE_INT 12037 && GET_MODE_SIZE (mode) > DWARF2_ADDR_SIZE) 12038 { 12039 dw_die_ref type_die = base_type_for_mode (mode, 0); 12040 dw_loc_descr_ref cvt; 12041 if (type_die == NULL) 12042 return NULL; 12043 cvt = new_loc_descr (DW_OP_GNU_convert, 0, 0); 12044 cvt->dw_loc_oprnd1.val_class = dw_val_class_die_ref; 12045 cvt->dw_loc_oprnd1.v.val_die_ref.die = type_die; 12046 cvt->dw_loc_oprnd1.v.val_die_ref.external = 0; 12047 add_loc_descr (&op0, cvt); 12048 cvt = new_loc_descr (DW_OP_GNU_convert, 0, 0); 12049 cvt->dw_loc_oprnd1.val_class = dw_val_class_die_ref; 12050 cvt->dw_loc_oprnd1.v.val_die_ref.die = type_die; 12051 cvt->dw_loc_oprnd1.v.val_die_ref.external = 0; 12052 add_loc_descr (&op1, cvt); 12053 } 12054 12055 if (GET_CODE (rtl) == SMIN || GET_CODE (rtl) == UMIN) 12056 op = DW_OP_lt; 12057 else 12058 op = DW_OP_gt; 12059 ret = op0; 12060 add_loc_descr (&ret, op1); 12061 add_loc_descr (&ret, new_loc_descr (op, 0, 0)); 12062 bra_node = new_loc_descr (DW_OP_bra, 0, 0); 12063 add_loc_descr (&ret, bra_node); 12064 add_loc_descr (&ret, new_loc_descr (DW_OP_swap, 0, 0)); 12065 drop_node = new_loc_descr (DW_OP_drop, 0, 0); 12066 add_loc_descr (&ret, drop_node); 12067 bra_node->dw_loc_oprnd1.val_class = dw_val_class_loc; 12068 bra_node->dw_loc_oprnd1.v.val_loc = drop_node; 12069 if ((GET_CODE (rtl) == SMIN || GET_CODE (rtl) == SMAX) 12070 && GET_MODE_CLASS (mode) == MODE_INT 12071 && GET_MODE_SIZE (mode) > DWARF2_ADDR_SIZE) 12072 ret = convert_descriptor_to_mode (mode, ret); 12073 return ret; 12074} 12075 12076/* Helper function for mem_loc_descriptor. Perform OP binary op, 12077 but after converting arguments to type_die, afterwards 12078 convert back to unsigned. */ 12079 12080static dw_loc_descr_ref 12081typed_binop (enum dwarf_location_atom op, rtx rtl, dw_die_ref type_die, 12082 machine_mode mode, machine_mode mem_mode) 12083{ 12084 dw_loc_descr_ref cvt, op0, op1; 12085 12086 if (type_die == NULL) 12087 return NULL; 12088 op0 = mem_loc_descriptor (XEXP (rtl, 0), mode, mem_mode, 12089 VAR_INIT_STATUS_INITIALIZED); 12090 op1 = mem_loc_descriptor (XEXP (rtl, 1), mode, mem_mode, 12091 VAR_INIT_STATUS_INITIALIZED); 12092 if (op0 == NULL || op1 == NULL) 12093 return NULL; 12094 cvt = new_loc_descr (DW_OP_GNU_convert, 0, 0); 12095 cvt->dw_loc_oprnd1.val_class = dw_val_class_die_ref; 12096 cvt->dw_loc_oprnd1.v.val_die_ref.die = type_die; 12097 cvt->dw_loc_oprnd1.v.val_die_ref.external = 0; 12098 add_loc_descr (&op0, cvt); 12099 cvt = new_loc_descr (DW_OP_GNU_convert, 0, 0); 12100 cvt->dw_loc_oprnd1.val_class = dw_val_class_die_ref; 12101 cvt->dw_loc_oprnd1.v.val_die_ref.die = type_die; 12102 cvt->dw_loc_oprnd1.v.val_die_ref.external = 0; 12103 add_loc_descr (&op1, cvt); 12104 add_loc_descr (&op0, op1); 12105 add_loc_descr (&op0, new_loc_descr (op, 0, 0)); 12106 return convert_descriptor_to_mode (mode, op0); 12107} 12108 12109/* CLZ (where constV is CLZ_DEFINED_VALUE_AT_ZERO computed value, 12110 const0 is DW_OP_lit0 or corresponding typed constant, 12111 const1 is DW_OP_lit1 or corresponding typed constant 12112 and constMSB is constant with just the MSB bit set 12113 for the mode): 12114 DW_OP_dup DW_OP_bra <L1> DW_OP_drop constV DW_OP_skip <L4> 12115 L1: const0 DW_OP_swap 12116 L2: DW_OP_dup constMSB DW_OP_and DW_OP_bra <L3> const1 DW_OP_shl 12117 DW_OP_swap DW_OP_plus_uconst <1> DW_OP_swap DW_OP_skip <L2> 12118 L3: DW_OP_drop 12119 L4: DW_OP_nop 12120 12121 CTZ is similar: 12122 DW_OP_dup DW_OP_bra <L1> DW_OP_drop constV DW_OP_skip <L4> 12123 L1: const0 DW_OP_swap 12124 L2: DW_OP_dup const1 DW_OP_and DW_OP_bra <L3> const1 DW_OP_shr 12125 DW_OP_swap DW_OP_plus_uconst <1> DW_OP_swap DW_OP_skip <L2> 12126 L3: DW_OP_drop 12127 L4: DW_OP_nop 12128 12129 FFS is similar: 12130 DW_OP_dup DW_OP_bra <L1> DW_OP_drop const0 DW_OP_skip <L4> 12131 L1: const1 DW_OP_swap 12132 L2: DW_OP_dup const1 DW_OP_and DW_OP_bra <L3> const1 DW_OP_shr 12133 DW_OP_swap DW_OP_plus_uconst <1> DW_OP_swap DW_OP_skip <L2> 12134 L3: DW_OP_drop 12135 L4: DW_OP_nop */ 12136 12137static dw_loc_descr_ref 12138clz_loc_descriptor (rtx rtl, machine_mode mode, 12139 machine_mode mem_mode) 12140{ 12141 dw_loc_descr_ref op0, ret, tmp; 12142 HOST_WIDE_INT valv; 12143 dw_loc_descr_ref l1jump, l1label; 12144 dw_loc_descr_ref l2jump, l2label; 12145 dw_loc_descr_ref l3jump, l3label; 12146 dw_loc_descr_ref l4jump, l4label; 12147 rtx msb; 12148 12149 if (GET_MODE_CLASS (mode) != MODE_INT 12150 || GET_MODE (XEXP (rtl, 0)) != mode) 12151 return NULL; 12152 12153 op0 = mem_loc_descriptor (XEXP (rtl, 0), mode, mem_mode, 12154 VAR_INIT_STATUS_INITIALIZED); 12155 if (op0 == NULL) 12156 return NULL; 12157 ret = op0; 12158 if (GET_CODE (rtl) == CLZ) 12159 { 12160 if (!CLZ_DEFINED_VALUE_AT_ZERO (mode, valv)) 12161 valv = GET_MODE_BITSIZE (mode); 12162 } 12163 else if (GET_CODE (rtl) == FFS) 12164 valv = 0; 12165 else if (!CTZ_DEFINED_VALUE_AT_ZERO (mode, valv)) 12166 valv = GET_MODE_BITSIZE (mode); 12167 add_loc_descr (&ret, new_loc_descr (DW_OP_dup, 0, 0)); 12168 l1jump = new_loc_descr (DW_OP_bra, 0, 0); 12169 add_loc_descr (&ret, l1jump); 12170 add_loc_descr (&ret, new_loc_descr (DW_OP_drop, 0, 0)); 12171 tmp = mem_loc_descriptor (GEN_INT (valv), mode, mem_mode, 12172 VAR_INIT_STATUS_INITIALIZED); 12173 if (tmp == NULL) 12174 return NULL; 12175 add_loc_descr (&ret, tmp); 12176 l4jump = new_loc_descr (DW_OP_skip, 0, 0); 12177 add_loc_descr (&ret, l4jump); 12178 l1label = mem_loc_descriptor (GET_CODE (rtl) == FFS 12179 ? const1_rtx : const0_rtx, 12180 mode, mem_mode, 12181 VAR_INIT_STATUS_INITIALIZED); 12182 if (l1label == NULL) 12183 return NULL; 12184 add_loc_descr (&ret, l1label); 12185 add_loc_descr (&ret, new_loc_descr (DW_OP_swap, 0, 0)); 12186 l2label = new_loc_descr (DW_OP_dup, 0, 0); 12187 add_loc_descr (&ret, l2label); 12188 if (GET_CODE (rtl) != CLZ) 12189 msb = const1_rtx; 12190 else if (GET_MODE_BITSIZE (mode) <= HOST_BITS_PER_WIDE_INT) 12191 msb = GEN_INT ((unsigned HOST_WIDE_INT) 1 12192 << (GET_MODE_BITSIZE (mode) - 1)); 12193 else 12194 msb = immed_wide_int_const 12195 (wi::set_bit_in_zero (GET_MODE_PRECISION (mode) - 1, 12196 GET_MODE_PRECISION (mode)), mode); 12197 if (GET_CODE (msb) == CONST_INT && INTVAL (msb) < 0) 12198 tmp = new_loc_descr (HOST_BITS_PER_WIDE_INT == 32 12199 ? DW_OP_const4u : HOST_BITS_PER_WIDE_INT == 64 12200 ? DW_OP_const8u : DW_OP_constu, INTVAL (msb), 0); 12201 else 12202 tmp = mem_loc_descriptor (msb, mode, mem_mode, 12203 VAR_INIT_STATUS_INITIALIZED); 12204 if (tmp == NULL) 12205 return NULL; 12206 add_loc_descr (&ret, tmp); 12207 add_loc_descr (&ret, new_loc_descr (DW_OP_and, 0, 0)); 12208 l3jump = new_loc_descr (DW_OP_bra, 0, 0); 12209 add_loc_descr (&ret, l3jump); 12210 tmp = mem_loc_descriptor (const1_rtx, mode, mem_mode, 12211 VAR_INIT_STATUS_INITIALIZED); 12212 if (tmp == NULL) 12213 return NULL; 12214 add_loc_descr (&ret, tmp); 12215 add_loc_descr (&ret, new_loc_descr (GET_CODE (rtl) == CLZ 12216 ? DW_OP_shl : DW_OP_shr, 0, 0)); 12217 add_loc_descr (&ret, new_loc_descr (DW_OP_swap, 0, 0)); 12218 add_loc_descr (&ret, new_loc_descr (DW_OP_plus_uconst, 1, 0)); 12219 add_loc_descr (&ret, new_loc_descr (DW_OP_swap, 0, 0)); 12220 l2jump = new_loc_descr (DW_OP_skip, 0, 0); 12221 add_loc_descr (&ret, l2jump); 12222 l3label = new_loc_descr (DW_OP_drop, 0, 0); 12223 add_loc_descr (&ret, l3label); 12224 l4label = new_loc_descr (DW_OP_nop, 0, 0); 12225 add_loc_descr (&ret, l4label); 12226 l1jump->dw_loc_oprnd1.val_class = dw_val_class_loc; 12227 l1jump->dw_loc_oprnd1.v.val_loc = l1label; 12228 l2jump->dw_loc_oprnd1.val_class = dw_val_class_loc; 12229 l2jump->dw_loc_oprnd1.v.val_loc = l2label; 12230 l3jump->dw_loc_oprnd1.val_class = dw_val_class_loc; 12231 l3jump->dw_loc_oprnd1.v.val_loc = l3label; 12232 l4jump->dw_loc_oprnd1.val_class = dw_val_class_loc; 12233 l4jump->dw_loc_oprnd1.v.val_loc = l4label; 12234 return ret; 12235} 12236 12237/* POPCOUNT (const0 is DW_OP_lit0 or corresponding typed constant, 12238 const1 is DW_OP_lit1 or corresponding typed constant): 12239 const0 DW_OP_swap 12240 L1: DW_OP_dup DW_OP_bra <L2> DW_OP_dup DW_OP_rot const1 DW_OP_and 12241 DW_OP_plus DW_OP_swap const1 DW_OP_shr DW_OP_skip <L1> 12242 L2: DW_OP_drop 12243 12244 PARITY is similar: 12245 L1: DW_OP_dup DW_OP_bra <L2> DW_OP_dup DW_OP_rot const1 DW_OP_and 12246 DW_OP_xor DW_OP_swap const1 DW_OP_shr DW_OP_skip <L1> 12247 L2: DW_OP_drop */ 12248 12249static dw_loc_descr_ref 12250popcount_loc_descriptor (rtx rtl, machine_mode mode, 12251 machine_mode mem_mode) 12252{ 12253 dw_loc_descr_ref op0, ret, tmp; 12254 dw_loc_descr_ref l1jump, l1label; 12255 dw_loc_descr_ref l2jump, l2label; 12256 12257 if (GET_MODE_CLASS (mode) != MODE_INT 12258 || GET_MODE (XEXP (rtl, 0)) != mode) 12259 return NULL; 12260 12261 op0 = mem_loc_descriptor (XEXP (rtl, 0), mode, mem_mode, 12262 VAR_INIT_STATUS_INITIALIZED); 12263 if (op0 == NULL) 12264 return NULL; 12265 ret = op0; 12266 tmp = mem_loc_descriptor (const0_rtx, mode, mem_mode, 12267 VAR_INIT_STATUS_INITIALIZED); 12268 if (tmp == NULL) 12269 return NULL; 12270 add_loc_descr (&ret, tmp); 12271 add_loc_descr (&ret, new_loc_descr (DW_OP_swap, 0, 0)); 12272 l1label = new_loc_descr (DW_OP_dup, 0, 0); 12273 add_loc_descr (&ret, l1label); 12274 l2jump = new_loc_descr (DW_OP_bra, 0, 0); 12275 add_loc_descr (&ret, l2jump); 12276 add_loc_descr (&ret, new_loc_descr (DW_OP_dup, 0, 0)); 12277 add_loc_descr (&ret, new_loc_descr (DW_OP_rot, 0, 0)); 12278 tmp = mem_loc_descriptor (const1_rtx, mode, mem_mode, 12279 VAR_INIT_STATUS_INITIALIZED); 12280 if (tmp == NULL) 12281 return NULL; 12282 add_loc_descr (&ret, tmp); 12283 add_loc_descr (&ret, new_loc_descr (DW_OP_and, 0, 0)); 12284 add_loc_descr (&ret, new_loc_descr (GET_CODE (rtl) == POPCOUNT 12285 ? DW_OP_plus : DW_OP_xor, 0, 0)); 12286 add_loc_descr (&ret, new_loc_descr (DW_OP_swap, 0, 0)); 12287 tmp = mem_loc_descriptor (const1_rtx, mode, mem_mode, 12288 VAR_INIT_STATUS_INITIALIZED); 12289 add_loc_descr (&ret, tmp); 12290 add_loc_descr (&ret, new_loc_descr (DW_OP_shr, 0, 0)); 12291 l1jump = new_loc_descr (DW_OP_skip, 0, 0); 12292 add_loc_descr (&ret, l1jump); 12293 l2label = new_loc_descr (DW_OP_drop, 0, 0); 12294 add_loc_descr (&ret, l2label); 12295 l1jump->dw_loc_oprnd1.val_class = dw_val_class_loc; 12296 l1jump->dw_loc_oprnd1.v.val_loc = l1label; 12297 l2jump->dw_loc_oprnd1.val_class = dw_val_class_loc; 12298 l2jump->dw_loc_oprnd1.v.val_loc = l2label; 12299 return ret; 12300} 12301 12302/* BSWAP (constS is initial shift count, either 56 or 24): 12303 constS const0 12304 L1: DW_OP_pick <2> constS DW_OP_pick <3> DW_OP_minus DW_OP_shr 12305 const255 DW_OP_and DW_OP_pick <2> DW_OP_shl DW_OP_or 12306 DW_OP_swap DW_OP_dup const0 DW_OP_eq DW_OP_bra <L2> const8 12307 DW_OP_minus DW_OP_swap DW_OP_skip <L1> 12308 L2: DW_OP_drop DW_OP_swap DW_OP_drop */ 12309 12310static dw_loc_descr_ref 12311bswap_loc_descriptor (rtx rtl, machine_mode mode, 12312 machine_mode mem_mode) 12313{ 12314 dw_loc_descr_ref op0, ret, tmp; 12315 dw_loc_descr_ref l1jump, l1label; 12316 dw_loc_descr_ref l2jump, l2label; 12317 12318 if (GET_MODE_CLASS (mode) != MODE_INT 12319 || BITS_PER_UNIT != 8 12320 || (GET_MODE_BITSIZE (mode) != 32 12321 && GET_MODE_BITSIZE (mode) != 64)) 12322 return NULL; 12323 12324 op0 = mem_loc_descriptor (XEXP (rtl, 0), mode, mem_mode, 12325 VAR_INIT_STATUS_INITIALIZED); 12326 if (op0 == NULL) 12327 return NULL; 12328 12329 ret = op0; 12330 tmp = mem_loc_descriptor (GEN_INT (GET_MODE_BITSIZE (mode) - 8), 12331 mode, mem_mode, 12332 VAR_INIT_STATUS_INITIALIZED); 12333 if (tmp == NULL) 12334 return NULL; 12335 add_loc_descr (&ret, tmp); 12336 tmp = mem_loc_descriptor (const0_rtx, mode, mem_mode, 12337 VAR_INIT_STATUS_INITIALIZED); 12338 if (tmp == NULL) 12339 return NULL; 12340 add_loc_descr (&ret, tmp); 12341 l1label = new_loc_descr (DW_OP_pick, 2, 0); 12342 add_loc_descr (&ret, l1label); 12343 tmp = mem_loc_descriptor (GEN_INT (GET_MODE_BITSIZE (mode) - 8), 12344 mode, mem_mode, 12345 VAR_INIT_STATUS_INITIALIZED); 12346 add_loc_descr (&ret, tmp); 12347 add_loc_descr (&ret, new_loc_descr (DW_OP_pick, 3, 0)); 12348 add_loc_descr (&ret, new_loc_descr (DW_OP_minus, 0, 0)); 12349 add_loc_descr (&ret, new_loc_descr (DW_OP_shr, 0, 0)); 12350 tmp = mem_loc_descriptor (GEN_INT (255), mode, mem_mode, 12351 VAR_INIT_STATUS_INITIALIZED); 12352 if (tmp == NULL) 12353 return NULL; 12354 add_loc_descr (&ret, tmp); 12355 add_loc_descr (&ret, new_loc_descr (DW_OP_and, 0, 0)); 12356 add_loc_descr (&ret, new_loc_descr (DW_OP_pick, 2, 0)); 12357 add_loc_descr (&ret, new_loc_descr (DW_OP_shl, 0, 0)); 12358 add_loc_descr (&ret, new_loc_descr (DW_OP_or, 0, 0)); 12359 add_loc_descr (&ret, new_loc_descr (DW_OP_swap, 0, 0)); 12360 add_loc_descr (&ret, new_loc_descr (DW_OP_dup, 0, 0)); 12361 tmp = mem_loc_descriptor (const0_rtx, mode, mem_mode, 12362 VAR_INIT_STATUS_INITIALIZED); 12363 add_loc_descr (&ret, tmp); 12364 add_loc_descr (&ret, new_loc_descr (DW_OP_eq, 0, 0)); 12365 l2jump = new_loc_descr (DW_OP_bra, 0, 0); 12366 add_loc_descr (&ret, l2jump); 12367 tmp = mem_loc_descriptor (GEN_INT (8), mode, mem_mode, 12368 VAR_INIT_STATUS_INITIALIZED); 12369 add_loc_descr (&ret, tmp); 12370 add_loc_descr (&ret, new_loc_descr (DW_OP_minus, 0, 0)); 12371 add_loc_descr (&ret, new_loc_descr (DW_OP_swap, 0, 0)); 12372 l1jump = new_loc_descr (DW_OP_skip, 0, 0); 12373 add_loc_descr (&ret, l1jump); 12374 l2label = new_loc_descr (DW_OP_drop, 0, 0); 12375 add_loc_descr (&ret, l2label); 12376 add_loc_descr (&ret, new_loc_descr (DW_OP_swap, 0, 0)); 12377 add_loc_descr (&ret, new_loc_descr (DW_OP_drop, 0, 0)); 12378 l1jump->dw_loc_oprnd1.val_class = dw_val_class_loc; 12379 l1jump->dw_loc_oprnd1.v.val_loc = l1label; 12380 l2jump->dw_loc_oprnd1.val_class = dw_val_class_loc; 12381 l2jump->dw_loc_oprnd1.v.val_loc = l2label; 12382 return ret; 12383} 12384 12385/* ROTATE (constMASK is mode mask, BITSIZE is bitsize of mode): 12386 DW_OP_over DW_OP_over DW_OP_shl [ constMASK DW_OP_and ] DW_OP_rot 12387 [ DW_OP_swap constMASK DW_OP_and DW_OP_swap ] DW_OP_neg 12388 DW_OP_plus_uconst <BITSIZE> DW_OP_shr DW_OP_or 12389 12390 ROTATERT is similar: 12391 DW_OP_over DW_OP_over DW_OP_neg DW_OP_plus_uconst <BITSIZE> 12392 DW_OP_shl [ constMASK DW_OP_and ] DW_OP_rot 12393 [ DW_OP_swap constMASK DW_OP_and DW_OP_swap ] DW_OP_shr DW_OP_or */ 12394 12395static dw_loc_descr_ref 12396rotate_loc_descriptor (rtx rtl, machine_mode mode, 12397 machine_mode mem_mode) 12398{ 12399 rtx rtlop1 = XEXP (rtl, 1); 12400 dw_loc_descr_ref op0, op1, ret, mask[2] = { NULL, NULL }; 12401 int i; 12402 12403 if (GET_MODE_CLASS (mode) != MODE_INT) 12404 return NULL; 12405 12406 if (GET_MODE (rtlop1) != VOIDmode 12407 && GET_MODE_BITSIZE (GET_MODE (rtlop1)) < GET_MODE_BITSIZE (mode)) 12408 rtlop1 = gen_rtx_ZERO_EXTEND (mode, rtlop1); 12409 op0 = mem_loc_descriptor (XEXP (rtl, 0), mode, mem_mode, 12410 VAR_INIT_STATUS_INITIALIZED); 12411 op1 = mem_loc_descriptor (rtlop1, mode, mem_mode, 12412 VAR_INIT_STATUS_INITIALIZED); 12413 if (op0 == NULL || op1 == NULL) 12414 return NULL; 12415 if (GET_MODE_SIZE (mode) < DWARF2_ADDR_SIZE) 12416 for (i = 0; i < 2; i++) 12417 { 12418 if (GET_MODE_BITSIZE (mode) < HOST_BITS_PER_WIDE_INT) 12419 mask[i] = mem_loc_descriptor (GEN_INT (GET_MODE_MASK (mode)), 12420 mode, mem_mode, 12421 VAR_INIT_STATUS_INITIALIZED); 12422 else if (GET_MODE_BITSIZE (mode) == HOST_BITS_PER_WIDE_INT) 12423 mask[i] = new_loc_descr (HOST_BITS_PER_WIDE_INT == 32 12424 ? DW_OP_const4u 12425 : HOST_BITS_PER_WIDE_INT == 64 12426 ? DW_OP_const8u : DW_OP_constu, 12427 GET_MODE_MASK (mode), 0); 12428 else 12429 mask[i] = NULL; 12430 if (mask[i] == NULL) 12431 return NULL; 12432 add_loc_descr (&mask[i], new_loc_descr (DW_OP_and, 0, 0)); 12433 } 12434 ret = op0; 12435 add_loc_descr (&ret, op1); 12436 add_loc_descr (&ret, new_loc_descr (DW_OP_over, 0, 0)); 12437 add_loc_descr (&ret, new_loc_descr (DW_OP_over, 0, 0)); 12438 if (GET_CODE (rtl) == ROTATERT) 12439 { 12440 add_loc_descr (&ret, new_loc_descr (DW_OP_neg, 0, 0)); 12441 add_loc_descr (&ret, new_loc_descr (DW_OP_plus_uconst, 12442 GET_MODE_BITSIZE (mode), 0)); 12443 } 12444 add_loc_descr (&ret, new_loc_descr (DW_OP_shl, 0, 0)); 12445 if (mask[0] != NULL) 12446 add_loc_descr (&ret, mask[0]); 12447 add_loc_descr (&ret, new_loc_descr (DW_OP_rot, 0, 0)); 12448 if (mask[1] != NULL) 12449 { 12450 add_loc_descr (&ret, new_loc_descr (DW_OP_swap, 0, 0)); 12451 add_loc_descr (&ret, mask[1]); 12452 add_loc_descr (&ret, new_loc_descr (DW_OP_swap, 0, 0)); 12453 } 12454 if (GET_CODE (rtl) == ROTATE) 12455 { 12456 add_loc_descr (&ret, new_loc_descr (DW_OP_neg, 0, 0)); 12457 add_loc_descr (&ret, new_loc_descr (DW_OP_plus_uconst, 12458 GET_MODE_BITSIZE (mode), 0)); 12459 } 12460 add_loc_descr (&ret, new_loc_descr (DW_OP_shr, 0, 0)); 12461 add_loc_descr (&ret, new_loc_descr (DW_OP_or, 0, 0)); 12462 return ret; 12463} 12464 12465/* Helper function for mem_loc_descriptor. Return DW_OP_GNU_parameter_ref 12466 for DEBUG_PARAMETER_REF RTL. */ 12467 12468static dw_loc_descr_ref 12469parameter_ref_descriptor (rtx rtl) 12470{ 12471 dw_loc_descr_ref ret; 12472 dw_die_ref ref; 12473 12474 if (dwarf_strict) 12475 return NULL; 12476 gcc_assert (TREE_CODE (DEBUG_PARAMETER_REF_DECL (rtl)) == PARM_DECL); 12477 ref = lookup_decl_die (DEBUG_PARAMETER_REF_DECL (rtl)); 12478 ret = new_loc_descr (DW_OP_GNU_parameter_ref, 0, 0); 12479 if (ref) 12480 { 12481 ret->dw_loc_oprnd1.val_class = dw_val_class_die_ref; 12482 ret->dw_loc_oprnd1.v.val_die_ref.die = ref; 12483 ret->dw_loc_oprnd1.v.val_die_ref.external = 0; 12484 } 12485 else 12486 { 12487 ret->dw_loc_oprnd1.val_class = dw_val_class_decl_ref; 12488 ret->dw_loc_oprnd1.v.val_decl_ref = DEBUG_PARAMETER_REF_DECL (rtl); 12489 } 12490 return ret; 12491} 12492 12493/* The following routine converts the RTL for a variable or parameter 12494 (resident in memory) into an equivalent Dwarf representation of a 12495 mechanism for getting the address of that same variable onto the top of a 12496 hypothetical "address evaluation" stack. 12497 12498 When creating memory location descriptors, we are effectively transforming 12499 the RTL for a memory-resident object into its Dwarf postfix expression 12500 equivalent. This routine recursively descends an RTL tree, turning 12501 it into Dwarf postfix code as it goes. 12502 12503 MODE is the mode that should be assumed for the rtl if it is VOIDmode. 12504 12505 MEM_MODE is the mode of the memory reference, needed to handle some 12506 autoincrement addressing modes. 12507 12508 Return 0 if we can't represent the location. */ 12509 12510dw_loc_descr_ref 12511mem_loc_descriptor (rtx rtl, machine_mode mode, 12512 machine_mode mem_mode, 12513 enum var_init_status initialized) 12514{ 12515 dw_loc_descr_ref mem_loc_result = NULL; 12516 enum dwarf_location_atom op; 12517 dw_loc_descr_ref op0, op1; 12518 rtx inner = NULL_RTX; 12519 12520 if (mode == VOIDmode) 12521 mode = GET_MODE (rtl); 12522 12523 /* Note that for a dynamically sized array, the location we will generate a 12524 description of here will be the lowest numbered location which is 12525 actually within the array. That's *not* necessarily the same as the 12526 zeroth element of the array. */ 12527 12528 rtl = targetm.delegitimize_address (rtl); 12529 12530 if (mode != GET_MODE (rtl) && GET_MODE (rtl) != VOIDmode) 12531 return NULL; 12532 12533 switch (GET_CODE (rtl)) 12534 { 12535 case POST_INC: 12536 case POST_DEC: 12537 case POST_MODIFY: 12538 return mem_loc_descriptor (XEXP (rtl, 0), mode, mem_mode, initialized); 12539 12540 case SUBREG: 12541 /* The case of a subreg may arise when we have a local (register) 12542 variable or a formal (register) parameter which doesn't quite fill 12543 up an entire register. For now, just assume that it is 12544 legitimate to make the Dwarf info refer to the whole register which 12545 contains the given subreg. */ 12546 if (!subreg_lowpart_p (rtl)) 12547 break; 12548 inner = SUBREG_REG (rtl); 12549 case TRUNCATE: 12550 if (inner == NULL_RTX) 12551 inner = XEXP (rtl, 0); 12552 if (GET_MODE_CLASS (mode) == MODE_INT 12553 && GET_MODE_CLASS (GET_MODE (inner)) == MODE_INT 12554 && (GET_MODE_SIZE (mode) <= DWARF2_ADDR_SIZE 12555#ifdef POINTERS_EXTEND_UNSIGNED 12556 || (mode == Pmode && mem_mode != VOIDmode) 12557#endif 12558 ) 12559 && GET_MODE_SIZE (GET_MODE (inner)) <= DWARF2_ADDR_SIZE) 12560 { 12561 mem_loc_result = mem_loc_descriptor (inner, 12562 GET_MODE (inner), 12563 mem_mode, initialized); 12564 break; 12565 } 12566 if (dwarf_strict) 12567 break; 12568 if (GET_MODE_SIZE (mode) > GET_MODE_SIZE (GET_MODE (inner))) 12569 break; 12570 if (GET_MODE_SIZE (mode) != GET_MODE_SIZE (GET_MODE (inner)) 12571 && (GET_MODE_CLASS (mode) != MODE_INT 12572 || GET_MODE_CLASS (GET_MODE (inner)) != MODE_INT)) 12573 break; 12574 else 12575 { 12576 dw_die_ref type_die; 12577 dw_loc_descr_ref cvt; 12578 12579 mem_loc_result = mem_loc_descriptor (inner, 12580 GET_MODE (inner), 12581 mem_mode, initialized); 12582 if (mem_loc_result == NULL) 12583 break; 12584 type_die = base_type_for_mode (mode, 12585 GET_MODE_CLASS (mode) == MODE_INT); 12586 if (type_die == NULL) 12587 { 12588 mem_loc_result = NULL; 12589 break; 12590 } 12591 if (GET_MODE_SIZE (mode) 12592 != GET_MODE_SIZE (GET_MODE (inner))) 12593 cvt = new_loc_descr (DW_OP_GNU_convert, 0, 0); 12594 else 12595 cvt = new_loc_descr (DW_OP_GNU_reinterpret, 0, 0); 12596 cvt->dw_loc_oprnd1.val_class = dw_val_class_die_ref; 12597 cvt->dw_loc_oprnd1.v.val_die_ref.die = type_die; 12598 cvt->dw_loc_oprnd1.v.val_die_ref.external = 0; 12599 add_loc_descr (&mem_loc_result, cvt); 12600 } 12601 break; 12602 12603 case REG: 12604 if (GET_MODE_CLASS (mode) != MODE_INT 12605 || (GET_MODE_SIZE (mode) > DWARF2_ADDR_SIZE 12606 && rtl != arg_pointer_rtx 12607 && rtl != frame_pointer_rtx 12608#ifdef POINTERS_EXTEND_UNSIGNED 12609 && (mode != Pmode || mem_mode == VOIDmode) 12610#endif 12611 )) 12612 { 12613 dw_die_ref type_die; 12614 unsigned int dbx_regnum; 12615 12616 if (dwarf_strict) 12617 break; 12618 if (REGNO (rtl) > FIRST_PSEUDO_REGISTER) 12619 break; 12620 type_die = base_type_for_mode (mode, 12621 GET_MODE_CLASS (mode) == MODE_INT); 12622 if (type_die == NULL) 12623 break; 12624 12625 dbx_regnum = dbx_reg_number (rtl); 12626 if (dbx_regnum == IGNORED_DWARF_REGNUM) 12627 break; 12628 mem_loc_result = new_loc_descr (DW_OP_GNU_regval_type, 12629 dbx_regnum, 0); 12630 mem_loc_result->dw_loc_oprnd2.val_class = dw_val_class_die_ref; 12631 mem_loc_result->dw_loc_oprnd2.v.val_die_ref.die = type_die; 12632 mem_loc_result->dw_loc_oprnd2.v.val_die_ref.external = 0; 12633 break; 12634 } 12635 /* Whenever a register number forms a part of the description of the 12636 method for calculating the (dynamic) address of a memory resident 12637 object, DWARF rules require the register number be referred to as 12638 a "base register". This distinction is not based in any way upon 12639 what category of register the hardware believes the given register 12640 belongs to. This is strictly DWARF terminology we're dealing with 12641 here. Note that in cases where the location of a memory-resident 12642 data object could be expressed as: OP_ADD (OP_BASEREG (basereg), 12643 OP_CONST (0)) the actual DWARF location descriptor that we generate 12644 may just be OP_BASEREG (basereg). This may look deceptively like 12645 the object in question was allocated to a register (rather than in 12646 memory) so DWARF consumers need to be aware of the subtle 12647 distinction between OP_REG and OP_BASEREG. */ 12648 if (REGNO (rtl) < FIRST_PSEUDO_REGISTER) 12649 mem_loc_result = based_loc_descr (rtl, 0, VAR_INIT_STATUS_INITIALIZED); 12650 else if (stack_realign_drap 12651 && crtl->drap_reg 12652 && crtl->args.internal_arg_pointer == rtl 12653 && REGNO (crtl->drap_reg) < FIRST_PSEUDO_REGISTER) 12654 { 12655 /* If RTL is internal_arg_pointer, which has been optimized 12656 out, use DRAP instead. */ 12657 mem_loc_result = based_loc_descr (crtl->drap_reg, 0, 12658 VAR_INIT_STATUS_INITIALIZED); 12659 } 12660 break; 12661 12662 case SIGN_EXTEND: 12663 case ZERO_EXTEND: 12664 if (GET_MODE_CLASS (mode) != MODE_INT) 12665 break; 12666 op0 = mem_loc_descriptor (XEXP (rtl, 0), GET_MODE (XEXP (rtl, 0)), 12667 mem_mode, VAR_INIT_STATUS_INITIALIZED); 12668 if (op0 == 0) 12669 break; 12670 else if (GET_CODE (rtl) == ZERO_EXTEND 12671 && GET_MODE_SIZE (mode) <= DWARF2_ADDR_SIZE 12672 && GET_MODE_BITSIZE (GET_MODE (XEXP (rtl, 0))) 12673 < HOST_BITS_PER_WIDE_INT 12674 /* If DW_OP_const{1,2,4}u won't be used, it is shorter 12675 to expand zero extend as two shifts instead of 12676 masking. */ 12677 && GET_MODE_SIZE (GET_MODE (XEXP (rtl, 0))) <= 4) 12678 { 12679 machine_mode imode = GET_MODE (XEXP (rtl, 0)); 12680 mem_loc_result = op0; 12681 add_loc_descr (&mem_loc_result, 12682 int_loc_descriptor (GET_MODE_MASK (imode))); 12683 add_loc_descr (&mem_loc_result, new_loc_descr (DW_OP_and, 0, 0)); 12684 } 12685 else if (GET_MODE_SIZE (mode) <= DWARF2_ADDR_SIZE) 12686 { 12687 int shift = DWARF2_ADDR_SIZE 12688 - GET_MODE_SIZE (GET_MODE (XEXP (rtl, 0))); 12689 shift *= BITS_PER_UNIT; 12690 if (GET_CODE (rtl) == SIGN_EXTEND) 12691 op = DW_OP_shra; 12692 else 12693 op = DW_OP_shr; 12694 mem_loc_result = op0; 12695 add_loc_descr (&mem_loc_result, int_loc_descriptor (shift)); 12696 add_loc_descr (&mem_loc_result, new_loc_descr (DW_OP_shl, 0, 0)); 12697 add_loc_descr (&mem_loc_result, int_loc_descriptor (shift)); 12698 add_loc_descr (&mem_loc_result, new_loc_descr (op, 0, 0)); 12699 } 12700 else if (!dwarf_strict) 12701 { 12702 dw_die_ref type_die1, type_die2; 12703 dw_loc_descr_ref cvt; 12704 12705 type_die1 = base_type_for_mode (GET_MODE (XEXP (rtl, 0)), 12706 GET_CODE (rtl) == ZERO_EXTEND); 12707 if (type_die1 == NULL) 12708 break; 12709 type_die2 = base_type_for_mode (mode, 1); 12710 if (type_die2 == NULL) 12711 break; 12712 mem_loc_result = op0; 12713 cvt = new_loc_descr (DW_OP_GNU_convert, 0, 0); 12714 cvt->dw_loc_oprnd1.val_class = dw_val_class_die_ref; 12715 cvt->dw_loc_oprnd1.v.val_die_ref.die = type_die1; 12716 cvt->dw_loc_oprnd1.v.val_die_ref.external = 0; 12717 add_loc_descr (&mem_loc_result, cvt); 12718 cvt = new_loc_descr (DW_OP_GNU_convert, 0, 0); 12719 cvt->dw_loc_oprnd1.val_class = dw_val_class_die_ref; 12720 cvt->dw_loc_oprnd1.v.val_die_ref.die = type_die2; 12721 cvt->dw_loc_oprnd1.v.val_die_ref.external = 0; 12722 add_loc_descr (&mem_loc_result, cvt); 12723 } 12724 break; 12725 12726 case MEM: 12727 { 12728 rtx new_rtl = avoid_constant_pool_reference (rtl); 12729 if (new_rtl != rtl) 12730 { 12731 mem_loc_result = mem_loc_descriptor (new_rtl, mode, mem_mode, 12732 initialized); 12733 if (mem_loc_result != NULL) 12734 return mem_loc_result; 12735 } 12736 } 12737 mem_loc_result = mem_loc_descriptor (XEXP (rtl, 0), 12738 get_address_mode (rtl), mode, 12739 VAR_INIT_STATUS_INITIALIZED); 12740 if (mem_loc_result == NULL) 12741 mem_loc_result = tls_mem_loc_descriptor (rtl); 12742 if (mem_loc_result != NULL) 12743 { 12744 if (GET_MODE_SIZE (mode) > DWARF2_ADDR_SIZE 12745 || GET_MODE_CLASS (mode) != MODE_INT) 12746 { 12747 dw_die_ref type_die; 12748 dw_loc_descr_ref deref; 12749 12750 if (dwarf_strict) 12751 return NULL; 12752 type_die 12753 = base_type_for_mode (mode, GET_MODE_CLASS (mode) == MODE_INT); 12754 if (type_die == NULL) 12755 return NULL; 12756 deref = new_loc_descr (DW_OP_GNU_deref_type, 12757 GET_MODE_SIZE (mode), 0); 12758 deref->dw_loc_oprnd2.val_class = dw_val_class_die_ref; 12759 deref->dw_loc_oprnd2.v.val_die_ref.die = type_die; 12760 deref->dw_loc_oprnd2.v.val_die_ref.external = 0; 12761 add_loc_descr (&mem_loc_result, deref); 12762 } 12763 else if (GET_MODE_SIZE (mode) == DWARF2_ADDR_SIZE) 12764 add_loc_descr (&mem_loc_result, new_loc_descr (DW_OP_deref, 0, 0)); 12765 else 12766 add_loc_descr (&mem_loc_result, 12767 new_loc_descr (DW_OP_deref_size, 12768 GET_MODE_SIZE (mode), 0)); 12769 } 12770 break; 12771 12772 case LO_SUM: 12773 return mem_loc_descriptor (XEXP (rtl, 1), mode, mem_mode, initialized); 12774 12775 case LABEL_REF: 12776 /* Some ports can transform a symbol ref into a label ref, because 12777 the symbol ref is too far away and has to be dumped into a constant 12778 pool. */ 12779 case CONST: 12780 case SYMBOL_REF: 12781 if ((GET_MODE_CLASS (mode) != MODE_INT 12782 && GET_MODE_CLASS (mode) != MODE_PARTIAL_INT) 12783 || (GET_MODE_SIZE (mode) > DWARF2_ADDR_SIZE 12784#ifdef POINTERS_EXTEND_UNSIGNED 12785 && (mode != Pmode || mem_mode == VOIDmode) 12786#endif 12787 )) 12788 break; 12789 if (GET_CODE (rtl) == SYMBOL_REF 12790 && SYMBOL_REF_TLS_MODEL (rtl) != TLS_MODEL_NONE) 12791 { 12792 dw_loc_descr_ref temp; 12793 12794 /* If this is not defined, we have no way to emit the data. */ 12795 if (!targetm.have_tls || !targetm.asm_out.output_dwarf_dtprel) 12796 break; 12797 12798 temp = new_addr_loc_descr (rtl, dtprel_true); 12799 12800 mem_loc_result = new_loc_descr (DW_OP_GNU_push_tls_address, 0, 0); 12801 add_loc_descr (&mem_loc_result, temp); 12802 12803 break; 12804 } 12805 12806 if (!const_ok_for_output (rtl)) 12807 break; 12808 12809 symref: 12810 mem_loc_result = new_addr_loc_descr (rtl, dtprel_false); 12811 vec_safe_push (used_rtx_array, rtl); 12812 break; 12813 12814 case CONCAT: 12815 case CONCATN: 12816 case VAR_LOCATION: 12817 case DEBUG_IMPLICIT_PTR: 12818 expansion_failed (NULL_TREE, rtl, 12819 "CONCAT/CONCATN/VAR_LOCATION is handled only by loc_descriptor"); 12820 return 0; 12821 12822 case ENTRY_VALUE: 12823 if (dwarf_strict) 12824 return NULL; 12825 if (REG_P (ENTRY_VALUE_EXP (rtl))) 12826 { 12827 if (GET_MODE_CLASS (mode) != MODE_INT 12828 || GET_MODE_SIZE (mode) > DWARF2_ADDR_SIZE) 12829 op0 = mem_loc_descriptor (ENTRY_VALUE_EXP (rtl), mode, 12830 VOIDmode, VAR_INIT_STATUS_INITIALIZED); 12831 else 12832 { 12833 unsigned int dbx_regnum = dbx_reg_number (ENTRY_VALUE_EXP (rtl)); 12834 if (dbx_regnum == IGNORED_DWARF_REGNUM) 12835 return NULL; 12836 op0 = one_reg_loc_descriptor (dbx_regnum, 12837 VAR_INIT_STATUS_INITIALIZED); 12838 } 12839 } 12840 else if (MEM_P (ENTRY_VALUE_EXP (rtl)) 12841 && REG_P (XEXP (ENTRY_VALUE_EXP (rtl), 0))) 12842 { 12843 op0 = mem_loc_descriptor (ENTRY_VALUE_EXP (rtl), mode, 12844 VOIDmode, VAR_INIT_STATUS_INITIALIZED); 12845 if (op0 && op0->dw_loc_opc == DW_OP_fbreg) 12846 return NULL; 12847 } 12848 else 12849 gcc_unreachable (); 12850 if (op0 == NULL) 12851 return NULL; 12852 mem_loc_result = new_loc_descr (DW_OP_GNU_entry_value, 0, 0); 12853 mem_loc_result->dw_loc_oprnd1.val_class = dw_val_class_loc; 12854 mem_loc_result->dw_loc_oprnd1.v.val_loc = op0; 12855 break; 12856 12857 case DEBUG_PARAMETER_REF: 12858 mem_loc_result = parameter_ref_descriptor (rtl); 12859 break; 12860 12861 case PRE_MODIFY: 12862 /* Extract the PLUS expression nested inside and fall into 12863 PLUS code below. */ 12864 rtl = XEXP (rtl, 1); 12865 goto plus; 12866 12867 case PRE_INC: 12868 case PRE_DEC: 12869 /* Turn these into a PLUS expression and fall into the PLUS code 12870 below. */ 12871 rtl = gen_rtx_PLUS (mode, XEXP (rtl, 0), 12872 gen_int_mode (GET_CODE (rtl) == PRE_INC 12873 ? GET_MODE_UNIT_SIZE (mem_mode) 12874 : -GET_MODE_UNIT_SIZE (mem_mode), 12875 mode)); 12876 12877 /* ... fall through ... */ 12878 12879 case PLUS: 12880 plus: 12881 if (is_based_loc (rtl) 12882 && (GET_MODE_SIZE (mode) <= DWARF2_ADDR_SIZE 12883 || XEXP (rtl, 0) == arg_pointer_rtx 12884 || XEXP (rtl, 0) == frame_pointer_rtx) 12885 && GET_MODE_CLASS (mode) == MODE_INT) 12886 mem_loc_result = based_loc_descr (XEXP (rtl, 0), 12887 INTVAL (XEXP (rtl, 1)), 12888 VAR_INIT_STATUS_INITIALIZED); 12889 else 12890 { 12891 mem_loc_result = mem_loc_descriptor (XEXP (rtl, 0), mode, mem_mode, 12892 VAR_INIT_STATUS_INITIALIZED); 12893 if (mem_loc_result == 0) 12894 break; 12895 12896 if (CONST_INT_P (XEXP (rtl, 1)) 12897 && GET_MODE_SIZE (mode) <= DWARF2_ADDR_SIZE) 12898 loc_descr_plus_const (&mem_loc_result, INTVAL (XEXP (rtl, 1))); 12899 else 12900 { 12901 op1 = mem_loc_descriptor (XEXP (rtl, 1), mode, mem_mode, 12902 VAR_INIT_STATUS_INITIALIZED); 12903 if (op1 == 0) 12904 return NULL; 12905 add_loc_descr (&mem_loc_result, op1); 12906 add_loc_descr (&mem_loc_result, 12907 new_loc_descr (DW_OP_plus, 0, 0)); 12908 } 12909 } 12910 break; 12911 12912 /* If a pseudo-reg is optimized away, it is possible for it to 12913 be replaced with a MEM containing a multiply or shift. */ 12914 case MINUS: 12915 op = DW_OP_minus; 12916 goto do_binop; 12917 12918 case MULT: 12919 op = DW_OP_mul; 12920 goto do_binop; 12921 12922 case DIV: 12923 if (!dwarf_strict 12924 && GET_MODE_CLASS (mode) == MODE_INT 12925 && GET_MODE_SIZE (mode) > DWARF2_ADDR_SIZE) 12926 { 12927 mem_loc_result = typed_binop (DW_OP_div, rtl, 12928 base_type_for_mode (mode, 0), 12929 mode, mem_mode); 12930 break; 12931 } 12932 op = DW_OP_div; 12933 goto do_binop; 12934 12935 case UMOD: 12936 op = DW_OP_mod; 12937 goto do_binop; 12938 12939 case ASHIFT: 12940 op = DW_OP_shl; 12941 goto do_shift; 12942 12943 case ASHIFTRT: 12944 op = DW_OP_shra; 12945 goto do_shift; 12946 12947 case LSHIFTRT: 12948 op = DW_OP_shr; 12949 goto do_shift; 12950 12951 do_shift: 12952 if (GET_MODE_CLASS (mode) != MODE_INT) 12953 break; 12954 op0 = mem_loc_descriptor (XEXP (rtl, 0), mode, mem_mode, 12955 VAR_INIT_STATUS_INITIALIZED); 12956 { 12957 rtx rtlop1 = XEXP (rtl, 1); 12958 if (GET_MODE (rtlop1) != VOIDmode 12959 && GET_MODE_BITSIZE (GET_MODE (rtlop1)) 12960 < GET_MODE_BITSIZE (mode)) 12961 rtlop1 = gen_rtx_ZERO_EXTEND (mode, rtlop1); 12962 op1 = mem_loc_descriptor (rtlop1, mode, mem_mode, 12963 VAR_INIT_STATUS_INITIALIZED); 12964 } 12965 12966 if (op0 == 0 || op1 == 0) 12967 break; 12968 12969 mem_loc_result = op0; 12970 add_loc_descr (&mem_loc_result, op1); 12971 add_loc_descr (&mem_loc_result, new_loc_descr (op, 0, 0)); 12972 break; 12973 12974 case AND: 12975 op = DW_OP_and; 12976 goto do_binop; 12977 12978 case IOR: 12979 op = DW_OP_or; 12980 goto do_binop; 12981 12982 case XOR: 12983 op = DW_OP_xor; 12984 goto do_binop; 12985 12986 do_binop: 12987 op0 = mem_loc_descriptor (XEXP (rtl, 0), mode, mem_mode, 12988 VAR_INIT_STATUS_INITIALIZED); 12989 op1 = mem_loc_descriptor (XEXP (rtl, 1), mode, mem_mode, 12990 VAR_INIT_STATUS_INITIALIZED); 12991 12992 if (op0 == 0 || op1 == 0) 12993 break; 12994 12995 mem_loc_result = op0; 12996 add_loc_descr (&mem_loc_result, op1); 12997 add_loc_descr (&mem_loc_result, new_loc_descr (op, 0, 0)); 12998 break; 12999 13000 case MOD: 13001 if (GET_MODE_SIZE (mode) > DWARF2_ADDR_SIZE && !dwarf_strict) 13002 { 13003 mem_loc_result = typed_binop (DW_OP_mod, rtl, 13004 base_type_for_mode (mode, 0), 13005 mode, mem_mode); 13006 break; 13007 } 13008 13009 op0 = mem_loc_descriptor (XEXP (rtl, 0), mode, mem_mode, 13010 VAR_INIT_STATUS_INITIALIZED); 13011 op1 = mem_loc_descriptor (XEXP (rtl, 1), mode, mem_mode, 13012 VAR_INIT_STATUS_INITIALIZED); 13013 13014 if (op0 == 0 || op1 == 0) 13015 break; 13016 13017 mem_loc_result = op0; 13018 add_loc_descr (&mem_loc_result, op1); 13019 add_loc_descr (&mem_loc_result, new_loc_descr (DW_OP_over, 0, 0)); 13020 add_loc_descr (&mem_loc_result, new_loc_descr (DW_OP_over, 0, 0)); 13021 add_loc_descr (&mem_loc_result, new_loc_descr (DW_OP_div, 0, 0)); 13022 add_loc_descr (&mem_loc_result, new_loc_descr (DW_OP_mul, 0, 0)); 13023 add_loc_descr (&mem_loc_result, new_loc_descr (DW_OP_minus, 0, 0)); 13024 break; 13025 13026 case UDIV: 13027 if (!dwarf_strict && GET_MODE_CLASS (mode) == MODE_INT) 13028 { 13029 if (GET_MODE_CLASS (mode) > DWARF2_ADDR_SIZE) 13030 { 13031 op = DW_OP_div; 13032 goto do_binop; 13033 } 13034 mem_loc_result = typed_binop (DW_OP_div, rtl, 13035 base_type_for_mode (mode, 1), 13036 mode, mem_mode); 13037 } 13038 break; 13039 13040 case NOT: 13041 op = DW_OP_not; 13042 goto do_unop; 13043 13044 case ABS: 13045 op = DW_OP_abs; 13046 goto do_unop; 13047 13048 case NEG: 13049 op = DW_OP_neg; 13050 goto do_unop; 13051 13052 do_unop: 13053 op0 = mem_loc_descriptor (XEXP (rtl, 0), mode, mem_mode, 13054 VAR_INIT_STATUS_INITIALIZED); 13055 13056 if (op0 == 0) 13057 break; 13058 13059 mem_loc_result = op0; 13060 add_loc_descr (&mem_loc_result, new_loc_descr (op, 0, 0)); 13061 break; 13062 13063 case CONST_INT: 13064 if (GET_MODE_SIZE (mode) <= DWARF2_ADDR_SIZE 13065#ifdef POINTERS_EXTEND_UNSIGNED 13066 || (mode == Pmode 13067 && mem_mode != VOIDmode 13068 && trunc_int_for_mode (INTVAL (rtl), ptr_mode) == INTVAL (rtl)) 13069#endif 13070 ) 13071 { 13072 mem_loc_result = int_loc_descriptor (INTVAL (rtl)); 13073 break; 13074 } 13075 if (!dwarf_strict 13076 && (GET_MODE_BITSIZE (mode) == HOST_BITS_PER_WIDE_INT 13077 || GET_MODE_BITSIZE (mode) == HOST_BITS_PER_DOUBLE_INT)) 13078 { 13079 dw_die_ref type_die = base_type_for_mode (mode, 1); 13080 machine_mode amode; 13081 if (type_die == NULL) 13082 return NULL; 13083 amode = mode_for_size (DWARF2_ADDR_SIZE * BITS_PER_UNIT, 13084 MODE_INT, 0); 13085 if (INTVAL (rtl) >= 0 13086 && amode != BLKmode 13087 && trunc_int_for_mode (INTVAL (rtl), amode) == INTVAL (rtl) 13088 /* const DW_OP_GNU_convert <XXX> vs. 13089 DW_OP_GNU_const_type <XXX, 1, const>. */ 13090 && size_of_int_loc_descriptor (INTVAL (rtl)) + 1 + 1 13091 < (unsigned long) 1 + 1 + 1 + GET_MODE_SIZE (mode)) 13092 { 13093 mem_loc_result = int_loc_descriptor (INTVAL (rtl)); 13094 op0 = new_loc_descr (DW_OP_GNU_convert, 0, 0); 13095 op0->dw_loc_oprnd1.val_class = dw_val_class_die_ref; 13096 op0->dw_loc_oprnd1.v.val_die_ref.die = type_die; 13097 op0->dw_loc_oprnd1.v.val_die_ref.external = 0; 13098 add_loc_descr (&mem_loc_result, op0); 13099 return mem_loc_result; 13100 } 13101 mem_loc_result = new_loc_descr (DW_OP_GNU_const_type, 0, 13102 INTVAL (rtl)); 13103 mem_loc_result->dw_loc_oprnd1.val_class = dw_val_class_die_ref; 13104 mem_loc_result->dw_loc_oprnd1.v.val_die_ref.die = type_die; 13105 mem_loc_result->dw_loc_oprnd1.v.val_die_ref.external = 0; 13106 if (GET_MODE_BITSIZE (mode) == HOST_BITS_PER_WIDE_INT) 13107 mem_loc_result->dw_loc_oprnd2.val_class = dw_val_class_const; 13108 else 13109 { 13110 mem_loc_result->dw_loc_oprnd2.val_class 13111 = dw_val_class_const_double; 13112 mem_loc_result->dw_loc_oprnd2.v.val_double 13113 = double_int::from_shwi (INTVAL (rtl)); 13114 } 13115 } 13116 break; 13117 13118 case CONST_DOUBLE: 13119 if (!dwarf_strict) 13120 { 13121 dw_die_ref type_die; 13122 13123 /* Note that if TARGET_SUPPORTS_WIDE_INT == 0, a 13124 CONST_DOUBLE rtx could represent either a large integer 13125 or a floating-point constant. If TARGET_SUPPORTS_WIDE_INT != 0, 13126 the value is always a floating point constant. 13127 13128 When it is an integer, a CONST_DOUBLE is used whenever 13129 the constant requires 2 HWIs to be adequately represented. 13130 We output CONST_DOUBLEs as blocks. */ 13131 if (mode == VOIDmode 13132 || (GET_MODE (rtl) == VOIDmode 13133 && GET_MODE_BITSIZE (mode) != HOST_BITS_PER_DOUBLE_INT)) 13134 break; 13135 type_die = base_type_for_mode (mode, 13136 GET_MODE_CLASS (mode) == MODE_INT); 13137 if (type_die == NULL) 13138 return NULL; 13139 mem_loc_result = new_loc_descr (DW_OP_GNU_const_type, 0, 0); 13140 mem_loc_result->dw_loc_oprnd1.val_class = dw_val_class_die_ref; 13141 mem_loc_result->dw_loc_oprnd1.v.val_die_ref.die = type_die; 13142 mem_loc_result->dw_loc_oprnd1.v.val_die_ref.external = 0; 13143#if TARGET_SUPPORTS_WIDE_INT == 0 13144 if (!SCALAR_FLOAT_MODE_P (mode)) 13145 { 13146 mem_loc_result->dw_loc_oprnd2.val_class 13147 = dw_val_class_const_double; 13148 mem_loc_result->dw_loc_oprnd2.v.val_double 13149 = rtx_to_double_int (rtl); 13150 } 13151 else 13152#endif 13153 { 13154 unsigned int length = GET_MODE_SIZE (mode); 13155 unsigned char *array = ggc_vec_alloc<unsigned char> (length); 13156 13157 insert_float (rtl, array); 13158 mem_loc_result->dw_loc_oprnd2.val_class = dw_val_class_vec; 13159 mem_loc_result->dw_loc_oprnd2.v.val_vec.length = length / 4; 13160 mem_loc_result->dw_loc_oprnd2.v.val_vec.elt_size = 4; 13161 mem_loc_result->dw_loc_oprnd2.v.val_vec.array = array; 13162 } 13163 } 13164 break; 13165 13166 case CONST_WIDE_INT: 13167 if (!dwarf_strict) 13168 { 13169 dw_die_ref type_die; 13170 13171 type_die = base_type_for_mode (mode, 13172 GET_MODE_CLASS (mode) == MODE_INT); 13173 if (type_die == NULL) 13174 return NULL; 13175 mem_loc_result = new_loc_descr (DW_OP_GNU_const_type, 0, 0); 13176 mem_loc_result->dw_loc_oprnd1.val_class = dw_val_class_die_ref; 13177 mem_loc_result->dw_loc_oprnd1.v.val_die_ref.die = type_die; 13178 mem_loc_result->dw_loc_oprnd1.v.val_die_ref.external = 0; 13179 mem_loc_result->dw_loc_oprnd2.val_class 13180 = dw_val_class_wide_int; 13181 mem_loc_result->dw_loc_oprnd2.v.val_wide = ggc_alloc<wide_int> (); 13182 *mem_loc_result->dw_loc_oprnd2.v.val_wide = std::make_pair (rtl, mode); 13183 } 13184 break; 13185 13186 case EQ: 13187 mem_loc_result = scompare_loc_descriptor (DW_OP_eq, rtl, mem_mode); 13188 break; 13189 13190 case GE: 13191 mem_loc_result = scompare_loc_descriptor (DW_OP_ge, rtl, mem_mode); 13192 break; 13193 13194 case GT: 13195 mem_loc_result = scompare_loc_descriptor (DW_OP_gt, rtl, mem_mode); 13196 break; 13197 13198 case LE: 13199 mem_loc_result = scompare_loc_descriptor (DW_OP_le, rtl, mem_mode); 13200 break; 13201 13202 case LT: 13203 mem_loc_result = scompare_loc_descriptor (DW_OP_lt, rtl, mem_mode); 13204 break; 13205 13206 case NE: 13207 mem_loc_result = scompare_loc_descriptor (DW_OP_ne, rtl, mem_mode); 13208 break; 13209 13210 case GEU: 13211 mem_loc_result = ucompare_loc_descriptor (DW_OP_ge, rtl, mem_mode); 13212 break; 13213 13214 case GTU: 13215 mem_loc_result = ucompare_loc_descriptor (DW_OP_gt, rtl, mem_mode); 13216 break; 13217 13218 case LEU: 13219 mem_loc_result = ucompare_loc_descriptor (DW_OP_le, rtl, mem_mode); 13220 break; 13221 13222 case LTU: 13223 mem_loc_result = ucompare_loc_descriptor (DW_OP_lt, rtl, mem_mode); 13224 break; 13225 13226 case UMIN: 13227 case UMAX: 13228 if (GET_MODE_CLASS (mode) != MODE_INT) 13229 break; 13230 /* FALLTHRU */ 13231 case SMIN: 13232 case SMAX: 13233 mem_loc_result = minmax_loc_descriptor (rtl, mode, mem_mode); 13234 break; 13235 13236 case ZERO_EXTRACT: 13237 case SIGN_EXTRACT: 13238 if (CONST_INT_P (XEXP (rtl, 1)) 13239 && CONST_INT_P (XEXP (rtl, 2)) 13240 && ((unsigned) INTVAL (XEXP (rtl, 1)) 13241 + (unsigned) INTVAL (XEXP (rtl, 2)) 13242 <= GET_MODE_BITSIZE (mode)) 13243 && GET_MODE_CLASS (mode) == MODE_INT 13244 && GET_MODE_SIZE (mode) <= DWARF2_ADDR_SIZE 13245 && GET_MODE_SIZE (GET_MODE (XEXP (rtl, 0))) <= DWARF2_ADDR_SIZE) 13246 { 13247 int shift, size; 13248 op0 = mem_loc_descriptor (XEXP (rtl, 0), GET_MODE (XEXP (rtl, 0)), 13249 mem_mode, VAR_INIT_STATUS_INITIALIZED); 13250 if (op0 == 0) 13251 break; 13252 if (GET_CODE (rtl) == SIGN_EXTRACT) 13253 op = DW_OP_shra; 13254 else 13255 op = DW_OP_shr; 13256 mem_loc_result = op0; 13257 size = INTVAL (XEXP (rtl, 1)); 13258 shift = INTVAL (XEXP (rtl, 2)); 13259 if (BITS_BIG_ENDIAN) 13260 shift = GET_MODE_BITSIZE (GET_MODE (XEXP (rtl, 0))) 13261 - shift - size; 13262 if (shift + size != (int) DWARF2_ADDR_SIZE) 13263 { 13264 add_loc_descr (&mem_loc_result, 13265 int_loc_descriptor (DWARF2_ADDR_SIZE 13266 - shift - size)); 13267 add_loc_descr (&mem_loc_result, new_loc_descr (DW_OP_shl, 0, 0)); 13268 } 13269 if (size != (int) DWARF2_ADDR_SIZE) 13270 { 13271 add_loc_descr (&mem_loc_result, 13272 int_loc_descriptor (DWARF2_ADDR_SIZE - size)); 13273 add_loc_descr (&mem_loc_result, new_loc_descr (op, 0, 0)); 13274 } 13275 } 13276 break; 13277 13278 case IF_THEN_ELSE: 13279 { 13280 dw_loc_descr_ref op2, bra_node, drop_node; 13281 op0 = mem_loc_descriptor (XEXP (rtl, 0), 13282 GET_MODE (XEXP (rtl, 0)) == VOIDmode 13283 ? word_mode : GET_MODE (XEXP (rtl, 0)), 13284 mem_mode, VAR_INIT_STATUS_INITIALIZED); 13285 op1 = mem_loc_descriptor (XEXP (rtl, 1), mode, mem_mode, 13286 VAR_INIT_STATUS_INITIALIZED); 13287 op2 = mem_loc_descriptor (XEXP (rtl, 2), mode, mem_mode, 13288 VAR_INIT_STATUS_INITIALIZED); 13289 if (op0 == NULL || op1 == NULL || op2 == NULL) 13290 break; 13291 13292 mem_loc_result = op1; 13293 add_loc_descr (&mem_loc_result, op2); 13294 add_loc_descr (&mem_loc_result, op0); 13295 bra_node = new_loc_descr (DW_OP_bra, 0, 0); 13296 add_loc_descr (&mem_loc_result, bra_node); 13297 add_loc_descr (&mem_loc_result, new_loc_descr (DW_OP_swap, 0, 0)); 13298 drop_node = new_loc_descr (DW_OP_drop, 0, 0); 13299 add_loc_descr (&mem_loc_result, drop_node); 13300 bra_node->dw_loc_oprnd1.val_class = dw_val_class_loc; 13301 bra_node->dw_loc_oprnd1.v.val_loc = drop_node; 13302 } 13303 break; 13304 13305 case FLOAT_EXTEND: 13306 case FLOAT_TRUNCATE: 13307 case FLOAT: 13308 case UNSIGNED_FLOAT: 13309 case FIX: 13310 case UNSIGNED_FIX: 13311 if (!dwarf_strict) 13312 { 13313 dw_die_ref type_die; 13314 dw_loc_descr_ref cvt; 13315 13316 op0 = mem_loc_descriptor (XEXP (rtl, 0), GET_MODE (XEXP (rtl, 0)), 13317 mem_mode, VAR_INIT_STATUS_INITIALIZED); 13318 if (op0 == NULL) 13319 break; 13320 if (GET_MODE_CLASS (GET_MODE (XEXP (rtl, 0))) == MODE_INT 13321 && (GET_CODE (rtl) == FLOAT 13322 || GET_MODE_SIZE (GET_MODE (XEXP (rtl, 0))) 13323 <= DWARF2_ADDR_SIZE)) 13324 { 13325 type_die = base_type_for_mode (GET_MODE (XEXP (rtl, 0)), 13326 GET_CODE (rtl) == UNSIGNED_FLOAT); 13327 if (type_die == NULL) 13328 break; 13329 cvt = new_loc_descr (DW_OP_GNU_convert, 0, 0); 13330 cvt->dw_loc_oprnd1.val_class = dw_val_class_die_ref; 13331 cvt->dw_loc_oprnd1.v.val_die_ref.die = type_die; 13332 cvt->dw_loc_oprnd1.v.val_die_ref.external = 0; 13333 add_loc_descr (&op0, cvt); 13334 } 13335 type_die = base_type_for_mode (mode, GET_CODE (rtl) == UNSIGNED_FIX); 13336 if (type_die == NULL) 13337 break; 13338 cvt = new_loc_descr (DW_OP_GNU_convert, 0, 0); 13339 cvt->dw_loc_oprnd1.val_class = dw_val_class_die_ref; 13340 cvt->dw_loc_oprnd1.v.val_die_ref.die = type_die; 13341 cvt->dw_loc_oprnd1.v.val_die_ref.external = 0; 13342 add_loc_descr (&op0, cvt); 13343 if (GET_MODE_CLASS (mode) == MODE_INT 13344 && (GET_CODE (rtl) == FIX 13345 || GET_MODE_SIZE (mode) < DWARF2_ADDR_SIZE)) 13346 { 13347 op0 = convert_descriptor_to_mode (mode, op0); 13348 if (op0 == NULL) 13349 break; 13350 } 13351 mem_loc_result = op0; 13352 } 13353 break; 13354 13355 case CLZ: 13356 case CTZ: 13357 case FFS: 13358 mem_loc_result = clz_loc_descriptor (rtl, mode, mem_mode); 13359 break; 13360 13361 case POPCOUNT: 13362 case PARITY: 13363 mem_loc_result = popcount_loc_descriptor (rtl, mode, mem_mode); 13364 break; 13365 13366 case BSWAP: 13367 mem_loc_result = bswap_loc_descriptor (rtl, mode, mem_mode); 13368 break; 13369 13370 case ROTATE: 13371 case ROTATERT: 13372 mem_loc_result = rotate_loc_descriptor (rtl, mode, mem_mode); 13373 break; 13374 13375 case COMPARE: 13376 /* In theory, we could implement the above. */ 13377 /* DWARF cannot represent the unsigned compare operations 13378 natively. */ 13379 case SS_MULT: 13380 case US_MULT: 13381 case SS_DIV: 13382 case US_DIV: 13383 case SS_PLUS: 13384 case US_PLUS: 13385 case SS_MINUS: 13386 case US_MINUS: 13387 case SS_NEG: 13388 case US_NEG: 13389 case SS_ABS: 13390 case SS_ASHIFT: 13391 case US_ASHIFT: 13392 case SS_TRUNCATE: 13393 case US_TRUNCATE: 13394 case UNORDERED: 13395 case ORDERED: 13396 case UNEQ: 13397 case UNGE: 13398 case UNGT: 13399 case UNLE: 13400 case UNLT: 13401 case LTGT: 13402 case FRACT_CONVERT: 13403 case UNSIGNED_FRACT_CONVERT: 13404 case SAT_FRACT: 13405 case UNSIGNED_SAT_FRACT: 13406 case SQRT: 13407 case ASM_OPERANDS: 13408 case VEC_MERGE: 13409 case VEC_SELECT: 13410 case VEC_CONCAT: 13411 case VEC_DUPLICATE: 13412 case UNSPEC: 13413 case HIGH: 13414 case FMA: 13415 case STRICT_LOW_PART: 13416 case CONST_VECTOR: 13417 case CONST_FIXED: 13418 case CLRSB: 13419 case CLOBBER: 13420 /* If delegitimize_address couldn't do anything with the UNSPEC, we 13421 can't express it in the debug info. This can happen e.g. with some 13422 TLS UNSPECs. */ 13423 break; 13424 13425 case CONST_STRING: 13426 resolve_one_addr (&rtl); 13427 goto symref; 13428 13429 default: 13430#ifdef ENABLE_CHECKING 13431 print_rtl (stderr, rtl); 13432 gcc_unreachable (); 13433#else 13434 break; 13435#endif 13436 } 13437 13438 if (mem_loc_result && initialized == VAR_INIT_STATUS_UNINITIALIZED) 13439 add_loc_descr (&mem_loc_result, new_loc_descr (DW_OP_GNU_uninit, 0, 0)); 13440 13441 return mem_loc_result; 13442} 13443 13444/* Return a descriptor that describes the concatenation of two locations. 13445 This is typically a complex variable. */ 13446 13447static dw_loc_descr_ref 13448concat_loc_descriptor (rtx x0, rtx x1, enum var_init_status initialized) 13449{ 13450 dw_loc_descr_ref cc_loc_result = NULL; 13451 dw_loc_descr_ref x0_ref 13452 = loc_descriptor (x0, VOIDmode, VAR_INIT_STATUS_INITIALIZED); 13453 dw_loc_descr_ref x1_ref 13454 = loc_descriptor (x1, VOIDmode, VAR_INIT_STATUS_INITIALIZED); 13455 13456 if (x0_ref == 0 || x1_ref == 0) 13457 return 0; 13458 13459 cc_loc_result = x0_ref; 13460 add_loc_descr_op_piece (&cc_loc_result, GET_MODE_SIZE (GET_MODE (x0))); 13461 13462 add_loc_descr (&cc_loc_result, x1_ref); 13463 add_loc_descr_op_piece (&cc_loc_result, GET_MODE_SIZE (GET_MODE (x1))); 13464 13465 if (initialized == VAR_INIT_STATUS_UNINITIALIZED) 13466 add_loc_descr (&cc_loc_result, new_loc_descr (DW_OP_GNU_uninit, 0, 0)); 13467 13468 return cc_loc_result; 13469} 13470 13471/* Return a descriptor that describes the concatenation of N 13472 locations. */ 13473 13474static dw_loc_descr_ref 13475concatn_loc_descriptor (rtx concatn, enum var_init_status initialized) 13476{ 13477 unsigned int i; 13478 dw_loc_descr_ref cc_loc_result = NULL; 13479 unsigned int n = XVECLEN (concatn, 0); 13480 13481 for (i = 0; i < n; ++i) 13482 { 13483 dw_loc_descr_ref ref; 13484 rtx x = XVECEXP (concatn, 0, i); 13485 13486 ref = loc_descriptor (x, VOIDmode, VAR_INIT_STATUS_INITIALIZED); 13487 if (ref == NULL) 13488 return NULL; 13489 13490 add_loc_descr (&cc_loc_result, ref); 13491 add_loc_descr_op_piece (&cc_loc_result, GET_MODE_SIZE (GET_MODE (x))); 13492 } 13493 13494 if (cc_loc_result && initialized == VAR_INIT_STATUS_UNINITIALIZED) 13495 add_loc_descr (&cc_loc_result, new_loc_descr (DW_OP_GNU_uninit, 0, 0)); 13496 13497 return cc_loc_result; 13498} 13499 13500/* Helper function for loc_descriptor. Return DW_OP_GNU_implicit_pointer 13501 for DEBUG_IMPLICIT_PTR RTL. */ 13502 13503static dw_loc_descr_ref 13504implicit_ptr_descriptor (rtx rtl, HOST_WIDE_INT offset) 13505{ 13506 dw_loc_descr_ref ret; 13507 dw_die_ref ref; 13508 13509 if (dwarf_strict) 13510 return NULL; 13511 gcc_assert (TREE_CODE (DEBUG_IMPLICIT_PTR_DECL (rtl)) == VAR_DECL 13512 || TREE_CODE (DEBUG_IMPLICIT_PTR_DECL (rtl)) == PARM_DECL 13513 || TREE_CODE (DEBUG_IMPLICIT_PTR_DECL (rtl)) == RESULT_DECL); 13514 ref = lookup_decl_die (DEBUG_IMPLICIT_PTR_DECL (rtl)); 13515 ret = new_loc_descr (DW_OP_GNU_implicit_pointer, 0, offset); 13516 ret->dw_loc_oprnd2.val_class = dw_val_class_const; 13517 if (ref) 13518 { 13519 ret->dw_loc_oprnd1.val_class = dw_val_class_die_ref; 13520 ret->dw_loc_oprnd1.v.val_die_ref.die = ref; 13521 ret->dw_loc_oprnd1.v.val_die_ref.external = 0; 13522 } 13523 else 13524 { 13525 ret->dw_loc_oprnd1.val_class = dw_val_class_decl_ref; 13526 ret->dw_loc_oprnd1.v.val_decl_ref = DEBUG_IMPLICIT_PTR_DECL (rtl); 13527 } 13528 return ret; 13529} 13530 13531/* Output a proper Dwarf location descriptor for a variable or parameter 13532 which is either allocated in a register or in a memory location. For a 13533 register, we just generate an OP_REG and the register number. For a 13534 memory location we provide a Dwarf postfix expression describing how to 13535 generate the (dynamic) address of the object onto the address stack. 13536 13537 MODE is mode of the decl if this loc_descriptor is going to be used in 13538 .debug_loc section where DW_OP_stack_value and DW_OP_implicit_value are 13539 allowed, VOIDmode otherwise. 13540 13541 If we don't know how to describe it, return 0. */ 13542 13543static dw_loc_descr_ref 13544loc_descriptor (rtx rtl, machine_mode mode, 13545 enum var_init_status initialized) 13546{ 13547 dw_loc_descr_ref loc_result = NULL; 13548 13549 switch (GET_CODE (rtl)) 13550 { 13551 case SUBREG: 13552 /* The case of a subreg may arise when we have a local (register) 13553 variable or a formal (register) parameter which doesn't quite fill 13554 up an entire register. For now, just assume that it is 13555 legitimate to make the Dwarf info refer to the whole register which 13556 contains the given subreg. */ 13557 if (REG_P (SUBREG_REG (rtl)) && subreg_lowpart_p (rtl)) 13558 loc_result = loc_descriptor (SUBREG_REG (rtl), 13559 GET_MODE (SUBREG_REG (rtl)), initialized); 13560 else 13561 goto do_default; 13562 break; 13563 13564 case REG: 13565 loc_result = reg_loc_descriptor (rtl, initialized); 13566 break; 13567 13568 case MEM: 13569 loc_result = mem_loc_descriptor (XEXP (rtl, 0), get_address_mode (rtl), 13570 GET_MODE (rtl), initialized); 13571 if (loc_result == NULL) 13572 loc_result = tls_mem_loc_descriptor (rtl); 13573 if (loc_result == NULL) 13574 { 13575 rtx new_rtl = avoid_constant_pool_reference (rtl); 13576 if (new_rtl != rtl) 13577 loc_result = loc_descriptor (new_rtl, mode, initialized); 13578 } 13579 break; 13580 13581 case CONCAT: 13582 loc_result = concat_loc_descriptor (XEXP (rtl, 0), XEXP (rtl, 1), 13583 initialized); 13584 break; 13585 13586 case CONCATN: 13587 loc_result = concatn_loc_descriptor (rtl, initialized); 13588 break; 13589 13590 case VAR_LOCATION: 13591 /* Single part. */ 13592 if (GET_CODE (PAT_VAR_LOCATION_LOC (rtl)) != PARALLEL) 13593 { 13594 rtx loc = PAT_VAR_LOCATION_LOC (rtl); 13595 if (GET_CODE (loc) == EXPR_LIST) 13596 loc = XEXP (loc, 0); 13597 loc_result = loc_descriptor (loc, mode, initialized); 13598 break; 13599 } 13600 13601 rtl = XEXP (rtl, 1); 13602 /* FALLTHRU */ 13603 13604 case PARALLEL: 13605 { 13606 rtvec par_elems = XVEC (rtl, 0); 13607 int num_elem = GET_NUM_ELEM (par_elems); 13608 machine_mode mode; 13609 int i; 13610 13611 /* Create the first one, so we have something to add to. */ 13612 loc_result = loc_descriptor (XEXP (RTVEC_ELT (par_elems, 0), 0), 13613 VOIDmode, initialized); 13614 if (loc_result == NULL) 13615 return NULL; 13616 mode = GET_MODE (XEXP (RTVEC_ELT (par_elems, 0), 0)); 13617 add_loc_descr_op_piece (&loc_result, GET_MODE_SIZE (mode)); 13618 for (i = 1; i < num_elem; i++) 13619 { 13620 dw_loc_descr_ref temp; 13621 13622 temp = loc_descriptor (XEXP (RTVEC_ELT (par_elems, i), 0), 13623 VOIDmode, initialized); 13624 if (temp == NULL) 13625 return NULL; 13626 add_loc_descr (&loc_result, temp); 13627 mode = GET_MODE (XEXP (RTVEC_ELT (par_elems, i), 0)); 13628 add_loc_descr_op_piece (&loc_result, GET_MODE_SIZE (mode)); 13629 } 13630 } 13631 break; 13632 13633 case CONST_INT: 13634 if (mode != VOIDmode && mode != BLKmode) 13635 loc_result = address_of_int_loc_descriptor (GET_MODE_SIZE (mode), 13636 INTVAL (rtl)); 13637 break; 13638 13639 case CONST_DOUBLE: 13640 if (mode == VOIDmode) 13641 mode = GET_MODE (rtl); 13642 13643 if (mode != VOIDmode && (dwarf_version >= 4 || !dwarf_strict)) 13644 { 13645 gcc_assert (mode == GET_MODE (rtl) || VOIDmode == GET_MODE (rtl)); 13646 13647 /* Note that a CONST_DOUBLE rtx could represent either an integer 13648 or a floating-point constant. A CONST_DOUBLE is used whenever 13649 the constant requires more than one word in order to be 13650 adequately represented. We output CONST_DOUBLEs as blocks. */ 13651 loc_result = new_loc_descr (DW_OP_implicit_value, 13652 GET_MODE_SIZE (mode), 0); 13653#if TARGET_SUPPORTS_WIDE_INT == 0 13654 if (!SCALAR_FLOAT_MODE_P (mode)) 13655 { 13656 loc_result->dw_loc_oprnd2.val_class = dw_val_class_const_double; 13657 loc_result->dw_loc_oprnd2.v.val_double 13658 = rtx_to_double_int (rtl); 13659 } 13660 else 13661#endif 13662 { 13663 unsigned int length = GET_MODE_SIZE (mode); 13664 unsigned char *array = ggc_vec_alloc<unsigned char> (length); 13665 13666 insert_float (rtl, array); 13667 loc_result->dw_loc_oprnd2.val_class = dw_val_class_vec; 13668 loc_result->dw_loc_oprnd2.v.val_vec.length = length / 4; 13669 loc_result->dw_loc_oprnd2.v.val_vec.elt_size = 4; 13670 loc_result->dw_loc_oprnd2.v.val_vec.array = array; 13671 } 13672 } 13673 break; 13674 13675 case CONST_WIDE_INT: 13676 if (mode == VOIDmode) 13677 mode = GET_MODE (rtl); 13678 13679 if (mode != VOIDmode && (dwarf_version >= 4 || !dwarf_strict)) 13680 { 13681 loc_result = new_loc_descr (DW_OP_implicit_value, 13682 GET_MODE_SIZE (mode), 0); 13683 loc_result->dw_loc_oprnd2.val_class = dw_val_class_wide_int; 13684 loc_result->dw_loc_oprnd2.v.val_wide = ggc_alloc<wide_int> (); 13685 *loc_result->dw_loc_oprnd2.v.val_wide = std::make_pair (rtl, mode); 13686 } 13687 break; 13688 13689 case CONST_VECTOR: 13690 if (mode == VOIDmode) 13691 mode = GET_MODE (rtl); 13692 13693 if (mode != VOIDmode && (dwarf_version >= 4 || !dwarf_strict)) 13694 { 13695 unsigned int elt_size = GET_MODE_UNIT_SIZE (GET_MODE (rtl)); 13696 unsigned int length = CONST_VECTOR_NUNITS (rtl); 13697 unsigned char *array 13698 = ggc_vec_alloc<unsigned char> (length * elt_size); 13699 unsigned int i; 13700 unsigned char *p; 13701 machine_mode imode = GET_MODE_INNER (mode); 13702 13703 gcc_assert (mode == GET_MODE (rtl) || VOIDmode == GET_MODE (rtl)); 13704 switch (GET_MODE_CLASS (mode)) 13705 { 13706 case MODE_VECTOR_INT: 13707 for (i = 0, p = array; i < length; i++, p += elt_size) 13708 { 13709 rtx elt = CONST_VECTOR_ELT (rtl, i); 13710 insert_wide_int (std::make_pair (elt, imode), p, elt_size); 13711 } 13712 break; 13713 13714 case MODE_VECTOR_FLOAT: 13715 for (i = 0, p = array; i < length; i++, p += elt_size) 13716 { 13717 rtx elt = CONST_VECTOR_ELT (rtl, i); 13718 insert_float (elt, p); 13719 } 13720 break; 13721 13722 default: 13723 gcc_unreachable (); 13724 } 13725 13726 loc_result = new_loc_descr (DW_OP_implicit_value, 13727 length * elt_size, 0); 13728 loc_result->dw_loc_oprnd2.val_class = dw_val_class_vec; 13729 loc_result->dw_loc_oprnd2.v.val_vec.length = length; 13730 loc_result->dw_loc_oprnd2.v.val_vec.elt_size = elt_size; 13731 loc_result->dw_loc_oprnd2.v.val_vec.array = array; 13732 } 13733 break; 13734 13735 case CONST: 13736 if (mode == VOIDmode 13737 || CONST_SCALAR_INT_P (XEXP (rtl, 0)) 13738 || CONST_DOUBLE_AS_FLOAT_P (XEXP (rtl, 0)) 13739 || GET_CODE (XEXP (rtl, 0)) == CONST_VECTOR) 13740 { 13741 loc_result = loc_descriptor (XEXP (rtl, 0), mode, initialized); 13742 break; 13743 } 13744 /* FALLTHROUGH */ 13745 case SYMBOL_REF: 13746 if (!const_ok_for_output (rtl)) 13747 break; 13748 case LABEL_REF: 13749 if (mode != VOIDmode && GET_MODE_SIZE (mode) == DWARF2_ADDR_SIZE 13750 && (dwarf_version >= 4 || !dwarf_strict)) 13751 { 13752 loc_result = new_addr_loc_descr (rtl, dtprel_false); 13753 add_loc_descr (&loc_result, new_loc_descr (DW_OP_stack_value, 0, 0)); 13754 vec_safe_push (used_rtx_array, rtl); 13755 } 13756 break; 13757 13758 case DEBUG_IMPLICIT_PTR: 13759 loc_result = implicit_ptr_descriptor (rtl, 0); 13760 break; 13761 13762 case PLUS: 13763 if (GET_CODE (XEXP (rtl, 0)) == DEBUG_IMPLICIT_PTR 13764 && CONST_INT_P (XEXP (rtl, 1))) 13765 { 13766 loc_result 13767 = implicit_ptr_descriptor (XEXP (rtl, 0), INTVAL (XEXP (rtl, 1))); 13768 break; 13769 } 13770 /* FALLTHRU */ 13771 do_default: 13772 default: 13773 if ((GET_MODE_CLASS (mode) == MODE_INT && GET_MODE (rtl) == mode 13774 && GET_MODE_SIZE (GET_MODE (rtl)) <= DWARF2_ADDR_SIZE 13775 && dwarf_version >= 4) 13776 || (!dwarf_strict && mode != VOIDmode && mode != BLKmode)) 13777 { 13778 /* Value expression. */ 13779 loc_result = mem_loc_descriptor (rtl, mode, VOIDmode, initialized); 13780 if (loc_result) 13781 add_loc_descr (&loc_result, 13782 new_loc_descr (DW_OP_stack_value, 0, 0)); 13783 } 13784 break; 13785 } 13786 13787 return loc_result; 13788} 13789 13790/* We need to figure out what section we should use as the base for the 13791 address ranges where a given location is valid. 13792 1. If this particular DECL has a section associated with it, use that. 13793 2. If this function has a section associated with it, use that. 13794 3. Otherwise, use the text section. 13795 XXX: If you split a variable across multiple sections, we won't notice. */ 13796 13797static const char * 13798secname_for_decl (const_tree decl) 13799{ 13800 const char *secname; 13801 13802 if (VAR_OR_FUNCTION_DECL_P (decl) 13803 && (DECL_EXTERNAL (decl) || TREE_PUBLIC (decl) || TREE_STATIC (decl)) 13804 && DECL_SECTION_NAME (decl)) 13805 secname = DECL_SECTION_NAME (decl); 13806 else if (current_function_decl && DECL_SECTION_NAME (current_function_decl)) 13807 secname = DECL_SECTION_NAME (current_function_decl); 13808 else if (cfun && in_cold_section_p) 13809 secname = crtl->subsections.cold_section_label; 13810 else 13811 secname = text_section_label; 13812 13813 return secname; 13814} 13815 13816/* Return true when DECL_BY_REFERENCE is defined and set for DECL. */ 13817 13818static bool 13819decl_by_reference_p (tree decl) 13820{ 13821 return ((TREE_CODE (decl) == PARM_DECL || TREE_CODE (decl) == RESULT_DECL 13822 || TREE_CODE (decl) == VAR_DECL) 13823 && DECL_BY_REFERENCE (decl)); 13824} 13825 13826/* Helper function for dw_loc_list. Compute proper Dwarf location descriptor 13827 for VARLOC. */ 13828 13829static dw_loc_descr_ref 13830dw_loc_list_1 (tree loc, rtx varloc, int want_address, 13831 enum var_init_status initialized) 13832{ 13833 int have_address = 0; 13834 dw_loc_descr_ref descr; 13835 machine_mode mode; 13836 13837 if (want_address != 2) 13838 { 13839 gcc_assert (GET_CODE (varloc) == VAR_LOCATION); 13840 /* Single part. */ 13841 if (GET_CODE (PAT_VAR_LOCATION_LOC (varloc)) != PARALLEL) 13842 { 13843 varloc = PAT_VAR_LOCATION_LOC (varloc); 13844 if (GET_CODE (varloc) == EXPR_LIST) 13845 varloc = XEXP (varloc, 0); 13846 mode = GET_MODE (varloc); 13847 if (MEM_P (varloc)) 13848 { 13849 rtx addr = XEXP (varloc, 0); 13850 descr = mem_loc_descriptor (addr, get_address_mode (varloc), 13851 mode, initialized); 13852 if (descr) 13853 have_address = 1; 13854 else 13855 { 13856 rtx x = avoid_constant_pool_reference (varloc); 13857 if (x != varloc) 13858 descr = mem_loc_descriptor (x, mode, VOIDmode, 13859 initialized); 13860 } 13861 } 13862 else 13863 descr = mem_loc_descriptor (varloc, mode, VOIDmode, initialized); 13864 } 13865 else 13866 return 0; 13867 } 13868 else 13869 { 13870 if (GET_CODE (varloc) == VAR_LOCATION) 13871 mode = DECL_MODE (PAT_VAR_LOCATION_DECL (varloc)); 13872 else 13873 mode = DECL_MODE (loc); 13874 descr = loc_descriptor (varloc, mode, initialized); 13875 have_address = 1; 13876 } 13877 13878 if (!descr) 13879 return 0; 13880 13881 if (want_address == 2 && !have_address 13882 && (dwarf_version >= 4 || !dwarf_strict)) 13883 { 13884 if (int_size_in_bytes (TREE_TYPE (loc)) > DWARF2_ADDR_SIZE) 13885 { 13886 expansion_failed (loc, NULL_RTX, 13887 "DWARF address size mismatch"); 13888 return 0; 13889 } 13890 add_loc_descr (&descr, new_loc_descr (DW_OP_stack_value, 0, 0)); 13891 have_address = 1; 13892 } 13893 /* Show if we can't fill the request for an address. */ 13894 if (want_address && !have_address) 13895 { 13896 expansion_failed (loc, NULL_RTX, 13897 "Want address and only have value"); 13898 return 0; 13899 } 13900 13901 /* If we've got an address and don't want one, dereference. */ 13902 if (!want_address && have_address) 13903 { 13904 HOST_WIDE_INT size = int_size_in_bytes (TREE_TYPE (loc)); 13905 enum dwarf_location_atom op; 13906 13907 if (size > DWARF2_ADDR_SIZE || size == -1) 13908 { 13909 expansion_failed (loc, NULL_RTX, 13910 "DWARF address size mismatch"); 13911 return 0; 13912 } 13913 else if (size == DWARF2_ADDR_SIZE) 13914 op = DW_OP_deref; 13915 else 13916 op = DW_OP_deref_size; 13917 13918 add_loc_descr (&descr, new_loc_descr (op, size, 0)); 13919 } 13920 13921 return descr; 13922} 13923 13924/* Create a DW_OP_piece or DW_OP_bit_piece for bitsize, or return NULL 13925 if it is not possible. */ 13926 13927static dw_loc_descr_ref 13928new_loc_descr_op_bit_piece (HOST_WIDE_INT bitsize, HOST_WIDE_INT offset) 13929{ 13930 if ((bitsize % BITS_PER_UNIT) == 0 && offset == 0) 13931 return new_loc_descr (DW_OP_piece, bitsize / BITS_PER_UNIT, 0); 13932 else if (dwarf_version >= 3 || !dwarf_strict) 13933 return new_loc_descr (DW_OP_bit_piece, bitsize, offset); 13934 else 13935 return NULL; 13936} 13937 13938/* Helper function for dw_loc_list. Compute proper Dwarf location descriptor 13939 for VAR_LOC_NOTE for variable DECL that has been optimized by SRA. */ 13940 13941static dw_loc_descr_ref 13942dw_sra_loc_expr (tree decl, rtx loc) 13943{ 13944 rtx p; 13945 unsigned HOST_WIDE_INT padsize = 0; 13946 dw_loc_descr_ref descr, *descr_tail; 13947 unsigned HOST_WIDE_INT decl_size; 13948 rtx varloc; 13949 enum var_init_status initialized; 13950 13951 if (DECL_SIZE (decl) == NULL 13952 || !tree_fits_uhwi_p (DECL_SIZE (decl))) 13953 return NULL; 13954 13955 decl_size = tree_to_uhwi (DECL_SIZE (decl)); 13956 descr = NULL; 13957 descr_tail = &descr; 13958 13959 for (p = loc; p; p = XEXP (p, 1)) 13960 { 13961 unsigned HOST_WIDE_INT bitsize = decl_piece_bitsize (p); 13962 rtx loc_note = *decl_piece_varloc_ptr (p); 13963 dw_loc_descr_ref cur_descr; 13964 dw_loc_descr_ref *tail, last = NULL; 13965 unsigned HOST_WIDE_INT opsize = 0; 13966 13967 if (loc_note == NULL_RTX 13968 || NOTE_VAR_LOCATION_LOC (loc_note) == NULL_RTX) 13969 { 13970 padsize += bitsize; 13971 continue; 13972 } 13973 initialized = NOTE_VAR_LOCATION_STATUS (loc_note); 13974 varloc = NOTE_VAR_LOCATION (loc_note); 13975 cur_descr = dw_loc_list_1 (decl, varloc, 2, initialized); 13976 if (cur_descr == NULL) 13977 { 13978 padsize += bitsize; 13979 continue; 13980 } 13981 13982 /* Check that cur_descr either doesn't use 13983 DW_OP_*piece operations, or their sum is equal 13984 to bitsize. Otherwise we can't embed it. */ 13985 for (tail = &cur_descr; *tail != NULL; 13986 tail = &(*tail)->dw_loc_next) 13987 if ((*tail)->dw_loc_opc == DW_OP_piece) 13988 { 13989 opsize += (*tail)->dw_loc_oprnd1.v.val_unsigned 13990 * BITS_PER_UNIT; 13991 last = *tail; 13992 } 13993 else if ((*tail)->dw_loc_opc == DW_OP_bit_piece) 13994 { 13995 opsize += (*tail)->dw_loc_oprnd1.v.val_unsigned; 13996 last = *tail; 13997 } 13998 13999 if (last != NULL && opsize != bitsize) 14000 { 14001 padsize += bitsize; 14002 /* Discard the current piece of the descriptor and release any 14003 addr_table entries it uses. */ 14004 remove_loc_list_addr_table_entries (cur_descr); 14005 continue; 14006 } 14007 14008 /* If there is a hole, add DW_OP_*piece after empty DWARF 14009 expression, which means that those bits are optimized out. */ 14010 if (padsize) 14011 { 14012 if (padsize > decl_size) 14013 { 14014 remove_loc_list_addr_table_entries (cur_descr); 14015 goto discard_descr; 14016 } 14017 decl_size -= padsize; 14018 *descr_tail = new_loc_descr_op_bit_piece (padsize, 0); 14019 if (*descr_tail == NULL) 14020 { 14021 remove_loc_list_addr_table_entries (cur_descr); 14022 goto discard_descr; 14023 } 14024 descr_tail = &(*descr_tail)->dw_loc_next; 14025 padsize = 0; 14026 } 14027 *descr_tail = cur_descr; 14028 descr_tail = tail; 14029 if (bitsize > decl_size) 14030 goto discard_descr; 14031 decl_size -= bitsize; 14032 if (last == NULL) 14033 { 14034 HOST_WIDE_INT offset = 0; 14035 if (GET_CODE (varloc) == VAR_LOCATION 14036 && GET_CODE (PAT_VAR_LOCATION_LOC (varloc)) != PARALLEL) 14037 { 14038 varloc = PAT_VAR_LOCATION_LOC (varloc); 14039 if (GET_CODE (varloc) == EXPR_LIST) 14040 varloc = XEXP (varloc, 0); 14041 } 14042 do 14043 { 14044 if (GET_CODE (varloc) == CONST 14045 || GET_CODE (varloc) == SIGN_EXTEND 14046 || GET_CODE (varloc) == ZERO_EXTEND) 14047 varloc = XEXP (varloc, 0); 14048 else if (GET_CODE (varloc) == SUBREG) 14049 varloc = SUBREG_REG (varloc); 14050 else 14051 break; 14052 } 14053 while (1); 14054 /* DW_OP_bit_size offset should be zero for register 14055 or implicit location descriptions and empty location 14056 descriptions, but for memory addresses needs big endian 14057 adjustment. */ 14058 if (MEM_P (varloc)) 14059 { 14060 unsigned HOST_WIDE_INT memsize 14061 = MEM_SIZE (varloc) * BITS_PER_UNIT; 14062 if (memsize != bitsize) 14063 { 14064 if (BYTES_BIG_ENDIAN != WORDS_BIG_ENDIAN 14065 && (memsize > BITS_PER_WORD || bitsize > BITS_PER_WORD)) 14066 goto discard_descr; 14067 if (memsize < bitsize) 14068 goto discard_descr; 14069 if (BITS_BIG_ENDIAN) 14070 offset = memsize - bitsize; 14071 } 14072 } 14073 14074 *descr_tail = new_loc_descr_op_bit_piece (bitsize, offset); 14075 if (*descr_tail == NULL) 14076 goto discard_descr; 14077 descr_tail = &(*descr_tail)->dw_loc_next; 14078 } 14079 } 14080 14081 /* If there were any non-empty expressions, add padding till the end of 14082 the decl. */ 14083 if (descr != NULL && decl_size != 0) 14084 { 14085 *descr_tail = new_loc_descr_op_bit_piece (decl_size, 0); 14086 if (*descr_tail == NULL) 14087 goto discard_descr; 14088 } 14089 return descr; 14090 14091discard_descr: 14092 /* Discard the descriptor and release any addr_table entries it uses. */ 14093 remove_loc_list_addr_table_entries (descr); 14094 return NULL; 14095} 14096 14097/* Return the dwarf representation of the location list LOC_LIST of 14098 DECL. WANT_ADDRESS has the same meaning as in loc_list_from_tree 14099 function. */ 14100 14101static dw_loc_list_ref 14102dw_loc_list (var_loc_list *loc_list, tree decl, int want_address) 14103{ 14104 const char *endname, *secname; 14105 rtx varloc; 14106 enum var_init_status initialized; 14107 struct var_loc_node *node; 14108 dw_loc_descr_ref descr; 14109 char label_id[MAX_ARTIFICIAL_LABEL_BYTES]; 14110 dw_loc_list_ref list = NULL; 14111 dw_loc_list_ref *listp = &list; 14112 14113 /* Now that we know what section we are using for a base, 14114 actually construct the list of locations. 14115 The first location information is what is passed to the 14116 function that creates the location list, and the remaining 14117 locations just get added on to that list. 14118 Note that we only know the start address for a location 14119 (IE location changes), so to build the range, we use 14120 the range [current location start, next location start]. 14121 This means we have to special case the last node, and generate 14122 a range of [last location start, end of function label]. */ 14123 14124 secname = secname_for_decl (decl); 14125 14126 for (node = loc_list->first; node; node = node->next) 14127 if (GET_CODE (node->loc) == EXPR_LIST 14128 || NOTE_VAR_LOCATION_LOC (node->loc) != NULL_RTX) 14129 { 14130 if (GET_CODE (node->loc) == EXPR_LIST) 14131 { 14132 /* This requires DW_OP_{,bit_}piece, which is not usable 14133 inside DWARF expressions. */ 14134 if (want_address != 2) 14135 continue; 14136 descr = dw_sra_loc_expr (decl, node->loc); 14137 if (descr == NULL) 14138 continue; 14139 } 14140 else 14141 { 14142 initialized = NOTE_VAR_LOCATION_STATUS (node->loc); 14143 varloc = NOTE_VAR_LOCATION (node->loc); 14144 descr = dw_loc_list_1 (decl, varloc, want_address, initialized); 14145 } 14146 if (descr) 14147 { 14148 bool range_across_switch = false; 14149 /* If section switch happens in between node->label 14150 and node->next->label (or end of function) and 14151 we can't emit it as a single entry list, 14152 emit two ranges, first one ending at the end 14153 of first partition and second one starting at the 14154 beginning of second partition. */ 14155 if (node == loc_list->last_before_switch 14156 && (node != loc_list->first || loc_list->first->next) 14157 && current_function_decl) 14158 { 14159 endname = cfun->fde->dw_fde_end; 14160 range_across_switch = true; 14161 } 14162 /* The variable has a location between NODE->LABEL and 14163 NODE->NEXT->LABEL. */ 14164 else if (node->next) 14165 endname = node->next->label; 14166 /* If the variable has a location at the last label 14167 it keeps its location until the end of function. */ 14168 else if (!current_function_decl) 14169 endname = text_end_label; 14170 else 14171 { 14172 ASM_GENERATE_INTERNAL_LABEL (label_id, FUNC_END_LABEL, 14173 current_function_funcdef_no); 14174 endname = ggc_strdup (label_id); 14175 } 14176 14177 *listp = new_loc_list (descr, node->label, endname, secname); 14178 if (TREE_CODE (decl) == PARM_DECL 14179 && node == loc_list->first 14180 && NOTE_P (node->loc) 14181 && strcmp (node->label, endname) == 0) 14182 (*listp)->force = true; 14183 listp = &(*listp)->dw_loc_next; 14184 14185 if (range_across_switch) 14186 { 14187 if (GET_CODE (node->loc) == EXPR_LIST) 14188 descr = dw_sra_loc_expr (decl, node->loc); 14189 else 14190 { 14191 initialized = NOTE_VAR_LOCATION_STATUS (node->loc); 14192 varloc = NOTE_VAR_LOCATION (node->loc); 14193 descr = dw_loc_list_1 (decl, varloc, want_address, 14194 initialized); 14195 } 14196 gcc_assert (descr); 14197 /* The variable has a location between NODE->LABEL and 14198 NODE->NEXT->LABEL. */ 14199 if (node->next) 14200 endname = node->next->label; 14201 else 14202 endname = cfun->fde->dw_fde_second_end; 14203 *listp = new_loc_list (descr, 14204 cfun->fde->dw_fde_second_begin, 14205 endname, secname); 14206 listp = &(*listp)->dw_loc_next; 14207 } 14208 } 14209 } 14210 14211 /* Try to avoid the overhead of a location list emitting a location 14212 expression instead, but only if we didn't have more than one 14213 location entry in the first place. If some entries were not 14214 representable, we don't want to pretend a single entry that was 14215 applies to the entire scope in which the variable is 14216 available. */ 14217 if (list && loc_list->first->next) 14218 gen_llsym (list); 14219 14220 return list; 14221} 14222 14223/* Return if the loc_list has only single element and thus can be represented 14224 as location description. */ 14225 14226static bool 14227single_element_loc_list_p (dw_loc_list_ref list) 14228{ 14229 gcc_assert (!list->dw_loc_next || list->ll_symbol); 14230 return !list->ll_symbol; 14231} 14232 14233/* To each location in list LIST add loc descr REF. */ 14234 14235static void 14236add_loc_descr_to_each (dw_loc_list_ref list, dw_loc_descr_ref ref) 14237{ 14238 dw_loc_descr_ref copy; 14239 add_loc_descr (&list->expr, ref); 14240 list = list->dw_loc_next; 14241 while (list) 14242 { 14243 copy = ggc_alloc<dw_loc_descr_node> (); 14244 memcpy (copy, ref, sizeof (dw_loc_descr_node)); 14245 add_loc_descr (&list->expr, copy); 14246 while (copy->dw_loc_next) 14247 { 14248 dw_loc_descr_ref new_copy = ggc_alloc<dw_loc_descr_node> (); 14249 memcpy (new_copy, copy->dw_loc_next, sizeof (dw_loc_descr_node)); 14250 copy->dw_loc_next = new_copy; 14251 copy = new_copy; 14252 } 14253 list = list->dw_loc_next; 14254 } 14255} 14256 14257/* Given two lists RET and LIST 14258 produce location list that is result of adding expression in LIST 14259 to expression in RET on each position in program. 14260 Might be destructive on both RET and LIST. 14261 14262 TODO: We handle only simple cases of RET or LIST having at most one 14263 element. General case would inolve sorting the lists in program order 14264 and merging them that will need some additional work. 14265 Adding that will improve quality of debug info especially for SRA-ed 14266 structures. */ 14267 14268static void 14269add_loc_list (dw_loc_list_ref *ret, dw_loc_list_ref list) 14270{ 14271 if (!list) 14272 return; 14273 if (!*ret) 14274 { 14275 *ret = list; 14276 return; 14277 } 14278 if (!list->dw_loc_next) 14279 { 14280 add_loc_descr_to_each (*ret, list->expr); 14281 return; 14282 } 14283 if (!(*ret)->dw_loc_next) 14284 { 14285 add_loc_descr_to_each (list, (*ret)->expr); 14286 *ret = list; 14287 return; 14288 } 14289 expansion_failed (NULL_TREE, NULL_RTX, 14290 "Don't know how to merge two non-trivial" 14291 " location lists.\n"); 14292 *ret = NULL; 14293 return; 14294} 14295 14296/* LOC is constant expression. Try a luck, look it up in constant 14297 pool and return its loc_descr of its address. */ 14298 14299static dw_loc_descr_ref 14300cst_pool_loc_descr (tree loc) 14301{ 14302 /* Get an RTL for this, if something has been emitted. */ 14303 rtx rtl = lookup_constant_def (loc); 14304 14305 if (!rtl || !MEM_P (rtl)) 14306 { 14307 gcc_assert (!rtl); 14308 return 0; 14309 } 14310 gcc_assert (GET_CODE (XEXP (rtl, 0)) == SYMBOL_REF); 14311 14312 /* TODO: We might get more coverage if we was actually delaying expansion 14313 of all expressions till end of compilation when constant pools are fully 14314 populated. */ 14315 if (!TREE_ASM_WRITTEN (SYMBOL_REF_DECL (XEXP (rtl, 0)))) 14316 { 14317 expansion_failed (loc, NULL_RTX, 14318 "CST value in contant pool but not marked."); 14319 return 0; 14320 } 14321 return mem_loc_descriptor (XEXP (rtl, 0), get_address_mode (rtl), 14322 GET_MODE (rtl), VAR_INIT_STATUS_INITIALIZED); 14323} 14324 14325/* Return dw_loc_list representing address of addr_expr LOC 14326 by looking for inner INDIRECT_REF expression and turning 14327 it into simple arithmetics. 14328 14329 See loc_list_from_tree for the meaning of CONTEXT. */ 14330 14331static dw_loc_list_ref 14332loc_list_for_address_of_addr_expr_of_indirect_ref (tree loc, bool toplev, 14333 const loc_descr_context *context) 14334{ 14335 tree obj, offset; 14336 HOST_WIDE_INT bitsize, bitpos, bytepos; 14337 machine_mode mode; 14338 int unsignedp, volatilep = 0; 14339 dw_loc_list_ref list_ret = NULL, list_ret1 = NULL; 14340 14341 obj = get_inner_reference (TREE_OPERAND (loc, 0), 14342 &bitsize, &bitpos, &offset, &mode, 14343 &unsignedp, &volatilep, false); 14344 STRIP_NOPS (obj); 14345 if (bitpos % BITS_PER_UNIT) 14346 { 14347 expansion_failed (loc, NULL_RTX, "bitfield access"); 14348 return 0; 14349 } 14350 if (!INDIRECT_REF_P (obj)) 14351 { 14352 expansion_failed (obj, 14353 NULL_RTX, "no indirect ref in inner refrence"); 14354 return 0; 14355 } 14356 if (!offset && !bitpos) 14357 list_ret = loc_list_from_tree (TREE_OPERAND (obj, 0), toplev ? 2 : 1, 14358 context); 14359 else if (toplev 14360 && int_size_in_bytes (TREE_TYPE (loc)) <= DWARF2_ADDR_SIZE 14361 && (dwarf_version >= 4 || !dwarf_strict)) 14362 { 14363 list_ret = loc_list_from_tree (TREE_OPERAND (obj, 0), 0, context); 14364 if (!list_ret) 14365 return 0; 14366 if (offset) 14367 { 14368 /* Variable offset. */ 14369 list_ret1 = loc_list_from_tree (offset, 0, context); 14370 if (list_ret1 == 0) 14371 return 0; 14372 add_loc_list (&list_ret, list_ret1); 14373 if (!list_ret) 14374 return 0; 14375 add_loc_descr_to_each (list_ret, 14376 new_loc_descr (DW_OP_plus, 0, 0)); 14377 } 14378 bytepos = bitpos / BITS_PER_UNIT; 14379 if (bytepos > 0) 14380 add_loc_descr_to_each (list_ret, 14381 new_loc_descr (DW_OP_plus_uconst, 14382 bytepos, 0)); 14383 else if (bytepos < 0) 14384 loc_list_plus_const (list_ret, bytepos); 14385 add_loc_descr_to_each (list_ret, 14386 new_loc_descr (DW_OP_stack_value, 0, 0)); 14387 } 14388 return list_ret; 14389} 14390 14391 14392/* Helper structure for location descriptions generation. */ 14393struct loc_descr_context 14394{ 14395 /* The type that is implicitly referenced by DW_OP_push_object_address, or 14396 NULL_TREE if DW_OP_push_object_address in invalid for this location 14397 description. This is used when processing PLACEHOLDER_EXPR nodes. */ 14398 tree context_type; 14399 /* The ..._DECL node that should be translated as a 14400 DW_OP_push_object_address operation. */ 14401 tree base_decl; 14402}; 14403 14404/* Generate Dwarf location list representing LOC. 14405 If WANT_ADDRESS is false, expression computing LOC will be computed 14406 If WANT_ADDRESS is 1, expression computing address of LOC will be returned 14407 if WANT_ADDRESS is 2, expression computing address useable in location 14408 will be returned (i.e. DW_OP_reg can be used 14409 to refer to register values). 14410 14411 CONTEXT provides information to customize the location descriptions 14412 generation. Its context_type field specifies what type is implicitly 14413 referenced by DW_OP_push_object_address. If it is NULL_TREE, this operation 14414 will not be generated. 14415 14416 If CONTEXT is NULL, the behavior is the same as if both context_type and 14417 base_decl fields were NULL_TREE. */ 14418 14419static dw_loc_list_ref 14420loc_list_from_tree (tree loc, int want_address, 14421 const struct loc_descr_context *context) 14422{ 14423 dw_loc_descr_ref ret = NULL, ret1 = NULL; 14424 dw_loc_list_ref list_ret = NULL, list_ret1 = NULL; 14425 int have_address = 0; 14426 enum dwarf_location_atom op; 14427 14428 /* ??? Most of the time we do not take proper care for sign/zero 14429 extending the values properly. Hopefully this won't be a real 14430 problem... */ 14431 14432 if (context != NULL 14433 && context->base_decl == loc 14434 && want_address == 0) 14435 { 14436 if (dwarf_version >= 3 || !dwarf_strict) 14437 return new_loc_list (new_loc_descr (DW_OP_push_object_address, 0, 0), 14438 NULL, NULL, NULL); 14439 else 14440 return NULL; 14441 } 14442 14443 switch (TREE_CODE (loc)) 14444 { 14445 case ERROR_MARK: 14446 expansion_failed (loc, NULL_RTX, "ERROR_MARK"); 14447 return 0; 14448 14449 case PLACEHOLDER_EXPR: 14450 /* This case involves extracting fields from an object to determine the 14451 position of other fields. It is supposed to appear only as the first 14452 operand of COMPONENT_REF nodes and to reference precisely the type 14453 that the context allows. */ 14454 if (context != NULL 14455 && TREE_TYPE (loc) == context->context_type 14456 && want_address >= 1) 14457 { 14458 if (dwarf_version >= 3 || !dwarf_strict) 14459 { 14460 ret = new_loc_descr (DW_OP_push_object_address, 0, 0); 14461 have_address = 1; 14462 break; 14463 } 14464 else 14465 return NULL; 14466 } 14467 else 14468 expansion_failed (loc, NULL_RTX, 14469 "PLACEHOLDER_EXPR for an unexpected type"); 14470 break; 14471 14472 case CALL_EXPR: 14473 expansion_failed (loc, NULL_RTX, "CALL_EXPR"); 14474 /* There are no opcodes for these operations. */ 14475 return 0; 14476 14477 case PREINCREMENT_EXPR: 14478 case PREDECREMENT_EXPR: 14479 case POSTINCREMENT_EXPR: 14480 case POSTDECREMENT_EXPR: 14481 expansion_failed (loc, NULL_RTX, "PRE/POST INDCREMENT/DECREMENT"); 14482 /* There are no opcodes for these operations. */ 14483 return 0; 14484 14485 case ADDR_EXPR: 14486 /* If we already want an address, see if there is INDIRECT_REF inside 14487 e.g. for &this->field. */ 14488 if (want_address) 14489 { 14490 list_ret = loc_list_for_address_of_addr_expr_of_indirect_ref 14491 (loc, want_address == 2, context); 14492 if (list_ret) 14493 have_address = 1; 14494 else if (decl_address_ip_invariant_p (TREE_OPERAND (loc, 0)) 14495 && (ret = cst_pool_loc_descr (loc))) 14496 have_address = 1; 14497 } 14498 /* Otherwise, process the argument and look for the address. */ 14499 if (!list_ret && !ret) 14500 list_ret = loc_list_from_tree (TREE_OPERAND (loc, 0), 1, context); 14501 else 14502 { 14503 if (want_address) 14504 expansion_failed (loc, NULL_RTX, "need address of ADDR_EXPR"); 14505 return NULL; 14506 } 14507 break; 14508 14509 case VAR_DECL: 14510 if (DECL_THREAD_LOCAL_P (loc)) 14511 { 14512 rtx rtl; 14513 enum dwarf_location_atom tls_op; 14514 enum dtprel_bool dtprel = dtprel_false; 14515 14516 if (targetm.have_tls) 14517 { 14518 /* If this is not defined, we have no way to emit the 14519 data. */ 14520 if (!targetm.asm_out.output_dwarf_dtprel) 14521 return 0; 14522 14523 /* The way DW_OP_GNU_push_tls_address is specified, we 14524 can only look up addresses of objects in the current 14525 module. We used DW_OP_addr as first op, but that's 14526 wrong, because DW_OP_addr is relocated by the debug 14527 info consumer, while DW_OP_GNU_push_tls_address 14528 operand shouldn't be. */ 14529 if (DECL_EXTERNAL (loc) && !targetm.binds_local_p (loc)) 14530 return 0; 14531 dtprel = dtprel_true; 14532 tls_op = DW_OP_GNU_push_tls_address; 14533 } 14534 else 14535 { 14536 if (!targetm.emutls.debug_form_tls_address 14537 || !(dwarf_version >= 3 || !dwarf_strict)) 14538 return 0; 14539 /* We stuffed the control variable into the DECL_VALUE_EXPR 14540 to signal (via DECL_HAS_VALUE_EXPR_P) that the decl should 14541 no longer appear in gimple code. We used the control 14542 variable in specific so that we could pick it up here. */ 14543 loc = DECL_VALUE_EXPR (loc); 14544 tls_op = DW_OP_form_tls_address; 14545 } 14546 14547 rtl = rtl_for_decl_location (loc); 14548 if (rtl == NULL_RTX) 14549 return 0; 14550 14551 if (!MEM_P (rtl)) 14552 return 0; 14553 rtl = XEXP (rtl, 0); 14554 if (! CONSTANT_P (rtl)) 14555 return 0; 14556 14557 ret = new_addr_loc_descr (rtl, dtprel); 14558 ret1 = new_loc_descr (tls_op, 0, 0); 14559 add_loc_descr (&ret, ret1); 14560 14561 have_address = 1; 14562 break; 14563 } 14564 /* FALLTHRU */ 14565 14566 case PARM_DECL: 14567 case RESULT_DECL: 14568 if (DECL_HAS_VALUE_EXPR_P (loc)) 14569 return loc_list_from_tree (DECL_VALUE_EXPR (loc), 14570 want_address, context); 14571 /* FALLTHRU */ 14572 14573 case FUNCTION_DECL: 14574 { 14575 rtx rtl; 14576 var_loc_list *loc_list = lookup_decl_loc (loc); 14577 14578 if (loc_list && loc_list->first) 14579 { 14580 list_ret = dw_loc_list (loc_list, loc, want_address); 14581 have_address = want_address != 0; 14582 break; 14583 } 14584 rtl = rtl_for_decl_location (loc); 14585 if (rtl == NULL_RTX) 14586 { 14587 expansion_failed (loc, NULL_RTX, "DECL has no RTL"); 14588 return 0; 14589 } 14590 else if (CONST_INT_P (rtl)) 14591 { 14592 HOST_WIDE_INT val = INTVAL (rtl); 14593 if (TYPE_UNSIGNED (TREE_TYPE (loc))) 14594 val &= GET_MODE_MASK (DECL_MODE (loc)); 14595 ret = int_loc_descriptor (val); 14596 } 14597 else if (GET_CODE (rtl) == CONST_STRING) 14598 { 14599 expansion_failed (loc, NULL_RTX, "CONST_STRING"); 14600 return 0; 14601 } 14602 else if (CONSTANT_P (rtl) && const_ok_for_output (rtl)) 14603 ret = new_addr_loc_descr (rtl, dtprel_false); 14604 else 14605 { 14606 machine_mode mode, mem_mode; 14607 14608 /* Certain constructs can only be represented at top-level. */ 14609 if (want_address == 2) 14610 { 14611 ret = loc_descriptor (rtl, VOIDmode, 14612 VAR_INIT_STATUS_INITIALIZED); 14613 have_address = 1; 14614 } 14615 else 14616 { 14617 mode = GET_MODE (rtl); 14618 mem_mode = VOIDmode; 14619 if (MEM_P (rtl)) 14620 { 14621 mem_mode = mode; 14622 mode = get_address_mode (rtl); 14623 rtl = XEXP (rtl, 0); 14624 have_address = 1; 14625 } 14626 ret = mem_loc_descriptor (rtl, mode, mem_mode, 14627 VAR_INIT_STATUS_INITIALIZED); 14628 } 14629 if (!ret) 14630 expansion_failed (loc, rtl, 14631 "failed to produce loc descriptor for rtl"); 14632 } 14633 } 14634 break; 14635 14636 case MEM_REF: 14637 if (!integer_zerop (TREE_OPERAND (loc, 1))) 14638 { 14639 have_address = 1; 14640 goto do_plus; 14641 } 14642 /* Fallthru. */ 14643 case INDIRECT_REF: 14644 list_ret = loc_list_from_tree (TREE_OPERAND (loc, 0), 0, context); 14645 have_address = 1; 14646 break; 14647 14648 case TARGET_MEM_REF: 14649 case SSA_NAME: 14650 case DEBUG_EXPR_DECL: 14651 return NULL; 14652 14653 case COMPOUND_EXPR: 14654 return loc_list_from_tree (TREE_OPERAND (loc, 1), want_address, context); 14655 14656 CASE_CONVERT: 14657 case VIEW_CONVERT_EXPR: 14658 case SAVE_EXPR: 14659 case MODIFY_EXPR: 14660 return loc_list_from_tree (TREE_OPERAND (loc, 0), want_address, context); 14661 14662 case COMPONENT_REF: 14663 case BIT_FIELD_REF: 14664 case ARRAY_REF: 14665 case ARRAY_RANGE_REF: 14666 case REALPART_EXPR: 14667 case IMAGPART_EXPR: 14668 { 14669 tree obj, offset; 14670 HOST_WIDE_INT bitsize, bitpos, bytepos; 14671 machine_mode mode; 14672 int unsignedp, volatilep = 0; 14673 14674 obj = get_inner_reference (loc, &bitsize, &bitpos, &offset, &mode, 14675 &unsignedp, &volatilep, false); 14676 14677 gcc_assert (obj != loc); 14678 14679 list_ret = loc_list_from_tree (obj, 14680 want_address == 2 14681 && !bitpos && !offset ? 2 : 1, 14682 context); 14683 /* TODO: We can extract value of the small expression via shifting even 14684 for nonzero bitpos. */ 14685 if (list_ret == 0) 14686 return 0; 14687 if (bitpos % BITS_PER_UNIT != 0 || bitsize % BITS_PER_UNIT != 0) 14688 { 14689 expansion_failed (loc, NULL_RTX, 14690 "bitfield access"); 14691 return 0; 14692 } 14693 14694 if (offset != NULL_TREE) 14695 { 14696 /* Variable offset. */ 14697 list_ret1 = loc_list_from_tree (offset, 0, context); 14698 if (list_ret1 == 0) 14699 return 0; 14700 add_loc_list (&list_ret, list_ret1); 14701 if (!list_ret) 14702 return 0; 14703 add_loc_descr_to_each (list_ret, new_loc_descr (DW_OP_plus, 0, 0)); 14704 } 14705 14706 bytepos = bitpos / BITS_PER_UNIT; 14707 if (bytepos > 0) 14708 add_loc_descr_to_each (list_ret, new_loc_descr (DW_OP_plus_uconst, bytepos, 0)); 14709 else if (bytepos < 0) 14710 loc_list_plus_const (list_ret, bytepos); 14711 14712 have_address = 1; 14713 break; 14714 } 14715 14716 case INTEGER_CST: 14717 if ((want_address || !tree_fits_shwi_p (loc)) 14718 && (ret = cst_pool_loc_descr (loc))) 14719 have_address = 1; 14720 else if (want_address == 2 14721 && tree_fits_shwi_p (loc) 14722 && (ret = address_of_int_loc_descriptor 14723 (int_size_in_bytes (TREE_TYPE (loc)), 14724 tree_to_shwi (loc)))) 14725 have_address = 1; 14726 else if (tree_fits_shwi_p (loc)) 14727 ret = int_loc_descriptor (tree_to_shwi (loc)); 14728 else 14729 { 14730 expansion_failed (loc, NULL_RTX, 14731 "Integer operand is not host integer"); 14732 return 0; 14733 } 14734 break; 14735 14736 case CONSTRUCTOR: 14737 case REAL_CST: 14738 case STRING_CST: 14739 case COMPLEX_CST: 14740 if ((ret = cst_pool_loc_descr (loc))) 14741 have_address = 1; 14742 else 14743 /* We can construct small constants here using int_loc_descriptor. */ 14744 expansion_failed (loc, NULL_RTX, 14745 "constructor or constant not in constant pool"); 14746 break; 14747 14748 case TRUTH_AND_EXPR: 14749 case TRUTH_ANDIF_EXPR: 14750 case BIT_AND_EXPR: 14751 op = DW_OP_and; 14752 goto do_binop; 14753 14754 case TRUTH_XOR_EXPR: 14755 case BIT_XOR_EXPR: 14756 op = DW_OP_xor; 14757 goto do_binop; 14758 14759 case TRUTH_OR_EXPR: 14760 case TRUTH_ORIF_EXPR: 14761 case BIT_IOR_EXPR: 14762 op = DW_OP_or; 14763 goto do_binop; 14764 14765 case FLOOR_DIV_EXPR: 14766 case CEIL_DIV_EXPR: 14767 case ROUND_DIV_EXPR: 14768 case TRUNC_DIV_EXPR: 14769 if (TYPE_UNSIGNED (TREE_TYPE (loc))) 14770 return 0; 14771 op = DW_OP_div; 14772 goto do_binop; 14773 14774 case MINUS_EXPR: 14775 op = DW_OP_minus; 14776 goto do_binop; 14777 14778 case FLOOR_MOD_EXPR: 14779 case CEIL_MOD_EXPR: 14780 case ROUND_MOD_EXPR: 14781 case TRUNC_MOD_EXPR: 14782 if (TYPE_UNSIGNED (TREE_TYPE (loc))) 14783 { 14784 op = DW_OP_mod; 14785 goto do_binop; 14786 } 14787 list_ret = loc_list_from_tree (TREE_OPERAND (loc, 0), 0, context); 14788 list_ret1 = loc_list_from_tree (TREE_OPERAND (loc, 1), 0, context); 14789 if (list_ret == 0 || list_ret1 == 0) 14790 return 0; 14791 14792 add_loc_list (&list_ret, list_ret1); 14793 if (list_ret == 0) 14794 return 0; 14795 add_loc_descr_to_each (list_ret, new_loc_descr (DW_OP_over, 0, 0)); 14796 add_loc_descr_to_each (list_ret, new_loc_descr (DW_OP_over, 0, 0)); 14797 add_loc_descr_to_each (list_ret, new_loc_descr (DW_OP_div, 0, 0)); 14798 add_loc_descr_to_each (list_ret, new_loc_descr (DW_OP_mul, 0, 0)); 14799 add_loc_descr_to_each (list_ret, new_loc_descr (DW_OP_minus, 0, 0)); 14800 break; 14801 14802 case MULT_EXPR: 14803 op = DW_OP_mul; 14804 goto do_binop; 14805 14806 case LSHIFT_EXPR: 14807 op = DW_OP_shl; 14808 goto do_binop; 14809 14810 case RSHIFT_EXPR: 14811 op = (TYPE_UNSIGNED (TREE_TYPE (loc)) ? DW_OP_shr : DW_OP_shra); 14812 goto do_binop; 14813 14814 case POINTER_PLUS_EXPR: 14815 case PLUS_EXPR: 14816 do_plus: 14817 if (tree_fits_shwi_p (TREE_OPERAND (loc, 1))) 14818 { 14819 list_ret = loc_list_from_tree (TREE_OPERAND (loc, 0), 0, context); 14820 if (list_ret == 0) 14821 return 0; 14822 14823 loc_list_plus_const (list_ret, tree_to_shwi (TREE_OPERAND (loc, 1))); 14824 break; 14825 } 14826 14827 op = DW_OP_plus; 14828 goto do_binop; 14829 14830 case LE_EXPR: 14831 if (TYPE_UNSIGNED (TREE_TYPE (TREE_OPERAND (loc, 0)))) 14832 return 0; 14833 14834 op = DW_OP_le; 14835 goto do_binop; 14836 14837 case GE_EXPR: 14838 if (TYPE_UNSIGNED (TREE_TYPE (TREE_OPERAND (loc, 0)))) 14839 return 0; 14840 14841 op = DW_OP_ge; 14842 goto do_binop; 14843 14844 case LT_EXPR: 14845 if (TYPE_UNSIGNED (TREE_TYPE (TREE_OPERAND (loc, 0)))) 14846 return 0; 14847 14848 op = DW_OP_lt; 14849 goto do_binop; 14850 14851 case GT_EXPR: 14852 if (TYPE_UNSIGNED (TREE_TYPE (TREE_OPERAND (loc, 0)))) 14853 return 0; 14854 14855 op = DW_OP_gt; 14856 goto do_binop; 14857 14858 case EQ_EXPR: 14859 op = DW_OP_eq; 14860 goto do_binop; 14861 14862 case NE_EXPR: 14863 op = DW_OP_ne; 14864 goto do_binop; 14865 14866 do_binop: 14867 list_ret = loc_list_from_tree (TREE_OPERAND (loc, 0), 0, context); 14868 list_ret1 = loc_list_from_tree (TREE_OPERAND (loc, 1), 0, context); 14869 if (list_ret == 0 || list_ret1 == 0) 14870 return 0; 14871 14872 add_loc_list (&list_ret, list_ret1); 14873 if (list_ret == 0) 14874 return 0; 14875 add_loc_descr_to_each (list_ret, new_loc_descr (op, 0, 0)); 14876 break; 14877 14878 case TRUTH_NOT_EXPR: 14879 case BIT_NOT_EXPR: 14880 op = DW_OP_not; 14881 goto do_unop; 14882 14883 case ABS_EXPR: 14884 op = DW_OP_abs; 14885 goto do_unop; 14886 14887 case NEGATE_EXPR: 14888 op = DW_OP_neg; 14889 goto do_unop; 14890 14891 do_unop: 14892 list_ret = loc_list_from_tree (TREE_OPERAND (loc, 0), 0, context); 14893 if (list_ret == 0) 14894 return 0; 14895 14896 add_loc_descr_to_each (list_ret, new_loc_descr (op, 0, 0)); 14897 break; 14898 14899 case MIN_EXPR: 14900 case MAX_EXPR: 14901 { 14902 const enum tree_code code = 14903 TREE_CODE (loc) == MIN_EXPR ? GT_EXPR : LT_EXPR; 14904 14905 loc = build3 (COND_EXPR, TREE_TYPE (loc), 14906 build2 (code, integer_type_node, 14907 TREE_OPERAND (loc, 0), TREE_OPERAND (loc, 1)), 14908 TREE_OPERAND (loc, 1), TREE_OPERAND (loc, 0)); 14909 } 14910 14911 /* ... fall through ... */ 14912 14913 case COND_EXPR: 14914 { 14915 dw_loc_descr_ref lhs 14916 = loc_descriptor_from_tree (TREE_OPERAND (loc, 1), 0, context); 14917 dw_loc_list_ref rhs 14918 = loc_list_from_tree (TREE_OPERAND (loc, 2), 0, context); 14919 dw_loc_descr_ref bra_node, jump_node, tmp; 14920 14921 list_ret = loc_list_from_tree (TREE_OPERAND (loc, 0), 0, context); 14922 if (list_ret == 0 || lhs == 0 || rhs == 0) 14923 return 0; 14924 14925 bra_node = new_loc_descr (DW_OP_bra, 0, 0); 14926 add_loc_descr_to_each (list_ret, bra_node); 14927 14928 add_loc_list (&list_ret, rhs); 14929 jump_node = new_loc_descr (DW_OP_skip, 0, 0); 14930 add_loc_descr_to_each (list_ret, jump_node); 14931 14932 add_loc_descr_to_each (list_ret, lhs); 14933 bra_node->dw_loc_oprnd1.val_class = dw_val_class_loc; 14934 bra_node->dw_loc_oprnd1.v.val_loc = lhs; 14935 14936 /* ??? Need a node to point the skip at. Use a nop. */ 14937 tmp = new_loc_descr (DW_OP_nop, 0, 0); 14938 add_loc_descr_to_each (list_ret, tmp); 14939 jump_node->dw_loc_oprnd1.val_class = dw_val_class_loc; 14940 jump_node->dw_loc_oprnd1.v.val_loc = tmp; 14941 } 14942 break; 14943 14944 case FIX_TRUNC_EXPR: 14945 return 0; 14946 14947 default: 14948 /* Leave front-end specific codes as simply unknown. This comes 14949 up, for instance, with the C STMT_EXPR. */ 14950 if ((unsigned int) TREE_CODE (loc) 14951 >= (unsigned int) LAST_AND_UNUSED_TREE_CODE) 14952 { 14953 expansion_failed (loc, NULL_RTX, 14954 "language specific tree node"); 14955 return 0; 14956 } 14957 14958#ifdef ENABLE_CHECKING 14959 /* Otherwise this is a generic code; we should just lists all of 14960 these explicitly. We forgot one. */ 14961 gcc_unreachable (); 14962#else 14963 /* In a release build, we want to degrade gracefully: better to 14964 generate incomplete debugging information than to crash. */ 14965 return NULL; 14966#endif 14967 } 14968 14969 if (!ret && !list_ret) 14970 return 0; 14971 14972 if (want_address == 2 && !have_address 14973 && (dwarf_version >= 4 || !dwarf_strict)) 14974 { 14975 if (int_size_in_bytes (TREE_TYPE (loc)) > DWARF2_ADDR_SIZE) 14976 { 14977 expansion_failed (loc, NULL_RTX, 14978 "DWARF address size mismatch"); 14979 return 0; 14980 } 14981 if (ret) 14982 add_loc_descr (&ret, new_loc_descr (DW_OP_stack_value, 0, 0)); 14983 else 14984 add_loc_descr_to_each (list_ret, 14985 new_loc_descr (DW_OP_stack_value, 0, 0)); 14986 have_address = 1; 14987 } 14988 /* Show if we can't fill the request for an address. */ 14989 if (want_address && !have_address) 14990 { 14991 expansion_failed (loc, NULL_RTX, 14992 "Want address and only have value"); 14993 return 0; 14994 } 14995 14996 gcc_assert (!ret || !list_ret); 14997 14998 /* If we've got an address and don't want one, dereference. */ 14999 if (!want_address && have_address) 15000 { 15001 HOST_WIDE_INT size = int_size_in_bytes (TREE_TYPE (loc)); 15002 15003 if (size > DWARF2_ADDR_SIZE || size == -1) 15004 { 15005 expansion_failed (loc, NULL_RTX, 15006 "DWARF address size mismatch"); 15007 return 0; 15008 } 15009 else if (size == DWARF2_ADDR_SIZE) 15010 op = DW_OP_deref; 15011 else 15012 op = DW_OP_deref_size; 15013 15014 if (ret) 15015 add_loc_descr (&ret, new_loc_descr (op, size, 0)); 15016 else 15017 add_loc_descr_to_each (list_ret, new_loc_descr (op, size, 0)); 15018 } 15019 if (ret) 15020 list_ret = new_loc_list (ret, NULL, NULL, NULL); 15021 15022 return list_ret; 15023} 15024 15025/* Same as above but return only single location expression. */ 15026static dw_loc_descr_ref 15027loc_descriptor_from_tree (tree loc, int want_address, 15028 const struct loc_descr_context *context) 15029{ 15030 dw_loc_list_ref ret = loc_list_from_tree (loc, want_address, context); 15031 if (!ret) 15032 return NULL; 15033 if (ret->dw_loc_next) 15034 { 15035 expansion_failed (loc, NULL_RTX, 15036 "Location list where only loc descriptor needed"); 15037 return NULL; 15038 } 15039 return ret->expr; 15040} 15041 15042/* Given a value, round it up to the lowest multiple of `boundary' 15043 which is not less than the value itself. */ 15044 15045static inline HOST_WIDE_INT 15046ceiling (HOST_WIDE_INT value, unsigned int boundary) 15047{ 15048 return (((value + boundary - 1) / boundary) * boundary); 15049} 15050 15051/* Given a pointer to what is assumed to be a FIELD_DECL node, return a 15052 pointer to the declared type for the relevant field variable, or return 15053 `integer_type_node' if the given node turns out to be an 15054 ERROR_MARK node. */ 15055 15056static inline tree 15057field_type (const_tree decl) 15058{ 15059 tree type; 15060 15061 if (TREE_CODE (decl) == ERROR_MARK) 15062 return integer_type_node; 15063 15064 type = DECL_BIT_FIELD_TYPE (decl); 15065 if (type == NULL_TREE) 15066 type = TREE_TYPE (decl); 15067 15068 return type; 15069} 15070 15071/* Given a pointer to a tree node, return the alignment in bits for 15072 it, or else return BITS_PER_WORD if the node actually turns out to 15073 be an ERROR_MARK node. */ 15074 15075static inline unsigned 15076simple_type_align_in_bits (const_tree type) 15077{ 15078 return (TREE_CODE (type) != ERROR_MARK) ? TYPE_ALIGN (type) : BITS_PER_WORD; 15079} 15080 15081static inline unsigned 15082simple_decl_align_in_bits (const_tree decl) 15083{ 15084 return (TREE_CODE (decl) != ERROR_MARK) ? DECL_ALIGN (decl) : BITS_PER_WORD; 15085} 15086 15087/* Return the result of rounding T up to ALIGN. */ 15088 15089static inline offset_int 15090round_up_to_align (const offset_int &t, unsigned int align) 15091{ 15092 return wi::udiv_trunc (t + align - 1, align) * align; 15093} 15094 15095/* Given a pointer to a FIELD_DECL, compute and return the byte offset of the 15096 lowest addressed byte of the "containing object" for the given FIELD_DECL, 15097 or return 0 if we are unable to determine what that offset is, either 15098 because the argument turns out to be a pointer to an ERROR_MARK node, or 15099 because the offset is actually variable. (We can't handle the latter case 15100 just yet). */ 15101 15102static HOST_WIDE_INT 15103field_byte_offset (const_tree decl) 15104{ 15105 offset_int object_offset_in_bits; 15106 offset_int object_offset_in_bytes; 15107 offset_int bitpos_int; 15108 15109 if (TREE_CODE (decl) == ERROR_MARK) 15110 return 0; 15111 15112 gcc_assert (TREE_CODE (decl) == FIELD_DECL); 15113 15114 /* We cannot yet cope with fields whose positions are variable, so 15115 for now, when we see such things, we simply return 0. Someday, we may 15116 be able to handle such cases, but it will be damn difficult. */ 15117 if (TREE_CODE (bit_position (decl)) != INTEGER_CST) 15118 return 0; 15119 15120 bitpos_int = wi::to_offset (bit_position (decl)); 15121 15122#ifdef PCC_BITFIELD_TYPE_MATTERS 15123 if (PCC_BITFIELD_TYPE_MATTERS) 15124 { 15125 tree type; 15126 tree field_size_tree; 15127 offset_int deepest_bitpos; 15128 offset_int field_size_in_bits; 15129 unsigned int type_align_in_bits; 15130 unsigned int decl_align_in_bits; 15131 offset_int type_size_in_bits; 15132 15133 type = field_type (decl); 15134 type_size_in_bits = offset_int_type_size_in_bits (type); 15135 type_align_in_bits = simple_type_align_in_bits (type); 15136 15137 field_size_tree = DECL_SIZE (decl); 15138 15139 /* The size could be unspecified if there was an error, or for 15140 a flexible array member. */ 15141 if (!field_size_tree) 15142 field_size_tree = bitsize_zero_node; 15143 15144 /* If the size of the field is not constant, use the type size. */ 15145 if (TREE_CODE (field_size_tree) == INTEGER_CST) 15146 field_size_in_bits = wi::to_offset (field_size_tree); 15147 else 15148 field_size_in_bits = type_size_in_bits; 15149 15150 decl_align_in_bits = simple_decl_align_in_bits (decl); 15151 15152 /* The GCC front-end doesn't make any attempt to keep track of the 15153 starting bit offset (relative to the start of the containing 15154 structure type) of the hypothetical "containing object" for a 15155 bit-field. Thus, when computing the byte offset value for the 15156 start of the "containing object" of a bit-field, we must deduce 15157 this information on our own. This can be rather tricky to do in 15158 some cases. For example, handling the following structure type 15159 definition when compiling for an i386/i486 target (which only 15160 aligns long long's to 32-bit boundaries) can be very tricky: 15161 15162 struct S { int field1; long long field2:31; }; 15163 15164 Fortunately, there is a simple rule-of-thumb which can be used 15165 in such cases. When compiling for an i386/i486, GCC will 15166 allocate 8 bytes for the structure shown above. It decides to 15167 do this based upon one simple rule for bit-field allocation. 15168 GCC allocates each "containing object" for each bit-field at 15169 the first (i.e. lowest addressed) legitimate alignment boundary 15170 (based upon the required minimum alignment for the declared 15171 type of the field) which it can possibly use, subject to the 15172 condition that there is still enough available space remaining 15173 in the containing object (when allocated at the selected point) 15174 to fully accommodate all of the bits of the bit-field itself. 15175 15176 This simple rule makes it obvious why GCC allocates 8 bytes for 15177 each object of the structure type shown above. When looking 15178 for a place to allocate the "containing object" for `field2', 15179 the compiler simply tries to allocate a 64-bit "containing 15180 object" at each successive 32-bit boundary (starting at zero) 15181 until it finds a place to allocate that 64- bit field such that 15182 at least 31 contiguous (and previously unallocated) bits remain 15183 within that selected 64 bit field. (As it turns out, for the 15184 example above, the compiler finds it is OK to allocate the 15185 "containing object" 64-bit field at bit-offset zero within the 15186 structure type.) 15187 15188 Here we attempt to work backwards from the limited set of facts 15189 we're given, and we try to deduce from those facts, where GCC 15190 must have believed that the containing object started (within 15191 the structure type). The value we deduce is then used (by the 15192 callers of this routine) to generate DW_AT_location and 15193 DW_AT_bit_offset attributes for fields (both bit-fields and, in 15194 the case of DW_AT_location, regular fields as well). */ 15195 15196 /* Figure out the bit-distance from the start of the structure to 15197 the "deepest" bit of the bit-field. */ 15198 deepest_bitpos = bitpos_int + field_size_in_bits; 15199 15200 /* This is the tricky part. Use some fancy footwork to deduce 15201 where the lowest addressed bit of the containing object must 15202 be. */ 15203 object_offset_in_bits = deepest_bitpos - type_size_in_bits; 15204 15205 /* Round up to type_align by default. This works best for 15206 bitfields. */ 15207 object_offset_in_bits 15208 = round_up_to_align (object_offset_in_bits, type_align_in_bits); 15209 15210 if (wi::gtu_p (object_offset_in_bits, bitpos_int)) 15211 { 15212 object_offset_in_bits = deepest_bitpos - type_size_in_bits; 15213 15214 /* Round up to decl_align instead. */ 15215 object_offset_in_bits 15216 = round_up_to_align (object_offset_in_bits, decl_align_in_bits); 15217 } 15218 } 15219 else 15220#endif /* PCC_BITFIELD_TYPE_MATTERS */ 15221 object_offset_in_bits = bitpos_int; 15222 15223 object_offset_in_bytes 15224 = wi::lrshift (object_offset_in_bits, LOG2_BITS_PER_UNIT); 15225 return object_offset_in_bytes.to_shwi (); 15226} 15227 15228/* The following routines define various Dwarf attributes and any data 15229 associated with them. */ 15230 15231/* Add a location description attribute value to a DIE. 15232 15233 This emits location attributes suitable for whole variables and 15234 whole parameters. Note that the location attributes for struct fields are 15235 generated by the routine `data_member_location_attribute' below. */ 15236 15237static inline void 15238add_AT_location_description (dw_die_ref die, enum dwarf_attribute attr_kind, 15239 dw_loc_list_ref descr) 15240{ 15241 if (descr == 0) 15242 return; 15243 if (single_element_loc_list_p (descr)) 15244 add_AT_loc (die, attr_kind, descr->expr); 15245 else 15246 add_AT_loc_list (die, attr_kind, descr); 15247} 15248 15249/* Add DW_AT_accessibility attribute to DIE if needed. */ 15250 15251static void 15252add_accessibility_attribute (dw_die_ref die, tree decl) 15253{ 15254 /* In DWARF3+ the default is DW_ACCESS_private only in DW_TAG_class_type 15255 children, otherwise the default is DW_ACCESS_public. In DWARF2 15256 the default has always been DW_ACCESS_public. */ 15257 if (TREE_PROTECTED (decl)) 15258 add_AT_unsigned (die, DW_AT_accessibility, DW_ACCESS_protected); 15259 else if (TREE_PRIVATE (decl)) 15260 { 15261 if (dwarf_version == 2 15262 || die->die_parent == NULL 15263 || die->die_parent->die_tag != DW_TAG_class_type) 15264 add_AT_unsigned (die, DW_AT_accessibility, DW_ACCESS_private); 15265 } 15266 else if (dwarf_version > 2 15267 && die->die_parent 15268 && die->die_parent->die_tag == DW_TAG_class_type) 15269 add_AT_unsigned (die, DW_AT_accessibility, DW_ACCESS_public); 15270} 15271 15272/* Attach the specialized form of location attribute used for data members of 15273 struct and union types. In the special case of a FIELD_DECL node which 15274 represents a bit-field, the "offset" part of this special location 15275 descriptor must indicate the distance in bytes from the lowest-addressed 15276 byte of the containing struct or union type to the lowest-addressed byte of 15277 the "containing object" for the bit-field. (See the `field_byte_offset' 15278 function above). 15279 15280 For any given bit-field, the "containing object" is a hypothetical object 15281 (of some integral or enum type) within which the given bit-field lives. The 15282 type of this hypothetical "containing object" is always the same as the 15283 declared type of the individual bit-field itself (for GCC anyway... the 15284 DWARF spec doesn't actually mandate this). Note that it is the size (in 15285 bytes) of the hypothetical "containing object" which will be given in the 15286 DW_AT_byte_size attribute for this bit-field. (See the 15287 `byte_size_attribute' function below.) It is also used when calculating the 15288 value of the DW_AT_bit_offset attribute. (See the `bit_offset_attribute' 15289 function below.) */ 15290 15291static void 15292add_data_member_location_attribute (dw_die_ref die, tree decl) 15293{ 15294 HOST_WIDE_INT offset; 15295 dw_loc_descr_ref loc_descr = 0; 15296 15297 if (TREE_CODE (decl) == TREE_BINFO) 15298 { 15299 /* We're working on the TAG_inheritance for a base class. */ 15300 if (BINFO_VIRTUAL_P (decl) && is_cxx ()) 15301 { 15302 /* For C++ virtual bases we can't just use BINFO_OFFSET, as they 15303 aren't at a fixed offset from all (sub)objects of the same 15304 type. We need to extract the appropriate offset from our 15305 vtable. The following dwarf expression means 15306 15307 BaseAddr = ObAddr + *((*ObAddr) - Offset) 15308 15309 This is specific to the V3 ABI, of course. */ 15310 15311 dw_loc_descr_ref tmp; 15312 15313 /* Make a copy of the object address. */ 15314 tmp = new_loc_descr (DW_OP_dup, 0, 0); 15315 add_loc_descr (&loc_descr, tmp); 15316 15317 /* Extract the vtable address. */ 15318 tmp = new_loc_descr (DW_OP_deref, 0, 0); 15319 add_loc_descr (&loc_descr, tmp); 15320 15321 /* Calculate the address of the offset. */ 15322 offset = tree_to_shwi (BINFO_VPTR_FIELD (decl)); 15323 gcc_assert (offset < 0); 15324 15325 tmp = int_loc_descriptor (-offset); 15326 add_loc_descr (&loc_descr, tmp); 15327 tmp = new_loc_descr (DW_OP_minus, 0, 0); 15328 add_loc_descr (&loc_descr, tmp); 15329 15330 /* Extract the offset. */ 15331 tmp = new_loc_descr (DW_OP_deref, 0, 0); 15332 add_loc_descr (&loc_descr, tmp); 15333 15334 /* Add it to the object address. */ 15335 tmp = new_loc_descr (DW_OP_plus, 0, 0); 15336 add_loc_descr (&loc_descr, tmp); 15337 } 15338 else 15339 offset = tree_to_shwi (BINFO_OFFSET (decl)); 15340 } 15341 else 15342 offset = field_byte_offset (decl); 15343 15344 if (! loc_descr) 15345 { 15346 if (dwarf_version > 2) 15347 { 15348 /* Don't need to output a location expression, just the constant. */ 15349 if (offset < 0) 15350 add_AT_int (die, DW_AT_data_member_location, offset); 15351 else 15352 add_AT_unsigned (die, DW_AT_data_member_location, offset); 15353 return; 15354 } 15355 else 15356 { 15357 enum dwarf_location_atom op; 15358 15359 /* The DWARF2 standard says that we should assume that the structure 15360 address is already on the stack, so we can specify a structure 15361 field address by using DW_OP_plus_uconst. */ 15362 op = DW_OP_plus_uconst; 15363 loc_descr = new_loc_descr (op, offset, 0); 15364 } 15365 } 15366 15367 add_AT_loc (die, DW_AT_data_member_location, loc_descr); 15368} 15369 15370/* Writes integer values to dw_vec_const array. */ 15371 15372static void 15373insert_int (HOST_WIDE_INT val, unsigned int size, unsigned char *dest) 15374{ 15375 while (size != 0) 15376 { 15377 *dest++ = val & 0xff; 15378 val >>= 8; 15379 --size; 15380 } 15381} 15382 15383/* Reads integers from dw_vec_const array. Inverse of insert_int. */ 15384 15385static HOST_WIDE_INT 15386extract_int (const unsigned char *src, unsigned int size) 15387{ 15388 HOST_WIDE_INT val = 0; 15389 15390 src += size; 15391 while (size != 0) 15392 { 15393 val <<= 8; 15394 val |= *--src & 0xff; 15395 --size; 15396 } 15397 return val; 15398} 15399 15400/* Writes wide_int values to dw_vec_const array. */ 15401 15402static void 15403insert_wide_int (const wide_int &val, unsigned char *dest, int elt_size) 15404{ 15405 int i; 15406 15407 if (elt_size <= HOST_BITS_PER_WIDE_INT/BITS_PER_UNIT) 15408 { 15409 insert_int ((HOST_WIDE_INT) val.elt (0), elt_size, dest); 15410 return; 15411 } 15412 15413 /* We'd have to extend this code to support odd sizes. */ 15414 gcc_assert (elt_size % (HOST_BITS_PER_WIDE_INT / BITS_PER_UNIT) == 0); 15415 15416 int n = elt_size / (HOST_BITS_PER_WIDE_INT / BITS_PER_UNIT); 15417 15418 if (WORDS_BIG_ENDIAN) 15419 for (i = n - 1; i >= 0; i--) 15420 { 15421 insert_int ((HOST_WIDE_INT) val.elt (i), sizeof (HOST_WIDE_INT), dest); 15422 dest += sizeof (HOST_WIDE_INT); 15423 } 15424 else 15425 for (i = 0; i < n; i++) 15426 { 15427 insert_int ((HOST_WIDE_INT) val.elt (i), sizeof (HOST_WIDE_INT), dest); 15428 dest += sizeof (HOST_WIDE_INT); 15429 } 15430} 15431 15432/* Writes floating point values to dw_vec_const array. */ 15433 15434static void 15435insert_float (const_rtx rtl, unsigned char *array) 15436{ 15437 REAL_VALUE_TYPE rv; 15438 long val[4]; 15439 int i; 15440 15441 REAL_VALUE_FROM_CONST_DOUBLE (rv, rtl); 15442 real_to_target (val, &rv, GET_MODE (rtl)); 15443 15444 /* real_to_target puts 32-bit pieces in each long. Pack them. */ 15445 for (i = 0; i < GET_MODE_SIZE (GET_MODE (rtl)) / 4; i++) 15446 { 15447 insert_int (val[i], 4, array); 15448 array += 4; 15449 } 15450} 15451 15452/* Attach a DW_AT_const_value attribute for a variable or a parameter which 15453 does not have a "location" either in memory or in a register. These 15454 things can arise in GNU C when a constant is passed as an actual parameter 15455 to an inlined function. They can also arise in C++ where declared 15456 constants do not necessarily get memory "homes". */ 15457 15458static bool 15459add_const_value_attribute (dw_die_ref die, rtx rtl) 15460{ 15461 switch (GET_CODE (rtl)) 15462 { 15463 case CONST_INT: 15464 { 15465 HOST_WIDE_INT val = INTVAL (rtl); 15466 15467 if (val < 0) 15468 add_AT_int (die, DW_AT_const_value, val); 15469 else 15470 add_AT_unsigned (die, DW_AT_const_value, (unsigned HOST_WIDE_INT) val); 15471 } 15472 return true; 15473 15474 case CONST_WIDE_INT: 15475 { 15476 wide_int w1 = std::make_pair (rtl, MAX_MODE_INT); 15477 unsigned int prec = MIN (wi::min_precision (w1, UNSIGNED), 15478 (unsigned int)CONST_WIDE_INT_NUNITS (rtl) * HOST_BITS_PER_WIDE_INT); 15479 wide_int w = wi::zext (w1, prec); 15480 add_AT_wide (die, DW_AT_const_value, w); 15481 } 15482 return true; 15483 15484 case CONST_DOUBLE: 15485 /* Note that a CONST_DOUBLE rtx could represent either an integer or a 15486 floating-point constant. A CONST_DOUBLE is used whenever the 15487 constant requires more than one word in order to be adequately 15488 represented. */ 15489 { 15490 machine_mode mode = GET_MODE (rtl); 15491 15492 if (TARGET_SUPPORTS_WIDE_INT == 0 && !SCALAR_FLOAT_MODE_P (mode)) 15493 add_AT_double (die, DW_AT_const_value, 15494 CONST_DOUBLE_HIGH (rtl), CONST_DOUBLE_LOW (rtl)); 15495 else 15496 { 15497 unsigned int length = GET_MODE_SIZE (mode); 15498 unsigned char *array = ggc_vec_alloc<unsigned char> (length); 15499 15500 insert_float (rtl, array); 15501 add_AT_vec (die, DW_AT_const_value, length / 4, 4, array); 15502 } 15503 } 15504 return true; 15505 15506 case CONST_VECTOR: 15507 { 15508 machine_mode mode = GET_MODE (rtl); 15509 unsigned int elt_size = GET_MODE_UNIT_SIZE (mode); 15510 unsigned int length = CONST_VECTOR_NUNITS (rtl); 15511 unsigned char *array 15512 = ggc_vec_alloc<unsigned char> (length * elt_size); 15513 unsigned int i; 15514 unsigned char *p; 15515 machine_mode imode = GET_MODE_INNER (mode); 15516 15517 switch (GET_MODE_CLASS (mode)) 15518 { 15519 case MODE_VECTOR_INT: 15520 for (i = 0, p = array; i < length; i++, p += elt_size) 15521 { 15522 rtx elt = CONST_VECTOR_ELT (rtl, i); 15523 insert_wide_int (std::make_pair (elt, imode), p, elt_size); 15524 } 15525 break; 15526 15527 case MODE_VECTOR_FLOAT: 15528 for (i = 0, p = array; i < length; i++, p += elt_size) 15529 { 15530 rtx elt = CONST_VECTOR_ELT (rtl, i); 15531 insert_float (elt, p); 15532 } 15533 break; 15534 15535 default: 15536 gcc_unreachable (); 15537 } 15538 15539 add_AT_vec (die, DW_AT_const_value, length, elt_size, array); 15540 } 15541 return true; 15542 15543 case CONST_STRING: 15544 if (dwarf_version >= 4 || !dwarf_strict) 15545 { 15546 dw_loc_descr_ref loc_result; 15547 resolve_one_addr (&rtl); 15548 rtl_addr: 15549 loc_result = new_addr_loc_descr (rtl, dtprel_false); 15550 add_loc_descr (&loc_result, new_loc_descr (DW_OP_stack_value, 0, 0)); 15551 add_AT_loc (die, DW_AT_location, loc_result); 15552 vec_safe_push (used_rtx_array, rtl); 15553 return true; 15554 } 15555 return false; 15556 15557 case CONST: 15558 if (CONSTANT_P (XEXP (rtl, 0))) 15559 return add_const_value_attribute (die, XEXP (rtl, 0)); 15560 /* FALLTHROUGH */ 15561 case SYMBOL_REF: 15562 if (!const_ok_for_output (rtl)) 15563 return false; 15564 case LABEL_REF: 15565 if (dwarf_version >= 4 || !dwarf_strict) 15566 goto rtl_addr; 15567 return false; 15568 15569 case PLUS: 15570 /* In cases where an inlined instance of an inline function is passed 15571 the address of an `auto' variable (which is local to the caller) we 15572 can get a situation where the DECL_RTL of the artificial local 15573 variable (for the inlining) which acts as a stand-in for the 15574 corresponding formal parameter (of the inline function) will look 15575 like (plus:SI (reg:SI FRAME_PTR) (const_int ...)). This is not 15576 exactly a compile-time constant expression, but it isn't the address 15577 of the (artificial) local variable either. Rather, it represents the 15578 *value* which the artificial local variable always has during its 15579 lifetime. We currently have no way to represent such quasi-constant 15580 values in Dwarf, so for now we just punt and generate nothing. */ 15581 return false; 15582 15583 case HIGH: 15584 case CONST_FIXED: 15585 return false; 15586 15587 case MEM: 15588 if (GET_CODE (XEXP (rtl, 0)) == CONST_STRING 15589 && MEM_READONLY_P (rtl) 15590 && GET_MODE (rtl) == BLKmode) 15591 { 15592 add_AT_string (die, DW_AT_const_value, XSTR (XEXP (rtl, 0), 0)); 15593 return true; 15594 } 15595 return false; 15596 15597 default: 15598 /* No other kinds of rtx should be possible here. */ 15599 gcc_unreachable (); 15600 } 15601 return false; 15602} 15603 15604/* Determine whether the evaluation of EXPR references any variables 15605 or functions which aren't otherwise used (and therefore may not be 15606 output). */ 15607static tree 15608reference_to_unused (tree * tp, int * walk_subtrees, 15609 void * data ATTRIBUTE_UNUSED) 15610{ 15611 if (! EXPR_P (*tp) && ! CONSTANT_CLASS_P (*tp)) 15612 *walk_subtrees = 0; 15613 15614 if (DECL_P (*tp) && ! TREE_PUBLIC (*tp) && ! TREE_USED (*tp) 15615 && ! TREE_ASM_WRITTEN (*tp)) 15616 return *tp; 15617 /* ??? The C++ FE emits debug information for using decls, so 15618 putting gcc_unreachable here falls over. See PR31899. For now 15619 be conservative. */ 15620 else if (!symtab->global_info_ready 15621 && (TREE_CODE (*tp) == VAR_DECL || TREE_CODE (*tp) == FUNCTION_DECL)) 15622 return *tp; 15623 else if (TREE_CODE (*tp) == VAR_DECL) 15624 { 15625 varpool_node *node = varpool_node::get (*tp); 15626 if (!node || !node->definition) 15627 return *tp; 15628 } 15629 else if (TREE_CODE (*tp) == FUNCTION_DECL 15630 && (!DECL_EXTERNAL (*tp) || DECL_DECLARED_INLINE_P (*tp))) 15631 { 15632 /* The call graph machinery must have finished analyzing, 15633 optimizing and gimplifying the CU by now. 15634 So if *TP has no call graph node associated 15635 to it, it means *TP will not be emitted. */ 15636 if (!cgraph_node::get (*tp)) 15637 return *tp; 15638 } 15639 else if (TREE_CODE (*tp) == STRING_CST && !TREE_ASM_WRITTEN (*tp)) 15640 return *tp; 15641 15642 return NULL_TREE; 15643} 15644 15645/* Generate an RTL constant from a decl initializer INIT with decl type TYPE, 15646 for use in a later add_const_value_attribute call. */ 15647 15648static rtx 15649rtl_for_decl_init (tree init, tree type) 15650{ 15651 rtx rtl = NULL_RTX; 15652 15653 STRIP_NOPS (init); 15654 15655 /* If a variable is initialized with a string constant without embedded 15656 zeros, build CONST_STRING. */ 15657 if (TREE_CODE (init) == STRING_CST && TREE_CODE (type) == ARRAY_TYPE) 15658 { 15659 tree enttype = TREE_TYPE (type); 15660 tree domain = TYPE_DOMAIN (type); 15661 machine_mode mode = TYPE_MODE (enttype); 15662 15663 if (GET_MODE_CLASS (mode) == MODE_INT && GET_MODE_SIZE (mode) == 1 15664 && domain 15665 && integer_zerop (TYPE_MIN_VALUE (domain)) 15666 && compare_tree_int (TYPE_MAX_VALUE (domain), 15667 TREE_STRING_LENGTH (init) - 1) == 0 15668 && ((size_t) TREE_STRING_LENGTH (init) 15669 == strlen (TREE_STRING_POINTER (init)) + 1)) 15670 { 15671 rtl = gen_rtx_CONST_STRING (VOIDmode, 15672 ggc_strdup (TREE_STRING_POINTER (init))); 15673 rtl = gen_rtx_MEM (BLKmode, rtl); 15674 MEM_READONLY_P (rtl) = 1; 15675 } 15676 } 15677 /* Other aggregates, and complex values, could be represented using 15678 CONCAT: FIXME! */ 15679 else if (AGGREGATE_TYPE_P (type) 15680 || (TREE_CODE (init) == VIEW_CONVERT_EXPR 15681 && AGGREGATE_TYPE_P (TREE_TYPE (TREE_OPERAND (init, 0)))) 15682 || TREE_CODE (type) == COMPLEX_TYPE) 15683 ; 15684 /* Vectors only work if their mode is supported by the target. 15685 FIXME: generic vectors ought to work too. */ 15686 else if (TREE_CODE (type) == VECTOR_TYPE 15687 && !VECTOR_MODE_P (TYPE_MODE (type))) 15688 ; 15689 /* If the initializer is something that we know will expand into an 15690 immediate RTL constant, expand it now. We must be careful not to 15691 reference variables which won't be output. */ 15692 else if (initializer_constant_valid_p (init, type) 15693 && ! walk_tree (&init, reference_to_unused, NULL, NULL)) 15694 { 15695 /* Convert vector CONSTRUCTOR initializers to VECTOR_CST if 15696 possible. */ 15697 if (TREE_CODE (type) == VECTOR_TYPE) 15698 switch (TREE_CODE (init)) 15699 { 15700 case VECTOR_CST: 15701 break; 15702 case CONSTRUCTOR: 15703 if (TREE_CONSTANT (init)) 15704 { 15705 vec<constructor_elt, va_gc> *elts = CONSTRUCTOR_ELTS (init); 15706 bool constant_p = true; 15707 tree value; 15708 unsigned HOST_WIDE_INT ix; 15709 15710 /* Even when ctor is constant, it might contain non-*_CST 15711 elements (e.g. { 1.0/0.0 - 1.0/0.0, 0.0 }) and those don't 15712 belong into VECTOR_CST nodes. */ 15713 FOR_EACH_CONSTRUCTOR_VALUE (elts, ix, value) 15714 if (!CONSTANT_CLASS_P (value)) 15715 { 15716 constant_p = false; 15717 break; 15718 } 15719 15720 if (constant_p) 15721 { 15722 init = build_vector_from_ctor (type, elts); 15723 break; 15724 } 15725 } 15726 /* FALLTHRU */ 15727 15728 default: 15729 return NULL; 15730 } 15731 15732 rtl = expand_expr (init, NULL_RTX, VOIDmode, EXPAND_INITIALIZER); 15733 15734 /* If expand_expr returns a MEM, it wasn't immediate. */ 15735 gcc_assert (!rtl || !MEM_P (rtl)); 15736 } 15737 15738 return rtl; 15739} 15740 15741/* Generate RTL for the variable DECL to represent its location. */ 15742 15743static rtx 15744rtl_for_decl_location (tree decl) 15745{ 15746 rtx rtl; 15747 15748 /* Here we have to decide where we are going to say the parameter "lives" 15749 (as far as the debugger is concerned). We only have a couple of 15750 choices. GCC provides us with DECL_RTL and with DECL_INCOMING_RTL. 15751 15752 DECL_RTL normally indicates where the parameter lives during most of the 15753 activation of the function. If optimization is enabled however, this 15754 could be either NULL or else a pseudo-reg. Both of those cases indicate 15755 that the parameter doesn't really live anywhere (as far as the code 15756 generation parts of GCC are concerned) during most of the function's 15757 activation. That will happen (for example) if the parameter is never 15758 referenced within the function. 15759 15760 We could just generate a location descriptor here for all non-NULL 15761 non-pseudo values of DECL_RTL and ignore all of the rest, but we can be 15762 a little nicer than that if we also consider DECL_INCOMING_RTL in cases 15763 where DECL_RTL is NULL or is a pseudo-reg. 15764 15765 Note however that we can only get away with using DECL_INCOMING_RTL as 15766 a backup substitute for DECL_RTL in certain limited cases. In cases 15767 where DECL_ARG_TYPE (decl) indicates the same type as TREE_TYPE (decl), 15768 we can be sure that the parameter was passed using the same type as it is 15769 declared to have within the function, and that its DECL_INCOMING_RTL 15770 points us to a place where a value of that type is passed. 15771 15772 In cases where DECL_ARG_TYPE (decl) and TREE_TYPE (decl) are different, 15773 we cannot (in general) use DECL_INCOMING_RTL as a substitute for DECL_RTL 15774 because in these cases DECL_INCOMING_RTL points us to a value of some 15775 type which is *different* from the type of the parameter itself. Thus, 15776 if we tried to use DECL_INCOMING_RTL to generate a location attribute in 15777 such cases, the debugger would end up (for example) trying to fetch a 15778 `float' from a place which actually contains the first part of a 15779 `double'. That would lead to really incorrect and confusing 15780 output at debug-time. 15781 15782 So, in general, we *do not* use DECL_INCOMING_RTL as a backup for DECL_RTL 15783 in cases where DECL_ARG_TYPE (decl) != TREE_TYPE (decl). There 15784 are a couple of exceptions however. On little-endian machines we can 15785 get away with using DECL_INCOMING_RTL even when DECL_ARG_TYPE (decl) is 15786 not the same as TREE_TYPE (decl), but only when DECL_ARG_TYPE (decl) is 15787 an integral type that is smaller than TREE_TYPE (decl). These cases arise 15788 when (on a little-endian machine) a non-prototyped function has a 15789 parameter declared to be of type `short' or `char'. In such cases, 15790 TREE_TYPE (decl) will be `short' or `char', DECL_ARG_TYPE (decl) will 15791 be `int', and DECL_INCOMING_RTL will point to the lowest-order byte of the 15792 passed `int' value. If the debugger then uses that address to fetch 15793 a `short' or a `char' (on a little-endian machine) the result will be 15794 the correct data, so we allow for such exceptional cases below. 15795 15796 Note that our goal here is to describe the place where the given formal 15797 parameter lives during most of the function's activation (i.e. between the 15798 end of the prologue and the start of the epilogue). We'll do that as best 15799 as we can. Note however that if the given formal parameter is modified 15800 sometime during the execution of the function, then a stack backtrace (at 15801 debug-time) will show the function as having been called with the *new* 15802 value rather than the value which was originally passed in. This happens 15803 rarely enough that it is not a major problem, but it *is* a problem, and 15804 I'd like to fix it. 15805 15806 A future version of dwarf2out.c may generate two additional attributes for 15807 any given DW_TAG_formal_parameter DIE which will describe the "passed 15808 type" and the "passed location" for the given formal parameter in addition 15809 to the attributes we now generate to indicate the "declared type" and the 15810 "active location" for each parameter. This additional set of attributes 15811 could be used by debuggers for stack backtraces. Separately, note that 15812 sometimes DECL_RTL can be NULL and DECL_INCOMING_RTL can be NULL also. 15813 This happens (for example) for inlined-instances of inline function formal 15814 parameters which are never referenced. This really shouldn't be 15815 happening. All PARM_DECL nodes should get valid non-NULL 15816 DECL_INCOMING_RTL values. FIXME. */ 15817 15818 /* Use DECL_RTL as the "location" unless we find something better. */ 15819 rtl = DECL_RTL_IF_SET (decl); 15820 15821 /* When generating abstract instances, ignore everything except 15822 constants, symbols living in memory, and symbols living in 15823 fixed registers. */ 15824 if (! reload_completed) 15825 { 15826 if (rtl 15827 && (CONSTANT_P (rtl) 15828 || (MEM_P (rtl) 15829 && CONSTANT_P (XEXP (rtl, 0))) 15830 || (REG_P (rtl) 15831 && TREE_CODE (decl) == VAR_DECL 15832 && TREE_STATIC (decl)))) 15833 { 15834 rtl = targetm.delegitimize_address (rtl); 15835 return rtl; 15836 } 15837 rtl = NULL_RTX; 15838 } 15839 else if (TREE_CODE (decl) == PARM_DECL) 15840 { 15841 if (rtl == NULL_RTX 15842 || is_pseudo_reg (rtl) 15843 || (MEM_P (rtl) 15844 && is_pseudo_reg (XEXP (rtl, 0)) 15845 && DECL_INCOMING_RTL (decl) 15846 && MEM_P (DECL_INCOMING_RTL (decl)) 15847 && GET_MODE (rtl) == GET_MODE (DECL_INCOMING_RTL (decl)))) 15848 { 15849 tree declared_type = TREE_TYPE (decl); 15850 tree passed_type = DECL_ARG_TYPE (decl); 15851 machine_mode dmode = TYPE_MODE (declared_type); 15852 machine_mode pmode = TYPE_MODE (passed_type); 15853 15854 /* This decl represents a formal parameter which was optimized out. 15855 Note that DECL_INCOMING_RTL may be NULL in here, but we handle 15856 all cases where (rtl == NULL_RTX) just below. */ 15857 if (dmode == pmode) 15858 rtl = DECL_INCOMING_RTL (decl); 15859 else if ((rtl == NULL_RTX || is_pseudo_reg (rtl)) 15860 && SCALAR_INT_MODE_P (dmode) 15861 && GET_MODE_SIZE (dmode) <= GET_MODE_SIZE (pmode) 15862 && DECL_INCOMING_RTL (decl)) 15863 { 15864 rtx inc = DECL_INCOMING_RTL (decl); 15865 if (REG_P (inc)) 15866 rtl = inc; 15867 else if (MEM_P (inc)) 15868 { 15869 if (BYTES_BIG_ENDIAN) 15870 rtl = adjust_address_nv (inc, dmode, 15871 GET_MODE_SIZE (pmode) 15872 - GET_MODE_SIZE (dmode)); 15873 else 15874 rtl = inc; 15875 } 15876 } 15877 } 15878 15879 /* If the parm was passed in registers, but lives on the stack, then 15880 make a big endian correction if the mode of the type of the 15881 parameter is not the same as the mode of the rtl. */ 15882 /* ??? This is the same series of checks that are made in dbxout.c before 15883 we reach the big endian correction code there. It isn't clear if all 15884 of these checks are necessary here, but keeping them all is the safe 15885 thing to do. */ 15886 else if (MEM_P (rtl) 15887 && XEXP (rtl, 0) != const0_rtx 15888 && ! CONSTANT_P (XEXP (rtl, 0)) 15889 /* Not passed in memory. */ 15890 && !MEM_P (DECL_INCOMING_RTL (decl)) 15891 /* Not passed by invisible reference. */ 15892 && (!REG_P (XEXP (rtl, 0)) 15893 || REGNO (XEXP (rtl, 0)) == HARD_FRAME_POINTER_REGNUM 15894 || REGNO (XEXP (rtl, 0)) == STACK_POINTER_REGNUM 15895#if !HARD_FRAME_POINTER_IS_ARG_POINTER 15896 || REGNO (XEXP (rtl, 0)) == ARG_POINTER_REGNUM 15897#endif 15898 ) 15899 /* Big endian correction check. */ 15900 && BYTES_BIG_ENDIAN 15901 && TYPE_MODE (TREE_TYPE (decl)) != GET_MODE (rtl) 15902 && (GET_MODE_SIZE (TYPE_MODE (TREE_TYPE (decl))) 15903 < UNITS_PER_WORD)) 15904 { 15905 machine_mode addr_mode = get_address_mode (rtl); 15906 int offset = (UNITS_PER_WORD 15907 - GET_MODE_SIZE (TYPE_MODE (TREE_TYPE (decl)))); 15908 15909 rtl = gen_rtx_MEM (TYPE_MODE (TREE_TYPE (decl)), 15910 plus_constant (addr_mode, XEXP (rtl, 0), offset)); 15911 } 15912 } 15913 else if (TREE_CODE (decl) == VAR_DECL 15914 && rtl 15915 && MEM_P (rtl) 15916 && GET_MODE (rtl) != TYPE_MODE (TREE_TYPE (decl)) 15917 && BYTES_BIG_ENDIAN) 15918 { 15919 machine_mode addr_mode = get_address_mode (rtl); 15920 int rsize = GET_MODE_SIZE (GET_MODE (rtl)); 15921 int dsize = GET_MODE_SIZE (TYPE_MODE (TREE_TYPE (decl))); 15922 15923 /* If a variable is declared "register" yet is smaller than 15924 a register, then if we store the variable to memory, it 15925 looks like we're storing a register-sized value, when in 15926 fact we are not. We need to adjust the offset of the 15927 storage location to reflect the actual value's bytes, 15928 else gdb will not be able to display it. */ 15929 if (rsize > dsize) 15930 rtl = gen_rtx_MEM (TYPE_MODE (TREE_TYPE (decl)), 15931 plus_constant (addr_mode, XEXP (rtl, 0), 15932 rsize - dsize)); 15933 } 15934 15935 /* A variable with no DECL_RTL but a DECL_INITIAL is a compile-time constant, 15936 and will have been substituted directly into all expressions that use it. 15937 C does not have such a concept, but C++ and other languages do. */ 15938 if (!rtl && TREE_CODE (decl) == VAR_DECL && DECL_INITIAL (decl)) 15939 rtl = rtl_for_decl_init (DECL_INITIAL (decl), TREE_TYPE (decl)); 15940 15941 if (rtl) 15942 rtl = targetm.delegitimize_address (rtl); 15943 15944 /* If we don't look past the constant pool, we risk emitting a 15945 reference to a constant pool entry that isn't referenced from 15946 code, and thus is not emitted. */ 15947 if (rtl) 15948 rtl = avoid_constant_pool_reference (rtl); 15949 15950 /* Try harder to get a rtl. If this symbol ends up not being emitted 15951 in the current CU, resolve_addr will remove the expression referencing 15952 it. */ 15953 if (rtl == NULL_RTX 15954 && TREE_CODE (decl) == VAR_DECL 15955 && !DECL_EXTERNAL (decl) 15956 && TREE_STATIC (decl) 15957 && DECL_NAME (decl) 15958 && !DECL_HARD_REGISTER (decl) 15959 && DECL_MODE (decl) != VOIDmode) 15960 { 15961 rtl = make_decl_rtl_for_debug (decl); 15962 if (!MEM_P (rtl) 15963 || GET_CODE (XEXP (rtl, 0)) != SYMBOL_REF 15964 || SYMBOL_REF_DECL (XEXP (rtl, 0)) != decl) 15965 rtl = NULL_RTX; 15966 } 15967 15968 return rtl; 15969} 15970 15971/* Check whether decl is a Fortran COMMON symbol. If not, NULL_TREE is 15972 returned. If so, the decl for the COMMON block is returned, and the 15973 value is the offset into the common block for the symbol. */ 15974 15975static tree 15976fortran_common (tree decl, HOST_WIDE_INT *value) 15977{ 15978 tree val_expr, cvar; 15979 machine_mode mode; 15980 HOST_WIDE_INT bitsize, bitpos; 15981 tree offset; 15982 int unsignedp, volatilep = 0; 15983 15984 /* If the decl isn't a VAR_DECL, or if it isn't static, or if 15985 it does not have a value (the offset into the common area), or if it 15986 is thread local (as opposed to global) then it isn't common, and shouldn't 15987 be handled as such. */ 15988 if (TREE_CODE (decl) != VAR_DECL 15989 || !TREE_STATIC (decl) 15990 || !DECL_HAS_VALUE_EXPR_P (decl) 15991 || !is_fortran ()) 15992 return NULL_TREE; 15993 15994 val_expr = DECL_VALUE_EXPR (decl); 15995 if (TREE_CODE (val_expr) != COMPONENT_REF) 15996 return NULL_TREE; 15997 15998 cvar = get_inner_reference (val_expr, &bitsize, &bitpos, &offset, 15999 &mode, &unsignedp, &volatilep, true); 16000 16001 if (cvar == NULL_TREE 16002 || TREE_CODE (cvar) != VAR_DECL 16003 || DECL_ARTIFICIAL (cvar) 16004 || !TREE_PUBLIC (cvar)) 16005 return NULL_TREE; 16006 16007 *value = 0; 16008 if (offset != NULL) 16009 { 16010 if (!tree_fits_shwi_p (offset)) 16011 return NULL_TREE; 16012 *value = tree_to_shwi (offset); 16013 } 16014 if (bitpos != 0) 16015 *value += bitpos / BITS_PER_UNIT; 16016 16017 return cvar; 16018} 16019 16020/* Generate *either* a DW_AT_location attribute or else a DW_AT_const_value 16021 data attribute for a variable or a parameter. We generate the 16022 DW_AT_const_value attribute only in those cases where the given variable 16023 or parameter does not have a true "location" either in memory or in a 16024 register. This can happen (for example) when a constant is passed as an 16025 actual argument in a call to an inline function. (It's possible that 16026 these things can crop up in other ways also.) Note that one type of 16027 constant value which can be passed into an inlined function is a constant 16028 pointer. This can happen for example if an actual argument in an inlined 16029 function call evaluates to a compile-time constant address. 16030 16031 CACHE_P is true if it is worth caching the location list for DECL, 16032 so that future calls can reuse it rather than regenerate it from scratch. 16033 This is true for BLOCK_NONLOCALIZED_VARS in inlined subroutines, 16034 since we will need to refer to them each time the function is inlined. */ 16035 16036static bool 16037add_location_or_const_value_attribute (dw_die_ref die, tree decl, bool cache_p, 16038 enum dwarf_attribute attr) 16039{ 16040 rtx rtl; 16041 dw_loc_list_ref list; 16042 var_loc_list *loc_list; 16043 cached_dw_loc_list *cache; 16044 16045 if (TREE_CODE (decl) == ERROR_MARK) 16046 return false; 16047 16048 gcc_assert (TREE_CODE (decl) == VAR_DECL || TREE_CODE (decl) == PARM_DECL 16049 || TREE_CODE (decl) == RESULT_DECL); 16050 16051 /* Try to get some constant RTL for this decl, and use that as the value of 16052 the location. */ 16053 16054 rtl = rtl_for_decl_location (decl); 16055 if (rtl && (CONSTANT_P (rtl) || GET_CODE (rtl) == CONST_STRING) 16056 && add_const_value_attribute (die, rtl)) 16057 return true; 16058 16059 /* See if we have single element location list that is equivalent to 16060 a constant value. That way we are better to use add_const_value_attribute 16061 rather than expanding constant value equivalent. */ 16062 loc_list = lookup_decl_loc (decl); 16063 if (loc_list 16064 && loc_list->first 16065 && loc_list->first->next == NULL 16066 && NOTE_P (loc_list->first->loc) 16067 && NOTE_VAR_LOCATION (loc_list->first->loc) 16068 && NOTE_VAR_LOCATION_LOC (loc_list->first->loc)) 16069 { 16070 struct var_loc_node *node; 16071 16072 node = loc_list->first; 16073 rtl = NOTE_VAR_LOCATION_LOC (node->loc); 16074 if (GET_CODE (rtl) == EXPR_LIST) 16075 rtl = XEXP (rtl, 0); 16076 if ((CONSTANT_P (rtl) || GET_CODE (rtl) == CONST_STRING) 16077 && add_const_value_attribute (die, rtl)) 16078 return true; 16079 } 16080 /* If this decl is from BLOCK_NONLOCALIZED_VARS, we might need its 16081 list several times. See if we've already cached the contents. */ 16082 list = NULL; 16083 if (loc_list == NULL || cached_dw_loc_list_table == NULL) 16084 cache_p = false; 16085 if (cache_p) 16086 { 16087 cache = cached_dw_loc_list_table->find_with_hash (decl, DECL_UID (decl)); 16088 if (cache) 16089 list = cache->loc_list; 16090 } 16091 if (list == NULL) 16092 { 16093 list = loc_list_from_tree (decl, decl_by_reference_p (decl) ? 0 : 2, 16094 NULL); 16095 /* It is usually worth caching this result if the decl is from 16096 BLOCK_NONLOCALIZED_VARS and if the list has at least two elements. */ 16097 if (cache_p && list && list->dw_loc_next) 16098 { 16099 cached_dw_loc_list **slot 16100 = cached_dw_loc_list_table->find_slot_with_hash (decl, 16101 DECL_UID (decl), 16102 INSERT); 16103 cache = ggc_cleared_alloc<cached_dw_loc_list> (); 16104 cache->decl_id = DECL_UID (decl); 16105 cache->loc_list = list; 16106 *slot = cache; 16107 } 16108 } 16109 if (list) 16110 { 16111 add_AT_location_description (die, attr, list); 16112 return true; 16113 } 16114 /* None of that worked, so it must not really have a location; 16115 try adding a constant value attribute from the DECL_INITIAL. */ 16116 return tree_add_const_value_attribute_for_decl (die, decl); 16117} 16118 16119/* Add VARIABLE and DIE into deferred locations list. */ 16120 16121static void 16122defer_location (tree variable, dw_die_ref die) 16123{ 16124 deferred_locations entry; 16125 entry.variable = variable; 16126 entry.die = die; 16127 vec_safe_push (deferred_locations_list, entry); 16128} 16129 16130/* Helper function for tree_add_const_value_attribute. Natively encode 16131 initializer INIT into an array. Return true if successful. */ 16132 16133static bool 16134native_encode_initializer (tree init, unsigned char *array, int size) 16135{ 16136 tree type; 16137 16138 if (init == NULL_TREE) 16139 return false; 16140 16141 STRIP_NOPS (init); 16142 switch (TREE_CODE (init)) 16143 { 16144 case STRING_CST: 16145 type = TREE_TYPE (init); 16146 if (TREE_CODE (type) == ARRAY_TYPE) 16147 { 16148 tree enttype = TREE_TYPE (type); 16149 machine_mode mode = TYPE_MODE (enttype); 16150 16151 if (GET_MODE_CLASS (mode) != MODE_INT || GET_MODE_SIZE (mode) != 1) 16152 return false; 16153 if (int_size_in_bytes (type) != size) 16154 return false; 16155 if (size > TREE_STRING_LENGTH (init)) 16156 { 16157 memcpy (array, TREE_STRING_POINTER (init), 16158 TREE_STRING_LENGTH (init)); 16159 memset (array + TREE_STRING_LENGTH (init), 16160 '\0', size - TREE_STRING_LENGTH (init)); 16161 } 16162 else 16163 memcpy (array, TREE_STRING_POINTER (init), size); 16164 return true; 16165 } 16166 return false; 16167 case CONSTRUCTOR: 16168 type = TREE_TYPE (init); 16169 if (int_size_in_bytes (type) != size) 16170 return false; 16171 if (TREE_CODE (type) == ARRAY_TYPE) 16172 { 16173 HOST_WIDE_INT min_index; 16174 unsigned HOST_WIDE_INT cnt; 16175 int curpos = 0, fieldsize; 16176 constructor_elt *ce; 16177 16178 if (TYPE_DOMAIN (type) == NULL_TREE 16179 || !tree_fits_shwi_p (TYPE_MIN_VALUE (TYPE_DOMAIN (type)))) 16180 return false; 16181 16182 fieldsize = int_size_in_bytes (TREE_TYPE (type)); 16183 if (fieldsize <= 0) 16184 return false; 16185 16186 min_index = tree_to_shwi (TYPE_MIN_VALUE (TYPE_DOMAIN (type))); 16187 memset (array, '\0', size); 16188 FOR_EACH_VEC_SAFE_ELT (CONSTRUCTOR_ELTS (init), cnt, ce) 16189 { 16190 tree val = ce->value; 16191 tree index = ce->index; 16192 int pos = curpos; 16193 if (index && TREE_CODE (index) == RANGE_EXPR) 16194 pos = (tree_to_shwi (TREE_OPERAND (index, 0)) - min_index) 16195 * fieldsize; 16196 else if (index) 16197 pos = (tree_to_shwi (index) - min_index) * fieldsize; 16198 16199 if (val) 16200 { 16201 STRIP_NOPS (val); 16202 if (!native_encode_initializer (val, array + pos, fieldsize)) 16203 return false; 16204 } 16205 curpos = pos + fieldsize; 16206 if (index && TREE_CODE (index) == RANGE_EXPR) 16207 { 16208 int count = tree_to_shwi (TREE_OPERAND (index, 1)) 16209 - tree_to_shwi (TREE_OPERAND (index, 0)); 16210 while (count-- > 0) 16211 { 16212 if (val) 16213 memcpy (array + curpos, array + pos, fieldsize); 16214 curpos += fieldsize; 16215 } 16216 } 16217 gcc_assert (curpos <= size); 16218 } 16219 return true; 16220 } 16221 else if (TREE_CODE (type) == RECORD_TYPE 16222 || TREE_CODE (type) == UNION_TYPE) 16223 { 16224 tree field = NULL_TREE; 16225 unsigned HOST_WIDE_INT cnt; 16226 constructor_elt *ce; 16227 16228 if (int_size_in_bytes (type) != size) 16229 return false; 16230 16231 if (TREE_CODE (type) == RECORD_TYPE) 16232 field = TYPE_FIELDS (type); 16233 16234 FOR_EACH_VEC_SAFE_ELT (CONSTRUCTOR_ELTS (init), cnt, ce) 16235 { 16236 tree val = ce->value; 16237 int pos, fieldsize; 16238 16239 if (ce->index != 0) 16240 field = ce->index; 16241 16242 if (val) 16243 STRIP_NOPS (val); 16244 16245 if (field == NULL_TREE || DECL_BIT_FIELD (field)) 16246 return false; 16247 16248 if (TREE_CODE (TREE_TYPE (field)) == ARRAY_TYPE 16249 && TYPE_DOMAIN (TREE_TYPE (field)) 16250 && ! TYPE_MAX_VALUE (TYPE_DOMAIN (TREE_TYPE (field)))) 16251 return false; 16252 else if (DECL_SIZE_UNIT (field) == NULL_TREE 16253 || !tree_fits_shwi_p (DECL_SIZE_UNIT (field))) 16254 return false; 16255 fieldsize = tree_to_shwi (DECL_SIZE_UNIT (field)); 16256 pos = int_byte_position (field); 16257 gcc_assert (pos + fieldsize <= size); 16258 if (val && fieldsize != 0 16259 && !native_encode_initializer (val, array + pos, fieldsize)) 16260 return false; 16261 } 16262 return true; 16263 } 16264 return false; 16265 case VIEW_CONVERT_EXPR: 16266 case NON_LVALUE_EXPR: 16267 return native_encode_initializer (TREE_OPERAND (init, 0), array, size); 16268 default: 16269 return native_encode_expr (init, array, size) == size; 16270 } 16271} 16272 16273/* Attach a DW_AT_const_value attribute to DIE. The value of the 16274 attribute is the const value T. */ 16275 16276static bool 16277tree_add_const_value_attribute (dw_die_ref die, tree t) 16278{ 16279 tree init; 16280 tree type = TREE_TYPE (t); 16281 rtx rtl; 16282 16283 if (!t || !TREE_TYPE (t) || TREE_TYPE (t) == error_mark_node) 16284 return false; 16285 16286 init = t; 16287 gcc_assert (!DECL_P (init)); 16288 16289 rtl = rtl_for_decl_init (init, type); 16290 if (rtl) 16291 return add_const_value_attribute (die, rtl); 16292 /* If the host and target are sane, try harder. */ 16293 else if (CHAR_BIT == 8 && BITS_PER_UNIT == 8 16294 && initializer_constant_valid_p (init, type)) 16295 { 16296 HOST_WIDE_INT size = int_size_in_bytes (TREE_TYPE (init)); 16297 if (size > 0 && (int) size == size) 16298 { 16299 unsigned char *array = ggc_cleared_vec_alloc<unsigned char> (size); 16300 16301 if (native_encode_initializer (init, array, size)) 16302 { 16303 add_AT_vec (die, DW_AT_const_value, size, 1, array); 16304 return true; 16305 } 16306 ggc_free (array); 16307 } 16308 } 16309 return false; 16310} 16311 16312/* Attach a DW_AT_const_value attribute to VAR_DIE. The value of the 16313 attribute is the const value of T, where T is an integral constant 16314 variable with static storage duration 16315 (so it can't be a PARM_DECL or a RESULT_DECL). */ 16316 16317static bool 16318tree_add_const_value_attribute_for_decl (dw_die_ref var_die, tree decl) 16319{ 16320 16321 if (!decl 16322 || (TREE_CODE (decl) != VAR_DECL 16323 && TREE_CODE (decl) != CONST_DECL) 16324 || (TREE_CODE (decl) == VAR_DECL 16325 && !TREE_STATIC (decl))) 16326 return false; 16327 16328 if (TREE_READONLY (decl) 16329 && ! TREE_THIS_VOLATILE (decl) 16330 && DECL_INITIAL (decl)) 16331 /* OK */; 16332 else 16333 return false; 16334 16335 /* Don't add DW_AT_const_value if abstract origin already has one. */ 16336 if (get_AT (var_die, DW_AT_const_value)) 16337 return false; 16338 16339 return tree_add_const_value_attribute (var_die, DECL_INITIAL (decl)); 16340} 16341 16342/* Convert the CFI instructions for the current function into a 16343 location list. This is used for DW_AT_frame_base when we targeting 16344 a dwarf2 consumer that does not support the dwarf3 16345 DW_OP_call_frame_cfa. OFFSET is a constant to be added to all CFA 16346 expressions. */ 16347 16348static dw_loc_list_ref 16349convert_cfa_to_fb_loc_list (HOST_WIDE_INT offset) 16350{ 16351 int ix; 16352 dw_fde_ref fde; 16353 dw_loc_list_ref list, *list_tail; 16354 dw_cfi_ref cfi; 16355 dw_cfa_location last_cfa, next_cfa; 16356 const char *start_label, *last_label, *section; 16357 dw_cfa_location remember; 16358 16359 fde = cfun->fde; 16360 gcc_assert (fde != NULL); 16361 16362 section = secname_for_decl (current_function_decl); 16363 list_tail = &list; 16364 list = NULL; 16365 16366 memset (&next_cfa, 0, sizeof (next_cfa)); 16367 next_cfa.reg = INVALID_REGNUM; 16368 remember = next_cfa; 16369 16370 start_label = fde->dw_fde_begin; 16371 16372 /* ??? Bald assumption that the CIE opcode list does not contain 16373 advance opcodes. */ 16374 FOR_EACH_VEC_ELT (*cie_cfi_vec, ix, cfi) 16375 lookup_cfa_1 (cfi, &next_cfa, &remember); 16376 16377 last_cfa = next_cfa; 16378 last_label = start_label; 16379 16380 if (fde->dw_fde_second_begin && fde->dw_fde_switch_cfi_index == 0) 16381 { 16382 /* If the first partition contained no CFI adjustments, the 16383 CIE opcodes apply to the whole first partition. */ 16384 *list_tail = new_loc_list (build_cfa_loc (&last_cfa, offset), 16385 fde->dw_fde_begin, fde->dw_fde_end, section); 16386 list_tail =&(*list_tail)->dw_loc_next; 16387 start_label = last_label = fde->dw_fde_second_begin; 16388 } 16389 16390 FOR_EACH_VEC_SAFE_ELT (fde->dw_fde_cfi, ix, cfi) 16391 { 16392 switch (cfi->dw_cfi_opc) 16393 { 16394 case DW_CFA_set_loc: 16395 case DW_CFA_advance_loc1: 16396 case DW_CFA_advance_loc2: 16397 case DW_CFA_advance_loc4: 16398 if (!cfa_equal_p (&last_cfa, &next_cfa)) 16399 { 16400 *list_tail = new_loc_list (build_cfa_loc (&last_cfa, offset), 16401 start_label, last_label, section); 16402 16403 list_tail = &(*list_tail)->dw_loc_next; 16404 last_cfa = next_cfa; 16405 start_label = last_label; 16406 } 16407 last_label = cfi->dw_cfi_oprnd1.dw_cfi_addr; 16408 break; 16409 16410 case DW_CFA_advance_loc: 16411 /* The encoding is complex enough that we should never emit this. */ 16412 gcc_unreachable (); 16413 16414 default: 16415 lookup_cfa_1 (cfi, &next_cfa, &remember); 16416 break; 16417 } 16418 if (ix + 1 == fde->dw_fde_switch_cfi_index) 16419 { 16420 if (!cfa_equal_p (&last_cfa, &next_cfa)) 16421 { 16422 *list_tail = new_loc_list (build_cfa_loc (&last_cfa, offset), 16423 start_label, last_label, section); 16424 16425 list_tail = &(*list_tail)->dw_loc_next; 16426 last_cfa = next_cfa; 16427 start_label = last_label; 16428 } 16429 *list_tail = new_loc_list (build_cfa_loc (&last_cfa, offset), 16430 start_label, fde->dw_fde_end, section); 16431 list_tail = &(*list_tail)->dw_loc_next; 16432 start_label = last_label = fde->dw_fde_second_begin; 16433 } 16434 } 16435 16436 if (!cfa_equal_p (&last_cfa, &next_cfa)) 16437 { 16438 *list_tail = new_loc_list (build_cfa_loc (&last_cfa, offset), 16439 start_label, last_label, section); 16440 list_tail = &(*list_tail)->dw_loc_next; 16441 start_label = last_label; 16442 } 16443 16444 *list_tail = new_loc_list (build_cfa_loc (&next_cfa, offset), 16445 start_label, 16446 fde->dw_fde_second_begin 16447 ? fde->dw_fde_second_end : fde->dw_fde_end, 16448 section); 16449 16450 if (list && list->dw_loc_next) 16451 gen_llsym (list); 16452 16453 return list; 16454} 16455 16456/* Compute a displacement from the "steady-state frame pointer" to the 16457 frame base (often the same as the CFA), and store it in 16458 frame_pointer_fb_offset. OFFSET is added to the displacement 16459 before the latter is negated. */ 16460 16461static void 16462compute_frame_pointer_to_fb_displacement (HOST_WIDE_INT offset) 16463{ 16464 rtx reg, elim; 16465 16466#ifdef FRAME_POINTER_CFA_OFFSET 16467 reg = frame_pointer_rtx; 16468 offset += FRAME_POINTER_CFA_OFFSET (current_function_decl); 16469#else 16470 reg = arg_pointer_rtx; 16471 offset += ARG_POINTER_CFA_OFFSET (current_function_decl); 16472#endif 16473 16474 elim = (ira_use_lra_p 16475 ? lra_eliminate_regs (reg, VOIDmode, NULL_RTX) 16476 : eliminate_regs (reg, VOIDmode, NULL_RTX)); 16477 if (GET_CODE (elim) == PLUS) 16478 { 16479 offset += INTVAL (XEXP (elim, 1)); 16480 elim = XEXP (elim, 0); 16481 } 16482 16483 frame_pointer_fb_offset = -offset; 16484 16485 /* ??? AVR doesn't set up valid eliminations when there is no stack frame 16486 in which to eliminate. This is because it's stack pointer isn't 16487 directly accessible as a register within the ISA. To work around 16488 this, assume that while we cannot provide a proper value for 16489 frame_pointer_fb_offset, we won't need one either. */ 16490 frame_pointer_fb_offset_valid 16491 = ((SUPPORTS_STACK_ALIGNMENT 16492 && (elim == hard_frame_pointer_rtx 16493 || elim == stack_pointer_rtx)) 16494 || elim == (frame_pointer_needed 16495 ? hard_frame_pointer_rtx 16496 : stack_pointer_rtx)); 16497} 16498 16499/* Generate a DW_AT_name attribute given some string value to be included as 16500 the value of the attribute. */ 16501 16502static void 16503add_name_attribute (dw_die_ref die, const char *name_string) 16504{ 16505 if (name_string != NULL && *name_string != 0) 16506 { 16507 if (demangle_name_func) 16508 name_string = (*demangle_name_func) (name_string); 16509 16510 add_AT_string (die, DW_AT_name, name_string); 16511 } 16512} 16513 16514/* Retrieve the descriptive type of TYPE, if any, make sure it has a 16515 DIE and attach a DW_AT_GNAT_descriptive_type attribute to the DIE 16516 of TYPE accordingly. 16517 16518 ??? This is a temporary measure until after we're able to generate 16519 regular DWARF for the complex Ada type system. */ 16520 16521static void 16522add_gnat_descriptive_type_attribute (dw_die_ref die, tree type, 16523 dw_die_ref context_die) 16524{ 16525 tree dtype; 16526 dw_die_ref dtype_die; 16527 16528 if (!lang_hooks.types.descriptive_type) 16529 return; 16530 16531 dtype = lang_hooks.types.descriptive_type (type); 16532 if (!dtype) 16533 return; 16534 16535 dtype_die = lookup_type_die (dtype); 16536 if (!dtype_die) 16537 { 16538 gen_type_die (dtype, context_die); 16539 dtype_die = lookup_type_die (dtype); 16540 gcc_assert (dtype_die); 16541 } 16542 16543 add_AT_die_ref (die, DW_AT_GNAT_descriptive_type, dtype_die); 16544} 16545 16546/* Retrieve the comp_dir string suitable for use with DW_AT_comp_dir. */ 16547 16548static const char * 16549comp_dir_string (void) 16550{ 16551 const char *wd; 16552 char *wd1; 16553 static const char *cached_wd = NULL; 16554 16555 if (cached_wd != NULL) 16556 return cached_wd; 16557 16558 wd = get_src_pwd (); 16559 if (wd == NULL) 16560 return NULL; 16561 16562 if (DWARF2_DIR_SHOULD_END_WITH_SEPARATOR) 16563 { 16564 int wdlen; 16565 16566 wdlen = strlen (wd); 16567 wd1 = ggc_vec_alloc<char> (wdlen + 2); 16568 strcpy (wd1, wd); 16569 wd1 [wdlen] = DIR_SEPARATOR; 16570 wd1 [wdlen + 1] = 0; 16571 wd = wd1; 16572 } 16573 16574 cached_wd = remap_debug_filename (wd); 16575 return cached_wd; 16576} 16577 16578/* Generate a DW_AT_comp_dir attribute for DIE. */ 16579 16580static void 16581add_comp_dir_attribute (dw_die_ref die) 16582{ 16583 const char * wd = comp_dir_string (); 16584 if (wd != NULL) 16585 add_AT_string (die, DW_AT_comp_dir, wd); 16586} 16587 16588/* Given a tree node VALUE describing a scalar attribute ATTR (i.e. a bound, a 16589 pointer computation, ...), output a representation for that bound according 16590 to the accepted FORMS (see enum dw_scalar_form) and add it to DIE. See 16591 loc_list_from_tree for the meaning of CONTEXT. */ 16592 16593static void 16594add_scalar_info (dw_die_ref die, enum dwarf_attribute attr, tree value, 16595 int forms, const struct loc_descr_context *context) 16596{ 16597 dw_die_ref ctx, decl_die; 16598 dw_loc_list_ref list; 16599 16600 bool strip_conversions = true; 16601 16602 while (strip_conversions) 16603 switch (TREE_CODE (value)) 16604 { 16605 case ERROR_MARK: 16606 case SAVE_EXPR: 16607 return; 16608 16609 CASE_CONVERT: 16610 case VIEW_CONVERT_EXPR: 16611 value = TREE_OPERAND (value, 0); 16612 break; 16613 16614 default: 16615 strip_conversions = false; 16616 break; 16617 } 16618 16619 /* If possible and permitted, output the attribute as a constant. */ 16620 if ((forms & dw_scalar_form_constant) != 0 16621 && TREE_CODE (value) == INTEGER_CST) 16622 { 16623 unsigned int prec = simple_type_size_in_bits (TREE_TYPE (value)); 16624 16625 /* If HOST_WIDE_INT is big enough then represent the bound as 16626 a constant value. We need to choose a form based on 16627 whether the type is signed or unsigned. We cannot just 16628 call add_AT_unsigned if the value itself is positive 16629 (add_AT_unsigned might add the unsigned value encoded as 16630 DW_FORM_data[1248]). Some DWARF consumers will lookup the 16631 bounds type and then sign extend any unsigned values found 16632 for signed types. This is needed only for 16633 DW_AT_{lower,upper}_bound, since for most other attributes, 16634 consumers will treat DW_FORM_data[1248] as unsigned values, 16635 regardless of the underlying type. */ 16636 if (prec <= HOST_BITS_PER_WIDE_INT 16637 || tree_fits_uhwi_p (value)) 16638 { 16639 if (TYPE_UNSIGNED (TREE_TYPE (value))) 16640 add_AT_unsigned (die, attr, TREE_INT_CST_LOW (value)); 16641 else 16642 add_AT_int (die, attr, TREE_INT_CST_LOW (value)); 16643 } 16644 else 16645 /* Otherwise represent the bound as an unsigned value with 16646 the precision of its type. The precision and signedness 16647 of the type will be necessary to re-interpret it 16648 unambiguously. */ 16649 add_AT_wide (die, attr, value); 16650 return; 16651 } 16652 16653 /* Otherwise, if it's possible and permitted too, output a reference to 16654 another DIE. */ 16655 if ((forms & dw_scalar_form_reference) != 0) 16656 { 16657 tree decl = NULL_TREE; 16658 16659 /* Some type attributes reference an outer type. For instance, the upper 16660 bound of an array may reference an embedding record (this happens in 16661 Ada). */ 16662 if (TREE_CODE (value) == COMPONENT_REF 16663 && TREE_CODE (TREE_OPERAND (value, 0)) == PLACEHOLDER_EXPR 16664 && TREE_CODE (TREE_OPERAND (value, 1)) == FIELD_DECL) 16665 decl = TREE_OPERAND (value, 1); 16666 16667 else if (TREE_CODE (value) == VAR_DECL 16668 || TREE_CODE (value) == PARM_DECL 16669 || TREE_CODE (value) == RESULT_DECL) 16670 decl = value; 16671 16672 if (decl != NULL_TREE) 16673 { 16674 dw_die_ref decl_die = lookup_decl_die (decl); 16675 16676 /* ??? Can this happen, or should the variable have been bound 16677 first? Probably it can, since I imagine that we try to create 16678 the types of parameters in the order in which they exist in 16679 the list, and won't have created a forward reference to a 16680 later parameter. */ 16681 if (decl_die != NULL) 16682 { 16683 add_AT_die_ref (die, attr, decl_die); 16684 return; 16685 } 16686 } 16687 } 16688 16689 /* Last chance: try to create a stack operation procedure to evaluate the 16690 value. Do nothing if even that is not possible or permitted. */ 16691 if ((forms & dw_scalar_form_exprloc) == 0) 16692 return; 16693 16694 list = loc_list_from_tree (value, 2, context); 16695 if (list == NULL || single_element_loc_list_p (list)) 16696 { 16697 /* If this attribute is not a reference nor constant, it is 16698 a DWARF expression rather than location description. For that 16699 loc_list_from_tree (value, 0, &context) is needed. */ 16700 dw_loc_list_ref list2 = loc_list_from_tree (value, 0, context); 16701 if (list2 && single_element_loc_list_p (list2)) 16702 { 16703 add_AT_loc (die, attr, list2->expr); 16704 return; 16705 } 16706 } 16707 16708 /* If that failed to give a single element location list, fall back to 16709 outputting this as a reference... still if permitted. */ 16710 if (list == NULL || (forms & dw_scalar_form_reference) == 0) 16711 return; 16712 16713 if (current_function_decl == 0) 16714 ctx = comp_unit_die (); 16715 else 16716 ctx = lookup_decl_die (current_function_decl); 16717 16718 decl_die = new_die (DW_TAG_variable, ctx, value); 16719 add_AT_flag (decl_die, DW_AT_artificial, 1); 16720 add_type_attribute (decl_die, TREE_TYPE (value), TYPE_QUAL_CONST, ctx); 16721 add_AT_location_description (decl_die, DW_AT_location, list); 16722 add_AT_die_ref (die, attr, decl_die); 16723} 16724 16725/* Return the default for DW_AT_lower_bound, or -1 if there is not any 16726 default. */ 16727 16728static int 16729lower_bound_default (void) 16730{ 16731 switch (get_AT_unsigned (comp_unit_die (), DW_AT_language)) 16732 { 16733 case DW_LANG_C: 16734 case DW_LANG_C89: 16735 case DW_LANG_C99: 16736 case DW_LANG_C11: 16737 case DW_LANG_C_plus_plus: 16738 case DW_LANG_C_plus_plus_11: 16739 case DW_LANG_C_plus_plus_14: 16740 case DW_LANG_ObjC: 16741 case DW_LANG_ObjC_plus_plus: 16742 case DW_LANG_Java: 16743 return 0; 16744 case DW_LANG_Fortran77: 16745 case DW_LANG_Fortran90: 16746 case DW_LANG_Fortran95: 16747 case DW_LANG_Fortran03: 16748 case DW_LANG_Fortran08: 16749 return 1; 16750 case DW_LANG_UPC: 16751 case DW_LANG_D: 16752 case DW_LANG_Python: 16753 return dwarf_version >= 4 ? 0 : -1; 16754 case DW_LANG_Ada95: 16755 case DW_LANG_Ada83: 16756 case DW_LANG_Cobol74: 16757 case DW_LANG_Cobol85: 16758 case DW_LANG_Pascal83: 16759 case DW_LANG_Modula2: 16760 case DW_LANG_PLI: 16761 return dwarf_version >= 4 ? 1 : -1; 16762 default: 16763 return -1; 16764 } 16765} 16766 16767/* Given a tree node describing an array bound (either lower or upper) output 16768 a representation for that bound. */ 16769 16770static void 16771add_bound_info (dw_die_ref subrange_die, enum dwarf_attribute bound_attr, 16772 tree bound, const struct loc_descr_context *context) 16773{ 16774 int dflt; 16775 16776 while (1) 16777 switch (TREE_CODE (bound)) 16778 { 16779 /* Strip all conversions. */ 16780 CASE_CONVERT: 16781 case VIEW_CONVERT_EXPR: 16782 bound = TREE_OPERAND (bound, 0); 16783 break; 16784 16785 /* All fixed-bounds are represented by INTEGER_CST nodes. Lower bounds 16786 are even omitted when they are the default. */ 16787 case INTEGER_CST: 16788 /* If the value for this bound is the default one, we can even omit the 16789 attribute. */ 16790 if (bound_attr == DW_AT_lower_bound 16791 && tree_fits_shwi_p (bound) 16792 && (dflt = lower_bound_default ()) != -1 16793 && tree_to_shwi (bound) == dflt) 16794 return; 16795 16796 /* FALLTHRU */ 16797 16798 default: 16799 add_scalar_info (subrange_die, bound_attr, bound, 16800 dw_scalar_form_constant 16801 | dw_scalar_form_exprloc 16802 | dw_scalar_form_reference, 16803 context); 16804 return; 16805 } 16806} 16807 16808/* Add subscript info to TYPE_DIE, describing an array TYPE, collapsing 16809 possibly nested array subscripts in a flat sequence if COLLAPSE_P is true. 16810 Note that the block of subscript information for an array type also 16811 includes information about the element type of the given array type. */ 16812 16813static void 16814add_subscript_info (dw_die_ref type_die, tree type, bool collapse_p) 16815{ 16816 unsigned dimension_number; 16817 tree lower, upper; 16818 dw_die_ref subrange_die; 16819 16820 for (dimension_number = 0; 16821 TREE_CODE (type) == ARRAY_TYPE && (dimension_number == 0 || collapse_p); 16822 type = TREE_TYPE (type), dimension_number++) 16823 { 16824 tree domain = TYPE_DOMAIN (type); 16825 16826 if (TYPE_STRING_FLAG (type) && is_fortran () && dimension_number > 0) 16827 break; 16828 16829 /* Arrays come in three flavors: Unspecified bounds, fixed bounds, 16830 and (in GNU C only) variable bounds. Handle all three forms 16831 here. */ 16832 subrange_die = new_die (DW_TAG_subrange_type, type_die, NULL); 16833 if (domain) 16834 { 16835 /* We have an array type with specified bounds. */ 16836 lower = TYPE_MIN_VALUE (domain); 16837 upper = TYPE_MAX_VALUE (domain); 16838 16839 /* Define the index type. */ 16840 if (TREE_TYPE (domain)) 16841 { 16842 /* ??? This is probably an Ada unnamed subrange type. Ignore the 16843 TREE_TYPE field. We can't emit debug info for this 16844 because it is an unnamed integral type. */ 16845 if (TREE_CODE (domain) == INTEGER_TYPE 16846 && TYPE_NAME (domain) == NULL_TREE 16847 && TREE_CODE (TREE_TYPE (domain)) == INTEGER_TYPE 16848 && TYPE_NAME (TREE_TYPE (domain)) == NULL_TREE) 16849 ; 16850 else 16851 add_type_attribute (subrange_die, TREE_TYPE (domain), 16852 TYPE_UNQUALIFIED, type_die); 16853 } 16854 16855 /* ??? If upper is NULL, the array has unspecified length, 16856 but it does have a lower bound. This happens with Fortran 16857 dimension arr(N:*) 16858 Since the debugger is definitely going to need to know N 16859 to produce useful results, go ahead and output the lower 16860 bound solo, and hope the debugger can cope. */ 16861 16862 add_bound_info (subrange_die, DW_AT_lower_bound, lower, NULL); 16863 if (upper) 16864 add_bound_info (subrange_die, DW_AT_upper_bound, upper, NULL); 16865 } 16866 16867 /* Otherwise we have an array type with an unspecified length. The 16868 DWARF-2 spec does not say how to handle this; let's just leave out the 16869 bounds. */ 16870 } 16871} 16872 16873/* Add a DW_AT_byte_size attribute to DIE with TREE_NODE's size. */ 16874 16875static void 16876add_byte_size_attribute (dw_die_ref die, tree tree_node) 16877{ 16878 dw_die_ref decl_die; 16879 HOST_WIDE_INT size; 16880 16881 switch (TREE_CODE (tree_node)) 16882 { 16883 case ERROR_MARK: 16884 size = 0; 16885 break; 16886 case ENUMERAL_TYPE: 16887 case RECORD_TYPE: 16888 case UNION_TYPE: 16889 case QUAL_UNION_TYPE: 16890 if (TREE_CODE (TYPE_SIZE_UNIT (tree_node)) == VAR_DECL 16891 && (decl_die = lookup_decl_die (TYPE_SIZE_UNIT (tree_node)))) 16892 { 16893 add_AT_die_ref (die, DW_AT_byte_size, decl_die); 16894 return; 16895 } 16896 size = int_size_in_bytes (tree_node); 16897 break; 16898 case FIELD_DECL: 16899 /* For a data member of a struct or union, the DW_AT_byte_size is 16900 generally given as the number of bytes normally allocated for an 16901 object of the *declared* type of the member itself. This is true 16902 even for bit-fields. */ 16903 size = int_size_in_bytes (field_type (tree_node)); 16904 break; 16905 default: 16906 gcc_unreachable (); 16907 } 16908 16909 /* Note that `size' might be -1 when we get to this point. If it is, that 16910 indicates that the byte size of the entity in question is variable. We 16911 have no good way of expressing this fact in Dwarf at the present time, 16912 when location description was not used by the caller code instead. */ 16913 if (size >= 0) 16914 add_AT_unsigned (die, DW_AT_byte_size, size); 16915} 16916 16917/* For a FIELD_DECL node which represents a bit-field, output an attribute 16918 which specifies the distance in bits from the highest order bit of the 16919 "containing object" for the bit-field to the highest order bit of the 16920 bit-field itself. 16921 16922 For any given bit-field, the "containing object" is a hypothetical object 16923 (of some integral or enum type) within which the given bit-field lives. The 16924 type of this hypothetical "containing object" is always the same as the 16925 declared type of the individual bit-field itself. The determination of the 16926 exact location of the "containing object" for a bit-field is rather 16927 complicated. It's handled by the `field_byte_offset' function (above). 16928 16929 Note that it is the size (in bytes) of the hypothetical "containing object" 16930 which will be given in the DW_AT_byte_size attribute for this bit-field. 16931 (See `byte_size_attribute' above). */ 16932 16933static inline void 16934add_bit_offset_attribute (dw_die_ref die, tree decl) 16935{ 16936 HOST_WIDE_INT object_offset_in_bytes = field_byte_offset (decl); 16937 tree type = DECL_BIT_FIELD_TYPE (decl); 16938 HOST_WIDE_INT bitpos_int; 16939 HOST_WIDE_INT highest_order_object_bit_offset; 16940 HOST_WIDE_INT highest_order_field_bit_offset; 16941 HOST_WIDE_INT bit_offset; 16942 16943 /* Must be a field and a bit field. */ 16944 gcc_assert (type && TREE_CODE (decl) == FIELD_DECL); 16945 16946 /* We can't yet handle bit-fields whose offsets are variable, so if we 16947 encounter such things, just return without generating any attribute 16948 whatsoever. Likewise for variable or too large size. */ 16949 if (! tree_fits_shwi_p (bit_position (decl)) 16950 || ! tree_fits_uhwi_p (DECL_SIZE (decl))) 16951 return; 16952 16953 bitpos_int = int_bit_position (decl); 16954 16955 /* Note that the bit offset is always the distance (in bits) from the 16956 highest-order bit of the "containing object" to the highest-order bit of 16957 the bit-field itself. Since the "high-order end" of any object or field 16958 is different on big-endian and little-endian machines, the computation 16959 below must take account of these differences. */ 16960 highest_order_object_bit_offset = object_offset_in_bytes * BITS_PER_UNIT; 16961 highest_order_field_bit_offset = bitpos_int; 16962 16963 if (! BYTES_BIG_ENDIAN) 16964 { 16965 highest_order_field_bit_offset += tree_to_shwi (DECL_SIZE (decl)); 16966 highest_order_object_bit_offset += simple_type_size_in_bits (type); 16967 } 16968 16969 bit_offset 16970 = (! BYTES_BIG_ENDIAN 16971 ? highest_order_object_bit_offset - highest_order_field_bit_offset 16972 : highest_order_field_bit_offset - highest_order_object_bit_offset); 16973 16974 if (bit_offset < 0) 16975 add_AT_int (die, DW_AT_bit_offset, bit_offset); 16976 else 16977 add_AT_unsigned (die, DW_AT_bit_offset, (unsigned HOST_WIDE_INT) bit_offset); 16978} 16979 16980/* For a FIELD_DECL node which represents a bit field, output an attribute 16981 which specifies the length in bits of the given field. */ 16982 16983static inline void 16984add_bit_size_attribute (dw_die_ref die, tree decl) 16985{ 16986 /* Must be a field and a bit field. */ 16987 gcc_assert (TREE_CODE (decl) == FIELD_DECL 16988 && DECL_BIT_FIELD_TYPE (decl)); 16989 16990 if (tree_fits_uhwi_p (DECL_SIZE (decl))) 16991 add_AT_unsigned (die, DW_AT_bit_size, tree_to_uhwi (DECL_SIZE (decl))); 16992} 16993 16994/* If the compiled language is ANSI C, then add a 'prototyped' 16995 attribute, if arg types are given for the parameters of a function. */ 16996 16997static inline void 16998add_prototyped_attribute (dw_die_ref die, tree func_type) 16999{ 17000 switch (get_AT_unsigned (comp_unit_die (), DW_AT_language)) 17001 { 17002 case DW_LANG_C: 17003 case DW_LANG_C89: 17004 case DW_LANG_C99: 17005 case DW_LANG_C11: 17006 case DW_LANG_ObjC: 17007 if (prototype_p (func_type)) 17008 add_AT_flag (die, DW_AT_prototyped, 1); 17009 break; 17010 default: 17011 break; 17012 } 17013} 17014 17015/* Add an 'abstract_origin' attribute below a given DIE. The DIE is found 17016 by looking in either the type declaration or object declaration 17017 equate table. */ 17018 17019static inline dw_die_ref 17020add_abstract_origin_attribute (dw_die_ref die, tree origin) 17021{ 17022 dw_die_ref origin_die = NULL; 17023 17024 if (TREE_CODE (origin) != FUNCTION_DECL) 17025 { 17026 /* We may have gotten separated from the block for the inlined 17027 function, if we're in an exception handler or some such; make 17028 sure that the abstract function has been written out. 17029 17030 Doing this for nested functions is wrong, however; functions are 17031 distinct units, and our context might not even be inline. */ 17032 tree fn = origin; 17033 17034 if (TYPE_P (fn)) 17035 fn = TYPE_STUB_DECL (fn); 17036 17037 fn = decl_function_context (fn); 17038 if (fn) 17039 dwarf2out_abstract_function (fn); 17040 } 17041 17042 if (DECL_P (origin)) 17043 origin_die = lookup_decl_die (origin); 17044 else if (TYPE_P (origin)) 17045 origin_die = lookup_type_die (origin); 17046 17047 /* XXX: Functions that are never lowered don't always have correct block 17048 trees (in the case of java, they simply have no block tree, in some other 17049 languages). For these functions, there is nothing we can really do to 17050 output correct debug info for inlined functions in all cases. Rather 17051 than die, we'll just produce deficient debug info now, in that we will 17052 have variables without a proper abstract origin. In the future, when all 17053 functions are lowered, we should re-add a gcc_assert (origin_die) 17054 here. */ 17055 17056 if (origin_die) 17057 add_AT_die_ref (die, DW_AT_abstract_origin, origin_die); 17058 return origin_die; 17059} 17060 17061/* We do not currently support the pure_virtual attribute. */ 17062 17063static inline void 17064add_pure_or_virtual_attribute (dw_die_ref die, tree func_decl) 17065{ 17066 if (DECL_VINDEX (func_decl)) 17067 { 17068 add_AT_unsigned (die, DW_AT_virtuality, DW_VIRTUALITY_virtual); 17069 17070 if (tree_fits_shwi_p (DECL_VINDEX (func_decl))) 17071 add_AT_loc (die, DW_AT_vtable_elem_location, 17072 new_loc_descr (DW_OP_constu, 17073 tree_to_shwi (DECL_VINDEX (func_decl)), 17074 0)); 17075 17076 /* GNU extension: Record what type this method came from originally. */ 17077 if (debug_info_level > DINFO_LEVEL_TERSE 17078 && DECL_CONTEXT (func_decl)) 17079 add_AT_die_ref (die, DW_AT_containing_type, 17080 lookup_type_die (DECL_CONTEXT (func_decl))); 17081 } 17082} 17083 17084/* Add a DW_AT_linkage_name or DW_AT_MIPS_linkage_name attribute for the 17085 given decl. This used to be a vendor extension until after DWARF 4 17086 standardized it. */ 17087 17088static void 17089add_linkage_attr (dw_die_ref die, tree decl) 17090{ 17091 const char *name = IDENTIFIER_POINTER (DECL_ASSEMBLER_NAME (decl)); 17092 17093 /* Mimic what assemble_name_raw does with a leading '*'. */ 17094 if (name[0] == '*') 17095 name = &name[1]; 17096 17097 if (dwarf_version >= 4) 17098 add_AT_string (die, DW_AT_linkage_name, name); 17099 else 17100 add_AT_string (die, DW_AT_MIPS_linkage_name, name); 17101} 17102 17103/* Add source coordinate attributes for the given decl. */ 17104 17105static void 17106add_src_coords_attributes (dw_die_ref die, tree decl) 17107{ 17108 expanded_location s; 17109 17110 if (LOCATION_LOCUS (DECL_SOURCE_LOCATION (decl)) == UNKNOWN_LOCATION) 17111 return; 17112 s = expand_location (DECL_SOURCE_LOCATION (decl)); 17113 add_AT_file (die, DW_AT_decl_file, lookup_filename (s.file)); 17114 add_AT_unsigned (die, DW_AT_decl_line, s.line); 17115} 17116 17117/* Add DW_AT_{,MIPS_}linkage_name attribute for the given decl. */ 17118 17119static void 17120add_linkage_name (dw_die_ref die, tree decl) 17121{ 17122 if (debug_info_level > DINFO_LEVEL_NONE 17123 && (TREE_CODE (decl) == FUNCTION_DECL || TREE_CODE (decl) == VAR_DECL) 17124 && TREE_PUBLIC (decl) 17125 && !(TREE_CODE (decl) == VAR_DECL && DECL_REGISTER (decl)) 17126 && die->die_tag != DW_TAG_member) 17127 { 17128 /* Defer until we have an assembler name set. */ 17129 if (!DECL_ASSEMBLER_NAME_SET_P (decl)) 17130 { 17131 limbo_die_node *asm_name; 17132 17133 asm_name = ggc_cleared_alloc<limbo_die_node> (); 17134 asm_name->die = die; 17135 asm_name->created_for = decl; 17136 asm_name->next = deferred_asm_name; 17137 deferred_asm_name = asm_name; 17138 } 17139 else if (DECL_ASSEMBLER_NAME (decl) != DECL_NAME (decl)) 17140 add_linkage_attr (die, decl); 17141 } 17142} 17143 17144/* Add a DW_AT_name attribute and source coordinate attribute for the 17145 given decl, but only if it actually has a name. */ 17146 17147static void 17148add_name_and_src_coords_attributes (dw_die_ref die, tree decl) 17149{ 17150 tree decl_name; 17151 17152 decl_name = DECL_NAME (decl); 17153 if (decl_name != NULL && IDENTIFIER_POINTER (decl_name) != NULL) 17154 { 17155 const char *name = dwarf2_name (decl, 0); 17156 if (name) 17157 add_name_attribute (die, name); 17158 if (! DECL_ARTIFICIAL (decl)) 17159 add_src_coords_attributes (die, decl); 17160 17161 add_linkage_name (die, decl); 17162 } 17163 17164#ifdef VMS_DEBUGGING_INFO 17165 /* Get the function's name, as described by its RTL. This may be different 17166 from the DECL_NAME name used in the source file. */ 17167 if (TREE_CODE (decl) == FUNCTION_DECL && TREE_ASM_WRITTEN (decl)) 17168 { 17169 add_AT_addr (die, DW_AT_VMS_rtnbeg_pd_address, 17170 XEXP (DECL_RTL (decl), 0), false); 17171 vec_safe_push (used_rtx_array, XEXP (DECL_RTL (decl), 0)); 17172 } 17173#endif /* VMS_DEBUGGING_INFO */ 17174} 17175 17176#ifdef VMS_DEBUGGING_INFO 17177/* Output the debug main pointer die for VMS */ 17178 17179void 17180dwarf2out_vms_debug_main_pointer (void) 17181{ 17182 char label[MAX_ARTIFICIAL_LABEL_BYTES]; 17183 dw_die_ref die; 17184 17185 /* Allocate the VMS debug main subprogram die. */ 17186 die = ggc_cleared_alloc<die_node> (); 17187 die->die_tag = DW_TAG_subprogram; 17188 add_name_attribute (die, VMS_DEBUG_MAIN_POINTER); 17189 ASM_GENERATE_INTERNAL_LABEL (label, PROLOGUE_END_LABEL, 17190 current_function_funcdef_no); 17191 add_AT_lbl_id (die, DW_AT_entry_pc, label); 17192 17193 /* Make it the first child of comp_unit_die (). */ 17194 die->die_parent = comp_unit_die (); 17195 if (comp_unit_die ()->die_child) 17196 { 17197 die->die_sib = comp_unit_die ()->die_child->die_sib; 17198 comp_unit_die ()->die_child->die_sib = die; 17199 } 17200 else 17201 { 17202 die->die_sib = die; 17203 comp_unit_die ()->die_child = die; 17204 } 17205} 17206#endif /* VMS_DEBUGGING_INFO */ 17207 17208/* Push a new declaration scope. */ 17209 17210static void 17211push_decl_scope (tree scope) 17212{ 17213 vec_safe_push (decl_scope_table, scope); 17214} 17215 17216/* Pop a declaration scope. */ 17217 17218static inline void 17219pop_decl_scope (void) 17220{ 17221 decl_scope_table->pop (); 17222} 17223 17224/* walk_tree helper function for uses_local_type, below. */ 17225 17226static tree 17227uses_local_type_r (tree *tp, int *walk_subtrees, void *data ATTRIBUTE_UNUSED) 17228{ 17229 if (!TYPE_P (*tp)) 17230 *walk_subtrees = 0; 17231 else 17232 { 17233 tree name = TYPE_NAME (*tp); 17234 if (name && DECL_P (name) && decl_function_context (name)) 17235 return *tp; 17236 } 17237 return NULL_TREE; 17238} 17239 17240/* If TYPE involves a function-local type (including a local typedef to a 17241 non-local type), returns that type; otherwise returns NULL_TREE. */ 17242 17243static tree 17244uses_local_type (tree type) 17245{ 17246 tree used = walk_tree_without_duplicates (&type, uses_local_type_r, NULL); 17247 return used; 17248} 17249 17250/* Return the DIE for the scope that immediately contains this type. 17251 Non-named types that do not involve a function-local type get global 17252 scope. Named types nested in namespaces or other types get their 17253 containing scope. All other types (i.e. function-local named types) get 17254 the current active scope. */ 17255 17256static dw_die_ref 17257scope_die_for (tree t, dw_die_ref context_die) 17258{ 17259 dw_die_ref scope_die = NULL; 17260 tree containing_scope; 17261 17262 /* Non-types always go in the current scope. */ 17263 gcc_assert (TYPE_P (t)); 17264 17265 /* Use the scope of the typedef, rather than the scope of the type 17266 it refers to. */ 17267 if (TYPE_NAME (t) && DECL_P (TYPE_NAME (t))) 17268 containing_scope = DECL_CONTEXT (TYPE_NAME (t)); 17269 else 17270 containing_scope = TYPE_CONTEXT (t); 17271 17272 /* Use the containing namespace if there is one. */ 17273 if (containing_scope && TREE_CODE (containing_scope) == NAMESPACE_DECL) 17274 { 17275 if (context_die == lookup_decl_die (containing_scope)) 17276 /* OK */; 17277 else if (debug_info_level > DINFO_LEVEL_TERSE) 17278 context_die = get_context_die (containing_scope); 17279 else 17280 containing_scope = NULL_TREE; 17281 } 17282 17283 /* Ignore function type "scopes" from the C frontend. They mean that 17284 a tagged type is local to a parmlist of a function declarator, but 17285 that isn't useful to DWARF. */ 17286 if (containing_scope && TREE_CODE (containing_scope) == FUNCTION_TYPE) 17287 containing_scope = NULL_TREE; 17288 17289 if (SCOPE_FILE_SCOPE_P (containing_scope)) 17290 { 17291 /* If T uses a local type keep it local as well, to avoid references 17292 to function-local DIEs from outside the function. */ 17293 if (current_function_decl && uses_local_type (t)) 17294 scope_die = context_die; 17295 else 17296 scope_die = comp_unit_die (); 17297 } 17298 else if (TYPE_P (containing_scope)) 17299 { 17300 /* For types, we can just look up the appropriate DIE. */ 17301 if (debug_info_level > DINFO_LEVEL_TERSE) 17302 scope_die = get_context_die (containing_scope); 17303 else 17304 { 17305 scope_die = lookup_type_die_strip_naming_typedef (containing_scope); 17306 if (scope_die == NULL) 17307 scope_die = comp_unit_die (); 17308 } 17309 } 17310 else 17311 scope_die = context_die; 17312 17313 return scope_die; 17314} 17315 17316/* Returns nonzero if CONTEXT_DIE is internal to a function. */ 17317 17318static inline int 17319local_scope_p (dw_die_ref context_die) 17320{ 17321 for (; context_die; context_die = context_die->die_parent) 17322 if (context_die->die_tag == DW_TAG_inlined_subroutine 17323 || context_die->die_tag == DW_TAG_subprogram) 17324 return 1; 17325 17326 return 0; 17327} 17328 17329/* Returns nonzero if CONTEXT_DIE is a class. */ 17330 17331static inline int 17332class_scope_p (dw_die_ref context_die) 17333{ 17334 return (context_die 17335 && (context_die->die_tag == DW_TAG_structure_type 17336 || context_die->die_tag == DW_TAG_class_type 17337 || context_die->die_tag == DW_TAG_interface_type 17338 || context_die->die_tag == DW_TAG_union_type)); 17339} 17340 17341/* Returns nonzero if CONTEXT_DIE is a class or namespace, for deciding 17342 whether or not to treat a DIE in this context as a declaration. */ 17343 17344static inline int 17345class_or_namespace_scope_p (dw_die_ref context_die) 17346{ 17347 return (class_scope_p (context_die) 17348 || (context_die && context_die->die_tag == DW_TAG_namespace)); 17349} 17350 17351/* Many forms of DIEs require a "type description" attribute. This 17352 routine locates the proper "type descriptor" die for the type given 17353 by 'type' plus any additional qualifiers given by 'cv_quals', and 17354 adds a DW_AT_type attribute below the given die. */ 17355 17356static void 17357add_type_attribute (dw_die_ref object_die, tree type, int cv_quals, 17358 dw_die_ref context_die) 17359{ 17360 enum tree_code code = TREE_CODE (type); 17361 dw_die_ref type_die = NULL; 17362 17363 /* ??? If this type is an unnamed subrange type of an integral, floating-point 17364 or fixed-point type, use the inner type. This is because we have no 17365 support for unnamed types in base_type_die. This can happen if this is 17366 an Ada subrange type. Correct solution is emit a subrange type die. */ 17367 if ((code == INTEGER_TYPE || code == REAL_TYPE || code == FIXED_POINT_TYPE) 17368 && TREE_TYPE (type) != 0 && TYPE_NAME (type) == 0) 17369 type = TREE_TYPE (type), code = TREE_CODE (type); 17370 17371 if (code == ERROR_MARK 17372 /* Handle a special case. For functions whose return type is void, we 17373 generate *no* type attribute. (Note that no object may have type 17374 `void', so this only applies to function return types). */ 17375 || code == VOID_TYPE) 17376 return; 17377 17378 type_die = modified_type_die (type, 17379 cv_quals | TYPE_QUALS_NO_ADDR_SPACE (type), 17380 context_die); 17381 17382 if (type_die != NULL) 17383 add_AT_die_ref (object_die, DW_AT_type, type_die); 17384} 17385 17386/* Given an object die, add the calling convention attribute for the 17387 function call type. */ 17388static void 17389add_calling_convention_attribute (dw_die_ref subr_die, tree decl) 17390{ 17391 enum dwarf_calling_convention value = DW_CC_normal; 17392 17393 value = ((enum dwarf_calling_convention) 17394 targetm.dwarf_calling_convention (TREE_TYPE (decl))); 17395 17396 if (is_fortran () 17397 && !strcmp (IDENTIFIER_POINTER (DECL_ASSEMBLER_NAME (decl)), "MAIN__")) 17398 { 17399 /* DWARF 2 doesn't provide a way to identify a program's source-level 17400 entry point. DW_AT_calling_convention attributes are only meant 17401 to describe functions' calling conventions. However, lacking a 17402 better way to signal the Fortran main program, we used this for 17403 a long time, following existing custom. Now, DWARF 4 has 17404 DW_AT_main_subprogram, which we add below, but some tools still 17405 rely on the old way, which we thus keep. */ 17406 value = DW_CC_program; 17407 17408 if (dwarf_version >= 4 || !dwarf_strict) 17409 add_AT_flag (subr_die, DW_AT_main_subprogram, 1); 17410 } 17411 17412 /* Only add the attribute if the backend requests it, and 17413 is not DW_CC_normal. */ 17414 if (value && (value != DW_CC_normal)) 17415 add_AT_unsigned (subr_die, DW_AT_calling_convention, value); 17416} 17417 17418/* Given a tree pointer to a struct, class, union, or enum type node, return 17419 a pointer to the (string) tag name for the given type, or zero if the type 17420 was declared without a tag. */ 17421 17422static const char * 17423type_tag (const_tree type) 17424{ 17425 const char *name = 0; 17426 17427 if (TYPE_NAME (type) != 0) 17428 { 17429 tree t = 0; 17430 17431 /* Find the IDENTIFIER_NODE for the type name. */ 17432 if (TREE_CODE (TYPE_NAME (type)) == IDENTIFIER_NODE 17433 && !TYPE_NAMELESS (type)) 17434 t = TYPE_NAME (type); 17435 17436 /* The g++ front end makes the TYPE_NAME of *each* tagged type point to 17437 a TYPE_DECL node, regardless of whether or not a `typedef' was 17438 involved. */ 17439 else if (TREE_CODE (TYPE_NAME (type)) == TYPE_DECL 17440 && ! DECL_IGNORED_P (TYPE_NAME (type))) 17441 { 17442 /* We want to be extra verbose. Don't call dwarf_name if 17443 DECL_NAME isn't set. The default hook for decl_printable_name 17444 doesn't like that, and in this context it's correct to return 17445 0, instead of "<anonymous>" or the like. */ 17446 if (DECL_NAME (TYPE_NAME (type)) 17447 && !DECL_NAMELESS (TYPE_NAME (type))) 17448 name = lang_hooks.dwarf_name (TYPE_NAME (type), 2); 17449 } 17450 17451 /* Now get the name as a string, or invent one. */ 17452 if (!name && t != 0) 17453 name = IDENTIFIER_POINTER (t); 17454 } 17455 17456 return (name == 0 || *name == '\0') ? 0 : name; 17457} 17458 17459/* Return the type associated with a data member, make a special check 17460 for bit field types. */ 17461 17462static inline tree 17463member_declared_type (const_tree member) 17464{ 17465 return (DECL_BIT_FIELD_TYPE (member) 17466 ? DECL_BIT_FIELD_TYPE (member) : TREE_TYPE (member)); 17467} 17468 17469/* Get the decl's label, as described by its RTL. This may be different 17470 from the DECL_NAME name used in the source file. */ 17471 17472#if 0 17473static const char * 17474decl_start_label (tree decl) 17475{ 17476 rtx x; 17477 const char *fnname; 17478 17479 x = DECL_RTL (decl); 17480 gcc_assert (MEM_P (x)); 17481 17482 x = XEXP (x, 0); 17483 gcc_assert (GET_CODE (x) == SYMBOL_REF); 17484 17485 fnname = XSTR (x, 0); 17486 return fnname; 17487} 17488#endif 17489 17490/* These routines generate the internal representation of the DIE's for 17491 the compilation unit. Debugging information is collected by walking 17492 the declaration trees passed in from dwarf2out_decl(). */ 17493 17494static void 17495gen_array_type_die (tree type, dw_die_ref context_die) 17496{ 17497 dw_die_ref scope_die = scope_die_for (type, context_die); 17498 dw_die_ref array_die; 17499 17500 /* GNU compilers represent multidimensional array types as sequences of one 17501 dimensional array types whose element types are themselves array types. 17502 We sometimes squish that down to a single array_type DIE with multiple 17503 subscripts in the Dwarf debugging info. The draft Dwarf specification 17504 say that we are allowed to do this kind of compression in C, because 17505 there is no difference between an array of arrays and a multidimensional 17506 array. We don't do this for Ada to remain as close as possible to the 17507 actual representation, which is especially important against the language 17508 flexibilty wrt arrays of variable size. */ 17509 17510 bool collapse_nested_arrays = !is_ada (); 17511 tree element_type; 17512 17513 /* Emit DW_TAG_string_type for Fortran character types (with kind 1 only, as 17514 DW_TAG_string_type doesn't have DW_AT_type attribute). */ 17515 if (TYPE_STRING_FLAG (type) 17516 && TREE_CODE (type) == ARRAY_TYPE 17517 && is_fortran () 17518 && TYPE_MODE (TREE_TYPE (type)) == TYPE_MODE (char_type_node)) 17519 { 17520 HOST_WIDE_INT size; 17521 17522 array_die = new_die (DW_TAG_string_type, scope_die, type); 17523 add_name_attribute (array_die, type_tag (type)); 17524 equate_type_number_to_die (type, array_die); 17525 size = int_size_in_bytes (type); 17526 if (size >= 0) 17527 add_AT_unsigned (array_die, DW_AT_byte_size, size); 17528 else if (TYPE_DOMAIN (type) != NULL_TREE 17529 && TYPE_MAX_VALUE (TYPE_DOMAIN (type)) != NULL_TREE 17530 && DECL_P (TYPE_MAX_VALUE (TYPE_DOMAIN (type)))) 17531 { 17532 tree szdecl = TYPE_MAX_VALUE (TYPE_DOMAIN (type)); 17533 dw_loc_list_ref loc = loc_list_from_tree (szdecl, 2, NULL); 17534 17535 size = int_size_in_bytes (TREE_TYPE (szdecl)); 17536 if (loc && size > 0) 17537 { 17538 add_AT_location_description (array_die, DW_AT_string_length, loc); 17539 if (size != DWARF2_ADDR_SIZE) 17540 add_AT_unsigned (array_die, DW_AT_byte_size, size); 17541 } 17542 } 17543 return; 17544 } 17545 17546 array_die = new_die (DW_TAG_array_type, scope_die, type); 17547 add_name_attribute (array_die, type_tag (type)); 17548 equate_type_number_to_die (type, array_die); 17549 17550 if (TREE_CODE (type) == VECTOR_TYPE) 17551 add_AT_flag (array_die, DW_AT_GNU_vector, 1); 17552 17553 /* For Fortran multidimensional arrays use DW_ORD_col_major ordering. */ 17554 if (is_fortran () 17555 && TREE_CODE (type) == ARRAY_TYPE 17556 && TREE_CODE (TREE_TYPE (type)) == ARRAY_TYPE 17557 && !TYPE_STRING_FLAG (TREE_TYPE (type))) 17558 add_AT_unsigned (array_die, DW_AT_ordering, DW_ORD_col_major); 17559 17560#if 0 17561 /* We default the array ordering. SDB will probably do 17562 the right things even if DW_AT_ordering is not present. It's not even 17563 an issue until we start to get into multidimensional arrays anyway. If 17564 SDB is ever caught doing the Wrong Thing for multi-dimensional arrays, 17565 then we'll have to put the DW_AT_ordering attribute back in. (But if 17566 and when we find out that we need to put these in, we will only do so 17567 for multidimensional arrays. */ 17568 add_AT_unsigned (array_die, DW_AT_ordering, DW_ORD_row_major); 17569#endif 17570 17571 if (TREE_CODE (type) == VECTOR_TYPE) 17572 { 17573 /* For VECTOR_TYPEs we use an array die with appropriate bounds. */ 17574 dw_die_ref subrange_die = new_die (DW_TAG_subrange_type, array_die, NULL); 17575 add_bound_info (subrange_die, DW_AT_lower_bound, size_zero_node, NULL); 17576 add_bound_info (subrange_die, DW_AT_upper_bound, 17577 size_int (TYPE_VECTOR_SUBPARTS (type) - 1), NULL); 17578 } 17579 else 17580 add_subscript_info (array_die, type, collapse_nested_arrays); 17581 17582 /* Add representation of the type of the elements of this array type and 17583 emit the corresponding DIE if we haven't done it already. */ 17584 element_type = TREE_TYPE (type); 17585 if (collapse_nested_arrays) 17586 while (TREE_CODE (element_type) == ARRAY_TYPE) 17587 { 17588 if (TYPE_STRING_FLAG (element_type) && is_fortran ()) 17589 break; 17590 element_type = TREE_TYPE (element_type); 17591 } 17592 17593 add_type_attribute (array_die, element_type, TYPE_UNQUALIFIED, context_die); 17594 17595 add_gnat_descriptive_type_attribute (array_die, type, context_die); 17596 if (TYPE_ARTIFICIAL (type)) 17597 add_AT_flag (array_die, DW_AT_artificial, 1); 17598 17599 if (get_AT (array_die, DW_AT_name)) 17600 add_pubtype (type, array_die); 17601} 17602 17603/* This routine generates DIE for array with hidden descriptor, details 17604 are filled into *info by a langhook. */ 17605 17606static void 17607gen_descr_array_type_die (tree type, struct array_descr_info *info, 17608 dw_die_ref context_die) 17609{ 17610 const dw_die_ref scope_die = scope_die_for (type, context_die); 17611 const dw_die_ref array_die = new_die (DW_TAG_array_type, scope_die, type); 17612 const struct loc_descr_context context = { type, info->base_decl }; 17613 int dim; 17614 17615 add_name_attribute (array_die, type_tag (type)); 17616 equate_type_number_to_die (type, array_die); 17617 17618 if (info->ndimensions > 1) 17619 switch (info->ordering) 17620 { 17621 case array_descr_ordering_row_major: 17622 add_AT_unsigned (array_die, DW_AT_ordering, DW_ORD_row_major); 17623 break; 17624 case array_descr_ordering_column_major: 17625 add_AT_unsigned (array_die, DW_AT_ordering, DW_ORD_col_major); 17626 break; 17627 default: 17628 break; 17629 } 17630 17631 if (dwarf_version >= 3 || !dwarf_strict) 17632 { 17633 if (info->data_location) 17634 add_scalar_info (array_die, DW_AT_data_location, info->data_location, 17635 dw_scalar_form_exprloc, &context); 17636 if (info->associated) 17637 add_scalar_info (array_die, DW_AT_associated, info->associated, 17638 dw_scalar_form_constant 17639 | dw_scalar_form_exprloc 17640 | dw_scalar_form_reference, &context); 17641 if (info->allocated) 17642 add_scalar_info (array_die, DW_AT_allocated, info->allocated, 17643 dw_scalar_form_constant 17644 | dw_scalar_form_exprloc 17645 | dw_scalar_form_reference, &context); 17646 } 17647 17648 add_gnat_descriptive_type_attribute (array_die, type, context_die); 17649 17650 for (dim = 0; dim < info->ndimensions; dim++) 17651 { 17652 dw_die_ref subrange_die 17653 = new_die (DW_TAG_subrange_type, array_die, NULL); 17654 17655 if (info->dimen[dim].bounds_type) 17656 add_type_attribute (subrange_die, 17657 info->dimen[dim].bounds_type, 0, 17658 context_die); 17659 if (info->dimen[dim].lower_bound) 17660 add_bound_info (subrange_die, DW_AT_lower_bound, 17661 info->dimen[dim].lower_bound, &context); 17662 if (info->dimen[dim].upper_bound) 17663 add_bound_info (subrange_die, DW_AT_upper_bound, 17664 info->dimen[dim].upper_bound, &context); 17665 if ((dwarf_version >= 3 || !dwarf_strict) && info->dimen[dim].stride) 17666 add_scalar_info (subrange_die, DW_AT_byte_stride, 17667 info->dimen[dim].stride, 17668 dw_scalar_form_constant 17669 | dw_scalar_form_exprloc 17670 | dw_scalar_form_reference, 17671 &context); 17672 } 17673 17674 gen_type_die (info->element_type, context_die); 17675 add_type_attribute (array_die, info->element_type, TYPE_UNQUALIFIED, 17676 context_die); 17677 17678 if (get_AT (array_die, DW_AT_name)) 17679 add_pubtype (type, array_die); 17680} 17681 17682#if 0 17683static void 17684gen_entry_point_die (tree decl, dw_die_ref context_die) 17685{ 17686 tree origin = decl_ultimate_origin (decl); 17687 dw_die_ref decl_die = new_die (DW_TAG_entry_point, context_die, decl); 17688 17689 if (origin != NULL) 17690 add_abstract_origin_attribute (decl_die, origin); 17691 else 17692 { 17693 add_name_and_src_coords_attributes (decl_die, decl); 17694 add_type_attribute (decl_die, TREE_TYPE (TREE_TYPE (decl)), 17695 TYPE_UNQUALIFIED, context_die); 17696 } 17697 17698 if (DECL_ABSTRACT_P (decl)) 17699 equate_decl_number_to_die (decl, decl_die); 17700 else 17701 add_AT_lbl_id (decl_die, DW_AT_low_pc, decl_start_label (decl)); 17702} 17703#endif 17704 17705/* Walk through the list of incomplete types again, trying once more to 17706 emit full debugging info for them. */ 17707 17708static void 17709retry_incomplete_types (void) 17710{ 17711 int i; 17712 17713 for (i = vec_safe_length (incomplete_types) - 1; i >= 0; i--) 17714 if (should_emit_struct_debug ((*incomplete_types)[i], DINFO_USAGE_DIR_USE)) 17715 gen_type_die ((*incomplete_types)[i], comp_unit_die ()); 17716} 17717 17718/* Determine what tag to use for a record type. */ 17719 17720static enum dwarf_tag 17721record_type_tag (tree type) 17722{ 17723 if (! lang_hooks.types.classify_record) 17724 return DW_TAG_structure_type; 17725 17726 switch (lang_hooks.types.classify_record (type)) 17727 { 17728 case RECORD_IS_STRUCT: 17729 return DW_TAG_structure_type; 17730 17731 case RECORD_IS_CLASS: 17732 return DW_TAG_class_type; 17733 17734 case RECORD_IS_INTERFACE: 17735 if (dwarf_version >= 3 || !dwarf_strict) 17736 return DW_TAG_interface_type; 17737 return DW_TAG_structure_type; 17738 17739 default: 17740 gcc_unreachable (); 17741 } 17742} 17743 17744/* Generate a DIE to represent an enumeration type. Note that these DIEs 17745 include all of the information about the enumeration values also. Each 17746 enumerated type name/value is listed as a child of the enumerated type 17747 DIE. */ 17748 17749static dw_die_ref 17750gen_enumeration_type_die (tree type, dw_die_ref context_die) 17751{ 17752 dw_die_ref type_die = lookup_type_die (type); 17753 17754 if (type_die == NULL) 17755 { 17756 type_die = new_die (DW_TAG_enumeration_type, 17757 scope_die_for (type, context_die), type); 17758 equate_type_number_to_die (type, type_die); 17759 add_name_attribute (type_die, type_tag (type)); 17760 if (dwarf_version >= 4 || !dwarf_strict) 17761 { 17762 if (ENUM_IS_SCOPED (type)) 17763 add_AT_flag (type_die, DW_AT_enum_class, 1); 17764 if (ENUM_IS_OPAQUE (type)) 17765 add_AT_flag (type_die, DW_AT_declaration, 1); 17766 } 17767 } 17768 else if (! TYPE_SIZE (type)) 17769 return type_die; 17770 else 17771 remove_AT (type_die, DW_AT_declaration); 17772 17773 /* Handle a GNU C/C++ extension, i.e. incomplete enum types. If the 17774 given enum type is incomplete, do not generate the DW_AT_byte_size 17775 attribute or the DW_AT_element_list attribute. */ 17776 if (TYPE_SIZE (type)) 17777 { 17778 tree link; 17779 17780 TREE_ASM_WRITTEN (type) = 1; 17781 add_byte_size_attribute (type_die, type); 17782 if (dwarf_version >= 3 || !dwarf_strict) 17783 { 17784 tree underlying = lang_hooks.types.enum_underlying_base_type (type); 17785 add_type_attribute (type_die, underlying, TYPE_UNQUALIFIED, 17786 context_die); 17787 } 17788 if (TYPE_STUB_DECL (type) != NULL_TREE) 17789 { 17790 add_src_coords_attributes (type_die, TYPE_STUB_DECL (type)); 17791 add_accessibility_attribute (type_die, TYPE_STUB_DECL (type)); 17792 } 17793 17794 /* If the first reference to this type was as the return type of an 17795 inline function, then it may not have a parent. Fix this now. */ 17796 if (type_die->die_parent == NULL) 17797 add_child_die (scope_die_for (type, context_die), type_die); 17798 17799 for (link = TYPE_VALUES (type); 17800 link != NULL; link = TREE_CHAIN (link)) 17801 { 17802 dw_die_ref enum_die = new_die (DW_TAG_enumerator, type_die, link); 17803 tree value = TREE_VALUE (link); 17804 17805 add_name_attribute (enum_die, 17806 IDENTIFIER_POINTER (TREE_PURPOSE (link))); 17807 17808 if (TREE_CODE (value) == CONST_DECL) 17809 value = DECL_INITIAL (value); 17810 17811 if (simple_type_size_in_bits (TREE_TYPE (value)) 17812 <= HOST_BITS_PER_WIDE_INT || tree_fits_shwi_p (value)) 17813 { 17814 /* For constant forms created by add_AT_unsigned DWARF 17815 consumers (GDB, elfutils, etc.) always zero extend 17816 the value. Only when the actual value is negative 17817 do we need to use add_AT_int to generate a constant 17818 form that can represent negative values. */ 17819 HOST_WIDE_INT val = TREE_INT_CST_LOW (value); 17820 if (TYPE_UNSIGNED (TREE_TYPE (value)) || val >= 0) 17821 add_AT_unsigned (enum_die, DW_AT_const_value, 17822 (unsigned HOST_WIDE_INT) val); 17823 else 17824 add_AT_int (enum_die, DW_AT_const_value, val); 17825 } 17826 else 17827 /* Enumeration constants may be wider than HOST_WIDE_INT. Handle 17828 that here. TODO: This should be re-worked to use correct 17829 signed/unsigned double tags for all cases. */ 17830 add_AT_wide (enum_die, DW_AT_const_value, value); 17831 } 17832 17833 add_gnat_descriptive_type_attribute (type_die, type, context_die); 17834 if (TYPE_ARTIFICIAL (type)) 17835 add_AT_flag (type_die, DW_AT_artificial, 1); 17836 } 17837 else 17838 add_AT_flag (type_die, DW_AT_declaration, 1); 17839 17840 add_pubtype (type, type_die); 17841 17842 return type_die; 17843} 17844 17845/* Generate a DIE to represent either a real live formal parameter decl or to 17846 represent just the type of some formal parameter position in some function 17847 type. 17848 17849 Note that this routine is a bit unusual because its argument may be a 17850 ..._DECL node (i.e. either a PARM_DECL or perhaps a VAR_DECL which 17851 represents an inlining of some PARM_DECL) or else some sort of a ..._TYPE 17852 node. If it's the former then this function is being called to output a 17853 DIE to represent a formal parameter object (or some inlining thereof). If 17854 it's the latter, then this function is only being called to output a 17855 DW_TAG_formal_parameter DIE to stand as a placeholder for some formal 17856 argument type of some subprogram type. 17857 If EMIT_NAME_P is true, name and source coordinate attributes 17858 are emitted. */ 17859 17860static dw_die_ref 17861gen_formal_parameter_die (tree node, tree origin, bool emit_name_p, 17862 dw_die_ref context_die) 17863{ 17864 tree node_or_origin = node ? node : origin; 17865 tree ultimate_origin; 17866 dw_die_ref parm_die 17867 = new_die (DW_TAG_formal_parameter, context_die, node); 17868 17869 switch (TREE_CODE_CLASS (TREE_CODE (node_or_origin))) 17870 { 17871 case tcc_declaration: 17872 ultimate_origin = decl_ultimate_origin (node_or_origin); 17873 if (node || ultimate_origin) 17874 origin = ultimate_origin; 17875 if (origin != NULL) 17876 add_abstract_origin_attribute (parm_die, origin); 17877 else if (emit_name_p) 17878 add_name_and_src_coords_attributes (parm_die, node); 17879 if (origin == NULL 17880 || (! DECL_ABSTRACT_P (node_or_origin) 17881 && variably_modified_type_p (TREE_TYPE (node_or_origin), 17882 decl_function_context 17883 (node_or_origin)))) 17884 { 17885 tree type = TREE_TYPE (node_or_origin); 17886 if (decl_by_reference_p (node_or_origin)) 17887 add_type_attribute (parm_die, TREE_TYPE (type), 17888 TYPE_UNQUALIFIED, context_die); 17889 else 17890 add_type_attribute (parm_die, type, 17891 decl_quals (node_or_origin), 17892 context_die); 17893 } 17894 if (origin == NULL && DECL_ARTIFICIAL (node)) 17895 add_AT_flag (parm_die, DW_AT_artificial, 1); 17896 17897 if (node && node != origin) 17898 equate_decl_number_to_die (node, parm_die); 17899 if (! DECL_ABSTRACT_P (node_or_origin)) 17900 add_location_or_const_value_attribute (parm_die, node_or_origin, 17901 node == NULL, DW_AT_location); 17902 17903 break; 17904 17905 case tcc_type: 17906 /* We were called with some kind of a ..._TYPE node. */ 17907 add_type_attribute (parm_die, node_or_origin, TYPE_UNQUALIFIED, 17908 context_die); 17909 break; 17910 17911 default: 17912 gcc_unreachable (); 17913 } 17914 17915 return parm_die; 17916} 17917 17918/* Generate and return a DW_TAG_GNU_formal_parameter_pack. Also generate 17919 children DW_TAG_formal_parameter DIEs representing the arguments of the 17920 parameter pack. 17921 17922 PARM_PACK must be a function parameter pack. 17923 PACK_ARG is the first argument of the parameter pack. Its TREE_CHAIN 17924 must point to the subsequent arguments of the function PACK_ARG belongs to. 17925 SUBR_DIE is the DIE of the function PACK_ARG belongs to. 17926 If NEXT_ARG is non NULL, *NEXT_ARG is set to the function argument 17927 following the last one for which a DIE was generated. */ 17928 17929static dw_die_ref 17930gen_formal_parameter_pack_die (tree parm_pack, 17931 tree pack_arg, 17932 dw_die_ref subr_die, 17933 tree *next_arg) 17934{ 17935 tree arg; 17936 dw_die_ref parm_pack_die; 17937 17938 gcc_assert (parm_pack 17939 && lang_hooks.function_parameter_pack_p (parm_pack) 17940 && subr_die); 17941 17942 parm_pack_die = new_die (DW_TAG_GNU_formal_parameter_pack, subr_die, parm_pack); 17943 add_src_coords_attributes (parm_pack_die, parm_pack); 17944 17945 for (arg = pack_arg; arg; arg = DECL_CHAIN (arg)) 17946 { 17947 if (! lang_hooks.decls.function_parm_expanded_from_pack_p (arg, 17948 parm_pack)) 17949 break; 17950 gen_formal_parameter_die (arg, NULL, 17951 false /* Don't emit name attribute. */, 17952 parm_pack_die); 17953 } 17954 if (next_arg) 17955 *next_arg = arg; 17956 return parm_pack_die; 17957} 17958 17959/* Generate a special type of DIE used as a stand-in for a trailing ellipsis 17960 at the end of an (ANSI prototyped) formal parameters list. */ 17961 17962static void 17963gen_unspecified_parameters_die (tree decl_or_type, dw_die_ref context_die) 17964{ 17965 new_die (DW_TAG_unspecified_parameters, context_die, decl_or_type); 17966} 17967 17968/* Generate a list of nameless DW_TAG_formal_parameter DIEs (and perhaps a 17969 DW_TAG_unspecified_parameters DIE) to represent the types of the formal 17970 parameters as specified in some function type specification (except for 17971 those which appear as part of a function *definition*). */ 17972 17973static void 17974gen_formal_types_die (tree function_or_method_type, dw_die_ref context_die) 17975{ 17976 tree link; 17977 tree formal_type = NULL; 17978 tree first_parm_type; 17979 tree arg; 17980 17981 if (TREE_CODE (function_or_method_type) == FUNCTION_DECL) 17982 { 17983 arg = DECL_ARGUMENTS (function_or_method_type); 17984 function_or_method_type = TREE_TYPE (function_or_method_type); 17985 } 17986 else 17987 arg = NULL_TREE; 17988 17989 first_parm_type = TYPE_ARG_TYPES (function_or_method_type); 17990 17991 /* Make our first pass over the list of formal parameter types and output a 17992 DW_TAG_formal_parameter DIE for each one. */ 17993 for (link = first_parm_type; link; ) 17994 { 17995 dw_die_ref parm_die; 17996 17997 formal_type = TREE_VALUE (link); 17998 if (formal_type == void_type_node) 17999 break; 18000 18001 /* Output a (nameless) DIE to represent the formal parameter itself. */ 18002 if (!POINTER_BOUNDS_TYPE_P (formal_type)) 18003 { 18004 parm_die = gen_formal_parameter_die (formal_type, NULL, 18005 true /* Emit name attribute. */, 18006 context_die); 18007 if (TREE_CODE (function_or_method_type) == METHOD_TYPE 18008 && link == first_parm_type) 18009 { 18010 add_AT_flag (parm_die, DW_AT_artificial, 1); 18011 if (dwarf_version >= 3 || !dwarf_strict) 18012 add_AT_die_ref (context_die, DW_AT_object_pointer, parm_die); 18013 } 18014 else if (arg && DECL_ARTIFICIAL (arg)) 18015 add_AT_flag (parm_die, DW_AT_artificial, 1); 18016 } 18017 18018 link = TREE_CHAIN (link); 18019 if (arg) 18020 arg = DECL_CHAIN (arg); 18021 } 18022 18023 /* If this function type has an ellipsis, add a 18024 DW_TAG_unspecified_parameters DIE to the end of the parameter list. */ 18025 if (formal_type != void_type_node) 18026 gen_unspecified_parameters_die (function_or_method_type, context_die); 18027 18028 /* Make our second (and final) pass over the list of formal parameter types 18029 and output DIEs to represent those types (as necessary). */ 18030 for (link = TYPE_ARG_TYPES (function_or_method_type); 18031 link && TREE_VALUE (link); 18032 link = TREE_CHAIN (link)) 18033 gen_type_die (TREE_VALUE (link), context_die); 18034} 18035 18036/* We want to generate the DIE for TYPE so that we can generate the 18037 die for MEMBER, which has been defined; we will need to refer back 18038 to the member declaration nested within TYPE. If we're trying to 18039 generate minimal debug info for TYPE, processing TYPE won't do the 18040 trick; we need to attach the member declaration by hand. */ 18041 18042static void 18043gen_type_die_for_member (tree type, tree member, dw_die_ref context_die) 18044{ 18045 gen_type_die (type, context_die); 18046 18047 /* If we're trying to avoid duplicate debug info, we may not have 18048 emitted the member decl for this function. Emit it now. */ 18049 if (TYPE_STUB_DECL (type) 18050 && TYPE_DECL_SUPPRESS_DEBUG (TYPE_STUB_DECL (type)) 18051 && ! lookup_decl_die (member)) 18052 { 18053 dw_die_ref type_die; 18054 gcc_assert (!decl_ultimate_origin (member)); 18055 18056 push_decl_scope (type); 18057 type_die = lookup_type_die_strip_naming_typedef (type); 18058 if (TREE_CODE (member) == FUNCTION_DECL) 18059 gen_subprogram_die (member, type_die); 18060 else if (TREE_CODE (member) == FIELD_DECL) 18061 { 18062 /* Ignore the nameless fields that are used to skip bits but handle 18063 C++ anonymous unions and structs. */ 18064 if (DECL_NAME (member) != NULL_TREE 18065 || TREE_CODE (TREE_TYPE (member)) == UNION_TYPE 18066 || TREE_CODE (TREE_TYPE (member)) == RECORD_TYPE) 18067 { 18068 gen_type_die (member_declared_type (member), type_die); 18069 gen_field_die (member, type_die); 18070 } 18071 } 18072 else 18073 gen_variable_die (member, NULL_TREE, type_die); 18074 18075 pop_decl_scope (); 18076 } 18077} 18078 18079/* Forward declare these functions, because they are mutually recursive 18080 with their set_block_* pairing functions. */ 18081static void set_decl_origin_self (tree); 18082static void set_decl_abstract_flags (tree, vec<tree> &); 18083 18084/* Given a pointer to some BLOCK node, if the BLOCK_ABSTRACT_ORIGIN for the 18085 given BLOCK node is NULL, set the BLOCK_ABSTRACT_ORIGIN for the node so 18086 that it points to the node itself, thus indicating that the node is its 18087 own (abstract) origin. Additionally, if the BLOCK_ABSTRACT_ORIGIN for 18088 the given node is NULL, recursively descend the decl/block tree which 18089 it is the root of, and for each other ..._DECL or BLOCK node contained 18090 therein whose DECL_ABSTRACT_ORIGINs or BLOCK_ABSTRACT_ORIGINs are also 18091 still NULL, set *their* DECL_ABSTRACT_ORIGIN or BLOCK_ABSTRACT_ORIGIN 18092 values to point to themselves. */ 18093 18094static void 18095set_block_origin_self (tree stmt) 18096{ 18097 if (BLOCK_ABSTRACT_ORIGIN (stmt) == NULL_TREE) 18098 { 18099 BLOCK_ABSTRACT_ORIGIN (stmt) = stmt; 18100 18101 { 18102 tree local_decl; 18103 18104 for (local_decl = BLOCK_VARS (stmt); 18105 local_decl != NULL_TREE; 18106 local_decl = DECL_CHAIN (local_decl)) 18107 /* Do not recurse on nested functions since the inlining status 18108 of parent and child can be different as per the DWARF spec. */ 18109 if (TREE_CODE (local_decl) != FUNCTION_DECL 18110 && !DECL_EXTERNAL (local_decl)) 18111 set_decl_origin_self (local_decl); 18112 } 18113 18114 { 18115 tree subblock; 18116 18117 for (subblock = BLOCK_SUBBLOCKS (stmt); 18118 subblock != NULL_TREE; 18119 subblock = BLOCK_CHAIN (subblock)) 18120 set_block_origin_self (subblock); /* Recurse. */ 18121 } 18122 } 18123} 18124 18125/* Given a pointer to some ..._DECL node, if the DECL_ABSTRACT_ORIGIN for 18126 the given ..._DECL node is NULL, set the DECL_ABSTRACT_ORIGIN for the 18127 node to so that it points to the node itself, thus indicating that the 18128 node represents its own (abstract) origin. Additionally, if the 18129 DECL_ABSTRACT_ORIGIN for the given node is NULL, recursively descend 18130 the decl/block tree of which the given node is the root of, and for 18131 each other ..._DECL or BLOCK node contained therein whose 18132 DECL_ABSTRACT_ORIGINs or BLOCK_ABSTRACT_ORIGINs are also still NULL, 18133 set *their* DECL_ABSTRACT_ORIGIN or BLOCK_ABSTRACT_ORIGIN values to 18134 point to themselves. */ 18135 18136static void 18137set_decl_origin_self (tree decl) 18138{ 18139 if (DECL_ABSTRACT_ORIGIN (decl) == NULL_TREE) 18140 { 18141 DECL_ABSTRACT_ORIGIN (decl) = decl; 18142 if (TREE_CODE (decl) == FUNCTION_DECL) 18143 { 18144 tree arg; 18145 18146 for (arg = DECL_ARGUMENTS (decl); arg; arg = DECL_CHAIN (arg)) 18147 DECL_ABSTRACT_ORIGIN (arg) = arg; 18148 if (DECL_INITIAL (decl) != NULL_TREE 18149 && DECL_INITIAL (decl) != error_mark_node) 18150 set_block_origin_self (DECL_INITIAL (decl)); 18151 } 18152 } 18153} 18154 18155/* Given a pointer to some BLOCK node, set the BLOCK_ABSTRACT flag to 1 18156 and if it wasn't 1 before, push it to abstract_vec vector. 18157 For all local decls and all local sub-blocks (recursively) do it 18158 too. */ 18159 18160static void 18161set_block_abstract_flags (tree stmt, vec<tree> &abstract_vec) 18162{ 18163 tree local_decl; 18164 tree subblock; 18165 unsigned int i; 18166 18167 if (!BLOCK_ABSTRACT (stmt)) 18168 { 18169 abstract_vec.safe_push (stmt); 18170 BLOCK_ABSTRACT (stmt) = 1; 18171 } 18172 18173 for (local_decl = BLOCK_VARS (stmt); 18174 local_decl != NULL_TREE; 18175 local_decl = DECL_CHAIN (local_decl)) 18176 if (! DECL_EXTERNAL (local_decl)) 18177 set_decl_abstract_flags (local_decl, abstract_vec); 18178 18179 for (i = 0; i < BLOCK_NUM_NONLOCALIZED_VARS (stmt); i++) 18180 { 18181 local_decl = BLOCK_NONLOCALIZED_VAR (stmt, i); 18182 if ((TREE_CODE (local_decl) == VAR_DECL && !TREE_STATIC (local_decl)) 18183 || TREE_CODE (local_decl) == PARM_DECL) 18184 set_decl_abstract_flags (local_decl, abstract_vec); 18185 } 18186 18187 for (subblock = BLOCK_SUBBLOCKS (stmt); 18188 subblock != NULL_TREE; 18189 subblock = BLOCK_CHAIN (subblock)) 18190 set_block_abstract_flags (subblock, abstract_vec); 18191} 18192 18193/* Given a pointer to some ..._DECL node, set DECL_ABSTRACT_P flag on it 18194 to 1 and if it wasn't 1 before, push to abstract_vec vector. 18195 In the case where the decl is a FUNCTION_DECL also set the abstract 18196 flags for all of the parameters, local vars, local 18197 blocks and sub-blocks (recursively). */ 18198 18199static void 18200set_decl_abstract_flags (tree decl, vec<tree> &abstract_vec) 18201{ 18202 if (!DECL_ABSTRACT_P (decl)) 18203 { 18204 abstract_vec.safe_push (decl); 18205 DECL_ABSTRACT_P (decl) = 1; 18206 } 18207 18208 if (TREE_CODE (decl) == FUNCTION_DECL) 18209 { 18210 tree arg; 18211 18212 for (arg = DECL_ARGUMENTS (decl); arg; arg = DECL_CHAIN (arg)) 18213 if (!DECL_ABSTRACT_P (arg)) 18214 { 18215 abstract_vec.safe_push (arg); 18216 DECL_ABSTRACT_P (arg) = 1; 18217 } 18218 if (DECL_INITIAL (decl) != NULL_TREE 18219 && DECL_INITIAL (decl) != error_mark_node) 18220 set_block_abstract_flags (DECL_INITIAL (decl), abstract_vec); 18221 } 18222} 18223 18224/* Generate the DWARF2 info for the "abstract" instance of a function which we 18225 may later generate inlined and/or out-of-line instances of. */ 18226 18227static void 18228dwarf2out_abstract_function (tree decl) 18229{ 18230 dw_die_ref old_die; 18231 tree save_fn; 18232 tree context; 18233 hash_table<decl_loc_hasher> *old_decl_loc_table; 18234 hash_table<dw_loc_list_hasher> *old_cached_dw_loc_list_table; 18235 int old_call_site_count, old_tail_call_site_count; 18236 struct call_arg_loc_node *old_call_arg_locations; 18237 18238 /* Make sure we have the actual abstract inline, not a clone. */ 18239 decl = DECL_ORIGIN (decl); 18240 18241 old_die = lookup_decl_die (decl); 18242 if (old_die && get_AT (old_die, DW_AT_inline)) 18243 /* We've already generated the abstract instance. */ 18244 return; 18245 18246 /* We can be called while recursively when seeing block defining inlined subroutine 18247 DIE. Be sure to not clobber the outer location table nor use it or we would 18248 get locations in abstract instantces. */ 18249 old_decl_loc_table = decl_loc_table; 18250 decl_loc_table = NULL; 18251 old_cached_dw_loc_list_table = cached_dw_loc_list_table; 18252 cached_dw_loc_list_table = NULL; 18253 old_call_arg_locations = call_arg_locations; 18254 call_arg_locations = NULL; 18255 old_call_site_count = call_site_count; 18256 call_site_count = -1; 18257 old_tail_call_site_count = tail_call_site_count; 18258 tail_call_site_count = -1; 18259 18260 /* Be sure we've emitted the in-class declaration DIE (if any) first, so 18261 we don't get confused by DECL_ABSTRACT_P. */ 18262 if (debug_info_level > DINFO_LEVEL_TERSE) 18263 { 18264 context = decl_class_context (decl); 18265 if (context) 18266 gen_type_die_for_member 18267 (context, decl, decl_function_context (decl) ? NULL : comp_unit_die ()); 18268 } 18269 18270 /* Pretend we've just finished compiling this function. */ 18271 save_fn = current_function_decl; 18272 current_function_decl = decl; 18273 18274 auto_vec<tree, 64> abstract_vec; 18275 set_decl_abstract_flags (decl, abstract_vec); 18276 dwarf2out_decl (decl); 18277 unsigned int i; 18278 tree t; 18279 FOR_EACH_VEC_ELT (abstract_vec, i, t) 18280 if (TREE_CODE (t) == BLOCK) 18281 BLOCK_ABSTRACT (t) = 0; 18282 else 18283 DECL_ABSTRACT_P (t) = 0; 18284 18285 current_function_decl = save_fn; 18286 decl_loc_table = old_decl_loc_table; 18287 cached_dw_loc_list_table = old_cached_dw_loc_list_table; 18288 call_arg_locations = old_call_arg_locations; 18289 call_site_count = old_call_site_count; 18290 tail_call_site_count = old_tail_call_site_count; 18291} 18292 18293/* Helper function of premark_used_types() which gets called through 18294 htab_traverse. 18295 18296 Marks the DIE of a given type in *SLOT as perennial, so it never gets 18297 marked as unused by prune_unused_types. */ 18298 18299bool 18300premark_used_types_helper (tree const &type, void *) 18301{ 18302 dw_die_ref die; 18303 18304 die = lookup_type_die (type); 18305 if (die != NULL) 18306 die->die_perennial_p = 1; 18307 return true; 18308} 18309 18310/* Helper function of premark_types_used_by_global_vars which gets called 18311 through htab_traverse. 18312 18313 Marks the DIE of a given type in *SLOT as perennial, so it never gets 18314 marked as unused by prune_unused_types. The DIE of the type is marked 18315 only if the global variable using the type will actually be emitted. */ 18316 18317int 18318premark_types_used_by_global_vars_helper (types_used_by_vars_entry **slot, 18319 void *) 18320{ 18321 struct types_used_by_vars_entry *entry; 18322 dw_die_ref die; 18323 18324 entry = (struct types_used_by_vars_entry *) *slot; 18325 gcc_assert (entry->type != NULL 18326 && entry->var_decl != NULL); 18327 die = lookup_type_die (entry->type); 18328 if (die) 18329 { 18330 /* Ask cgraph if the global variable really is to be emitted. 18331 If yes, then we'll keep the DIE of ENTRY->TYPE. */ 18332 varpool_node *node = varpool_node::get (entry->var_decl); 18333 if (node && node->definition) 18334 { 18335 die->die_perennial_p = 1; 18336 /* Keep the parent DIEs as well. */ 18337 while ((die = die->die_parent) && die->die_perennial_p == 0) 18338 die->die_perennial_p = 1; 18339 } 18340 } 18341 return 1; 18342} 18343 18344/* Mark all members of used_types_hash as perennial. */ 18345 18346static void 18347premark_used_types (struct function *fun) 18348{ 18349 if (fun && fun->used_types_hash) 18350 fun->used_types_hash->traverse<void *, premark_used_types_helper> (NULL); 18351} 18352 18353/* Mark all members of types_used_by_vars_entry as perennial. */ 18354 18355static void 18356premark_types_used_by_global_vars (void) 18357{ 18358 if (types_used_by_vars_hash) 18359 types_used_by_vars_hash 18360 ->traverse<void *, premark_types_used_by_global_vars_helper> (NULL); 18361} 18362 18363/* Generate a DW_TAG_GNU_call_site DIE in function DECL under SUBR_DIE 18364 for CA_LOC call arg loc node. */ 18365 18366static dw_die_ref 18367gen_call_site_die (tree decl, dw_die_ref subr_die, 18368 struct call_arg_loc_node *ca_loc) 18369{ 18370 dw_die_ref stmt_die = NULL, die; 18371 tree block = ca_loc->block; 18372 18373 while (block 18374 && block != DECL_INITIAL (decl) 18375 && TREE_CODE (block) == BLOCK) 18376 { 18377 if (block_map.length () > BLOCK_NUMBER (block)) 18378 stmt_die = block_map[BLOCK_NUMBER (block)]; 18379 if (stmt_die) 18380 break; 18381 block = BLOCK_SUPERCONTEXT (block); 18382 } 18383 if (stmt_die == NULL) 18384 stmt_die = subr_die; 18385 die = new_die (DW_TAG_GNU_call_site, stmt_die, NULL_TREE); 18386 add_AT_lbl_id (die, DW_AT_low_pc, ca_loc->label); 18387 if (ca_loc->tail_call_p) 18388 add_AT_flag (die, DW_AT_GNU_tail_call, 1); 18389 if (ca_loc->symbol_ref) 18390 { 18391 dw_die_ref tdie = lookup_decl_die (SYMBOL_REF_DECL (ca_loc->symbol_ref)); 18392 if (tdie) 18393 add_AT_die_ref (die, DW_AT_abstract_origin, tdie); 18394 else 18395 add_AT_addr (die, DW_AT_abstract_origin, ca_loc->symbol_ref, false); 18396 } 18397 return die; 18398} 18399 18400/* Generate a DIE to represent a declared function (either file-scope or 18401 block-local). */ 18402 18403static void 18404gen_subprogram_die (tree decl, dw_die_ref context_die) 18405{ 18406 tree origin = decl_ultimate_origin (decl); 18407 dw_die_ref subr_die; 18408 tree outer_scope; 18409 dw_die_ref old_die = lookup_decl_die (decl); 18410 int declaration = (current_function_decl != decl 18411 || class_or_namespace_scope_p (context_die)); 18412 18413 premark_used_types (DECL_STRUCT_FUNCTION (decl)); 18414 18415 /* It is possible to have both DECL_ABSTRACT_P and DECLARATION be true if we 18416 started to generate the abstract instance of an inline, decided to output 18417 its containing class, and proceeded to emit the declaration of the inline 18418 from the member list for the class. If so, DECLARATION takes priority; 18419 we'll get back to the abstract instance when done with the class. */ 18420 18421 /* The class-scope declaration DIE must be the primary DIE. */ 18422 if (origin && declaration && class_or_namespace_scope_p (context_die)) 18423 { 18424 origin = NULL; 18425 gcc_assert (!old_die); 18426 } 18427 18428 /* Now that the C++ front end lazily declares artificial member fns, we 18429 might need to retrofit the declaration into its class. */ 18430 if (!declaration && !origin && !old_die 18431 && DECL_CONTEXT (decl) && TYPE_P (DECL_CONTEXT (decl)) 18432 && !class_or_namespace_scope_p (context_die) 18433 && debug_info_level > DINFO_LEVEL_TERSE) 18434 old_die = force_decl_die (decl); 18435 18436 if (origin != NULL) 18437 { 18438 gcc_assert (!declaration || local_scope_p (context_die)); 18439 18440 /* Fixup die_parent for the abstract instance of a nested 18441 inline function. */ 18442 if (old_die && old_die->die_parent == NULL) 18443 add_child_die (context_die, old_die); 18444 18445 subr_die = new_die (DW_TAG_subprogram, context_die, decl); 18446 add_abstract_origin_attribute (subr_die, origin); 18447 /* This is where the actual code for a cloned function is. 18448 Let's emit linkage name attribute for it. This helps 18449 debuggers to e.g, set breakpoints into 18450 constructors/destructors when the user asks "break 18451 K::K". */ 18452 add_linkage_name (subr_die, decl); 18453 } 18454 else if (old_die) 18455 { 18456 expanded_location s = expand_location (DECL_SOURCE_LOCATION (decl)); 18457 struct dwarf_file_data * file_index = lookup_filename (s.file); 18458 18459 if (!get_AT_flag (old_die, DW_AT_declaration) 18460 /* We can have a normal definition following an inline one in the 18461 case of redefinition of GNU C extern inlines. 18462 It seems reasonable to use AT_specification in this case. */ 18463 && !get_AT (old_die, DW_AT_inline)) 18464 { 18465 /* Detect and ignore this case, where we are trying to output 18466 something we have already output. */ 18467 return; 18468 } 18469 18470 /* If the definition comes from the same place as the declaration, 18471 maybe use the old DIE. We always want the DIE for this function 18472 that has the *_pc attributes to be under comp_unit_die so the 18473 debugger can find it. We also need to do this for abstract 18474 instances of inlines, since the spec requires the out-of-line copy 18475 to have the same parent. For local class methods, this doesn't 18476 apply; we just use the old DIE. */ 18477 if ((is_cu_die (old_die->die_parent) || context_die == NULL) 18478 && (DECL_ARTIFICIAL (decl) 18479 || (get_AT_file (old_die, DW_AT_decl_file) == file_index 18480 && (get_AT_unsigned (old_die, DW_AT_decl_line) 18481 == (unsigned) s.line)))) 18482 { 18483 subr_die = old_die; 18484 18485 /* Clear out the declaration attribute and the formal parameters. 18486 Do not remove all children, because it is possible that this 18487 declaration die was forced using force_decl_die(). In such 18488 cases die that forced declaration die (e.g. TAG_imported_module) 18489 is one of the children that we do not want to remove. */ 18490 remove_AT (subr_die, DW_AT_declaration); 18491 remove_AT (subr_die, DW_AT_object_pointer); 18492 remove_child_TAG (subr_die, DW_TAG_formal_parameter); 18493 } 18494 else 18495 { 18496 subr_die = new_die (DW_TAG_subprogram, context_die, decl); 18497 add_AT_specification (subr_die, old_die); 18498 add_pubname (decl, subr_die); 18499 if (get_AT_file (old_die, DW_AT_decl_file) != file_index) 18500 add_AT_file (subr_die, DW_AT_decl_file, file_index); 18501 if (get_AT_unsigned (old_die, DW_AT_decl_line) != (unsigned) s.line) 18502 add_AT_unsigned (subr_die, DW_AT_decl_line, s.line); 18503 18504 /* If the prototype had an 'auto' or 'decltype(auto)' return type, 18505 emit the real type on the definition die. */ 18506 if (is_cxx() && debug_info_level > DINFO_LEVEL_TERSE) 18507 { 18508 dw_die_ref die = get_AT_ref (old_die, DW_AT_type); 18509 if (die == auto_die || die == decltype_auto_die) 18510 add_type_attribute (subr_die, TREE_TYPE (TREE_TYPE (decl)), 18511 TYPE_UNQUALIFIED, context_die); 18512 } 18513 } 18514 } 18515 else 18516 { 18517 subr_die = new_die (DW_TAG_subprogram, context_die, decl); 18518 18519 if (TREE_PUBLIC (decl)) 18520 add_AT_flag (subr_die, DW_AT_external, 1); 18521 18522 add_name_and_src_coords_attributes (subr_die, decl); 18523 add_pubname (decl, subr_die); 18524 if (debug_info_level > DINFO_LEVEL_TERSE) 18525 { 18526 add_prototyped_attribute (subr_die, TREE_TYPE (decl)); 18527 add_type_attribute (subr_die, TREE_TYPE (TREE_TYPE (decl)), 18528 TYPE_UNQUALIFIED, context_die); 18529 } 18530 18531 add_pure_or_virtual_attribute (subr_die, decl); 18532 if (DECL_ARTIFICIAL (decl)) 18533 add_AT_flag (subr_die, DW_AT_artificial, 1); 18534 18535 if (TREE_THIS_VOLATILE (decl) && (dwarf_version >= 5 || !dwarf_strict)) 18536 add_AT_flag (subr_die, DW_AT_noreturn, 1); 18537 18538 add_accessibility_attribute (subr_die, decl); 18539 } 18540 18541 if (declaration) 18542 { 18543 if (!old_die || !get_AT (old_die, DW_AT_inline)) 18544 { 18545 add_AT_flag (subr_die, DW_AT_declaration, 1); 18546 18547 /* If this is an explicit function declaration then generate 18548 a DW_AT_explicit attribute. */ 18549 if (lang_hooks.decls.function_decl_explicit_p (decl) 18550 && (dwarf_version >= 3 || !dwarf_strict)) 18551 add_AT_flag (subr_die, DW_AT_explicit, 1); 18552 18553 /* If this is a C++11 deleted special function member then generate 18554 a DW_AT_GNU_deleted attribute. */ 18555 if (lang_hooks.decls.function_decl_deleted_p (decl) 18556 && (! dwarf_strict)) 18557 add_AT_flag (subr_die, DW_AT_GNU_deleted, 1); 18558 18559 /* The first time we see a member function, it is in the context of 18560 the class to which it belongs. We make sure of this by emitting 18561 the class first. The next time is the definition, which is 18562 handled above. The two may come from the same source text. 18563 18564 Note that force_decl_die() forces function declaration die. It is 18565 later reused to represent definition. */ 18566 equate_decl_number_to_die (decl, subr_die); 18567 } 18568 } 18569 else if (DECL_ABSTRACT_P (decl)) 18570 { 18571 if (DECL_DECLARED_INLINE_P (decl)) 18572 { 18573 if (cgraph_function_possibly_inlined_p (decl)) 18574 add_AT_unsigned (subr_die, DW_AT_inline, DW_INL_declared_inlined); 18575 else 18576 add_AT_unsigned (subr_die, DW_AT_inline, DW_INL_declared_not_inlined); 18577 } 18578 else 18579 { 18580 if (cgraph_function_possibly_inlined_p (decl)) 18581 add_AT_unsigned (subr_die, DW_AT_inline, DW_INL_inlined); 18582 else 18583 add_AT_unsigned (subr_die, DW_AT_inline, DW_INL_not_inlined); 18584 } 18585 18586 if (DECL_DECLARED_INLINE_P (decl) 18587 && lookup_attribute ("artificial", DECL_ATTRIBUTES (decl))) 18588 add_AT_flag (subr_die, DW_AT_artificial, 1); 18589 18590 equate_decl_number_to_die (decl, subr_die); 18591 } 18592 else if (!DECL_EXTERNAL (decl)) 18593 { 18594 HOST_WIDE_INT cfa_fb_offset; 18595 struct function *fun = DECL_STRUCT_FUNCTION (decl); 18596 18597 if (!old_die || !get_AT (old_die, DW_AT_inline)) 18598 equate_decl_number_to_die (decl, subr_die); 18599 18600 gcc_checking_assert (fun); 18601 if (!flag_reorder_blocks_and_partition) 18602 { 18603 dw_fde_ref fde = fun->fde; 18604 if (fde->dw_fde_begin) 18605 { 18606 /* We have already generated the labels. */ 18607 add_AT_low_high_pc (subr_die, fde->dw_fde_begin, 18608 fde->dw_fde_end, false); 18609 } 18610 else 18611 { 18612 /* Create start/end labels and add the range. */ 18613 char label_id_low[MAX_ARTIFICIAL_LABEL_BYTES]; 18614 char label_id_high[MAX_ARTIFICIAL_LABEL_BYTES]; 18615 ASM_GENERATE_INTERNAL_LABEL (label_id_low, FUNC_BEGIN_LABEL, 18616 current_function_funcdef_no); 18617 ASM_GENERATE_INTERNAL_LABEL (label_id_high, FUNC_END_LABEL, 18618 current_function_funcdef_no); 18619 add_AT_low_high_pc (subr_die, label_id_low, label_id_high, 18620 false); 18621 } 18622 18623#if VMS_DEBUGGING_INFO 18624 /* HP OpenVMS Industry Standard 64: DWARF Extensions 18625 Section 2.3 Prologue and Epilogue Attributes: 18626 When a breakpoint is set on entry to a function, it is generally 18627 desirable for execution to be suspended, not on the very first 18628 instruction of the function, but rather at a point after the 18629 function's frame has been set up, after any language defined local 18630 declaration processing has been completed, and before execution of 18631 the first statement of the function begins. Debuggers generally 18632 cannot properly determine where this point is. Similarly for a 18633 breakpoint set on exit from a function. The prologue and epilogue 18634 attributes allow a compiler to communicate the location(s) to use. */ 18635 18636 { 18637 if (fde->dw_fde_vms_end_prologue) 18638 add_AT_vms_delta (subr_die, DW_AT_HP_prologue, 18639 fde->dw_fde_begin, fde->dw_fde_vms_end_prologue); 18640 18641 if (fde->dw_fde_vms_begin_epilogue) 18642 add_AT_vms_delta (subr_die, DW_AT_HP_epilogue, 18643 fde->dw_fde_begin, fde->dw_fde_vms_begin_epilogue); 18644 } 18645#endif 18646 18647 } 18648 else 18649 { 18650 /* Generate pubnames entries for the split function code ranges. */ 18651 dw_fde_ref fde = fun->fde; 18652 18653 if (fde->dw_fde_second_begin) 18654 { 18655 if (dwarf_version >= 3 || !dwarf_strict) 18656 { 18657 /* We should use ranges for non-contiguous code section 18658 addresses. Use the actual code range for the initial 18659 section, since the HOT/COLD labels might precede an 18660 alignment offset. */ 18661 bool range_list_added = false; 18662 add_ranges_by_labels (subr_die, fde->dw_fde_begin, 18663 fde->dw_fde_end, &range_list_added, 18664 false); 18665 add_ranges_by_labels (subr_die, fde->dw_fde_second_begin, 18666 fde->dw_fde_second_end, 18667 &range_list_added, false); 18668 if (range_list_added) 18669 add_ranges (NULL); 18670 } 18671 else 18672 { 18673 /* There is no real support in DW2 for this .. so we make 18674 a work-around. First, emit the pub name for the segment 18675 containing the function label. Then make and emit a 18676 simplified subprogram DIE for the second segment with the 18677 name pre-fixed by __hot/cold_sect_of_. We use the same 18678 linkage name for the second die so that gdb will find both 18679 sections when given "b foo". */ 18680 const char *name = NULL; 18681 tree decl_name = DECL_NAME (decl); 18682 dw_die_ref seg_die; 18683 18684 /* Do the 'primary' section. */ 18685 add_AT_low_high_pc (subr_die, fde->dw_fde_begin, 18686 fde->dw_fde_end, false); 18687 18688 /* Build a minimal DIE for the secondary section. */ 18689 seg_die = new_die (DW_TAG_subprogram, 18690 subr_die->die_parent, decl); 18691 18692 if (TREE_PUBLIC (decl)) 18693 add_AT_flag (seg_die, DW_AT_external, 1); 18694 18695 if (decl_name != NULL 18696 && IDENTIFIER_POINTER (decl_name) != NULL) 18697 { 18698 name = dwarf2_name (decl, 1); 18699 if (! DECL_ARTIFICIAL (decl)) 18700 add_src_coords_attributes (seg_die, decl); 18701 18702 add_linkage_name (seg_die, decl); 18703 } 18704 gcc_assert (name != NULL); 18705 add_pure_or_virtual_attribute (seg_die, decl); 18706 if (DECL_ARTIFICIAL (decl)) 18707 add_AT_flag (seg_die, DW_AT_artificial, 1); 18708 18709 name = concat ("__second_sect_of_", name, NULL); 18710 add_AT_low_high_pc (seg_die, fde->dw_fde_second_begin, 18711 fde->dw_fde_second_end, false); 18712 add_name_attribute (seg_die, name); 18713 if (want_pubnames ()) 18714 add_pubname_string (name, seg_die); 18715 } 18716 } 18717 else 18718 add_AT_low_high_pc (subr_die, fde->dw_fde_begin, fde->dw_fde_end, 18719 false); 18720 } 18721 18722 cfa_fb_offset = CFA_FRAME_BASE_OFFSET (decl); 18723 18724 /* We define the "frame base" as the function's CFA. This is more 18725 convenient for several reasons: (1) It's stable across the prologue 18726 and epilogue, which makes it better than just a frame pointer, 18727 (2) With dwarf3, there exists a one-byte encoding that allows us 18728 to reference the .debug_frame data by proxy, but failing that, 18729 (3) We can at least reuse the code inspection and interpretation 18730 code that determines the CFA position at various points in the 18731 function. */ 18732 if (dwarf_version >= 3 && targetm.debug_unwind_info () == UI_DWARF2) 18733 { 18734 dw_loc_descr_ref op = new_loc_descr (DW_OP_call_frame_cfa, 0, 0); 18735 add_AT_loc (subr_die, DW_AT_frame_base, op); 18736 } 18737 else 18738 { 18739 dw_loc_list_ref list = convert_cfa_to_fb_loc_list (cfa_fb_offset); 18740 if (list->dw_loc_next) 18741 add_AT_loc_list (subr_die, DW_AT_frame_base, list); 18742 else 18743 add_AT_loc (subr_die, DW_AT_frame_base, list->expr); 18744 } 18745 18746 /* Compute a displacement from the "steady-state frame pointer" to 18747 the CFA. The former is what all stack slots and argument slots 18748 will reference in the rtl; the latter is what we've told the 18749 debugger about. We'll need to adjust all frame_base references 18750 by this displacement. */ 18751 compute_frame_pointer_to_fb_displacement (cfa_fb_offset); 18752 18753 if (fun->static_chain_decl) 18754 add_AT_location_description (subr_die, DW_AT_static_link, 18755 loc_list_from_tree (fun->static_chain_decl, 2, NULL)); 18756 } 18757 18758 /* Generate child dies for template paramaters. */ 18759 if (debug_info_level > DINFO_LEVEL_TERSE) 18760 gen_generic_params_dies (decl); 18761 18762 /* Now output descriptions of the arguments for this function. This gets 18763 (unnecessarily?) complex because of the fact that the DECL_ARGUMENT list 18764 for a FUNCTION_DECL doesn't indicate cases where there was a trailing 18765 `...' at the end of the formal parameter list. In order to find out if 18766 there was a trailing ellipsis or not, we must instead look at the type 18767 associated with the FUNCTION_DECL. This will be a node of type 18768 FUNCTION_TYPE. If the chain of type nodes hanging off of this 18769 FUNCTION_TYPE node ends with a void_type_node then there should *not* be 18770 an ellipsis at the end. */ 18771 18772 /* In the case where we are describing a mere function declaration, all we 18773 need to do here (and all we *can* do here) is to describe the *types* of 18774 its formal parameters. */ 18775 if (debug_info_level <= DINFO_LEVEL_TERSE) 18776 ; 18777 else if (declaration) 18778 gen_formal_types_die (decl, subr_die); 18779 else 18780 { 18781 /* Generate DIEs to represent all known formal parameters. */ 18782 tree parm = DECL_ARGUMENTS (decl); 18783 tree generic_decl = lang_hooks.decls.get_generic_function_decl (decl); 18784 tree generic_decl_parm = generic_decl 18785 ? DECL_ARGUMENTS (generic_decl) 18786 : NULL; 18787 18788 /* Now we want to walk the list of parameters of the function and 18789 emit their relevant DIEs. 18790 18791 We consider the case of DECL being an instance of a generic function 18792 as well as it being a normal function. 18793 18794 If DECL is an instance of a generic function we walk the 18795 parameters of the generic function declaration _and_ the parameters of 18796 DECL itself. This is useful because we want to emit specific DIEs for 18797 function parameter packs and those are declared as part of the 18798 generic function declaration. In that particular case, 18799 the parameter pack yields a DW_TAG_GNU_formal_parameter_pack DIE. 18800 That DIE has children DIEs representing the set of arguments 18801 of the pack. Note that the set of pack arguments can be empty. 18802 In that case, the DW_TAG_GNU_formal_parameter_pack DIE will not have any 18803 children DIE. 18804 18805 Otherwise, we just consider the parameters of DECL. */ 18806 while (generic_decl_parm || parm) 18807 { 18808 if (generic_decl_parm 18809 && lang_hooks.function_parameter_pack_p (generic_decl_parm)) 18810 gen_formal_parameter_pack_die (generic_decl_parm, 18811 parm, subr_die, 18812 &parm); 18813 else if (parm && !POINTER_BOUNDS_P (parm)) 18814 { 18815 dw_die_ref parm_die = gen_decl_die (parm, NULL, subr_die); 18816 18817 if (parm == DECL_ARGUMENTS (decl) 18818 && TREE_CODE (TREE_TYPE (decl)) == METHOD_TYPE 18819 && parm_die 18820 && (dwarf_version >= 3 || !dwarf_strict)) 18821 add_AT_die_ref (subr_die, DW_AT_object_pointer, parm_die); 18822 18823 parm = DECL_CHAIN (parm); 18824 } 18825 else if (parm) 18826 parm = DECL_CHAIN (parm); 18827 18828 if (generic_decl_parm) 18829 generic_decl_parm = DECL_CHAIN (generic_decl_parm); 18830 } 18831 18832 /* Decide whether we need an unspecified_parameters DIE at the end. 18833 There are 2 more cases to do this for: 1) the ansi ... declaration - 18834 this is detectable when the end of the arg list is not a 18835 void_type_node 2) an unprototyped function declaration (not a 18836 definition). This just means that we have no info about the 18837 parameters at all. */ 18838 if (prototype_p (TREE_TYPE (decl))) 18839 { 18840 /* This is the prototyped case, check for.... */ 18841 if (stdarg_p (TREE_TYPE (decl))) 18842 gen_unspecified_parameters_die (decl, subr_die); 18843 } 18844 else if (DECL_INITIAL (decl) == NULL_TREE) 18845 gen_unspecified_parameters_die (decl, subr_die); 18846 } 18847 18848 /* Output Dwarf info for all of the stuff within the body of the function 18849 (if it has one - it may be just a declaration). */ 18850 outer_scope = DECL_INITIAL (decl); 18851 18852 /* OUTER_SCOPE is a pointer to the outermost BLOCK node created to represent 18853 a function. This BLOCK actually represents the outermost binding contour 18854 for the function, i.e. the contour in which the function's formal 18855 parameters and labels get declared. Curiously, it appears that the front 18856 end doesn't actually put the PARM_DECL nodes for the current function onto 18857 the BLOCK_VARS list for this outer scope, but are strung off of the 18858 DECL_ARGUMENTS list for the function instead. 18859 18860 The BLOCK_VARS list for the `outer_scope' does provide us with a list of 18861 the LABEL_DECL nodes for the function however, and we output DWARF info 18862 for those in decls_for_scope. Just within the `outer_scope' there will be 18863 a BLOCK node representing the function's outermost pair of curly braces, 18864 and any blocks used for the base and member initializers of a C++ 18865 constructor function. */ 18866 if (! declaration && outer_scope && TREE_CODE (outer_scope) != ERROR_MARK) 18867 { 18868 int call_site_note_count = 0; 18869 int tail_call_site_note_count = 0; 18870 18871 /* Emit a DW_TAG_variable DIE for a named return value. */ 18872 if (DECL_NAME (DECL_RESULT (decl))) 18873 gen_decl_die (DECL_RESULT (decl), NULL, subr_die); 18874 18875 decls_for_scope (outer_scope, subr_die); 18876 18877 if (call_arg_locations && !dwarf_strict) 18878 { 18879 struct call_arg_loc_node *ca_loc; 18880 for (ca_loc = call_arg_locations; ca_loc; ca_loc = ca_loc->next) 18881 { 18882 dw_die_ref die = NULL; 18883 rtx tloc = NULL_RTX, tlocc = NULL_RTX; 18884 rtx arg, next_arg; 18885 18886 for (arg = NOTE_VAR_LOCATION (ca_loc->call_arg_loc_note); 18887 arg; arg = next_arg) 18888 { 18889 dw_loc_descr_ref reg, val; 18890 machine_mode mode = GET_MODE (XEXP (XEXP (arg, 0), 1)); 18891 dw_die_ref cdie, tdie = NULL; 18892 18893 next_arg = XEXP (arg, 1); 18894 if (REG_P (XEXP (XEXP (arg, 0), 0)) 18895 && next_arg 18896 && MEM_P (XEXP (XEXP (next_arg, 0), 0)) 18897 && REG_P (XEXP (XEXP (XEXP (next_arg, 0), 0), 0)) 18898 && REGNO (XEXP (XEXP (arg, 0), 0)) 18899 == REGNO (XEXP (XEXP (XEXP (next_arg, 0), 0), 0))) 18900 next_arg = XEXP (next_arg, 1); 18901 if (mode == VOIDmode) 18902 { 18903 mode = GET_MODE (XEXP (XEXP (arg, 0), 0)); 18904 if (mode == VOIDmode) 18905 mode = GET_MODE (XEXP (arg, 0)); 18906 } 18907 if (mode == VOIDmode || mode == BLKmode) 18908 continue; 18909 if (XEXP (XEXP (arg, 0), 0) == pc_rtx) 18910 { 18911 gcc_assert (ca_loc->symbol_ref == NULL_RTX); 18912 tloc = XEXP (XEXP (arg, 0), 1); 18913 continue; 18914 } 18915 else if (GET_CODE (XEXP (XEXP (arg, 0), 0)) == CLOBBER 18916 && XEXP (XEXP (XEXP (arg, 0), 0), 0) == pc_rtx) 18917 { 18918 gcc_assert (ca_loc->symbol_ref == NULL_RTX); 18919 tlocc = XEXP (XEXP (arg, 0), 1); 18920 continue; 18921 } 18922 reg = NULL; 18923 if (REG_P (XEXP (XEXP (arg, 0), 0))) 18924 reg = reg_loc_descriptor (XEXP (XEXP (arg, 0), 0), 18925 VAR_INIT_STATUS_INITIALIZED); 18926 else if (MEM_P (XEXP (XEXP (arg, 0), 0))) 18927 { 18928 rtx mem = XEXP (XEXP (arg, 0), 0); 18929 reg = mem_loc_descriptor (XEXP (mem, 0), 18930 get_address_mode (mem), 18931 GET_MODE (mem), 18932 VAR_INIT_STATUS_INITIALIZED); 18933 } 18934 else if (GET_CODE (XEXP (XEXP (arg, 0), 0)) 18935 == DEBUG_PARAMETER_REF) 18936 { 18937 tree tdecl 18938 = DEBUG_PARAMETER_REF_DECL (XEXP (XEXP (arg, 0), 0)); 18939 tdie = lookup_decl_die (tdecl); 18940 if (tdie == NULL) 18941 continue; 18942 } 18943 else 18944 continue; 18945 if (reg == NULL 18946 && GET_CODE (XEXP (XEXP (arg, 0), 0)) 18947 != DEBUG_PARAMETER_REF) 18948 continue; 18949 val = mem_loc_descriptor (XEXP (XEXP (arg, 0), 1), mode, 18950 VOIDmode, 18951 VAR_INIT_STATUS_INITIALIZED); 18952 if (val == NULL) 18953 continue; 18954 if (die == NULL) 18955 die = gen_call_site_die (decl, subr_die, ca_loc); 18956 cdie = new_die (DW_TAG_GNU_call_site_parameter, die, 18957 NULL_TREE); 18958 if (reg != NULL) 18959 add_AT_loc (cdie, DW_AT_location, reg); 18960 else if (tdie != NULL) 18961 add_AT_die_ref (cdie, DW_AT_abstract_origin, tdie); 18962 add_AT_loc (cdie, DW_AT_GNU_call_site_value, val); 18963 if (next_arg != XEXP (arg, 1)) 18964 { 18965 mode = GET_MODE (XEXP (XEXP (XEXP (arg, 1), 0), 1)); 18966 if (mode == VOIDmode) 18967 mode = GET_MODE (XEXP (XEXP (XEXP (arg, 1), 0), 0)); 18968 val = mem_loc_descriptor (XEXP (XEXP (XEXP (arg, 1), 18969 0), 1), 18970 mode, VOIDmode, 18971 VAR_INIT_STATUS_INITIALIZED); 18972 if (val != NULL) 18973 add_AT_loc (cdie, DW_AT_GNU_call_site_data_value, val); 18974 } 18975 } 18976 if (die == NULL 18977 && (ca_loc->symbol_ref || tloc)) 18978 die = gen_call_site_die (decl, subr_die, ca_loc); 18979 if (die != NULL && (tloc != NULL_RTX || tlocc != NULL_RTX)) 18980 { 18981 dw_loc_descr_ref tval = NULL; 18982 18983 if (tloc != NULL_RTX) 18984 tval = mem_loc_descriptor (tloc, 18985 GET_MODE (tloc) == VOIDmode 18986 ? Pmode : GET_MODE (tloc), 18987 VOIDmode, 18988 VAR_INIT_STATUS_INITIALIZED); 18989 if (tval) 18990 add_AT_loc (die, DW_AT_GNU_call_site_target, tval); 18991 else if (tlocc != NULL_RTX) 18992 { 18993 tval = mem_loc_descriptor (tlocc, 18994 GET_MODE (tlocc) == VOIDmode 18995 ? Pmode : GET_MODE (tlocc), 18996 VOIDmode, 18997 VAR_INIT_STATUS_INITIALIZED); 18998 if (tval) 18999 add_AT_loc (die, DW_AT_GNU_call_site_target_clobbered, 19000 tval); 19001 } 19002 } 19003 if (die != NULL) 19004 { 19005 call_site_note_count++; 19006 if (ca_loc->tail_call_p) 19007 tail_call_site_note_count++; 19008 } 19009 } 19010 } 19011 call_arg_locations = NULL; 19012 call_arg_loc_last = NULL; 19013 if (tail_call_site_count >= 0 19014 && tail_call_site_count == tail_call_site_note_count 19015 && !dwarf_strict) 19016 { 19017 if (call_site_count >= 0 19018 && call_site_count == call_site_note_count) 19019 add_AT_flag (subr_die, DW_AT_GNU_all_call_sites, 1); 19020 else 19021 add_AT_flag (subr_die, DW_AT_GNU_all_tail_call_sites, 1); 19022 } 19023 call_site_count = -1; 19024 tail_call_site_count = -1; 19025 } 19026 19027 if (subr_die != old_die) 19028 /* Add the calling convention attribute if requested. */ 19029 add_calling_convention_attribute (subr_die, decl); 19030} 19031 19032/* Returns a hash value for X (which really is a die_struct). */ 19033 19034hashval_t 19035block_die_hasher::hash (die_struct *d) 19036{ 19037 return (hashval_t) d->decl_id ^ htab_hash_pointer (d->die_parent); 19038} 19039 19040/* Return nonzero if decl_id and die_parent of die_struct X is the same 19041 as decl_id and die_parent of die_struct Y. */ 19042 19043bool 19044block_die_hasher::equal (die_struct *x, die_struct *y) 19045{ 19046 return x->decl_id == y->decl_id && x->die_parent == y->die_parent; 19047} 19048 19049/* Generate a DIE to represent a declared data object. 19050 Either DECL or ORIGIN must be non-null. */ 19051 19052static void 19053gen_variable_die (tree decl, tree origin, dw_die_ref context_die) 19054{ 19055 HOST_WIDE_INT off = 0; 19056 tree com_decl; 19057 tree decl_or_origin = decl ? decl : origin; 19058 tree ultimate_origin; 19059 dw_die_ref var_die; 19060 dw_die_ref old_die = decl ? lookup_decl_die (decl) : NULL; 19061 dw_die_ref origin_die; 19062 bool declaration = (DECL_EXTERNAL (decl_or_origin) 19063 || class_or_namespace_scope_p (context_die)); 19064 bool specialization_p = false; 19065 19066 ultimate_origin = decl_ultimate_origin (decl_or_origin); 19067 if (decl || ultimate_origin) 19068 origin = ultimate_origin; 19069 com_decl = fortran_common (decl_or_origin, &off); 19070 19071 /* Symbol in common gets emitted as a child of the common block, in the form 19072 of a data member. */ 19073 if (com_decl) 19074 { 19075 dw_die_ref com_die; 19076 dw_loc_list_ref loc; 19077 die_node com_die_arg; 19078 19079 var_die = lookup_decl_die (decl_or_origin); 19080 if (var_die) 19081 { 19082 if (get_AT (var_die, DW_AT_location) == NULL) 19083 { 19084 loc = loc_list_from_tree (com_decl, off ? 1 : 2, NULL); 19085 if (loc) 19086 { 19087 if (off) 19088 { 19089 /* Optimize the common case. */ 19090 if (single_element_loc_list_p (loc) 19091 && loc->expr->dw_loc_opc == DW_OP_addr 19092 && loc->expr->dw_loc_next == NULL 19093 && GET_CODE (loc->expr->dw_loc_oprnd1.v.val_addr) 19094 == SYMBOL_REF) 19095 { 19096 rtx x = loc->expr->dw_loc_oprnd1.v.val_addr; 19097 loc->expr->dw_loc_oprnd1.v.val_addr 19098 = plus_constant (GET_MODE (x), x , off); 19099 } 19100 else 19101 loc_list_plus_const (loc, off); 19102 } 19103 add_AT_location_description (var_die, DW_AT_location, loc); 19104 remove_AT (var_die, DW_AT_declaration); 19105 } 19106 } 19107 return; 19108 } 19109 19110 if (common_block_die_table == NULL) 19111 common_block_die_table = hash_table<block_die_hasher>::create_ggc (10); 19112 19113 com_die_arg.decl_id = DECL_UID (com_decl); 19114 com_die_arg.die_parent = context_die; 19115 com_die = common_block_die_table->find (&com_die_arg); 19116 loc = loc_list_from_tree (com_decl, 2, NULL); 19117 if (com_die == NULL) 19118 { 19119 const char *cnam 19120 = IDENTIFIER_POINTER (DECL_ASSEMBLER_NAME (com_decl)); 19121 die_node **slot; 19122 19123 com_die = new_die (DW_TAG_common_block, context_die, decl); 19124 add_name_and_src_coords_attributes (com_die, com_decl); 19125 if (loc) 19126 { 19127 add_AT_location_description (com_die, DW_AT_location, loc); 19128 /* Avoid sharing the same loc descriptor between 19129 DW_TAG_common_block and DW_TAG_variable. */ 19130 loc = loc_list_from_tree (com_decl, 2, NULL); 19131 } 19132 else if (DECL_EXTERNAL (decl_or_origin)) 19133 add_AT_flag (com_die, DW_AT_declaration, 1); 19134 if (want_pubnames ()) 19135 add_pubname_string (cnam, com_die); /* ??? needed? */ 19136 com_die->decl_id = DECL_UID (com_decl); 19137 slot = common_block_die_table->find_slot (com_die, INSERT); 19138 *slot = com_die; 19139 } 19140 else if (get_AT (com_die, DW_AT_location) == NULL && loc) 19141 { 19142 add_AT_location_description (com_die, DW_AT_location, loc); 19143 loc = loc_list_from_tree (com_decl, 2, NULL); 19144 remove_AT (com_die, DW_AT_declaration); 19145 } 19146 var_die = new_die (DW_TAG_variable, com_die, decl); 19147 add_name_and_src_coords_attributes (var_die, decl_or_origin); 19148 add_type_attribute (var_die, TREE_TYPE (decl_or_origin), 19149 decl_quals (decl_or_origin), context_die); 19150 add_AT_flag (var_die, DW_AT_external, 1); 19151 if (loc) 19152 { 19153 if (off) 19154 { 19155 /* Optimize the common case. */ 19156 if (single_element_loc_list_p (loc) 19157 && loc->expr->dw_loc_opc == DW_OP_addr 19158 && loc->expr->dw_loc_next == NULL 19159 && GET_CODE (loc->expr->dw_loc_oprnd1.v.val_addr) == SYMBOL_REF) 19160 { 19161 rtx x = loc->expr->dw_loc_oprnd1.v.val_addr; 19162 loc->expr->dw_loc_oprnd1.v.val_addr 19163 = plus_constant (GET_MODE (x), x, off); 19164 } 19165 else 19166 loc_list_plus_const (loc, off); 19167 } 19168 add_AT_location_description (var_die, DW_AT_location, loc); 19169 } 19170 else if (DECL_EXTERNAL (decl_or_origin)) 19171 add_AT_flag (var_die, DW_AT_declaration, 1); 19172 if (decl) 19173 equate_decl_number_to_die (decl, var_die); 19174 return; 19175 } 19176 19177 /* If the compiler emitted a definition for the DECL declaration 19178 and if we already emitted a DIE for it, don't emit a second 19179 DIE for it again. Allow re-declarations of DECLs that are 19180 inside functions, though. */ 19181 if (old_die && declaration && !local_scope_p (context_die)) 19182 return; 19183 19184 /* For static data members, the declaration in the class is supposed 19185 to have DW_TAG_member tag; the specification should still be 19186 DW_TAG_variable referencing the DW_TAG_member DIE. */ 19187 if (declaration && class_scope_p (context_die)) 19188 var_die = new_die (DW_TAG_member, context_die, decl); 19189 else 19190 var_die = new_die (DW_TAG_variable, context_die, decl); 19191 19192 origin_die = NULL; 19193 if (origin != NULL) 19194 origin_die = add_abstract_origin_attribute (var_die, origin); 19195 19196 /* Loop unrolling can create multiple blocks that refer to the same 19197 static variable, so we must test for the DW_AT_declaration flag. 19198 19199 ??? Loop unrolling/reorder_blocks should perhaps be rewritten to 19200 copy decls and set the DECL_ABSTRACT_P flag on them instead of 19201 sharing them. 19202 19203 ??? Duplicated blocks have been rewritten to use .debug_ranges. 19204 19205 ??? The declare_in_namespace support causes us to get two DIEs for one 19206 variable, both of which are declarations. We want to avoid considering 19207 one to be a specification, so we must test that this DIE is not a 19208 declaration. */ 19209 else if (old_die && TREE_STATIC (decl) && ! declaration 19210 && get_AT_flag (old_die, DW_AT_declaration) == 1) 19211 { 19212 /* This is a definition of a C++ class level static. */ 19213 add_AT_specification (var_die, old_die); 19214 specialization_p = true; 19215 if (DECL_NAME (decl)) 19216 { 19217 expanded_location s = expand_location (DECL_SOURCE_LOCATION (decl)); 19218 struct dwarf_file_data * file_index = lookup_filename (s.file); 19219 19220 if (get_AT_file (old_die, DW_AT_decl_file) != file_index) 19221 add_AT_file (var_die, DW_AT_decl_file, file_index); 19222 19223 if (get_AT_unsigned (old_die, DW_AT_decl_line) != (unsigned) s.line) 19224 add_AT_unsigned (var_die, DW_AT_decl_line, s.line); 19225 19226 if (old_die->die_tag == DW_TAG_member) 19227 add_linkage_name (var_die, decl); 19228 } 19229 } 19230 else 19231 add_name_and_src_coords_attributes (var_die, decl); 19232 19233 if ((origin == NULL && !specialization_p) 19234 || (origin != NULL 19235 && !DECL_ABSTRACT_P (decl_or_origin) 19236 && variably_modified_type_p (TREE_TYPE (decl_or_origin), 19237 decl_function_context 19238 (decl_or_origin)))) 19239 { 19240 tree type = TREE_TYPE (decl_or_origin); 19241 19242 if (decl_by_reference_p (decl_or_origin)) 19243 add_type_attribute (var_die, TREE_TYPE (type), TYPE_UNQUALIFIED, 19244 context_die); 19245 else 19246 add_type_attribute (var_die, type, decl_quals (decl_or_origin), 19247 context_die); 19248 } 19249 19250 if (origin == NULL && !specialization_p) 19251 { 19252 if (TREE_PUBLIC (decl)) 19253 add_AT_flag (var_die, DW_AT_external, 1); 19254 19255 if (DECL_ARTIFICIAL (decl)) 19256 add_AT_flag (var_die, DW_AT_artificial, 1); 19257 19258 add_accessibility_attribute (var_die, decl); 19259 } 19260 19261 if (declaration) 19262 add_AT_flag (var_die, DW_AT_declaration, 1); 19263 19264 if (decl && (DECL_ABSTRACT_P (decl) || declaration || old_die == NULL)) 19265 equate_decl_number_to_die (decl, var_die); 19266 19267 if (! declaration 19268 && (! DECL_ABSTRACT_P (decl_or_origin) 19269 /* Local static vars are shared between all clones/inlines, 19270 so emit DW_AT_location on the abstract DIE if DECL_RTL is 19271 already set. */ 19272 || (TREE_CODE (decl_or_origin) == VAR_DECL 19273 && TREE_STATIC (decl_or_origin) 19274 && DECL_RTL_SET_P (decl_or_origin))) 19275 /* When abstract origin already has DW_AT_location attribute, no need 19276 to add it again. */ 19277 && (origin_die == NULL || get_AT (origin_die, DW_AT_location) == NULL)) 19278 { 19279 if (TREE_CODE (decl_or_origin) == VAR_DECL && TREE_STATIC (decl_or_origin) 19280 && !TREE_SYMBOL_REFERENCED (DECL_ASSEMBLER_NAME (decl_or_origin))) 19281 defer_location (decl_or_origin, var_die); 19282 else 19283 add_location_or_const_value_attribute (var_die, decl_or_origin, 19284 decl == NULL, DW_AT_location); 19285 add_pubname (decl_or_origin, var_die); 19286 } 19287 else 19288 tree_add_const_value_attribute_for_decl (var_die, decl_or_origin); 19289} 19290 19291/* Generate a DIE to represent a named constant. */ 19292 19293static void 19294gen_const_die (tree decl, dw_die_ref context_die) 19295{ 19296 dw_die_ref const_die; 19297 tree type = TREE_TYPE (decl); 19298 19299 const_die = new_die (DW_TAG_constant, context_die, decl); 19300 add_name_and_src_coords_attributes (const_die, decl); 19301 add_type_attribute (const_die, type, TYPE_QUAL_CONST, context_die); 19302 if (TREE_PUBLIC (decl)) 19303 add_AT_flag (const_die, DW_AT_external, 1); 19304 if (DECL_ARTIFICIAL (decl)) 19305 add_AT_flag (const_die, DW_AT_artificial, 1); 19306 tree_add_const_value_attribute_for_decl (const_die, decl); 19307} 19308 19309/* Generate a DIE to represent a label identifier. */ 19310 19311static void 19312gen_label_die (tree decl, dw_die_ref context_die) 19313{ 19314 tree origin = decl_ultimate_origin (decl); 19315 dw_die_ref lbl_die = new_die (DW_TAG_label, context_die, decl); 19316 rtx insn; 19317 char label[MAX_ARTIFICIAL_LABEL_BYTES]; 19318 19319 if (origin != NULL) 19320 add_abstract_origin_attribute (lbl_die, origin); 19321 else 19322 add_name_and_src_coords_attributes (lbl_die, decl); 19323 19324 if (DECL_ABSTRACT_P (decl)) 19325 equate_decl_number_to_die (decl, lbl_die); 19326 else 19327 { 19328 insn = DECL_RTL_IF_SET (decl); 19329 19330 /* Deleted labels are programmer specified labels which have been 19331 eliminated because of various optimizations. We still emit them 19332 here so that it is possible to put breakpoints on them. */ 19333 if (insn 19334 && (LABEL_P (insn) 19335 || ((NOTE_P (insn) 19336 && NOTE_KIND (insn) == NOTE_INSN_DELETED_LABEL)))) 19337 { 19338 /* When optimization is enabled (via -O) some parts of the compiler 19339 (e.g. jump.c and cse.c) may try to delete CODE_LABEL insns which 19340 represent source-level labels which were explicitly declared by 19341 the user. This really shouldn't be happening though, so catch 19342 it if it ever does happen. */ 19343 gcc_assert (!as_a<rtx_insn *> (insn)->deleted ()); 19344 19345 ASM_GENERATE_INTERNAL_LABEL (label, "L", CODE_LABEL_NUMBER (insn)); 19346 add_AT_lbl_id (lbl_die, DW_AT_low_pc, label); 19347 } 19348 else if (insn 19349 && NOTE_P (insn) 19350 && NOTE_KIND (insn) == NOTE_INSN_DELETED_DEBUG_LABEL 19351 && CODE_LABEL_NUMBER (insn) != -1) 19352 { 19353 ASM_GENERATE_INTERNAL_LABEL (label, "LDL", CODE_LABEL_NUMBER (insn)); 19354 add_AT_lbl_id (lbl_die, DW_AT_low_pc, label); 19355 } 19356 } 19357} 19358 19359/* A helper function for gen_inlined_subroutine_die. Add source coordinate 19360 attributes to the DIE for a block STMT, to describe where the inlined 19361 function was called from. This is similar to add_src_coords_attributes. */ 19362 19363static inline void 19364add_call_src_coords_attributes (tree stmt, dw_die_ref die) 19365{ 19366 expanded_location s = expand_location (BLOCK_SOURCE_LOCATION (stmt)); 19367 19368 if (dwarf_version >= 3 || !dwarf_strict) 19369 { 19370 add_AT_file (die, DW_AT_call_file, lookup_filename (s.file)); 19371 add_AT_unsigned (die, DW_AT_call_line, s.line); 19372 } 19373} 19374 19375 19376/* A helper function for gen_lexical_block_die and gen_inlined_subroutine_die. 19377 Add low_pc and high_pc attributes to the DIE for a block STMT. */ 19378 19379static inline void 19380add_high_low_attributes (tree stmt, dw_die_ref die) 19381{ 19382 char label[MAX_ARTIFICIAL_LABEL_BYTES]; 19383 19384 if (BLOCK_FRAGMENT_CHAIN (stmt) 19385 && (dwarf_version >= 3 || !dwarf_strict)) 19386 { 19387 tree chain, superblock = NULL_TREE; 19388 dw_die_ref pdie; 19389 dw_attr_ref attr = NULL; 19390 19391 if (inlined_function_outer_scope_p (stmt)) 19392 { 19393 ASM_GENERATE_INTERNAL_LABEL (label, BLOCK_BEGIN_LABEL, 19394 BLOCK_NUMBER (stmt)); 19395 add_AT_lbl_id (die, DW_AT_entry_pc, label); 19396 } 19397 19398 /* Optimize duplicate .debug_ranges lists or even tails of 19399 lists. If this BLOCK has same ranges as its supercontext, 19400 lookup DW_AT_ranges attribute in the supercontext (and 19401 recursively so), verify that the ranges_table contains the 19402 right values and use it instead of adding a new .debug_range. */ 19403 for (chain = stmt, pdie = die; 19404 BLOCK_SAME_RANGE (chain); 19405 chain = BLOCK_SUPERCONTEXT (chain)) 19406 { 19407 dw_attr_ref new_attr; 19408 19409 pdie = pdie->die_parent; 19410 if (pdie == NULL) 19411 break; 19412 if (BLOCK_SUPERCONTEXT (chain) == NULL_TREE) 19413 break; 19414 new_attr = get_AT (pdie, DW_AT_ranges); 19415 if (new_attr == NULL 19416 || new_attr->dw_attr_val.val_class != dw_val_class_range_list) 19417 break; 19418 attr = new_attr; 19419 superblock = BLOCK_SUPERCONTEXT (chain); 19420 } 19421 if (attr != NULL 19422 && (ranges_table[attr->dw_attr_val.v.val_offset 19423 / 2 / DWARF2_ADDR_SIZE].num 19424 == BLOCK_NUMBER (superblock)) 19425 && BLOCK_FRAGMENT_CHAIN (superblock)) 19426 { 19427 unsigned long off = attr->dw_attr_val.v.val_offset 19428 / 2 / DWARF2_ADDR_SIZE; 19429 unsigned long supercnt = 0, thiscnt = 0; 19430 for (chain = BLOCK_FRAGMENT_CHAIN (superblock); 19431 chain; chain = BLOCK_FRAGMENT_CHAIN (chain)) 19432 { 19433 ++supercnt; 19434 gcc_checking_assert (ranges_table[off + supercnt].num 19435 == BLOCK_NUMBER (chain)); 19436 } 19437 gcc_checking_assert (ranges_table[off + supercnt + 1].num == 0); 19438 for (chain = BLOCK_FRAGMENT_CHAIN (stmt); 19439 chain; chain = BLOCK_FRAGMENT_CHAIN (chain)) 19440 ++thiscnt; 19441 gcc_assert (supercnt >= thiscnt); 19442 add_AT_range_list (die, DW_AT_ranges, 19443 ((off + supercnt - thiscnt) 19444 * 2 * DWARF2_ADDR_SIZE), 19445 false); 19446 return; 19447 } 19448 19449 add_AT_range_list (die, DW_AT_ranges, add_ranges (stmt), false); 19450 19451 chain = BLOCK_FRAGMENT_CHAIN (stmt); 19452 do 19453 { 19454 add_ranges (chain); 19455 chain = BLOCK_FRAGMENT_CHAIN (chain); 19456 } 19457 while (chain); 19458 add_ranges (NULL); 19459 } 19460 else 19461 { 19462 char label_high[MAX_ARTIFICIAL_LABEL_BYTES]; 19463 ASM_GENERATE_INTERNAL_LABEL (label, BLOCK_BEGIN_LABEL, 19464 BLOCK_NUMBER (stmt)); 19465 ASM_GENERATE_INTERNAL_LABEL (label_high, BLOCK_END_LABEL, 19466 BLOCK_NUMBER (stmt)); 19467 add_AT_low_high_pc (die, label, label_high, false); 19468 } 19469} 19470 19471/* Generate a DIE for a lexical block. */ 19472 19473static void 19474gen_lexical_block_die (tree stmt, dw_die_ref context_die) 19475{ 19476 dw_die_ref stmt_die = new_die (DW_TAG_lexical_block, context_die, stmt); 19477 19478 if (call_arg_locations) 19479 { 19480 if (block_map.length () <= BLOCK_NUMBER (stmt)) 19481 block_map.safe_grow_cleared (BLOCK_NUMBER (stmt) + 1); 19482 block_map[BLOCK_NUMBER (stmt)] = stmt_die; 19483 } 19484 19485 if (! BLOCK_ABSTRACT (stmt) && TREE_ASM_WRITTEN (stmt)) 19486 add_high_low_attributes (stmt, stmt_die); 19487 19488 decls_for_scope (stmt, stmt_die); 19489} 19490 19491/* Generate a DIE for an inlined subprogram. */ 19492 19493static void 19494gen_inlined_subroutine_die (tree stmt, dw_die_ref context_die) 19495{ 19496 tree decl; 19497 19498 /* The instance of function that is effectively being inlined shall not 19499 be abstract. */ 19500 gcc_assert (! BLOCK_ABSTRACT (stmt)); 19501 19502 decl = block_ultimate_origin (stmt); 19503 19504 /* Emit info for the abstract instance first, if we haven't yet. We 19505 must emit this even if the block is abstract, otherwise when we 19506 emit the block below (or elsewhere), we may end up trying to emit 19507 a die whose origin die hasn't been emitted, and crashing. */ 19508 dwarf2out_abstract_function (decl); 19509 19510 if (! BLOCK_ABSTRACT (stmt)) 19511 { 19512 dw_die_ref subr_die 19513 = new_die (DW_TAG_inlined_subroutine, context_die, stmt); 19514 19515 if (call_arg_locations) 19516 { 19517 if (block_map.length () <= BLOCK_NUMBER (stmt)) 19518 block_map.safe_grow_cleared (BLOCK_NUMBER (stmt) + 1); 19519 block_map[BLOCK_NUMBER (stmt)] = subr_die; 19520 } 19521 add_abstract_origin_attribute (subr_die, decl); 19522 if (TREE_ASM_WRITTEN (stmt)) 19523 add_high_low_attributes (stmt, subr_die); 19524 add_call_src_coords_attributes (stmt, subr_die); 19525 19526 decls_for_scope (stmt, subr_die); 19527 } 19528} 19529 19530/* Generate a DIE for a field in a record, or structure. */ 19531 19532static void 19533gen_field_die (tree decl, dw_die_ref context_die) 19534{ 19535 dw_die_ref decl_die; 19536 19537 if (TREE_TYPE (decl) == error_mark_node) 19538 return; 19539 19540 decl_die = new_die (DW_TAG_member, context_die, decl); 19541 add_name_and_src_coords_attributes (decl_die, decl); 19542 add_type_attribute (decl_die, member_declared_type (decl), 19543 decl_quals (decl), context_die); 19544 19545 if (DECL_BIT_FIELD_TYPE (decl)) 19546 { 19547 add_byte_size_attribute (decl_die, decl); 19548 add_bit_size_attribute (decl_die, decl); 19549 add_bit_offset_attribute (decl_die, decl); 19550 } 19551 19552 if (TREE_CODE (DECL_FIELD_CONTEXT (decl)) != UNION_TYPE) 19553 add_data_member_location_attribute (decl_die, decl); 19554 19555 if (DECL_ARTIFICIAL (decl)) 19556 add_AT_flag (decl_die, DW_AT_artificial, 1); 19557 19558 add_accessibility_attribute (decl_die, decl); 19559 19560 /* Equate decl number to die, so that we can look up this decl later on. */ 19561 equate_decl_number_to_die (decl, decl_die); 19562} 19563 19564#if 0 19565/* Don't generate either pointer_type DIEs or reference_type DIEs here. 19566 Use modified_type_die instead. 19567 We keep this code here just in case these types of DIEs may be needed to 19568 represent certain things in other languages (e.g. Pascal) someday. */ 19569 19570static void 19571gen_pointer_type_die (tree type, dw_die_ref context_die) 19572{ 19573 dw_die_ref ptr_die 19574 = new_die (DW_TAG_pointer_type, scope_die_for (type, context_die), type); 19575 19576 equate_type_number_to_die (type, ptr_die); 19577 add_type_attribute (ptr_die, TREE_TYPE (type), TYPE_UNQUALIFIED, 19578 context_die); 19579 add_AT_unsigned (mod_type_die, DW_AT_byte_size, PTR_SIZE); 19580} 19581 19582/* Don't generate either pointer_type DIEs or reference_type DIEs here. 19583 Use modified_type_die instead. 19584 We keep this code here just in case these types of DIEs may be needed to 19585 represent certain things in other languages (e.g. Pascal) someday. */ 19586 19587static void 19588gen_reference_type_die (tree type, dw_die_ref context_die) 19589{ 19590 dw_die_ref ref_die, scope_die = scope_die_for (type, context_die); 19591 19592 if (TYPE_REF_IS_RVALUE (type) && dwarf_version >= 4) 19593 ref_die = new_die (DW_TAG_rvalue_reference_type, scope_die, type); 19594 else 19595 ref_die = new_die (DW_TAG_reference_type, scope_die, type); 19596 19597 equate_type_number_to_die (type, ref_die); 19598 add_type_attribute (ref_die, TREE_TYPE (type), TYPE_UNQUALIFIED, 19599 context_die); 19600 add_AT_unsigned (mod_type_die, DW_AT_byte_size, PTR_SIZE); 19601} 19602#endif 19603 19604/* Generate a DIE for a pointer to a member type. */ 19605 19606static void 19607gen_ptr_to_mbr_type_die (tree type, dw_die_ref context_die) 19608{ 19609 dw_die_ref ptr_die 19610 = new_die (DW_TAG_ptr_to_member_type, 19611 scope_die_for (type, context_die), type); 19612 19613 equate_type_number_to_die (type, ptr_die); 19614 add_AT_die_ref (ptr_die, DW_AT_containing_type, 19615 lookup_type_die (TYPE_OFFSET_BASETYPE (type))); 19616 add_type_attribute (ptr_die, TREE_TYPE (type), TYPE_UNQUALIFIED, 19617 context_die); 19618} 19619 19620typedef const char *dchar_p; /* For DEF_VEC_P. */ 19621 19622static char *producer_string; 19623 19624/* Return a heap allocated producer string including command line options 19625 if -grecord-gcc-switches. */ 19626 19627static char * 19628gen_producer_string (void) 19629{ 19630 size_t j; 19631 auto_vec<dchar_p> switches; 19632 const char *language_string = lang_hooks.name; 19633 char *producer, *tail; 19634 const char *p; 19635 size_t len = dwarf_record_gcc_switches ? 0 : 3; 19636 size_t plen = strlen (language_string) + 1 + strlen (version_string); 19637 19638 for (j = 1; dwarf_record_gcc_switches && j < save_decoded_options_count; j++) 19639 switch (save_decoded_options[j].opt_index) 19640 { 19641 case OPT_o: 19642 case OPT_d: 19643 case OPT_dumpbase: 19644 case OPT_dumpdir: 19645 case OPT_auxbase: 19646 case OPT_auxbase_strip: 19647 case OPT_quiet: 19648 case OPT_version: 19649 case OPT_v: 19650 case OPT_w: 19651 case OPT_L: 19652 case OPT_D: 19653 case OPT_I: 19654 case OPT_U: 19655 case OPT_SPECIAL_unknown: 19656 case OPT_SPECIAL_ignore: 19657 case OPT_SPECIAL_program_name: 19658 case OPT_SPECIAL_input_file: 19659 case OPT_grecord_gcc_switches: 19660 case OPT_gno_record_gcc_switches: 19661 case OPT__output_pch_: 19662 case OPT_fdiagnostics_show_location_: 19663 case OPT_fdiagnostics_show_option: 19664 case OPT_fdiagnostics_show_caret: 19665 case OPT_fdiagnostics_color_: 19666 case OPT_fverbose_asm: 19667 case OPT____: 19668 case OPT__sysroot_: 19669 case OPT_nostdinc: 19670 case OPT_nostdinc__: 19671 case OPT_fpreprocessed: 19672 case OPT_fltrans_output_list_: 19673 case OPT_fresolution_: 19674 /* Ignore these. */ 19675 continue; 19676 default: 19677 if (cl_options[save_decoded_options[j].opt_index].flags 19678 & CL_NO_DWARF_RECORD) 19679 continue; 19680 gcc_checking_assert (save_decoded_options[j].canonical_option[0][0] 19681 == '-'); 19682 switch (save_decoded_options[j].canonical_option[0][1]) 19683 { 19684 case 'M': 19685 case 'i': 19686 case 'W': 19687 continue; 19688 case 'f': 19689 if (strncmp (save_decoded_options[j].canonical_option[0] + 2, 19690 "dump", 4) == 0) 19691 continue; 19692 break; 19693 default: 19694 break; 19695 } 19696 switches.safe_push (save_decoded_options[j].orig_option_with_args_text); 19697 len += strlen (save_decoded_options[j].orig_option_with_args_text) + 1; 19698 break; 19699 } 19700 19701 producer = XNEWVEC (char, plen + 1 + len + 1); 19702 tail = producer; 19703 sprintf (tail, "%s %s", language_string, version_string); 19704 tail += plen; 19705 19706 FOR_EACH_VEC_ELT (switches, j, p) 19707 { 19708 len = strlen (p); 19709 *tail = ' '; 19710 memcpy (tail + 1, p, len); 19711 tail += len + 1; 19712 } 19713 19714 *tail = '\0'; 19715 return producer; 19716} 19717 19718/* Given a C and/or C++ language/version string return the "highest". 19719 C++ is assumed to be "higher" than C in this case. Used for merging 19720 LTO translation unit languages. */ 19721static const char * 19722highest_c_language (const char *lang1, const char *lang2) 19723{ 19724 if (strcmp ("GNU C++14", lang1) == 0 || strcmp ("GNU C++14", lang2) == 0) 19725 return "GNU C++14"; 19726 if (strcmp ("GNU C++11", lang1) == 0 || strcmp ("GNU C++11", lang2) == 0) 19727 return "GNU C++11"; 19728 if (strcmp ("GNU C++98", lang1) == 0 || strcmp ("GNU C++98", lang2) == 0) 19729 return "GNU C++98"; 19730 19731 if (strcmp ("GNU C11", lang1) == 0 || strcmp ("GNU C11", lang2) == 0) 19732 return "GNU C11"; 19733 if (strcmp ("GNU C99", lang1) == 0 || strcmp ("GNU C99", lang2) == 0) 19734 return "GNU C99"; 19735 if (strcmp ("GNU C89", lang1) == 0 || strcmp ("GNU C89", lang2) == 0) 19736 return "GNU C89"; 19737 19738 gcc_unreachable (); 19739} 19740 19741 19742/* Generate the DIE for the compilation unit. */ 19743 19744static dw_die_ref 19745gen_compile_unit_die (const char *filename) 19746{ 19747 dw_die_ref die; 19748 const char *language_string = lang_hooks.name; 19749 int language; 19750 19751 die = new_die (DW_TAG_compile_unit, NULL, NULL); 19752 19753 if (filename) 19754 { 19755 add_name_attribute (die, filename); 19756 /* Don't add cwd for <built-in>. */ 19757 if (!IS_ABSOLUTE_PATH (filename) && filename[0] != '<') 19758 add_comp_dir_attribute (die); 19759 } 19760 19761 add_AT_string (die, DW_AT_producer, producer_string ? producer_string : ""); 19762 19763 /* If our producer is LTO try to figure out a common language to use 19764 from the global list of translation units. */ 19765 if (strcmp (language_string, "GNU GIMPLE") == 0) 19766 { 19767 unsigned i; 19768 tree t; 19769 const char *common_lang = NULL; 19770 19771 FOR_EACH_VEC_SAFE_ELT (all_translation_units, i, t) 19772 { 19773 if (!TRANSLATION_UNIT_LANGUAGE (t)) 19774 continue; 19775 if (!common_lang) 19776 common_lang = TRANSLATION_UNIT_LANGUAGE (t); 19777 else if (strcmp (common_lang, TRANSLATION_UNIT_LANGUAGE (t)) == 0) 19778 ; 19779 else if (strncmp (common_lang, "GNU C", 5) == 0 19780 && strncmp (TRANSLATION_UNIT_LANGUAGE (t), "GNU C", 5) == 0) 19781 /* Mixing C and C++ is ok, use C++ in that case. */ 19782 common_lang = highest_c_language (common_lang, 19783 TRANSLATION_UNIT_LANGUAGE (t)); 19784 else 19785 { 19786 /* Fall back to C. */ 19787 common_lang = NULL; 19788 break; 19789 } 19790 } 19791 19792 if (common_lang) 19793 language_string = common_lang; 19794 } 19795 19796 language = DW_LANG_C; 19797 if (strncmp (language_string, "GNU C", 5) == 0 19798 && ISDIGIT (language_string[5])) 19799 { 19800 language = DW_LANG_C89; 19801 if (dwarf_version >= 3 || !dwarf_strict) 19802 { 19803 if (strcmp (language_string, "GNU C89") != 0) 19804 language = DW_LANG_C99; 19805 19806 if (dwarf_version >= 5 /* || !dwarf_strict */) 19807 if (strcmp (language_string, "GNU C11") == 0) 19808 language = DW_LANG_C11; 19809 } 19810 } 19811 else if (strncmp (language_string, "GNU C++", 7) == 0) 19812 { 19813 language = DW_LANG_C_plus_plus; 19814 if (dwarf_version >= 5 /* || !dwarf_strict */) 19815 { 19816 if (strcmp (language_string, "GNU C++11") == 0) 19817 language = DW_LANG_C_plus_plus_11; 19818 else if (strcmp (language_string, "GNU C++14") == 0) 19819 language = DW_LANG_C_plus_plus_14; 19820 } 19821 } 19822 else if (strcmp (language_string, "GNU F77") == 0) 19823 language = DW_LANG_Fortran77; 19824 else if (strcmp (language_string, "GNU Pascal") == 0) 19825 language = DW_LANG_Pascal83; 19826 else if (dwarf_version >= 3 || !dwarf_strict) 19827 { 19828 if (strcmp (language_string, "GNU Ada") == 0) 19829 language = DW_LANG_Ada95; 19830 else if (strncmp (language_string, "GNU Fortran", 11) == 0) 19831 { 19832 language = DW_LANG_Fortran95; 19833 if (dwarf_version >= 5 /* || !dwarf_strict */) 19834 { 19835 if (strcmp (language_string, "GNU Fortran2003") == 0) 19836 language = DW_LANG_Fortran03; 19837 else if (strcmp (language_string, "GNU Fortran2008") == 0) 19838 language = DW_LANG_Fortran08; 19839 } 19840 } 19841 else if (strcmp (language_string, "GNU Java") == 0) 19842 language = DW_LANG_Java; 19843 else if (strcmp (language_string, "GNU Objective-C") == 0) 19844 language = DW_LANG_ObjC; 19845 else if (strcmp (language_string, "GNU Objective-C++") == 0) 19846 language = DW_LANG_ObjC_plus_plus; 19847 else if (dwarf_version >= 5 || !dwarf_strict) 19848 { 19849 if (strcmp (language_string, "GNU Go") == 0) 19850 language = DW_LANG_Go; 19851 } 19852 } 19853 /* Use a degraded Fortran setting in strict DWARF2 so is_fortran works. */ 19854 else if (strncmp (language_string, "GNU Fortran", 11) == 0) 19855 language = DW_LANG_Fortran90; 19856 19857 add_AT_unsigned (die, DW_AT_language, language); 19858 19859 switch (language) 19860 { 19861 case DW_LANG_Fortran77: 19862 case DW_LANG_Fortran90: 19863 case DW_LANG_Fortran95: 19864 case DW_LANG_Fortran03: 19865 case DW_LANG_Fortran08: 19866 /* Fortran has case insensitive identifiers and the front-end 19867 lowercases everything. */ 19868 add_AT_unsigned (die, DW_AT_identifier_case, DW_ID_down_case); 19869 break; 19870 default: 19871 /* The default DW_ID_case_sensitive doesn't need to be specified. */ 19872 break; 19873 } 19874 return die; 19875} 19876 19877/* Generate the DIE for a base class. */ 19878 19879static void 19880gen_inheritance_die (tree binfo, tree access, dw_die_ref context_die) 19881{ 19882 dw_die_ref die = new_die (DW_TAG_inheritance, context_die, binfo); 19883 19884 add_type_attribute (die, BINFO_TYPE (binfo), TYPE_UNQUALIFIED, context_die); 19885 add_data_member_location_attribute (die, binfo); 19886 19887 if (BINFO_VIRTUAL_P (binfo)) 19888 add_AT_unsigned (die, DW_AT_virtuality, DW_VIRTUALITY_virtual); 19889 19890 /* In DWARF3+ the default is DW_ACCESS_private only in DW_TAG_class_type 19891 children, otherwise the default is DW_ACCESS_public. In DWARF2 19892 the default has always been DW_ACCESS_private. */ 19893 if (access == access_public_node) 19894 { 19895 if (dwarf_version == 2 19896 || context_die->die_tag == DW_TAG_class_type) 19897 add_AT_unsigned (die, DW_AT_accessibility, DW_ACCESS_public); 19898 } 19899 else if (access == access_protected_node) 19900 add_AT_unsigned (die, DW_AT_accessibility, DW_ACCESS_protected); 19901 else if (dwarf_version > 2 19902 && context_die->die_tag != DW_TAG_class_type) 19903 add_AT_unsigned (die, DW_AT_accessibility, DW_ACCESS_private); 19904} 19905 19906/* Generate a DIE for a class member. */ 19907 19908static void 19909gen_member_die (tree type, dw_die_ref context_die) 19910{ 19911 tree member; 19912 tree binfo = TYPE_BINFO (type); 19913 dw_die_ref child; 19914 19915 /* If this is not an incomplete type, output descriptions of each of its 19916 members. Note that as we output the DIEs necessary to represent the 19917 members of this record or union type, we will also be trying to output 19918 DIEs to represent the *types* of those members. However the `type' 19919 function (above) will specifically avoid generating type DIEs for member 19920 types *within* the list of member DIEs for this (containing) type except 19921 for those types (of members) which are explicitly marked as also being 19922 members of this (containing) type themselves. The g++ front- end can 19923 force any given type to be treated as a member of some other (containing) 19924 type by setting the TYPE_CONTEXT of the given (member) type to point to 19925 the TREE node representing the appropriate (containing) type. */ 19926 19927 /* First output info about the base classes. */ 19928 if (binfo) 19929 { 19930 vec<tree, va_gc> *accesses = BINFO_BASE_ACCESSES (binfo); 19931 int i; 19932 tree base; 19933 19934 for (i = 0; BINFO_BASE_ITERATE (binfo, i, base); i++) 19935 gen_inheritance_die (base, 19936 (accesses ? (*accesses)[i] : access_public_node), 19937 context_die); 19938 } 19939 19940 /* Now output info about the data members and type members. */ 19941 for (member = TYPE_FIELDS (type); member; member = DECL_CHAIN (member)) 19942 { 19943 /* If we thought we were generating minimal debug info for TYPE 19944 and then changed our minds, some of the member declarations 19945 may have already been defined. Don't define them again, but 19946 do put them in the right order. */ 19947 19948 child = lookup_decl_die (member); 19949 if (child) 19950 splice_child_die (context_die, child); 19951 else 19952 gen_decl_die (member, NULL, context_die); 19953 } 19954 19955 /* Now output info about the function members (if any). */ 19956 for (member = TYPE_METHODS (type); member; member = DECL_CHAIN (member)) 19957 { 19958 /* Don't include clones in the member list. */ 19959 if (DECL_ABSTRACT_ORIGIN (member)) 19960 continue; 19961 19962 child = lookup_decl_die (member); 19963 if (child) 19964 splice_child_die (context_die, child); 19965 else 19966 gen_decl_die (member, NULL, context_die); 19967 } 19968} 19969 19970/* Generate a DIE for a structure or union type. If TYPE_DECL_SUPPRESS_DEBUG 19971 is set, we pretend that the type was never defined, so we only get the 19972 member DIEs needed by later specification DIEs. */ 19973 19974static void 19975gen_struct_or_union_type_die (tree type, dw_die_ref context_die, 19976 enum debug_info_usage usage) 19977{ 19978 dw_die_ref type_die = lookup_type_die (type); 19979 dw_die_ref scope_die = 0; 19980 int nested = 0; 19981 int complete = (TYPE_SIZE (type) 19982 && (! TYPE_STUB_DECL (type) 19983 || ! TYPE_DECL_SUPPRESS_DEBUG (TYPE_STUB_DECL (type)))); 19984 int ns_decl = (context_die && context_die->die_tag == DW_TAG_namespace); 19985 complete = complete && should_emit_struct_debug (type, usage); 19986 19987 if (type_die && ! complete) 19988 return; 19989 19990 if (TYPE_CONTEXT (type) != NULL_TREE 19991 && (AGGREGATE_TYPE_P (TYPE_CONTEXT (type)) 19992 || TREE_CODE (TYPE_CONTEXT (type)) == NAMESPACE_DECL)) 19993 nested = 1; 19994 19995 scope_die = scope_die_for (type, context_die); 19996 19997 /* Generate child dies for template paramaters. */ 19998 if (!type_die && debug_info_level > DINFO_LEVEL_TERSE) 19999 schedule_generic_params_dies_gen (type); 20000 20001 if (! type_die || (nested && is_cu_die (scope_die))) 20002 /* First occurrence of type or toplevel definition of nested class. */ 20003 { 20004 dw_die_ref old_die = type_die; 20005 20006 type_die = new_die (TREE_CODE (type) == RECORD_TYPE 20007 ? record_type_tag (type) : DW_TAG_union_type, 20008 scope_die, type); 20009 equate_type_number_to_die (type, type_die); 20010 if (old_die) 20011 add_AT_specification (type_die, old_die); 20012 else 20013 add_name_attribute (type_die, type_tag (type)); 20014 } 20015 else 20016 remove_AT (type_die, DW_AT_declaration); 20017 20018 /* If this type has been completed, then give it a byte_size attribute and 20019 then give a list of members. */ 20020 if (complete && !ns_decl) 20021 { 20022 /* Prevent infinite recursion in cases where the type of some member of 20023 this type is expressed in terms of this type itself. */ 20024 TREE_ASM_WRITTEN (type) = 1; 20025 add_byte_size_attribute (type_die, type); 20026 if (TYPE_STUB_DECL (type) != NULL_TREE) 20027 { 20028 add_src_coords_attributes (type_die, TYPE_STUB_DECL (type)); 20029 add_accessibility_attribute (type_die, TYPE_STUB_DECL (type)); 20030 } 20031 20032 /* If the first reference to this type was as the return type of an 20033 inline function, then it may not have a parent. Fix this now. */ 20034 if (type_die->die_parent == NULL) 20035 add_child_die (scope_die, type_die); 20036 20037 push_decl_scope (type); 20038 gen_member_die (type, type_die); 20039 pop_decl_scope (); 20040 20041 add_gnat_descriptive_type_attribute (type_die, type, context_die); 20042 if (TYPE_ARTIFICIAL (type)) 20043 add_AT_flag (type_die, DW_AT_artificial, 1); 20044 20045 /* GNU extension: Record what type our vtable lives in. */ 20046 if (TYPE_VFIELD (type)) 20047 { 20048 tree vtype = DECL_FCONTEXT (TYPE_VFIELD (type)); 20049 20050 gen_type_die (vtype, context_die); 20051 add_AT_die_ref (type_die, DW_AT_containing_type, 20052 lookup_type_die (vtype)); 20053 } 20054 } 20055 else 20056 { 20057 add_AT_flag (type_die, DW_AT_declaration, 1); 20058 20059 /* We don't need to do this for function-local types. */ 20060 if (TYPE_STUB_DECL (type) 20061 && ! decl_function_context (TYPE_STUB_DECL (type))) 20062 vec_safe_push (incomplete_types, type); 20063 } 20064 20065 if (get_AT (type_die, DW_AT_name)) 20066 add_pubtype (type, type_die); 20067} 20068 20069/* Generate a DIE for a subroutine _type_. */ 20070 20071static void 20072gen_subroutine_type_die (tree type, dw_die_ref context_die) 20073{ 20074 tree return_type = TREE_TYPE (type); 20075 dw_die_ref subr_die 20076 = new_die (DW_TAG_subroutine_type, 20077 scope_die_for (type, context_die), type); 20078 20079 equate_type_number_to_die (type, subr_die); 20080 add_prototyped_attribute (subr_die, type); 20081 add_type_attribute (subr_die, return_type, TYPE_UNQUALIFIED, context_die); 20082 gen_formal_types_die (type, subr_die); 20083 20084 if (get_AT (subr_die, DW_AT_name)) 20085 add_pubtype (type, subr_die); 20086} 20087 20088/* Generate a DIE for a type definition. */ 20089 20090static void 20091gen_typedef_die (tree decl, dw_die_ref context_die) 20092{ 20093 dw_die_ref type_die; 20094 tree origin; 20095 20096 if (TREE_ASM_WRITTEN (decl)) 20097 return; 20098 20099 TREE_ASM_WRITTEN (decl) = 1; 20100 type_die = new_die (DW_TAG_typedef, context_die, decl); 20101 origin = decl_ultimate_origin (decl); 20102 if (origin != NULL) 20103 add_abstract_origin_attribute (type_die, origin); 20104 else 20105 { 20106 tree type; 20107 20108 add_name_and_src_coords_attributes (type_die, decl); 20109 if (DECL_ORIGINAL_TYPE (decl)) 20110 { 20111 type = DECL_ORIGINAL_TYPE (decl); 20112 20113 gcc_assert (type != TREE_TYPE (decl)); 20114 equate_type_number_to_die (TREE_TYPE (decl), type_die); 20115 } 20116 else 20117 { 20118 type = TREE_TYPE (decl); 20119 20120 if (is_naming_typedef_decl (TYPE_NAME (type))) 20121 { 20122 /* Here, we are in the case of decl being a typedef naming 20123 an anonymous type, e.g: 20124 typedef struct {...} foo; 20125 In that case TREE_TYPE (decl) is not a typedef variant 20126 type and TYPE_NAME of the anonymous type is set to the 20127 TYPE_DECL of the typedef. This construct is emitted by 20128 the C++ FE. 20129 20130 TYPE is the anonymous struct named by the typedef 20131 DECL. As we need the DW_AT_type attribute of the 20132 DW_TAG_typedef to point to the DIE of TYPE, let's 20133 generate that DIE right away. add_type_attribute 20134 called below will then pick (via lookup_type_die) that 20135 anonymous struct DIE. */ 20136 if (!TREE_ASM_WRITTEN (type)) 20137 gen_tagged_type_die (type, context_die, DINFO_USAGE_DIR_USE); 20138 20139 /* This is a GNU Extension. We are adding a 20140 DW_AT_linkage_name attribute to the DIE of the 20141 anonymous struct TYPE. The value of that attribute 20142 is the name of the typedef decl naming the anonymous 20143 struct. This greatly eases the work of consumers of 20144 this debug info. */ 20145 add_linkage_attr (lookup_type_die (type), decl); 20146 } 20147 } 20148 20149 add_type_attribute (type_die, type, decl_quals (decl), context_die); 20150 20151 if (is_naming_typedef_decl (decl)) 20152 /* We want that all subsequent calls to lookup_type_die with 20153 TYPE in argument yield the DW_TAG_typedef we have just 20154 created. */ 20155 equate_type_number_to_die (type, type_die); 20156 20157 add_accessibility_attribute (type_die, decl); 20158 } 20159 20160 if (DECL_ABSTRACT_P (decl)) 20161 equate_decl_number_to_die (decl, type_die); 20162 20163 if (get_AT (type_die, DW_AT_name)) 20164 add_pubtype (decl, type_die); 20165} 20166 20167/* Generate a DIE for a struct, class, enum or union type. */ 20168 20169static void 20170gen_tagged_type_die (tree type, 20171 dw_die_ref context_die, 20172 enum debug_info_usage usage) 20173{ 20174 int need_pop; 20175 20176 if (type == NULL_TREE 20177 || !is_tagged_type (type)) 20178 return; 20179 20180 /* If this is a nested type whose containing class hasn't been written 20181 out yet, writing it out will cover this one, too. This does not apply 20182 to instantiations of member class templates; they need to be added to 20183 the containing class as they are generated. FIXME: This hurts the 20184 idea of combining type decls from multiple TUs, since we can't predict 20185 what set of template instantiations we'll get. */ 20186 if (TYPE_CONTEXT (type) 20187 && AGGREGATE_TYPE_P (TYPE_CONTEXT (type)) 20188 && ! TREE_ASM_WRITTEN (TYPE_CONTEXT (type))) 20189 { 20190 gen_type_die_with_usage (TYPE_CONTEXT (type), context_die, usage); 20191 20192 if (TREE_ASM_WRITTEN (type)) 20193 return; 20194 20195 /* If that failed, attach ourselves to the stub. */ 20196 push_decl_scope (TYPE_CONTEXT (type)); 20197 context_die = lookup_type_die (TYPE_CONTEXT (type)); 20198 need_pop = 1; 20199 } 20200 else if (TYPE_CONTEXT (type) != NULL_TREE 20201 && (TREE_CODE (TYPE_CONTEXT (type)) == FUNCTION_DECL)) 20202 { 20203 /* If this type is local to a function that hasn't been written 20204 out yet, use a NULL context for now; it will be fixed up in 20205 decls_for_scope. */ 20206 context_die = lookup_decl_die (TYPE_CONTEXT (type)); 20207 /* A declaration DIE doesn't count; nested types need to go in the 20208 specification. */ 20209 if (context_die && is_declaration_die (context_die)) 20210 context_die = NULL; 20211 need_pop = 0; 20212 } 20213 else 20214 { 20215 context_die = declare_in_namespace (type, context_die); 20216 need_pop = 0; 20217 } 20218 20219 if (TREE_CODE (type) == ENUMERAL_TYPE) 20220 { 20221 /* This might have been written out by the call to 20222 declare_in_namespace. */ 20223 if (!TREE_ASM_WRITTEN (type)) 20224 gen_enumeration_type_die (type, context_die); 20225 } 20226 else 20227 gen_struct_or_union_type_die (type, context_die, usage); 20228 20229 if (need_pop) 20230 pop_decl_scope (); 20231 20232 /* Don't set TREE_ASM_WRITTEN on an incomplete struct; we want to fix 20233 it up if it is ever completed. gen_*_type_die will set it for us 20234 when appropriate. */ 20235} 20236 20237/* Generate a type description DIE. */ 20238 20239static void 20240gen_type_die_with_usage (tree type, dw_die_ref context_die, 20241 enum debug_info_usage usage) 20242{ 20243 struct array_descr_info info; 20244 20245 if (type == NULL_TREE || type == error_mark_node) 20246 return; 20247 20248 if (TYPE_NAME (type) != NULL_TREE 20249 && TREE_CODE (TYPE_NAME (type)) == TYPE_DECL 20250 && is_redundant_typedef (TYPE_NAME (type)) 20251 && DECL_ORIGINAL_TYPE (TYPE_NAME (type))) 20252 /* The DECL of this type is a typedef we don't want to emit debug 20253 info for but we want debug info for its underlying typedef. 20254 This can happen for e.g, the injected-class-name of a C++ 20255 type. */ 20256 type = DECL_ORIGINAL_TYPE (TYPE_NAME (type)); 20257 20258 /* If TYPE is a typedef type variant, let's generate debug info 20259 for the parent typedef which TYPE is a type of. */ 20260 if (typedef_variant_p (type)) 20261 { 20262 if (TREE_ASM_WRITTEN (type)) 20263 return; 20264 20265 /* Prevent broken recursion; we can't hand off to the same type. */ 20266 gcc_assert (DECL_ORIGINAL_TYPE (TYPE_NAME (type)) != type); 20267 20268 /* Give typedefs the right scope. */ 20269 context_die = scope_die_for (type, context_die); 20270 20271 TREE_ASM_WRITTEN (type) = 1; 20272 20273 gen_decl_die (TYPE_NAME (type), NULL, context_die); 20274 return; 20275 } 20276 20277 /* If type is an anonymous tagged type named by a typedef, let's 20278 generate debug info for the typedef. */ 20279 if (is_naming_typedef_decl (TYPE_NAME (type))) 20280 { 20281 /* Use the DIE of the containing namespace as the parent DIE of 20282 the type description DIE we want to generate. */ 20283 if (DECL_CONTEXT (TYPE_NAME (type)) 20284 && TREE_CODE (DECL_CONTEXT (TYPE_NAME (type))) == NAMESPACE_DECL) 20285 context_die = get_context_die (DECL_CONTEXT (TYPE_NAME (type))); 20286 20287 gen_decl_die (TYPE_NAME (type), NULL, context_die); 20288 return; 20289 } 20290 20291 /* We are going to output a DIE to represent the unqualified version 20292 of this type (i.e. without any const or volatile qualifiers) so 20293 get the main variant (i.e. the unqualified version) of this type 20294 now. (Vectors and arrays are special because the debugging info is in the 20295 cloned type itself). */ 20296 if (TREE_CODE (type) != VECTOR_TYPE 20297 && TREE_CODE (type) != ARRAY_TYPE) 20298 type = type_main_variant (type); 20299 20300 /* If this is an array type with hidden descriptor, handle it first. */ 20301 if (!TREE_ASM_WRITTEN (type) 20302 && lang_hooks.types.get_array_descr_info) 20303 { 20304 memset (&info, 0, sizeof (info)); 20305 if (lang_hooks.types.get_array_descr_info (type, &info)) 20306 { 20307 gen_descr_array_type_die (type, &info, context_die); 20308 TREE_ASM_WRITTEN (type) = 1; 20309 return; 20310 } 20311 } 20312 20313 if (TREE_ASM_WRITTEN (type)) 20314 return; 20315 20316 switch (TREE_CODE (type)) 20317 { 20318 case ERROR_MARK: 20319 break; 20320 20321 case POINTER_TYPE: 20322 case REFERENCE_TYPE: 20323 /* We must set TREE_ASM_WRITTEN in case this is a recursive type. This 20324 ensures that the gen_type_die recursion will terminate even if the 20325 type is recursive. Recursive types are possible in Ada. */ 20326 /* ??? We could perhaps do this for all types before the switch 20327 statement. */ 20328 TREE_ASM_WRITTEN (type) = 1; 20329 20330 /* For these types, all that is required is that we output a DIE (or a 20331 set of DIEs) to represent the "basis" type. */ 20332 gen_type_die_with_usage (TREE_TYPE (type), context_die, 20333 DINFO_USAGE_IND_USE); 20334 break; 20335 20336 case OFFSET_TYPE: 20337 /* This code is used for C++ pointer-to-data-member types. 20338 Output a description of the relevant class type. */ 20339 gen_type_die_with_usage (TYPE_OFFSET_BASETYPE (type), context_die, 20340 DINFO_USAGE_IND_USE); 20341 20342 /* Output a description of the type of the object pointed to. */ 20343 gen_type_die_with_usage (TREE_TYPE (type), context_die, 20344 DINFO_USAGE_IND_USE); 20345 20346 /* Now output a DIE to represent this pointer-to-data-member type 20347 itself. */ 20348 gen_ptr_to_mbr_type_die (type, context_die); 20349 break; 20350 20351 case FUNCTION_TYPE: 20352 /* Force out return type (in case it wasn't forced out already). */ 20353 gen_type_die_with_usage (TREE_TYPE (type), context_die, 20354 DINFO_USAGE_DIR_USE); 20355 gen_subroutine_type_die (type, context_die); 20356 break; 20357 20358 case METHOD_TYPE: 20359 /* Force out return type (in case it wasn't forced out already). */ 20360 gen_type_die_with_usage (TREE_TYPE (type), context_die, 20361 DINFO_USAGE_DIR_USE); 20362 gen_subroutine_type_die (type, context_die); 20363 break; 20364 20365 case ARRAY_TYPE: 20366 gen_array_type_die (type, context_die); 20367 break; 20368 20369 case VECTOR_TYPE: 20370 gen_array_type_die (type, context_die); 20371 break; 20372 20373 case ENUMERAL_TYPE: 20374 case RECORD_TYPE: 20375 case UNION_TYPE: 20376 case QUAL_UNION_TYPE: 20377 gen_tagged_type_die (type, context_die, usage); 20378 return; 20379 20380 case VOID_TYPE: 20381 case INTEGER_TYPE: 20382 case REAL_TYPE: 20383 case FIXED_POINT_TYPE: 20384 case COMPLEX_TYPE: 20385 case BOOLEAN_TYPE: 20386 case POINTER_BOUNDS_TYPE: 20387 /* No DIEs needed for fundamental types. */ 20388 break; 20389 20390 case NULLPTR_TYPE: 20391 case LANG_TYPE: 20392 /* Just use DW_TAG_unspecified_type. */ 20393 { 20394 dw_die_ref type_die = lookup_type_die (type); 20395 if (type_die == NULL) 20396 { 20397 tree name = TYPE_IDENTIFIER (type); 20398 type_die = new_die (DW_TAG_unspecified_type, comp_unit_die (), 20399 type); 20400 add_name_attribute (type_die, IDENTIFIER_POINTER (name)); 20401 equate_type_number_to_die (type, type_die); 20402 } 20403 } 20404 break; 20405 20406 default: 20407 if (is_cxx_auto (type)) 20408 { 20409 tree name = TYPE_IDENTIFIER (type); 20410 dw_die_ref *die = (name == get_identifier ("auto") 20411 ? &auto_die : &decltype_auto_die); 20412 if (!*die) 20413 { 20414 *die = new_die (DW_TAG_unspecified_type, 20415 comp_unit_die (), NULL_TREE); 20416 add_name_attribute (*die, IDENTIFIER_POINTER (name)); 20417 } 20418 equate_type_number_to_die (type, *die); 20419 break; 20420 } 20421 gcc_unreachable (); 20422 } 20423 20424 TREE_ASM_WRITTEN (type) = 1; 20425} 20426 20427static void 20428gen_type_die (tree type, dw_die_ref context_die) 20429{ 20430 gen_type_die_with_usage (type, context_die, DINFO_USAGE_DIR_USE); 20431} 20432 20433/* Generate a DW_TAG_lexical_block DIE followed by DIEs to represent all of the 20434 things which are local to the given block. */ 20435 20436static void 20437gen_block_die (tree stmt, dw_die_ref context_die) 20438{ 20439 int must_output_die = 0; 20440 bool inlined_func; 20441 20442 /* Ignore blocks that are NULL. */ 20443 if (stmt == NULL_TREE) 20444 return; 20445 20446 inlined_func = inlined_function_outer_scope_p (stmt); 20447 20448 /* If the block is one fragment of a non-contiguous block, do not 20449 process the variables, since they will have been done by the 20450 origin block. Do process subblocks. */ 20451 if (BLOCK_FRAGMENT_ORIGIN (stmt)) 20452 { 20453 tree sub; 20454 20455 for (sub = BLOCK_SUBBLOCKS (stmt); sub; sub = BLOCK_CHAIN (sub)) 20456 gen_block_die (sub, context_die); 20457 20458 return; 20459 } 20460 20461 /* Determine if we need to output any Dwarf DIEs at all to represent this 20462 block. */ 20463 if (inlined_func) 20464 /* The outer scopes for inlinings *must* always be represented. We 20465 generate DW_TAG_inlined_subroutine DIEs for them. (See below.) */ 20466 must_output_die = 1; 20467 else 20468 { 20469 /* Determine if this block directly contains any "significant" 20470 local declarations which we will need to output DIEs for. */ 20471 if (debug_info_level > DINFO_LEVEL_TERSE) 20472 /* We are not in terse mode so *any* local declaration counts 20473 as being a "significant" one. */ 20474 must_output_die = ((BLOCK_VARS (stmt) != NULL 20475 || BLOCK_NUM_NONLOCALIZED_VARS (stmt)) 20476 && (TREE_USED (stmt) 20477 || TREE_ASM_WRITTEN (stmt) 20478 || BLOCK_ABSTRACT (stmt))); 20479 else if ((TREE_USED (stmt) 20480 || TREE_ASM_WRITTEN (stmt) 20481 || BLOCK_ABSTRACT (stmt)) 20482 && !dwarf2out_ignore_block (stmt)) 20483 must_output_die = 1; 20484 } 20485 20486 /* It would be a waste of space to generate a Dwarf DW_TAG_lexical_block 20487 DIE for any block which contains no significant local declarations at 20488 all. Rather, in such cases we just call `decls_for_scope' so that any 20489 needed Dwarf info for any sub-blocks will get properly generated. Note 20490 that in terse mode, our definition of what constitutes a "significant" 20491 local declaration gets restricted to include only inlined function 20492 instances and local (nested) function definitions. */ 20493 if (must_output_die) 20494 { 20495 if (inlined_func) 20496 { 20497 /* If STMT block is abstract, that means we have been called 20498 indirectly from dwarf2out_abstract_function. 20499 That function rightfully marks the descendent blocks (of 20500 the abstract function it is dealing with) as being abstract, 20501 precisely to prevent us from emitting any 20502 DW_TAG_inlined_subroutine DIE as a descendent 20503 of an abstract function instance. So in that case, we should 20504 not call gen_inlined_subroutine_die. 20505 20506 Later though, when cgraph asks dwarf2out to emit info 20507 for the concrete instance of the function decl into which 20508 the concrete instance of STMT got inlined, the later will lead 20509 to the generation of a DW_TAG_inlined_subroutine DIE. */ 20510 if (! BLOCK_ABSTRACT (stmt)) 20511 gen_inlined_subroutine_die (stmt, context_die); 20512 } 20513 else 20514 gen_lexical_block_die (stmt, context_die); 20515 } 20516 else 20517 decls_for_scope (stmt, context_die); 20518} 20519 20520/* Process variable DECL (or variable with origin ORIGIN) within 20521 block STMT and add it to CONTEXT_DIE. */ 20522static void 20523process_scope_var (tree stmt, tree decl, tree origin, dw_die_ref context_die) 20524{ 20525 dw_die_ref die; 20526 tree decl_or_origin = decl ? decl : origin; 20527 20528 if (TREE_CODE (decl_or_origin) == FUNCTION_DECL) 20529 die = lookup_decl_die (decl_or_origin); 20530 else if (TREE_CODE (decl_or_origin) == TYPE_DECL 20531 && TYPE_DECL_IS_STUB (decl_or_origin)) 20532 die = lookup_type_die (TREE_TYPE (decl_or_origin)); 20533 else 20534 die = NULL; 20535 20536 if (die != NULL && die->die_parent == NULL) 20537 add_child_die (context_die, die); 20538 else if (TREE_CODE (decl_or_origin) == IMPORTED_DECL) 20539 dwarf2out_imported_module_or_decl_1 (decl_or_origin, DECL_NAME (decl_or_origin), 20540 stmt, context_die); 20541 else 20542 gen_decl_die (decl, origin, context_die); 20543} 20544 20545/* Generate all of the decls declared within a given scope and (recursively) 20546 all of its sub-blocks. */ 20547 20548static void 20549decls_for_scope (tree stmt, dw_die_ref context_die) 20550{ 20551 tree decl; 20552 unsigned int i; 20553 tree subblocks; 20554 20555 /* Ignore NULL blocks. */ 20556 if (stmt == NULL_TREE) 20557 return; 20558 20559 /* Output the DIEs to represent all of the data objects and typedefs 20560 declared directly within this block but not within any nested 20561 sub-blocks. Also, nested function and tag DIEs have been 20562 generated with a parent of NULL; fix that up now. We don't 20563 have to do this if we're at -g1. */ 20564 if (debug_info_level > DINFO_LEVEL_TERSE) 20565 { 20566 for (decl = BLOCK_VARS (stmt); decl != NULL; decl = DECL_CHAIN (decl)) 20567 process_scope_var (stmt, decl, NULL_TREE, context_die); 20568 for (i = 0; i < BLOCK_NUM_NONLOCALIZED_VARS (stmt); i++) 20569 process_scope_var (stmt, NULL, BLOCK_NONLOCALIZED_VAR (stmt, i), 20570 context_die); 20571 } 20572 20573 /* Even if we're at -g1, we need to process the subblocks in order to get 20574 inlined call information. */ 20575 20576 /* Output the DIEs to represent all sub-blocks (and the items declared 20577 therein) of this block. */ 20578 for (subblocks = BLOCK_SUBBLOCKS (stmt); 20579 subblocks != NULL; 20580 subblocks = BLOCK_CHAIN (subblocks)) 20581 gen_block_die (subblocks, context_die); 20582} 20583 20584/* Is this a typedef we can avoid emitting? */ 20585 20586static inline int 20587is_redundant_typedef (const_tree decl) 20588{ 20589 if (TYPE_DECL_IS_STUB (decl)) 20590 return 1; 20591 20592 if (DECL_ARTIFICIAL (decl) 20593 && DECL_CONTEXT (decl) 20594 && is_tagged_type (DECL_CONTEXT (decl)) 20595 && TREE_CODE (TYPE_NAME (DECL_CONTEXT (decl))) == TYPE_DECL 20596 && DECL_NAME (decl) == DECL_NAME (TYPE_NAME (DECL_CONTEXT (decl)))) 20597 /* Also ignore the artificial member typedef for the class name. */ 20598 return 1; 20599 20600 return 0; 20601} 20602 20603/* Return TRUE if TYPE is a typedef that names a type for linkage 20604 purposes. This kind of typedefs is produced by the C++ FE for 20605 constructs like: 20606 20607 typedef struct {...} foo; 20608 20609 In that case, there is no typedef variant type produced for foo. 20610 Rather, the TREE_TYPE of the TYPE_DECL of foo is the anonymous 20611 struct type. */ 20612 20613static bool 20614is_naming_typedef_decl (const_tree decl) 20615{ 20616 if (decl == NULL_TREE 20617 || TREE_CODE (decl) != TYPE_DECL 20618 || !is_tagged_type (TREE_TYPE (decl)) 20619 || DECL_IS_BUILTIN (decl) 20620 || is_redundant_typedef (decl) 20621 /* It looks like Ada produces TYPE_DECLs that are very similar 20622 to C++ naming typedefs but that have different 20623 semantics. Let's be specific to c++ for now. */ 20624 || !is_cxx ()) 20625 return FALSE; 20626 20627 return (DECL_ORIGINAL_TYPE (decl) == NULL_TREE 20628 && TYPE_NAME (TREE_TYPE (decl)) == decl 20629 && (TYPE_STUB_DECL (TREE_TYPE (decl)) 20630 != TYPE_NAME (TREE_TYPE (decl)))); 20631} 20632 20633/* Looks up the DIE for a context. */ 20634 20635static inline dw_die_ref 20636lookup_context_die (tree context) 20637{ 20638 if (context) 20639 { 20640 /* Find die that represents this context. */ 20641 if (TYPE_P (context)) 20642 { 20643 context = TYPE_MAIN_VARIANT (context); 20644 dw_die_ref ctx = lookup_type_die (context); 20645 if (!ctx) 20646 return NULL; 20647 return strip_naming_typedef (context, ctx); 20648 } 20649 else 20650 return lookup_decl_die (context); 20651 } 20652 return comp_unit_die (); 20653} 20654 20655/* Returns the DIE for a context. */ 20656 20657static inline dw_die_ref 20658get_context_die (tree context) 20659{ 20660 if (context) 20661 { 20662 /* Find die that represents this context. */ 20663 if (TYPE_P (context)) 20664 { 20665 context = TYPE_MAIN_VARIANT (context); 20666 return strip_naming_typedef (context, force_type_die (context)); 20667 } 20668 else 20669 return force_decl_die (context); 20670 } 20671 return comp_unit_die (); 20672} 20673 20674/* Returns the DIE for decl. A DIE will always be returned. */ 20675 20676static dw_die_ref 20677force_decl_die (tree decl) 20678{ 20679 dw_die_ref decl_die; 20680 unsigned saved_external_flag; 20681 tree save_fn = NULL_TREE; 20682 decl_die = lookup_decl_die (decl); 20683 if (!decl_die) 20684 { 20685 dw_die_ref context_die = get_context_die (DECL_CONTEXT (decl)); 20686 20687 decl_die = lookup_decl_die (decl); 20688 if (decl_die) 20689 return decl_die; 20690 20691 switch (TREE_CODE (decl)) 20692 { 20693 case FUNCTION_DECL: 20694 /* Clear current_function_decl, so that gen_subprogram_die thinks 20695 that this is a declaration. At this point, we just want to force 20696 declaration die. */ 20697 save_fn = current_function_decl; 20698 current_function_decl = NULL_TREE; 20699 gen_subprogram_die (decl, context_die); 20700 current_function_decl = save_fn; 20701 break; 20702 20703 case VAR_DECL: 20704 /* Set external flag to force declaration die. Restore it after 20705 gen_decl_die() call. */ 20706 saved_external_flag = DECL_EXTERNAL (decl); 20707 DECL_EXTERNAL (decl) = 1; 20708 gen_decl_die (decl, NULL, context_die); 20709 DECL_EXTERNAL (decl) = saved_external_flag; 20710 break; 20711 20712 case NAMESPACE_DECL: 20713 if (dwarf_version >= 3 || !dwarf_strict) 20714 dwarf2out_decl (decl); 20715 else 20716 /* DWARF2 has neither DW_TAG_module, nor DW_TAG_namespace. */ 20717 decl_die = comp_unit_die (); 20718 break; 20719 20720 case TRANSLATION_UNIT_DECL: 20721 decl_die = comp_unit_die (); 20722 break; 20723 20724 default: 20725 gcc_unreachable (); 20726 } 20727 20728 /* We should be able to find the DIE now. */ 20729 if (!decl_die) 20730 decl_die = lookup_decl_die (decl); 20731 gcc_assert (decl_die); 20732 } 20733 20734 return decl_die; 20735} 20736 20737/* Returns the DIE for TYPE, that must not be a base type. A DIE is 20738 always returned. */ 20739 20740static dw_die_ref 20741force_type_die (tree type) 20742{ 20743 dw_die_ref type_die; 20744 20745 type_die = lookup_type_die (type); 20746 if (!type_die) 20747 { 20748 dw_die_ref context_die = get_context_die (TYPE_CONTEXT (type)); 20749 20750 type_die = modified_type_die (type, TYPE_QUALS_NO_ADDR_SPACE (type), 20751 context_die); 20752 gcc_assert (type_die); 20753 } 20754 return type_die; 20755} 20756 20757/* Force out any required namespaces to be able to output DECL, 20758 and return the new context_die for it, if it's changed. */ 20759 20760static dw_die_ref 20761setup_namespace_context (tree thing, dw_die_ref context_die) 20762{ 20763 tree context = (DECL_P (thing) 20764 ? DECL_CONTEXT (thing) : TYPE_CONTEXT (thing)); 20765 if (context && TREE_CODE (context) == NAMESPACE_DECL) 20766 /* Force out the namespace. */ 20767 context_die = force_decl_die (context); 20768 20769 return context_die; 20770} 20771 20772/* Emit a declaration DIE for THING (which is either a DECL or a tagged 20773 type) within its namespace, if appropriate. 20774 20775 For compatibility with older debuggers, namespace DIEs only contain 20776 declarations; all definitions are emitted at CU scope. */ 20777 20778static dw_die_ref 20779declare_in_namespace (tree thing, dw_die_ref context_die) 20780{ 20781 dw_die_ref ns_context; 20782 20783 if (debug_info_level <= DINFO_LEVEL_TERSE) 20784 return context_die; 20785 20786 /* External declarations in the local scope only need to be emitted 20787 once, not once in the namespace and once in the scope. 20788 20789 This avoids declaring the `extern' below in the 20790 namespace DIE as well as in the innermost scope: 20791 20792 namespace S 20793 { 20794 int i=5; 20795 int foo() 20796 { 20797 int i=8; 20798 extern int i; 20799 return i; 20800 } 20801 } 20802 */ 20803 if (DECL_P (thing) && DECL_EXTERNAL (thing) && local_scope_p (context_die)) 20804 return context_die; 20805 20806 /* If this decl is from an inlined function, then don't try to emit it in its 20807 namespace, as we will get confused. It would have already been emitted 20808 when the abstract instance of the inline function was emitted anyways. */ 20809 if (DECL_P (thing) && DECL_ABSTRACT_ORIGIN (thing)) 20810 return context_die; 20811 20812 ns_context = setup_namespace_context (thing, context_die); 20813 20814 if (ns_context != context_die) 20815 { 20816 if (is_fortran ()) 20817 return ns_context; 20818 if (DECL_P (thing)) 20819 gen_decl_die (thing, NULL, ns_context); 20820 else 20821 gen_type_die (thing, ns_context); 20822 } 20823 return context_die; 20824} 20825 20826/* Generate a DIE for a namespace or namespace alias. */ 20827 20828static void 20829gen_namespace_die (tree decl, dw_die_ref context_die) 20830{ 20831 dw_die_ref namespace_die; 20832 20833 /* Namespace aliases have a DECL_ABSTRACT_ORIGIN of the namespace 20834 they are an alias of. */ 20835 if (DECL_ABSTRACT_ORIGIN (decl) == NULL) 20836 { 20837 /* Output a real namespace or module. */ 20838 context_die = setup_namespace_context (decl, comp_unit_die ()); 20839 namespace_die = new_die (is_fortran () 20840 ? DW_TAG_module : DW_TAG_namespace, 20841 context_die, decl); 20842 /* For Fortran modules defined in different CU don't add src coords. */ 20843 if (namespace_die->die_tag == DW_TAG_module && DECL_EXTERNAL (decl)) 20844 { 20845 const char *name = dwarf2_name (decl, 0); 20846 if (name) 20847 add_name_attribute (namespace_die, name); 20848 } 20849 else 20850 add_name_and_src_coords_attributes (namespace_die, decl); 20851 if (DECL_EXTERNAL (decl)) 20852 add_AT_flag (namespace_die, DW_AT_declaration, 1); 20853 equate_decl_number_to_die (decl, namespace_die); 20854 } 20855 else 20856 { 20857 /* Output a namespace alias. */ 20858 20859 /* Force out the namespace we are an alias of, if necessary. */ 20860 dw_die_ref origin_die 20861 = force_decl_die (DECL_ABSTRACT_ORIGIN (decl)); 20862 20863 if (DECL_FILE_SCOPE_P (decl) 20864 || TREE_CODE (DECL_CONTEXT (decl)) == NAMESPACE_DECL) 20865 context_die = setup_namespace_context (decl, comp_unit_die ()); 20866 /* Now create the namespace alias DIE. */ 20867 namespace_die = new_die (DW_TAG_imported_declaration, context_die, decl); 20868 add_name_and_src_coords_attributes (namespace_die, decl); 20869 add_AT_die_ref (namespace_die, DW_AT_import, origin_die); 20870 equate_decl_number_to_die (decl, namespace_die); 20871 } 20872 /* Bypass dwarf2_name's check for DECL_NAMELESS. */ 20873 if (want_pubnames ()) 20874 add_pubname_string (lang_hooks.dwarf_name (decl, 1), namespace_die); 20875} 20876 20877/* Generate Dwarf debug information for a decl described by DECL. 20878 The return value is currently only meaningful for PARM_DECLs, 20879 for all other decls it returns NULL. */ 20880 20881static dw_die_ref 20882gen_decl_die (tree decl, tree origin, dw_die_ref context_die) 20883{ 20884 tree decl_or_origin = decl ? decl : origin; 20885 tree class_origin = NULL, ultimate_origin; 20886 20887 if (DECL_P (decl_or_origin) && DECL_IGNORED_P (decl_or_origin)) 20888 return NULL; 20889 20890 /* Ignore pointer bounds decls. */ 20891 if (DECL_P (decl_or_origin) 20892 && TREE_TYPE (decl_or_origin) 20893 && POINTER_BOUNDS_P (decl_or_origin)) 20894 return NULL; 20895 20896 switch (TREE_CODE (decl_or_origin)) 20897 { 20898 case ERROR_MARK: 20899 break; 20900 20901 case CONST_DECL: 20902 if (!is_fortran () && !is_ada ()) 20903 { 20904 /* The individual enumerators of an enum type get output when we output 20905 the Dwarf representation of the relevant enum type itself. */ 20906 break; 20907 } 20908 20909 /* Emit its type. */ 20910 gen_type_die (TREE_TYPE (decl), context_die); 20911 20912 /* And its containing namespace. */ 20913 context_die = declare_in_namespace (decl, context_die); 20914 20915 gen_const_die (decl, context_die); 20916 break; 20917 20918 case FUNCTION_DECL: 20919 /* Don't output any DIEs to represent mere function declarations, 20920 unless they are class members or explicit block externs. */ 20921 if (DECL_INITIAL (decl_or_origin) == NULL_TREE 20922 && DECL_FILE_SCOPE_P (decl_or_origin) 20923 && (current_function_decl == NULL_TREE 20924 || DECL_ARTIFICIAL (decl_or_origin))) 20925 break; 20926 20927#if 0 20928 /* FIXME */ 20929 /* This doesn't work because the C frontend sets DECL_ABSTRACT_ORIGIN 20930 on local redeclarations of global functions. That seems broken. */ 20931 if (current_function_decl != decl) 20932 /* This is only a declaration. */; 20933#endif 20934 20935 /* If we're emitting a clone, emit info for the abstract instance. */ 20936 if (origin || DECL_ORIGIN (decl) != decl) 20937 dwarf2out_abstract_function (origin 20938 ? DECL_ORIGIN (origin) 20939 : DECL_ABSTRACT_ORIGIN (decl)); 20940 20941 /* If we're emitting an out-of-line copy of an inline function, 20942 emit info for the abstract instance and set up to refer to it. */ 20943 else if (cgraph_function_possibly_inlined_p (decl) 20944 && ! DECL_ABSTRACT_P (decl) 20945 && ! class_or_namespace_scope_p (context_die) 20946 /* dwarf2out_abstract_function won't emit a die if this is just 20947 a declaration. We must avoid setting DECL_ABSTRACT_ORIGIN in 20948 that case, because that works only if we have a die. */ 20949 && DECL_INITIAL (decl) != NULL_TREE) 20950 { 20951 dwarf2out_abstract_function (decl); 20952 set_decl_origin_self (decl); 20953 } 20954 20955 /* Otherwise we're emitting the primary DIE for this decl. */ 20956 else if (debug_info_level > DINFO_LEVEL_TERSE) 20957 { 20958 /* Before we describe the FUNCTION_DECL itself, make sure that we 20959 have its containing type. */ 20960 if (!origin) 20961 origin = decl_class_context (decl); 20962 if (origin != NULL_TREE) 20963 gen_type_die (origin, context_die); 20964 20965 /* And its return type. */ 20966 gen_type_die (TREE_TYPE (TREE_TYPE (decl)), context_die); 20967 20968 /* And its virtual context. */ 20969 if (DECL_VINDEX (decl) != NULL_TREE) 20970 gen_type_die (DECL_CONTEXT (decl), context_die); 20971 20972 /* Make sure we have a member DIE for decl. */ 20973 if (origin != NULL_TREE) 20974 gen_type_die_for_member (origin, decl, context_die); 20975 20976 /* And its containing namespace. */ 20977 context_die = declare_in_namespace (decl, context_die); 20978 } 20979 20980 /* Now output a DIE to represent the function itself. */ 20981 if (decl) 20982 gen_subprogram_die (decl, context_die); 20983 break; 20984 20985 case TYPE_DECL: 20986 /* If we are in terse mode, don't generate any DIEs to represent any 20987 actual typedefs. */ 20988 if (debug_info_level <= DINFO_LEVEL_TERSE) 20989 break; 20990 20991 /* In the special case of a TYPE_DECL node representing the declaration 20992 of some type tag, if the given TYPE_DECL is marked as having been 20993 instantiated from some other (original) TYPE_DECL node (e.g. one which 20994 was generated within the original definition of an inline function) we 20995 used to generate a special (abbreviated) DW_TAG_structure_type, 20996 DW_TAG_union_type, or DW_TAG_enumeration_type DIE here. But nothing 20997 should be actually referencing those DIEs, as variable DIEs with that 20998 type would be emitted already in the abstract origin, so it was always 20999 removed during unused type prunning. Don't add anything in this 21000 case. */ 21001 if (TYPE_DECL_IS_STUB (decl) && decl_ultimate_origin (decl) != NULL_TREE) 21002 break; 21003 21004 if (is_redundant_typedef (decl)) 21005 gen_type_die (TREE_TYPE (decl), context_die); 21006 else 21007 /* Output a DIE to represent the typedef itself. */ 21008 gen_typedef_die (decl, context_die); 21009 break; 21010 21011 case LABEL_DECL: 21012 if (debug_info_level >= DINFO_LEVEL_NORMAL) 21013 gen_label_die (decl, context_die); 21014 break; 21015 21016 case VAR_DECL: 21017 case RESULT_DECL: 21018 /* If we are in terse mode, don't generate any DIEs to represent any 21019 variable declarations or definitions. */ 21020 if (debug_info_level <= DINFO_LEVEL_TERSE) 21021 break; 21022 21023 /* Output any DIEs that are needed to specify the type of this data 21024 object. */ 21025 if (decl_by_reference_p (decl_or_origin)) 21026 gen_type_die (TREE_TYPE (TREE_TYPE (decl_or_origin)), context_die); 21027 else 21028 gen_type_die (TREE_TYPE (decl_or_origin), context_die); 21029 21030 /* And its containing type. */ 21031 class_origin = decl_class_context (decl_or_origin); 21032 if (class_origin != NULL_TREE) 21033 gen_type_die_for_member (class_origin, decl_or_origin, context_die); 21034 21035 /* And its containing namespace. */ 21036 context_die = declare_in_namespace (decl_or_origin, context_die); 21037 21038 /* Now output the DIE to represent the data object itself. This gets 21039 complicated because of the possibility that the VAR_DECL really 21040 represents an inlined instance of a formal parameter for an inline 21041 function. */ 21042 ultimate_origin = decl_ultimate_origin (decl_or_origin); 21043 if (ultimate_origin != NULL_TREE 21044 && TREE_CODE (ultimate_origin) == PARM_DECL) 21045 gen_formal_parameter_die (decl, origin, 21046 true /* Emit name attribute. */, 21047 context_die); 21048 else 21049 gen_variable_die (decl, origin, context_die); 21050 break; 21051 21052 case FIELD_DECL: 21053 /* Ignore the nameless fields that are used to skip bits but handle C++ 21054 anonymous unions and structs. */ 21055 if (DECL_NAME (decl) != NULL_TREE 21056 || TREE_CODE (TREE_TYPE (decl)) == UNION_TYPE 21057 || TREE_CODE (TREE_TYPE (decl)) == RECORD_TYPE) 21058 { 21059 gen_type_die (member_declared_type (decl), context_die); 21060 gen_field_die (decl, context_die); 21061 } 21062 break; 21063 21064 case PARM_DECL: 21065 if (DECL_BY_REFERENCE (decl_or_origin)) 21066 gen_type_die (TREE_TYPE (TREE_TYPE (decl_or_origin)), context_die); 21067 else 21068 gen_type_die (TREE_TYPE (decl_or_origin), context_die); 21069 return gen_formal_parameter_die (decl, origin, 21070 true /* Emit name attribute. */, 21071 context_die); 21072 21073 case NAMESPACE_DECL: 21074 case IMPORTED_DECL: 21075 if (dwarf_version >= 3 || !dwarf_strict) 21076 gen_namespace_die (decl, context_die); 21077 break; 21078 21079 case NAMELIST_DECL: 21080 gen_namelist_decl (DECL_NAME (decl), context_die, 21081 NAMELIST_DECL_ASSOCIATED_DECL (decl)); 21082 break; 21083 21084 default: 21085 /* Probably some frontend-internal decl. Assume we don't care. */ 21086 gcc_assert ((int)TREE_CODE (decl) > NUM_TREE_CODES); 21087 break; 21088 } 21089 21090 return NULL; 21091} 21092 21093/* Output debug information for global decl DECL. Called from toplev.c after 21094 compilation proper has finished. */ 21095 21096static void 21097dwarf2out_global_decl (tree decl) 21098{ 21099 /* Output DWARF2 information for file-scope tentative data object 21100 declarations, file-scope (extern) function declarations (which 21101 had no corresponding body) and file-scope tagged type declarations 21102 and definitions which have not yet been forced out. */ 21103 if ((TREE_CODE (decl) != FUNCTION_DECL || !DECL_INITIAL (decl)) 21104 && !POINTER_BOUNDS_P (decl)) 21105 dwarf2out_decl (decl); 21106} 21107 21108/* Output debug information for type decl DECL. Called from toplev.c 21109 and from language front ends (to record built-in types). */ 21110static void 21111dwarf2out_type_decl (tree decl, int local) 21112{ 21113 if (!local) 21114 dwarf2out_decl (decl); 21115} 21116 21117/* Output debug information for imported module or decl DECL. 21118 NAME is non-NULL name in the lexical block if the decl has been renamed. 21119 LEXICAL_BLOCK is the lexical block (which TREE_CODE is a BLOCK) 21120 that DECL belongs to. 21121 LEXICAL_BLOCK_DIE is the DIE of LEXICAL_BLOCK. */ 21122static void 21123dwarf2out_imported_module_or_decl_1 (tree decl, 21124 tree name, 21125 tree lexical_block, 21126 dw_die_ref lexical_block_die) 21127{ 21128 expanded_location xloc; 21129 dw_die_ref imported_die = NULL; 21130 dw_die_ref at_import_die; 21131 21132 if (TREE_CODE (decl) == IMPORTED_DECL) 21133 { 21134 xloc = expand_location (DECL_SOURCE_LOCATION (decl)); 21135 decl = IMPORTED_DECL_ASSOCIATED_DECL (decl); 21136 gcc_assert (decl); 21137 } 21138 else 21139 xloc = expand_location (input_location); 21140 21141 if (TREE_CODE (decl) == TYPE_DECL || TREE_CODE (decl) == CONST_DECL) 21142 { 21143 at_import_die = force_type_die (TREE_TYPE (decl)); 21144 /* For namespace N { typedef void T; } using N::T; base_type_die 21145 returns NULL, but DW_TAG_imported_declaration requires 21146 the DW_AT_import tag. Force creation of DW_TAG_typedef. */ 21147 if (!at_import_die) 21148 { 21149 gcc_assert (TREE_CODE (decl) == TYPE_DECL); 21150 gen_typedef_die (decl, get_context_die (DECL_CONTEXT (decl))); 21151 at_import_die = lookup_type_die (TREE_TYPE (decl)); 21152 gcc_assert (at_import_die); 21153 } 21154 } 21155 else 21156 { 21157 at_import_die = lookup_decl_die (decl); 21158 if (!at_import_die) 21159 { 21160 /* If we're trying to avoid duplicate debug info, we may not have 21161 emitted the member decl for this field. Emit it now. */ 21162 if (TREE_CODE (decl) == FIELD_DECL) 21163 { 21164 tree type = DECL_CONTEXT (decl); 21165 21166 if (TYPE_CONTEXT (type) 21167 && TYPE_P (TYPE_CONTEXT (type)) 21168 && !should_emit_struct_debug (TYPE_CONTEXT (type), 21169 DINFO_USAGE_DIR_USE)) 21170 return; 21171 gen_type_die_for_member (type, decl, 21172 get_context_die (TYPE_CONTEXT (type))); 21173 } 21174 if (TREE_CODE (decl) == NAMELIST_DECL) 21175 at_import_die = gen_namelist_decl (DECL_NAME (decl), 21176 get_context_die (DECL_CONTEXT (decl)), 21177 NULL_TREE); 21178 else 21179 at_import_die = force_decl_die (decl); 21180 } 21181 } 21182 21183 if (TREE_CODE (decl) == NAMESPACE_DECL) 21184 { 21185 if (dwarf_version >= 3 || !dwarf_strict) 21186 imported_die = new_die (DW_TAG_imported_module, 21187 lexical_block_die, 21188 lexical_block); 21189 else 21190 return; 21191 } 21192 else 21193 imported_die = new_die (DW_TAG_imported_declaration, 21194 lexical_block_die, 21195 lexical_block); 21196 21197 add_AT_file (imported_die, DW_AT_decl_file, lookup_filename (xloc.file)); 21198 add_AT_unsigned (imported_die, DW_AT_decl_line, xloc.line); 21199 if (name) 21200 add_AT_string (imported_die, DW_AT_name, 21201 IDENTIFIER_POINTER (name)); 21202 add_AT_die_ref (imported_die, DW_AT_import, at_import_die); 21203} 21204 21205/* Output debug information for imported module or decl DECL. 21206 NAME is non-NULL name in context if the decl has been renamed. 21207 CHILD is true if decl is one of the renamed decls as part of 21208 importing whole module. */ 21209 21210static void 21211dwarf2out_imported_module_or_decl (tree decl, tree name, tree context, 21212 bool child) 21213{ 21214 /* dw_die_ref at_import_die; */ 21215 dw_die_ref scope_die; 21216 21217 if (debug_info_level <= DINFO_LEVEL_TERSE) 21218 return; 21219 21220 gcc_assert (decl); 21221 21222 /* To emit DW_TAG_imported_module or DW_TAG_imported_decl, we need two DIEs. 21223 We need decl DIE for reference and scope die. First, get DIE for the decl 21224 itself. */ 21225 21226 /* Get the scope die for decl context. Use comp_unit_die for global module 21227 or decl. If die is not found for non globals, force new die. */ 21228 if (context 21229 && TYPE_P (context) 21230 && !should_emit_struct_debug (context, DINFO_USAGE_DIR_USE)) 21231 return; 21232 21233 if (!(dwarf_version >= 3 || !dwarf_strict)) 21234 return; 21235 21236 scope_die = get_context_die (context); 21237 21238 if (child) 21239 { 21240 gcc_assert (scope_die->die_child); 21241 gcc_assert (scope_die->die_child->die_tag == DW_TAG_imported_module); 21242 gcc_assert (TREE_CODE (decl) != NAMESPACE_DECL); 21243 scope_die = scope_die->die_child; 21244 } 21245 21246 /* OK, now we have DIEs for decl as well as scope. Emit imported die. */ 21247 dwarf2out_imported_module_or_decl_1 (decl, name, context, scope_die); 21248 21249} 21250 21251/* Output debug information for namelists. */ 21252 21253static dw_die_ref 21254gen_namelist_decl (tree name, dw_die_ref scope_die, tree item_decls) 21255{ 21256 dw_die_ref nml_die, nml_item_die, nml_item_ref_die; 21257 tree value; 21258 unsigned i; 21259 21260 if (debug_info_level <= DINFO_LEVEL_TERSE) 21261 return NULL; 21262 21263 gcc_assert (scope_die != NULL); 21264 nml_die = new_die (DW_TAG_namelist, scope_die, NULL); 21265 add_AT_string (nml_die, DW_AT_name, IDENTIFIER_POINTER (name)); 21266 21267 /* If there are no item_decls, we have a nondefining namelist, e.g. 21268 with USE association; hence, set DW_AT_declaration. */ 21269 if (item_decls == NULL_TREE) 21270 { 21271 add_AT_flag (nml_die, DW_AT_declaration, 1); 21272 return nml_die; 21273 } 21274 21275 FOR_EACH_CONSTRUCTOR_VALUE (CONSTRUCTOR_ELTS (item_decls), i, value) 21276 { 21277 nml_item_ref_die = lookup_decl_die (value); 21278 if (!nml_item_ref_die) 21279 nml_item_ref_die = force_decl_die (value); 21280 21281 nml_item_die = new_die (DW_TAG_namelist_item, nml_die, NULL); 21282 add_AT_die_ref (nml_item_die, DW_AT_namelist_items, nml_item_ref_die); 21283 } 21284 return nml_die; 21285} 21286 21287 21288/* Write the debugging output for DECL. */ 21289 21290static void 21291dwarf2out_decl (tree decl) 21292{ 21293 dw_die_ref context_die = comp_unit_die (); 21294 21295 switch (TREE_CODE (decl)) 21296 { 21297 case ERROR_MARK: 21298 return; 21299 21300 case FUNCTION_DECL: 21301 /* What we would really like to do here is to filter out all mere 21302 file-scope declarations of file-scope functions which are never 21303 referenced later within this translation unit (and keep all of ones 21304 that *are* referenced later on) but we aren't clairvoyant, so we have 21305 no idea which functions will be referenced in the future (i.e. later 21306 on within the current translation unit). So here we just ignore all 21307 file-scope function declarations which are not also definitions. If 21308 and when the debugger needs to know something about these functions, 21309 it will have to hunt around and find the DWARF information associated 21310 with the definition of the function. 21311 21312 We can't just check DECL_EXTERNAL to find out which FUNCTION_DECL 21313 nodes represent definitions and which ones represent mere 21314 declarations. We have to check DECL_INITIAL instead. That's because 21315 the C front-end supports some weird semantics for "extern inline" 21316 function definitions. These can get inlined within the current 21317 translation unit (and thus, we need to generate Dwarf info for their 21318 abstract instances so that the Dwarf info for the concrete inlined 21319 instances can have something to refer to) but the compiler never 21320 generates any out-of-lines instances of such things (despite the fact 21321 that they *are* definitions). 21322 21323 The important point is that the C front-end marks these "extern 21324 inline" functions as DECL_EXTERNAL, but we need to generate DWARF for 21325 them anyway. Note that the C++ front-end also plays some similar games 21326 for inline function definitions appearing within include files which 21327 also contain `#pragma interface' pragmas. 21328 21329 If we are called from dwarf2out_abstract_function output a DIE 21330 anyway. We can end up here this way with early inlining and LTO 21331 where the inlined function is output in a different LTRANS unit 21332 or not at all. */ 21333 if (DECL_INITIAL (decl) == NULL_TREE 21334 && ! DECL_ABSTRACT_P (decl)) 21335 return; 21336 21337 /* If we're a nested function, initially use a parent of NULL; if we're 21338 a plain function, this will be fixed up in decls_for_scope. If 21339 we're a method, it will be ignored, since we already have a DIE. */ 21340 if (decl_function_context (decl) 21341 /* But if we're in terse mode, we don't care about scope. */ 21342 && debug_info_level > DINFO_LEVEL_TERSE) 21343 context_die = NULL; 21344 break; 21345 21346 case VAR_DECL: 21347 /* Ignore this VAR_DECL if it refers to a file-scope extern data object 21348 declaration and if the declaration was never even referenced from 21349 within this entire compilation unit. We suppress these DIEs in 21350 order to save space in the .debug section (by eliminating entries 21351 which are probably useless). Note that we must not suppress 21352 block-local extern declarations (whether used or not) because that 21353 would screw-up the debugger's name lookup mechanism and cause it to 21354 miss things which really ought to be in scope at a given point. */ 21355 if (DECL_EXTERNAL (decl) && !TREE_USED (decl)) 21356 return; 21357 21358 /* For local statics lookup proper context die. */ 21359 if (TREE_STATIC (decl) 21360 && DECL_CONTEXT (decl) 21361 && TREE_CODE (DECL_CONTEXT (decl)) == FUNCTION_DECL) 21362 context_die = lookup_decl_die (DECL_CONTEXT (decl)); 21363 21364 /* If we are in terse mode, don't generate any DIEs to represent any 21365 variable declarations or definitions. */ 21366 if (debug_info_level <= DINFO_LEVEL_TERSE) 21367 return; 21368 break; 21369 21370 case CONST_DECL: 21371 if (debug_info_level <= DINFO_LEVEL_TERSE) 21372 return; 21373 if (!is_fortran () && !is_ada ()) 21374 return; 21375 if (TREE_STATIC (decl) && decl_function_context (decl)) 21376 context_die = lookup_decl_die (DECL_CONTEXT (decl)); 21377 break; 21378 21379 case NAMESPACE_DECL: 21380 case IMPORTED_DECL: 21381 if (debug_info_level <= DINFO_LEVEL_TERSE) 21382 return; 21383 if (lookup_decl_die (decl) != NULL) 21384 return; 21385 break; 21386 21387 case TYPE_DECL: 21388 /* Don't emit stubs for types unless they are needed by other DIEs. */ 21389 if (TYPE_DECL_SUPPRESS_DEBUG (decl)) 21390 return; 21391 21392 /* Don't bother trying to generate any DIEs to represent any of the 21393 normal built-in types for the language we are compiling. */ 21394 if (DECL_IS_BUILTIN (decl)) 21395 return; 21396 21397 /* If we are in terse mode, don't generate any DIEs for types. */ 21398 if (debug_info_level <= DINFO_LEVEL_TERSE) 21399 return; 21400 21401 /* If we're a function-scope tag, initially use a parent of NULL; 21402 this will be fixed up in decls_for_scope. */ 21403 if (decl_function_context (decl)) 21404 context_die = NULL; 21405 21406 break; 21407 21408 case NAMELIST_DECL: 21409 break; 21410 21411 default: 21412 return; 21413 } 21414 21415 gen_decl_die (decl, NULL, context_die); 21416} 21417 21418/* Write the debugging output for DECL. */ 21419 21420static void 21421dwarf2out_function_decl (tree decl) 21422{ 21423 dwarf2out_decl (decl); 21424 call_arg_locations = NULL; 21425 call_arg_loc_last = NULL; 21426 call_site_count = -1; 21427 tail_call_site_count = -1; 21428 block_map.release (); 21429 decl_loc_table->empty (); 21430 cached_dw_loc_list_table->empty (); 21431} 21432 21433/* Output a marker (i.e. a label) for the beginning of the generated code for 21434 a lexical block. */ 21435 21436static void 21437dwarf2out_begin_block (unsigned int line ATTRIBUTE_UNUSED, 21438 unsigned int blocknum) 21439{ 21440 switch_to_section (current_function_section ()); 21441 ASM_OUTPUT_DEBUG_LABEL (asm_out_file, BLOCK_BEGIN_LABEL, blocknum); 21442} 21443 21444/* Output a marker (i.e. a label) for the end of the generated code for a 21445 lexical block. */ 21446 21447static void 21448dwarf2out_end_block (unsigned int line ATTRIBUTE_UNUSED, unsigned int blocknum) 21449{ 21450 switch_to_section (current_function_section ()); 21451 ASM_OUTPUT_DEBUG_LABEL (asm_out_file, BLOCK_END_LABEL, blocknum); 21452} 21453 21454/* Returns nonzero if it is appropriate not to emit any debugging 21455 information for BLOCK, because it doesn't contain any instructions. 21456 21457 Don't allow this for blocks with nested functions or local classes 21458 as we would end up with orphans, and in the presence of scheduling 21459 we may end up calling them anyway. */ 21460 21461static bool 21462dwarf2out_ignore_block (const_tree block) 21463{ 21464 tree decl; 21465 unsigned int i; 21466 21467 for (decl = BLOCK_VARS (block); decl; decl = DECL_CHAIN (decl)) 21468 if (TREE_CODE (decl) == FUNCTION_DECL 21469 || (TREE_CODE (decl) == TYPE_DECL && TYPE_DECL_IS_STUB (decl))) 21470 return 0; 21471 for (i = 0; i < BLOCK_NUM_NONLOCALIZED_VARS (block); i++) 21472 { 21473 decl = BLOCK_NONLOCALIZED_VAR (block, i); 21474 if (TREE_CODE (decl) == FUNCTION_DECL 21475 || (TREE_CODE (decl) == TYPE_DECL && TYPE_DECL_IS_STUB (decl))) 21476 return 0; 21477 } 21478 21479 return 1; 21480} 21481 21482/* Hash table routines for file_hash. */ 21483 21484bool 21485dwarf_file_hasher::equal (dwarf_file_data *p1, const char *p2) 21486{ 21487 return filename_cmp (p1->filename, p2) == 0; 21488} 21489 21490hashval_t 21491dwarf_file_hasher::hash (dwarf_file_data *p) 21492{ 21493 return htab_hash_string (p->filename); 21494} 21495 21496/* Lookup FILE_NAME (in the list of filenames that we know about here in 21497 dwarf2out.c) and return its "index". The index of each (known) filename is 21498 just a unique number which is associated with only that one filename. We 21499 need such numbers for the sake of generating labels (in the .debug_sfnames 21500 section) and references to those files numbers (in the .debug_srcinfo 21501 and.debug_macinfo sections). If the filename given as an argument is not 21502 found in our current list, add it to the list and assign it the next 21503 available unique index number. In order to speed up searches, we remember 21504 the index of the filename was looked up last. This handles the majority of 21505 all searches. */ 21506 21507static struct dwarf_file_data * 21508lookup_filename (const char *file_name) 21509{ 21510 struct dwarf_file_data * created; 21511 21512 /* Check to see if the file name that was searched on the previous 21513 call matches this file name. If so, return the index. */ 21514 if (file_table_last_lookup 21515 && (file_name == file_table_last_lookup->filename 21516 || filename_cmp (file_table_last_lookup->filename, file_name) == 0)) 21517 return file_table_last_lookup; 21518 21519 /* Didn't match the previous lookup, search the table. */ 21520 dwarf_file_data **slot 21521 = file_table->find_slot_with_hash (file_name, htab_hash_string (file_name), 21522 INSERT); 21523 if (*slot) 21524 return *slot; 21525 21526 created = ggc_alloc<dwarf_file_data> (); 21527 created->filename = file_name; 21528 created->emitted_number = 0; 21529 *slot = created; 21530 return created; 21531} 21532 21533/* If the assembler will construct the file table, then translate the compiler 21534 internal file table number into the assembler file table number, and emit 21535 a .file directive if we haven't already emitted one yet. The file table 21536 numbers are different because we prune debug info for unused variables and 21537 types, which may include filenames. */ 21538 21539static int 21540maybe_emit_file (struct dwarf_file_data * fd) 21541{ 21542 if (! fd->emitted_number) 21543 { 21544 if (last_emitted_file) 21545 fd->emitted_number = last_emitted_file->emitted_number + 1; 21546 else 21547 fd->emitted_number = 1; 21548 last_emitted_file = fd; 21549 21550 if (DWARF2_ASM_LINE_DEBUG_INFO) 21551 { 21552 fprintf (asm_out_file, "\t.file %u ", fd->emitted_number); 21553 output_quoted_string (asm_out_file, 21554 remap_debug_filename (fd->filename)); 21555 fputc ('\n', asm_out_file); 21556 } 21557 } 21558 21559 return fd->emitted_number; 21560} 21561 21562/* Schedule generation of a DW_AT_const_value attribute to DIE. 21563 That generation should happen after function debug info has been 21564 generated. The value of the attribute is the constant value of ARG. */ 21565 21566static void 21567append_entry_to_tmpl_value_parm_die_table (dw_die_ref die, tree arg) 21568{ 21569 die_arg_entry entry; 21570 21571 if (!die || !arg) 21572 return; 21573 21574 if (!tmpl_value_parm_die_table) 21575 vec_alloc (tmpl_value_parm_die_table, 32); 21576 21577 entry.die = die; 21578 entry.arg = arg; 21579 vec_safe_push (tmpl_value_parm_die_table, entry); 21580} 21581 21582/* Return TRUE if T is an instance of generic type, FALSE 21583 otherwise. */ 21584 21585static bool 21586generic_type_p (tree t) 21587{ 21588 if (t == NULL_TREE || !TYPE_P (t)) 21589 return false; 21590 return lang_hooks.get_innermost_generic_parms (t) != NULL_TREE; 21591} 21592 21593/* Schedule the generation of the generic parameter dies for the 21594 instance of generic type T. The proper generation itself is later 21595 done by gen_scheduled_generic_parms_dies. */ 21596 21597static void 21598schedule_generic_params_dies_gen (tree t) 21599{ 21600 if (!generic_type_p (t)) 21601 return; 21602 21603 if (!generic_type_instances) 21604 vec_alloc (generic_type_instances, 256); 21605 21606 vec_safe_push (generic_type_instances, t); 21607} 21608 21609/* Add a DW_AT_const_value attribute to DIEs that were scheduled 21610 by append_entry_to_tmpl_value_parm_die_table. This function must 21611 be called after function DIEs have been generated. */ 21612 21613static void 21614gen_remaining_tmpl_value_param_die_attribute (void) 21615{ 21616 if (tmpl_value_parm_die_table) 21617 { 21618 unsigned i; 21619 die_arg_entry *e; 21620 21621 FOR_EACH_VEC_ELT (*tmpl_value_parm_die_table, i, e) 21622 tree_add_const_value_attribute (e->die, e->arg); 21623 } 21624} 21625 21626/* Generate generic parameters DIEs for instances of generic types 21627 that have been previously scheduled by 21628 schedule_generic_params_dies_gen. This function must be called 21629 after all the types of the CU have been laid out. */ 21630 21631static void 21632gen_scheduled_generic_parms_dies (void) 21633{ 21634 unsigned i; 21635 tree t; 21636 21637 if (!generic_type_instances) 21638 return; 21639 21640 FOR_EACH_VEC_ELT (*generic_type_instances, i, t) 21641 if (COMPLETE_TYPE_P (t)) 21642 gen_generic_params_dies (t); 21643} 21644 21645 21646/* Replace DW_AT_name for the decl with name. */ 21647 21648static void 21649dwarf2out_set_name (tree decl, tree name) 21650{ 21651 dw_die_ref die; 21652 dw_attr_ref attr; 21653 const char *dname; 21654 21655 die = TYPE_SYMTAB_DIE (decl); 21656 if (!die) 21657 return; 21658 21659 dname = dwarf2_name (name, 0); 21660 if (!dname) 21661 return; 21662 21663 attr = get_AT (die, DW_AT_name); 21664 if (attr) 21665 { 21666 struct indirect_string_node *node; 21667 21668 node = find_AT_string (dname); 21669 /* replace the string. */ 21670 attr->dw_attr_val.v.val_str = node; 21671 } 21672 21673 else 21674 add_name_attribute (die, dname); 21675} 21676 21677/* True if before or during processing of the first function being emitted. */ 21678static bool in_first_function_p = true; 21679/* True if loc_note during dwarf2out_var_location call might still be 21680 before first real instruction at address equal to .Ltext0. */ 21681static bool maybe_at_text_label_p = true; 21682/* One above highest N where .LVLN label might be equal to .Ltext0 label. */ 21683static unsigned int first_loclabel_num_not_at_text_label; 21684 21685/* Called by the final INSN scan whenever we see a var location. We 21686 use it to drop labels in the right places, and throw the location in 21687 our lookup table. */ 21688 21689static void 21690dwarf2out_var_location (rtx_insn *loc_note) 21691{ 21692 char loclabel[MAX_ARTIFICIAL_LABEL_BYTES + 2]; 21693 struct var_loc_node *newloc; 21694 rtx_insn *next_real, *next_note; 21695 static const char *last_label; 21696 static const char *last_postcall_label; 21697 static bool last_in_cold_section_p; 21698 static rtx_insn *expected_next_loc_note; 21699 tree decl; 21700 bool var_loc_p; 21701 21702 if (!NOTE_P (loc_note)) 21703 { 21704 if (CALL_P (loc_note)) 21705 { 21706 call_site_count++; 21707 if (SIBLING_CALL_P (loc_note)) 21708 tail_call_site_count++; 21709 } 21710 return; 21711 } 21712 21713 var_loc_p = NOTE_KIND (loc_note) == NOTE_INSN_VAR_LOCATION; 21714 if (var_loc_p && !DECL_P (NOTE_VAR_LOCATION_DECL (loc_note))) 21715 return; 21716 21717 /* Optimize processing a large consecutive sequence of location 21718 notes so we don't spend too much time in next_real_insn. If the 21719 next insn is another location note, remember the next_real_insn 21720 calculation for next time. */ 21721 next_real = cached_next_real_insn; 21722 if (next_real) 21723 { 21724 if (expected_next_loc_note != loc_note) 21725 next_real = NULL; 21726 } 21727 21728 next_note = NEXT_INSN (loc_note); 21729 if (! next_note 21730 || next_note->deleted () 21731 || ! NOTE_P (next_note) 21732 || (NOTE_KIND (next_note) != NOTE_INSN_VAR_LOCATION 21733 && NOTE_KIND (next_note) != NOTE_INSN_CALL_ARG_LOCATION)) 21734 next_note = NULL; 21735 21736 if (! next_real) 21737 next_real = next_real_insn (loc_note); 21738 21739 if (next_note) 21740 { 21741 expected_next_loc_note = next_note; 21742 cached_next_real_insn = next_real; 21743 } 21744 else 21745 cached_next_real_insn = NULL; 21746 21747 /* If there are no instructions which would be affected by this note, 21748 don't do anything. */ 21749 if (var_loc_p 21750 && next_real == NULL_RTX 21751 && !NOTE_DURING_CALL_P (loc_note)) 21752 return; 21753 21754 if (next_real == NULL_RTX) 21755 next_real = get_last_insn (); 21756 21757 /* If there were any real insns between note we processed last time 21758 and this note (or if it is the first note), clear 21759 last_{,postcall_}label so that they are not reused this time. */ 21760 if (last_var_location_insn == NULL_RTX 21761 || last_var_location_insn != next_real 21762 || last_in_cold_section_p != in_cold_section_p) 21763 { 21764 last_label = NULL; 21765 last_postcall_label = NULL; 21766 } 21767 21768 if (var_loc_p) 21769 { 21770 decl = NOTE_VAR_LOCATION_DECL (loc_note); 21771 newloc = add_var_loc_to_decl (decl, loc_note, 21772 NOTE_DURING_CALL_P (loc_note) 21773 ? last_postcall_label : last_label); 21774 if (newloc == NULL) 21775 return; 21776 } 21777 else 21778 { 21779 decl = NULL_TREE; 21780 newloc = NULL; 21781 } 21782 21783 /* If there were no real insns between note we processed last time 21784 and this note, use the label we emitted last time. Otherwise 21785 create a new label and emit it. */ 21786 if (last_label == NULL) 21787 { 21788 ASM_GENERATE_INTERNAL_LABEL (loclabel, "LVL", loclabel_num); 21789 ASM_OUTPUT_DEBUG_LABEL (asm_out_file, "LVL", loclabel_num); 21790 loclabel_num++; 21791 last_label = ggc_strdup (loclabel); 21792 /* See if loclabel might be equal to .Ltext0. If yes, 21793 bump first_loclabel_num_not_at_text_label. */ 21794 if (!have_multiple_function_sections 21795 && in_first_function_p 21796 && maybe_at_text_label_p) 21797 { 21798 static rtx_insn *last_start; 21799 rtx_insn *insn; 21800 for (insn = loc_note; insn; insn = previous_insn (insn)) 21801 if (insn == last_start) 21802 break; 21803 else if (!NONDEBUG_INSN_P (insn)) 21804 continue; 21805 else 21806 { 21807 rtx body = PATTERN (insn); 21808 if (GET_CODE (body) == USE || GET_CODE (body) == CLOBBER) 21809 continue; 21810 /* Inline asm could occupy zero bytes. */ 21811 else if (GET_CODE (body) == ASM_INPUT 21812 || asm_noperands (body) >= 0) 21813 continue; 21814#ifdef HAVE_attr_length 21815 else if (get_attr_min_length (insn) == 0) 21816 continue; 21817#endif 21818 else 21819 { 21820 /* Assume insn has non-zero length. */ 21821 maybe_at_text_label_p = false; 21822 break; 21823 } 21824 } 21825 if (maybe_at_text_label_p) 21826 { 21827 last_start = loc_note; 21828 first_loclabel_num_not_at_text_label = loclabel_num; 21829 } 21830 } 21831 } 21832 21833 if (!var_loc_p) 21834 { 21835 struct call_arg_loc_node *ca_loc 21836 = ggc_cleared_alloc<call_arg_loc_node> (); 21837 rtx_insn *prev = prev_real_insn (loc_note); 21838 rtx x; 21839 ca_loc->call_arg_loc_note = loc_note; 21840 ca_loc->next = NULL; 21841 ca_loc->label = last_label; 21842 gcc_assert (prev 21843 && (CALL_P (prev) 21844 || (NONJUMP_INSN_P (prev) 21845 && GET_CODE (PATTERN (prev)) == SEQUENCE 21846 && CALL_P (XVECEXP (PATTERN (prev), 0, 0))))); 21847 if (!CALL_P (prev)) 21848 prev = as_a <rtx_sequence *> (PATTERN (prev))->insn (0); 21849 ca_loc->tail_call_p = SIBLING_CALL_P (prev); 21850 x = get_call_rtx_from (PATTERN (prev)); 21851 if (x) 21852 { 21853 x = XEXP (XEXP (x, 0), 0); 21854 if (GET_CODE (x) == SYMBOL_REF 21855 && SYMBOL_REF_DECL (x) 21856 && TREE_CODE (SYMBOL_REF_DECL (x)) == FUNCTION_DECL) 21857 ca_loc->symbol_ref = x; 21858 } 21859 ca_loc->block = insn_scope (prev); 21860 if (call_arg_locations) 21861 call_arg_loc_last->next = ca_loc; 21862 else 21863 call_arg_locations = ca_loc; 21864 call_arg_loc_last = ca_loc; 21865 } 21866 else if (!NOTE_DURING_CALL_P (loc_note)) 21867 newloc->label = last_label; 21868 else 21869 { 21870 if (!last_postcall_label) 21871 { 21872 sprintf (loclabel, "%s-1", last_label); 21873 last_postcall_label = ggc_strdup (loclabel); 21874 } 21875 newloc->label = last_postcall_label; 21876 } 21877 21878 last_var_location_insn = next_real; 21879 last_in_cold_section_p = in_cold_section_p; 21880} 21881 21882/* Note in one location list that text section has changed. */ 21883 21884int 21885var_location_switch_text_section_1 (var_loc_list **slot, void *) 21886{ 21887 var_loc_list *list = *slot; 21888 if (list->first) 21889 list->last_before_switch 21890 = list->last->next ? list->last->next : list->last; 21891 return 1; 21892} 21893 21894/* Note in all location lists that text section has changed. */ 21895 21896static void 21897var_location_switch_text_section (void) 21898{ 21899 if (decl_loc_table == NULL) 21900 return; 21901 21902 decl_loc_table->traverse<void *, var_location_switch_text_section_1> (NULL); 21903} 21904 21905/* Create a new line number table. */ 21906 21907static dw_line_info_table * 21908new_line_info_table (void) 21909{ 21910 dw_line_info_table *table; 21911 21912 table = ggc_cleared_alloc<dw_line_info_table_struct> (); 21913 table->file_num = 1; 21914 table->line_num = 1; 21915 table->is_stmt = DWARF_LINE_DEFAULT_IS_STMT_START; 21916 21917 return table; 21918} 21919 21920/* Lookup the "current" table into which we emit line info, so 21921 that we don't have to do it for every source line. */ 21922 21923static void 21924set_cur_line_info_table (section *sec) 21925{ 21926 dw_line_info_table *table; 21927 21928 if (sec == text_section) 21929 table = text_section_line_info; 21930 else if (sec == cold_text_section) 21931 { 21932 table = cold_text_section_line_info; 21933 if (!table) 21934 { 21935 cold_text_section_line_info = table = new_line_info_table (); 21936 table->end_label = cold_end_label; 21937 } 21938 } 21939 else 21940 { 21941 const char *end_label; 21942 21943 if (flag_reorder_blocks_and_partition) 21944 { 21945 if (in_cold_section_p) 21946 end_label = crtl->subsections.cold_section_end_label; 21947 else 21948 end_label = crtl->subsections.hot_section_end_label; 21949 } 21950 else 21951 { 21952 char label[MAX_ARTIFICIAL_LABEL_BYTES]; 21953 ASM_GENERATE_INTERNAL_LABEL (label, FUNC_END_LABEL, 21954 current_function_funcdef_no); 21955 end_label = ggc_strdup (label); 21956 } 21957 21958 table = new_line_info_table (); 21959 table->end_label = end_label; 21960 21961 vec_safe_push (separate_line_info, table); 21962 } 21963 21964 if (DWARF2_ASM_LINE_DEBUG_INFO) 21965 table->is_stmt = (cur_line_info_table 21966 ? cur_line_info_table->is_stmt 21967 : DWARF_LINE_DEFAULT_IS_STMT_START); 21968 cur_line_info_table = table; 21969} 21970 21971 21972/* We need to reset the locations at the beginning of each 21973 function. We can't do this in the end_function hook, because the 21974 declarations that use the locations won't have been output when 21975 that hook is called. Also compute have_multiple_function_sections here. */ 21976 21977static void 21978dwarf2out_begin_function (tree fun) 21979{ 21980 section *sec = function_section (fun); 21981 21982 if (sec != text_section) 21983 have_multiple_function_sections = true; 21984 21985 if (flag_reorder_blocks_and_partition && !cold_text_section) 21986 { 21987 gcc_assert (current_function_decl == fun); 21988 cold_text_section = unlikely_text_section (); 21989 switch_to_section (cold_text_section); 21990 ASM_OUTPUT_LABEL (asm_out_file, cold_text_section_label); 21991 switch_to_section (sec); 21992 } 21993 21994 dwarf2out_note_section_used (); 21995 call_site_count = 0; 21996 tail_call_site_count = 0; 21997 21998 set_cur_line_info_table (sec); 21999} 22000 22001/* Helper function of dwarf2out_end_function, called only after emitting 22002 the very first function into assembly. Check if some .debug_loc range 22003 might end with a .LVL* label that could be equal to .Ltext0. 22004 In that case we must force using absolute addresses in .debug_loc ranges, 22005 because this range could be .LVLN-.Ltext0 .. .LVLM-.Ltext0 for 22006 .LVLN == .LVLM == .Ltext0, thus 0 .. 0, which is a .debug_loc 22007 list terminator. 22008 Set have_multiple_function_sections to true in that case and 22009 terminate htab traversal. */ 22010 22011int 22012find_empty_loc_ranges_at_text_label (var_loc_list **slot, int) 22013{ 22014 var_loc_list *entry = *slot; 22015 struct var_loc_node *node; 22016 22017 node = entry->first; 22018 if (node && node->next && node->next->label) 22019 { 22020 unsigned int i; 22021 const char *label = node->next->label; 22022 char loclabel[MAX_ARTIFICIAL_LABEL_BYTES]; 22023 22024 for (i = 0; i < first_loclabel_num_not_at_text_label; i++) 22025 { 22026 ASM_GENERATE_INTERNAL_LABEL (loclabel, "LVL", i); 22027 if (strcmp (label, loclabel) == 0) 22028 { 22029 have_multiple_function_sections = true; 22030 return 0; 22031 } 22032 } 22033 } 22034 return 1; 22035} 22036 22037/* Hook called after emitting a function into assembly. 22038 This does something only for the very first function emitted. */ 22039 22040static void 22041dwarf2out_end_function (unsigned int) 22042{ 22043 if (in_first_function_p 22044 && !have_multiple_function_sections 22045 && first_loclabel_num_not_at_text_label 22046 && decl_loc_table) 22047 decl_loc_table->traverse<int, find_empty_loc_ranges_at_text_label> (0); 22048 in_first_function_p = false; 22049 maybe_at_text_label_p = false; 22050} 22051 22052/* Temporary holder for dwarf2out_register_main_translation_unit. Used to let 22053 front-ends register a translation unit even before dwarf2out_init is 22054 called. */ 22055static tree main_translation_unit = NULL_TREE; 22056 22057/* Hook called by front-ends after they built their main translation unit. 22058 Associate comp_unit_die to UNIT. */ 22059 22060static void 22061dwarf2out_register_main_translation_unit (tree unit) 22062{ 22063 gcc_assert (TREE_CODE (unit) == TRANSLATION_UNIT_DECL 22064 && main_translation_unit == NULL_TREE); 22065 main_translation_unit = unit; 22066 /* If dwarf2out_init has not been called yet, it will perform the association 22067 itself looking at main_translation_unit. */ 22068 if (decl_die_table != NULL) 22069 equate_decl_number_to_die (unit, comp_unit_die ()); 22070} 22071 22072/* Add OPCODE+VAL as an entry at the end of the opcode array in TABLE. */ 22073 22074static void 22075push_dw_line_info_entry (dw_line_info_table *table, 22076 enum dw_line_info_opcode opcode, unsigned int val) 22077{ 22078 dw_line_info_entry e; 22079 e.opcode = opcode; 22080 e.val = val; 22081 vec_safe_push (table->entries, e); 22082} 22083 22084/* Output a label to mark the beginning of a source code line entry 22085 and record information relating to this source line, in 22086 'line_info_table' for later output of the .debug_line section. */ 22087/* ??? The discriminator parameter ought to be unsigned. */ 22088 22089static void 22090dwarf2out_source_line (unsigned int line, const char *filename, 22091 int discriminator, bool is_stmt) 22092{ 22093 unsigned int file_num; 22094 dw_line_info_table *table; 22095 22096 if (debug_info_level < DINFO_LEVEL_TERSE || line == 0) 22097 return; 22098 22099 /* The discriminator column was added in dwarf4. Simplify the below 22100 by simply removing it if we're not supposed to output it. */ 22101 if (dwarf_version < 4 && dwarf_strict) 22102 discriminator = 0; 22103 22104 table = cur_line_info_table; 22105 file_num = maybe_emit_file (lookup_filename (filename)); 22106 22107 /* ??? TODO: Elide duplicate line number entries. Traditionally, 22108 the debugger has used the second (possibly duplicate) line number 22109 at the beginning of the function to mark the end of the prologue. 22110 We could eliminate any other duplicates within the function. For 22111 Dwarf3, we ought to include the DW_LNS_set_prologue_end mark in 22112 that second line number entry. */ 22113 /* Recall that this end-of-prologue indication is *not* the same thing 22114 as the end_prologue debug hook. The NOTE_INSN_PROLOGUE_END note, 22115 to which the hook corresponds, follows the last insn that was 22116 emitted by gen_prologue. What we need is to precede the first insn 22117 that had been emitted after NOTE_INSN_FUNCTION_BEG, i.e. the first 22118 insn that corresponds to something the user wrote. These may be 22119 very different locations once scheduling is enabled. */ 22120 22121 if (0 && file_num == table->file_num 22122 && line == table->line_num 22123 && discriminator == table->discrim_num 22124 && is_stmt == table->is_stmt) 22125 return; 22126 22127 switch_to_section (current_function_section ()); 22128 22129 /* If requested, emit something human-readable. */ 22130 if (flag_debug_asm) 22131 fprintf (asm_out_file, "\t%s %s:%d\n", ASM_COMMENT_START, filename, line); 22132 22133 if (DWARF2_ASM_LINE_DEBUG_INFO) 22134 { 22135 /* Emit the .loc directive understood by GNU as. */ 22136 /* "\t.loc %u %u 0 is_stmt %u discriminator %u", 22137 file_num, line, is_stmt, discriminator */ 22138 fputs ("\t.loc ", asm_out_file); 22139 fprint_ul (asm_out_file, file_num); 22140 putc (' ', asm_out_file); 22141 fprint_ul (asm_out_file, line); 22142 putc (' ', asm_out_file); 22143 putc ('0', asm_out_file); 22144 22145 if (is_stmt != table->is_stmt) 22146 { 22147 fputs (" is_stmt ", asm_out_file); 22148 putc (is_stmt ? '1' : '0', asm_out_file); 22149 } 22150 if (SUPPORTS_DISCRIMINATOR && discriminator != 0) 22151 { 22152 gcc_assert (discriminator > 0); 22153 fputs (" discriminator ", asm_out_file); 22154 fprint_ul (asm_out_file, (unsigned long) discriminator); 22155 } 22156 putc ('\n', asm_out_file); 22157 } 22158 else 22159 { 22160 unsigned int label_num = ++line_info_label_num; 22161 22162 targetm.asm_out.internal_label (asm_out_file, LINE_CODE_LABEL, label_num); 22163 22164 push_dw_line_info_entry (table, LI_set_address, label_num); 22165 if (file_num != table->file_num) 22166 push_dw_line_info_entry (table, LI_set_file, file_num); 22167 if (discriminator != table->discrim_num) 22168 push_dw_line_info_entry (table, LI_set_discriminator, discriminator); 22169 if (is_stmt != table->is_stmt) 22170 push_dw_line_info_entry (table, LI_negate_stmt, 0); 22171 push_dw_line_info_entry (table, LI_set_line, line); 22172 } 22173 22174 table->file_num = file_num; 22175 table->line_num = line; 22176 table->discrim_num = discriminator; 22177 table->is_stmt = is_stmt; 22178 table->in_use = true; 22179} 22180 22181/* Record the beginning of a new source file. */ 22182 22183static void 22184dwarf2out_start_source_file (unsigned int lineno, const char *filename) 22185{ 22186 if (flag_eliminate_dwarf2_dups) 22187 { 22188 /* Record the beginning of the file for break_out_includes. */ 22189 dw_die_ref bincl_die; 22190 22191 bincl_die = new_die (DW_TAG_GNU_BINCL, comp_unit_die (), NULL); 22192 add_AT_string (bincl_die, DW_AT_name, remap_debug_filename (filename)); 22193 } 22194 22195 if (debug_info_level >= DINFO_LEVEL_VERBOSE) 22196 { 22197 macinfo_entry e; 22198 e.code = DW_MACINFO_start_file; 22199 e.lineno = lineno; 22200 e.info = ggc_strdup (filename); 22201 vec_safe_push (macinfo_table, e); 22202 } 22203} 22204 22205/* Record the end of a source file. */ 22206 22207static void 22208dwarf2out_end_source_file (unsigned int lineno ATTRIBUTE_UNUSED) 22209{ 22210 if (flag_eliminate_dwarf2_dups) 22211 /* Record the end of the file for break_out_includes. */ 22212 new_die (DW_TAG_GNU_EINCL, comp_unit_die (), NULL); 22213 22214 if (debug_info_level >= DINFO_LEVEL_VERBOSE) 22215 { 22216 macinfo_entry e; 22217 e.code = DW_MACINFO_end_file; 22218 e.lineno = lineno; 22219 e.info = NULL; 22220 vec_safe_push (macinfo_table, e); 22221 } 22222} 22223 22224/* Called from debug_define in toplev.c. The `buffer' parameter contains 22225 the tail part of the directive line, i.e. the part which is past the 22226 initial whitespace, #, whitespace, directive-name, whitespace part. */ 22227 22228static void 22229dwarf2out_define (unsigned int lineno ATTRIBUTE_UNUSED, 22230 const char *buffer ATTRIBUTE_UNUSED) 22231{ 22232 if (debug_info_level >= DINFO_LEVEL_VERBOSE) 22233 { 22234 macinfo_entry e; 22235 /* Insert a dummy first entry to be able to optimize the whole 22236 predefined macro block using DW_MACRO_GNU_transparent_include. */ 22237 if (macinfo_table->is_empty () && lineno <= 1) 22238 { 22239 e.code = 0; 22240 e.lineno = 0; 22241 e.info = NULL; 22242 vec_safe_push (macinfo_table, e); 22243 } 22244 e.code = DW_MACINFO_define; 22245 e.lineno = lineno; 22246 e.info = ggc_strdup (buffer); 22247 vec_safe_push (macinfo_table, e); 22248 } 22249} 22250 22251/* Called from debug_undef in toplev.c. The `buffer' parameter contains 22252 the tail part of the directive line, i.e. the part which is past the 22253 initial whitespace, #, whitespace, directive-name, whitespace part. */ 22254 22255static void 22256dwarf2out_undef (unsigned int lineno ATTRIBUTE_UNUSED, 22257 const char *buffer ATTRIBUTE_UNUSED) 22258{ 22259 if (debug_info_level >= DINFO_LEVEL_VERBOSE) 22260 { 22261 macinfo_entry e; 22262 /* Insert a dummy first entry to be able to optimize the whole 22263 predefined macro block using DW_MACRO_GNU_transparent_include. */ 22264 if (macinfo_table->is_empty () && lineno <= 1) 22265 { 22266 e.code = 0; 22267 e.lineno = 0; 22268 e.info = NULL; 22269 vec_safe_push (macinfo_table, e); 22270 } 22271 e.code = DW_MACINFO_undef; 22272 e.lineno = lineno; 22273 e.info = ggc_strdup (buffer); 22274 vec_safe_push (macinfo_table, e); 22275 } 22276} 22277 22278/* Helpers to manipulate hash table of CUs. */ 22279 22280struct macinfo_entry_hasher : typed_noop_remove <macinfo_entry> 22281{ 22282 typedef macinfo_entry value_type; 22283 typedef macinfo_entry compare_type; 22284 static inline hashval_t hash (const value_type *); 22285 static inline bool equal (const value_type *, const compare_type *); 22286}; 22287 22288inline hashval_t 22289macinfo_entry_hasher::hash (const value_type *entry) 22290{ 22291 return htab_hash_string (entry->info); 22292} 22293 22294inline bool 22295macinfo_entry_hasher::equal (const value_type *entry1, 22296 const compare_type *entry2) 22297{ 22298 return !strcmp (entry1->info, entry2->info); 22299} 22300 22301typedef hash_table<macinfo_entry_hasher> macinfo_hash_type; 22302 22303/* Output a single .debug_macinfo entry. */ 22304 22305static void 22306output_macinfo_op (macinfo_entry *ref) 22307{ 22308 int file_num; 22309 size_t len; 22310 struct indirect_string_node *node; 22311 char label[MAX_ARTIFICIAL_LABEL_BYTES]; 22312 struct dwarf_file_data *fd; 22313 22314 switch (ref->code) 22315 { 22316 case DW_MACINFO_start_file: 22317 fd = lookup_filename (ref->info); 22318 file_num = maybe_emit_file (fd); 22319 dw2_asm_output_data (1, DW_MACINFO_start_file, "Start new file"); 22320 dw2_asm_output_data_uleb128 (ref->lineno, 22321 "Included from line number %lu", 22322 (unsigned long) ref->lineno); 22323 dw2_asm_output_data_uleb128 (file_num, "file %s", ref->info); 22324 break; 22325 case DW_MACINFO_end_file: 22326 dw2_asm_output_data (1, DW_MACINFO_end_file, "End file"); 22327 break; 22328 case DW_MACINFO_define: 22329 case DW_MACINFO_undef: 22330 len = strlen (ref->info) + 1; 22331 if (!dwarf_strict 22332 && len > DWARF_OFFSET_SIZE 22333 && !DWARF2_INDIRECT_STRING_SUPPORT_MISSING_ON_TARGET 22334 && (debug_str_section->common.flags & SECTION_MERGE) != 0) 22335 { 22336 ref->code = ref->code == DW_MACINFO_define 22337 ? DW_MACRO_GNU_define_indirect 22338 : DW_MACRO_GNU_undef_indirect; 22339 output_macinfo_op (ref); 22340 return; 22341 } 22342 dw2_asm_output_data (1, ref->code, 22343 ref->code == DW_MACINFO_define 22344 ? "Define macro" : "Undefine macro"); 22345 dw2_asm_output_data_uleb128 (ref->lineno, "At line number %lu", 22346 (unsigned long) ref->lineno); 22347 dw2_asm_output_nstring (ref->info, -1, "The macro"); 22348 break; 22349 case DW_MACRO_GNU_define_indirect: 22350 case DW_MACRO_GNU_undef_indirect: 22351 node = find_AT_string (ref->info); 22352 gcc_assert (node 22353 && ((node->form == DW_FORM_strp) 22354 || (node->form == DW_FORM_GNU_str_index))); 22355 dw2_asm_output_data (1, ref->code, 22356 ref->code == DW_MACRO_GNU_define_indirect 22357 ? "Define macro indirect" 22358 : "Undefine macro indirect"); 22359 dw2_asm_output_data_uleb128 (ref->lineno, "At line number %lu", 22360 (unsigned long) ref->lineno); 22361 if (node->form == DW_FORM_strp) 22362 dw2_asm_output_offset (DWARF_OFFSET_SIZE, node->label, 22363 debug_str_section, "The macro: \"%s\"", 22364 ref->info); 22365 else 22366 dw2_asm_output_data_uleb128 (node->index, "The macro: \"%s\"", 22367 ref->info); 22368 break; 22369 case DW_MACRO_GNU_transparent_include: 22370 dw2_asm_output_data (1, ref->code, "Transparent include"); 22371 ASM_GENERATE_INTERNAL_LABEL (label, 22372 DEBUG_MACRO_SECTION_LABEL, ref->lineno); 22373 dw2_asm_output_offset (DWARF_OFFSET_SIZE, label, NULL, NULL); 22374 break; 22375 default: 22376 fprintf (asm_out_file, "%s unrecognized macinfo code %lu\n", 22377 ASM_COMMENT_START, (unsigned long) ref->code); 22378 break; 22379 } 22380} 22381 22382/* Attempt to make a sequence of define/undef macinfo ops shareable with 22383 other compilation unit .debug_macinfo sections. IDX is the first 22384 index of a define/undef, return the number of ops that should be 22385 emitted in a comdat .debug_macinfo section and emit 22386 a DW_MACRO_GNU_transparent_include entry referencing it. 22387 If the define/undef entry should be emitted normally, return 0. */ 22388 22389static unsigned 22390optimize_macinfo_range (unsigned int idx, vec<macinfo_entry, va_gc> *files, 22391 macinfo_hash_type **macinfo_htab) 22392{ 22393 macinfo_entry *first, *second, *cur, *inc; 22394 char linebuf[sizeof (HOST_WIDE_INT) * 3 + 1]; 22395 unsigned char checksum[16]; 22396 struct md5_ctx ctx; 22397 char *grp_name, *tail; 22398 const char *base; 22399 unsigned int i, count, encoded_filename_len, linebuf_len; 22400 macinfo_entry **slot; 22401 22402 first = &(*macinfo_table)[idx]; 22403 second = &(*macinfo_table)[idx + 1]; 22404 22405 /* Optimize only if there are at least two consecutive define/undef ops, 22406 and either all of them are before first DW_MACINFO_start_file 22407 with lineno {0,1} (i.e. predefined macro block), or all of them are 22408 in some included header file. */ 22409 if (second->code != DW_MACINFO_define && second->code != DW_MACINFO_undef) 22410 return 0; 22411 if (vec_safe_is_empty (files)) 22412 { 22413 if (first->lineno > 1 || second->lineno > 1) 22414 return 0; 22415 } 22416 else if (first->lineno == 0) 22417 return 0; 22418 22419 /* Find the last define/undef entry that can be grouped together 22420 with first and at the same time compute md5 checksum of their 22421 codes, linenumbers and strings. */ 22422 md5_init_ctx (&ctx); 22423 for (i = idx; macinfo_table->iterate (i, &cur); i++) 22424 if (cur->code != DW_MACINFO_define && cur->code != DW_MACINFO_undef) 22425 break; 22426 else if (vec_safe_is_empty (files) && cur->lineno > 1) 22427 break; 22428 else 22429 { 22430 unsigned char code = cur->code; 22431 md5_process_bytes (&code, 1, &ctx); 22432 checksum_uleb128 (cur->lineno, &ctx); 22433 md5_process_bytes (cur->info, strlen (cur->info) + 1, &ctx); 22434 } 22435 md5_finish_ctx (&ctx, checksum); 22436 count = i - idx; 22437 22438 /* From the containing include filename (if any) pick up just 22439 usable characters from its basename. */ 22440 if (vec_safe_is_empty (files)) 22441 base = ""; 22442 else 22443 base = lbasename (files->last ().info); 22444 for (encoded_filename_len = 0, i = 0; base[i]; i++) 22445 if (ISIDNUM (base[i]) || base[i] == '.') 22446 encoded_filename_len++; 22447 /* Count . at the end. */ 22448 if (encoded_filename_len) 22449 encoded_filename_len++; 22450 22451 sprintf (linebuf, HOST_WIDE_INT_PRINT_UNSIGNED, first->lineno); 22452 linebuf_len = strlen (linebuf); 22453 22454 /* The group name format is: wmN.[<encoded filename>.]<lineno>.<md5sum> */ 22455 grp_name = XALLOCAVEC (char, 4 + encoded_filename_len + linebuf_len + 1 22456 + 16 * 2 + 1); 22457 memcpy (grp_name, DWARF_OFFSET_SIZE == 4 ? "wm4." : "wm8.", 4); 22458 tail = grp_name + 4; 22459 if (encoded_filename_len) 22460 { 22461 for (i = 0; base[i]; i++) 22462 if (ISIDNUM (base[i]) || base[i] == '.') 22463 *tail++ = base[i]; 22464 *tail++ = '.'; 22465 } 22466 memcpy (tail, linebuf, linebuf_len); 22467 tail += linebuf_len; 22468 *tail++ = '.'; 22469 for (i = 0; i < 16; i++) 22470 sprintf (tail + i * 2, "%02x", checksum[i] & 0xff); 22471 22472 /* Construct a macinfo_entry for DW_MACRO_GNU_transparent_include 22473 in the empty vector entry before the first define/undef. */ 22474 inc = &(*macinfo_table)[idx - 1]; 22475 inc->code = DW_MACRO_GNU_transparent_include; 22476 inc->lineno = 0; 22477 inc->info = ggc_strdup (grp_name); 22478 if (!*macinfo_htab) 22479 *macinfo_htab = new macinfo_hash_type (10); 22480 /* Avoid emitting duplicates. */ 22481 slot = (*macinfo_htab)->find_slot (inc, INSERT); 22482 if (*slot != NULL) 22483 { 22484 inc->code = 0; 22485 inc->info = NULL; 22486 /* If such an entry has been used before, just emit 22487 a DW_MACRO_GNU_transparent_include op. */ 22488 inc = *slot; 22489 output_macinfo_op (inc); 22490 /* And clear all macinfo_entry in the range to avoid emitting them 22491 in the second pass. */ 22492 for (i = idx; macinfo_table->iterate (i, &cur) && i < idx + count; i++) 22493 { 22494 cur->code = 0; 22495 cur->info = NULL; 22496 } 22497 } 22498 else 22499 { 22500 *slot = inc; 22501 inc->lineno = (*macinfo_htab)->elements (); 22502 output_macinfo_op (inc); 22503 } 22504 return count; 22505} 22506 22507/* Save any strings needed by the macinfo table in the debug str 22508 table. All strings must be collected into the table by the time 22509 index_string is called. */ 22510 22511static void 22512save_macinfo_strings (void) 22513{ 22514 unsigned len; 22515 unsigned i; 22516 macinfo_entry *ref; 22517 22518 for (i = 0; macinfo_table && macinfo_table->iterate (i, &ref); i++) 22519 { 22520 switch (ref->code) 22521 { 22522 /* Match the logic in output_macinfo_op to decide on 22523 indirect strings. */ 22524 case DW_MACINFO_define: 22525 case DW_MACINFO_undef: 22526 len = strlen (ref->info) + 1; 22527 if (!dwarf_strict 22528 && len > DWARF_OFFSET_SIZE 22529 && !DWARF2_INDIRECT_STRING_SUPPORT_MISSING_ON_TARGET 22530 && (debug_str_section->common.flags & SECTION_MERGE) != 0) 22531 set_indirect_string (find_AT_string (ref->info)); 22532 break; 22533 case DW_MACRO_GNU_define_indirect: 22534 case DW_MACRO_GNU_undef_indirect: 22535 set_indirect_string (find_AT_string (ref->info)); 22536 break; 22537 default: 22538 break; 22539 } 22540 } 22541} 22542 22543/* Output macinfo section(s). */ 22544 22545static void 22546output_macinfo (void) 22547{ 22548 unsigned i; 22549 unsigned long length = vec_safe_length (macinfo_table); 22550 macinfo_entry *ref; 22551 vec<macinfo_entry, va_gc> *files = NULL; 22552 macinfo_hash_type *macinfo_htab = NULL; 22553 22554 if (! length) 22555 return; 22556 22557 /* output_macinfo* uses these interchangeably. */ 22558 gcc_assert ((int) DW_MACINFO_define == (int) DW_MACRO_GNU_define 22559 && (int) DW_MACINFO_undef == (int) DW_MACRO_GNU_undef 22560 && (int) DW_MACINFO_start_file == (int) DW_MACRO_GNU_start_file 22561 && (int) DW_MACINFO_end_file == (int) DW_MACRO_GNU_end_file); 22562 22563 /* For .debug_macro emit the section header. */ 22564 if (!dwarf_strict) 22565 { 22566 dw2_asm_output_data (2, 4, "DWARF macro version number"); 22567 if (DWARF_OFFSET_SIZE == 8) 22568 dw2_asm_output_data (1, 3, "Flags: 64-bit, lineptr present"); 22569 else 22570 dw2_asm_output_data (1, 2, "Flags: 32-bit, lineptr present"); 22571 dw2_asm_output_offset (DWARF_OFFSET_SIZE, 22572 (!dwarf_split_debug_info ? debug_line_section_label 22573 : debug_skeleton_line_section_label), 22574 debug_line_section, NULL); 22575 } 22576 22577 /* In the first loop, it emits the primary .debug_macinfo section 22578 and after each emitted op the macinfo_entry is cleared. 22579 If a longer range of define/undef ops can be optimized using 22580 DW_MACRO_GNU_transparent_include, the 22581 DW_MACRO_GNU_transparent_include op is emitted and kept in 22582 the vector before the first define/undef in the range and the 22583 whole range of define/undef ops is not emitted and kept. */ 22584 for (i = 0; macinfo_table->iterate (i, &ref); i++) 22585 { 22586 switch (ref->code) 22587 { 22588 case DW_MACINFO_start_file: 22589 vec_safe_push (files, *ref); 22590 break; 22591 case DW_MACINFO_end_file: 22592 if (!vec_safe_is_empty (files)) 22593 files->pop (); 22594 break; 22595 case DW_MACINFO_define: 22596 case DW_MACINFO_undef: 22597 if (!dwarf_strict 22598 && HAVE_COMDAT_GROUP 22599 && vec_safe_length (files) != 1 22600 && i > 0 22601 && i + 1 < length 22602 && (*macinfo_table)[i - 1].code == 0) 22603 { 22604 unsigned count = optimize_macinfo_range (i, files, &macinfo_htab); 22605 if (count) 22606 { 22607 i += count - 1; 22608 continue; 22609 } 22610 } 22611 break; 22612 case 0: 22613 /* A dummy entry may be inserted at the beginning to be able 22614 to optimize the whole block of predefined macros. */ 22615 if (i == 0) 22616 continue; 22617 default: 22618 break; 22619 } 22620 output_macinfo_op (ref); 22621 ref->info = NULL; 22622 ref->code = 0; 22623 } 22624 22625 if (!macinfo_htab) 22626 return; 22627 22628 delete macinfo_htab; 22629 macinfo_htab = NULL; 22630 22631 /* If any DW_MACRO_GNU_transparent_include were used, on those 22632 DW_MACRO_GNU_transparent_include entries terminate the 22633 current chain and switch to a new comdat .debug_macinfo 22634 section and emit the define/undef entries within it. */ 22635 for (i = 0; macinfo_table->iterate (i, &ref); i++) 22636 switch (ref->code) 22637 { 22638 case 0: 22639 continue; 22640 case DW_MACRO_GNU_transparent_include: 22641 { 22642 char label[MAX_ARTIFICIAL_LABEL_BYTES]; 22643 tree comdat_key = get_identifier (ref->info); 22644 /* Terminate the previous .debug_macinfo section. */ 22645 dw2_asm_output_data (1, 0, "End compilation unit"); 22646 targetm.asm_out.named_section (DEBUG_MACRO_SECTION, 22647 SECTION_DEBUG 22648 | SECTION_LINKONCE, 22649 comdat_key); 22650 ASM_GENERATE_INTERNAL_LABEL (label, 22651 DEBUG_MACRO_SECTION_LABEL, 22652 ref->lineno); 22653 ASM_OUTPUT_LABEL (asm_out_file, label); 22654 ref->code = 0; 22655 ref->info = NULL; 22656 dw2_asm_output_data (2, 4, "DWARF macro version number"); 22657 if (DWARF_OFFSET_SIZE == 8) 22658 dw2_asm_output_data (1, 1, "Flags: 64-bit"); 22659 else 22660 dw2_asm_output_data (1, 0, "Flags: 32-bit"); 22661 } 22662 break; 22663 case DW_MACINFO_define: 22664 case DW_MACINFO_undef: 22665 output_macinfo_op (ref); 22666 ref->code = 0; 22667 ref->info = NULL; 22668 break; 22669 default: 22670 gcc_unreachable (); 22671 } 22672} 22673 22674/* Set up for Dwarf output at the start of compilation. */ 22675 22676static void 22677dwarf2out_init (const char *filename ATTRIBUTE_UNUSED) 22678{ 22679 /* This option is currently broken, see (PR53118 and PR46102). */ 22680 if (flag_eliminate_dwarf2_dups 22681 && strstr (lang_hooks.name, "C++")) 22682 { 22683 warning (0, "-feliminate-dwarf2-dups is broken for C++, ignoring"); 22684 flag_eliminate_dwarf2_dups = 0; 22685 } 22686 22687 /* Allocate the file_table. */ 22688 file_table = hash_table<dwarf_file_hasher>::create_ggc (50); 22689 22690 /* Allocate the decl_die_table. */ 22691 decl_die_table = hash_table<decl_die_hasher>::create_ggc (10); 22692 22693 /* Allocate the decl_loc_table. */ 22694 decl_loc_table = hash_table<decl_loc_hasher>::create_ggc (10); 22695 22696 /* Allocate the cached_dw_loc_list_table. */ 22697 cached_dw_loc_list_table = hash_table<dw_loc_list_hasher>::create_ggc (10); 22698 22699 /* Allocate the initial hunk of the decl_scope_table. */ 22700 vec_alloc (decl_scope_table, 256); 22701 22702 /* Allocate the initial hunk of the abbrev_die_table. */ 22703 abbrev_die_table = ggc_cleared_vec_alloc<dw_die_ref> 22704 (ABBREV_DIE_TABLE_INCREMENT); 22705 abbrev_die_table_allocated = ABBREV_DIE_TABLE_INCREMENT; 22706 /* Zero-th entry is allocated, but unused. */ 22707 abbrev_die_table_in_use = 1; 22708 22709 /* Allocate the pubtypes and pubnames vectors. */ 22710 vec_alloc (pubname_table, 32); 22711 vec_alloc (pubtype_table, 32); 22712 22713 vec_alloc (incomplete_types, 64); 22714 22715 vec_alloc (used_rtx_array, 32); 22716 22717 if (!dwarf_split_debug_info) 22718 { 22719 debug_info_section = get_section (DEBUG_INFO_SECTION, 22720 SECTION_DEBUG, NULL); 22721 debug_abbrev_section = get_section (DEBUG_ABBREV_SECTION, 22722 SECTION_DEBUG, NULL); 22723 debug_loc_section = get_section (DEBUG_LOC_SECTION, 22724 SECTION_DEBUG, NULL); 22725 } 22726 else 22727 { 22728 debug_info_section = get_section (DEBUG_DWO_INFO_SECTION, 22729 SECTION_DEBUG | SECTION_EXCLUDE, NULL); 22730 debug_abbrev_section = get_section (DEBUG_DWO_ABBREV_SECTION, 22731 SECTION_DEBUG | SECTION_EXCLUDE, 22732 NULL); 22733 debug_addr_section = get_section (DEBUG_ADDR_SECTION, 22734 SECTION_DEBUG, NULL); 22735 debug_skeleton_info_section = get_section (DEBUG_INFO_SECTION, 22736 SECTION_DEBUG, NULL); 22737 debug_skeleton_abbrev_section = get_section (DEBUG_ABBREV_SECTION, 22738 SECTION_DEBUG, NULL); 22739 ASM_GENERATE_INTERNAL_LABEL (debug_skeleton_abbrev_section_label, 22740 DEBUG_SKELETON_ABBREV_SECTION_LABEL, 0); 22741 22742 /* Somewhat confusing detail: The skeleton_[abbrev|info] sections stay in 22743 the main .o, but the skeleton_line goes into the split off dwo. */ 22744 debug_skeleton_line_section 22745 = get_section (DEBUG_DWO_LINE_SECTION, 22746 SECTION_DEBUG | SECTION_EXCLUDE, NULL); 22747 ASM_GENERATE_INTERNAL_LABEL (debug_skeleton_line_section_label, 22748 DEBUG_SKELETON_LINE_SECTION_LABEL, 0); 22749 debug_str_offsets_section = get_section (DEBUG_STR_OFFSETS_SECTION, 22750 SECTION_DEBUG | SECTION_EXCLUDE, 22751 NULL); 22752 ASM_GENERATE_INTERNAL_LABEL (debug_skeleton_info_section_label, 22753 DEBUG_SKELETON_INFO_SECTION_LABEL, 0); 22754 debug_loc_section = get_section (DEBUG_DWO_LOC_SECTION, 22755 SECTION_DEBUG | SECTION_EXCLUDE, NULL); 22756 debug_str_dwo_section = get_section (DEBUG_STR_DWO_SECTION, 22757 DEBUG_STR_DWO_SECTION_FLAGS, NULL); 22758 } 22759 debug_aranges_section = get_section (DEBUG_ARANGES_SECTION, 22760 SECTION_DEBUG, NULL); 22761 debug_macinfo_section = get_section (dwarf_strict 22762 ? DEBUG_MACINFO_SECTION 22763 : DEBUG_MACRO_SECTION, 22764 DEBUG_MACRO_SECTION_FLAGS, NULL); 22765 debug_line_section = get_section (DEBUG_LINE_SECTION, 22766 SECTION_DEBUG, NULL); 22767 debug_pubnames_section = get_section (DEBUG_PUBNAMES_SECTION, 22768 SECTION_DEBUG, NULL); 22769 debug_pubtypes_section = get_section (DEBUG_PUBTYPES_SECTION, 22770 SECTION_DEBUG, NULL); 22771 debug_str_section = get_section (DEBUG_STR_SECTION, 22772 DEBUG_STR_SECTION_FLAGS, NULL); 22773 debug_ranges_section = get_section (DEBUG_RANGES_SECTION, 22774 SECTION_DEBUG, NULL); 22775 debug_frame_section = get_section (DEBUG_FRAME_SECTION, 22776 SECTION_DEBUG, NULL); 22777 22778 ASM_GENERATE_INTERNAL_LABEL (text_end_label, TEXT_END_LABEL, 0); 22779 ASM_GENERATE_INTERNAL_LABEL (abbrev_section_label, 22780 DEBUG_ABBREV_SECTION_LABEL, 0); 22781 ASM_GENERATE_INTERNAL_LABEL (text_section_label, TEXT_SECTION_LABEL, 0); 22782 ASM_GENERATE_INTERNAL_LABEL (cold_text_section_label, 22783 COLD_TEXT_SECTION_LABEL, 0); 22784 ASM_GENERATE_INTERNAL_LABEL (cold_end_label, COLD_END_LABEL, 0); 22785 22786 ASM_GENERATE_INTERNAL_LABEL (debug_info_section_label, 22787 DEBUG_INFO_SECTION_LABEL, 0); 22788 ASM_GENERATE_INTERNAL_LABEL (debug_line_section_label, 22789 DEBUG_LINE_SECTION_LABEL, 0); 22790 ASM_GENERATE_INTERNAL_LABEL (ranges_section_label, 22791 DEBUG_RANGES_SECTION_LABEL, 0); 22792 ASM_GENERATE_INTERNAL_LABEL (debug_addr_section_label, 22793 DEBUG_ADDR_SECTION_LABEL, 0); 22794 ASM_GENERATE_INTERNAL_LABEL (macinfo_section_label, 22795 dwarf_strict 22796 ? DEBUG_MACINFO_SECTION_LABEL 22797 : DEBUG_MACRO_SECTION_LABEL, 0); 22798 ASM_GENERATE_INTERNAL_LABEL (loc_section_label, DEBUG_LOC_SECTION_LABEL, 0); 22799 22800 if (debug_info_level >= DINFO_LEVEL_VERBOSE) 22801 vec_alloc (macinfo_table, 64); 22802 22803 switch_to_section (text_section); 22804 ASM_OUTPUT_LABEL (asm_out_file, text_section_label); 22805 22806 /* Make sure the line number table for .text always exists. */ 22807 text_section_line_info = new_line_info_table (); 22808 text_section_line_info->end_label = text_end_label; 22809 22810 /* If front-ends already registered a main translation unit but we were not 22811 ready to perform the association, do this now. */ 22812 if (main_translation_unit != NULL_TREE) 22813 equate_decl_number_to_die (main_translation_unit, comp_unit_die ()); 22814} 22815 22816/* Called before compile () starts outputtting functions, variables 22817 and toplevel asms into assembly. */ 22818 22819static void 22820dwarf2out_assembly_start (void) 22821{ 22822 if (HAVE_GAS_CFI_SECTIONS_DIRECTIVE 22823 && dwarf2out_do_cfi_asm () 22824 && (!(flag_unwind_tables || flag_exceptions) 22825 || targetm_common.except_unwind_info (&global_options) != UI_DWARF2)) 22826 fprintf (asm_out_file, "\t.cfi_sections\t.debug_frame\n"); 22827} 22828 22829/* A helper function for dwarf2out_finish called through 22830 htab_traverse. Assign a string its index. All strings must be 22831 collected into the table by the time index_string is called, 22832 because the indexing code relies on htab_traverse to traverse nodes 22833 in the same order for each run. */ 22834 22835int 22836index_string (indirect_string_node **h, unsigned int *index) 22837{ 22838 indirect_string_node *node = *h; 22839 22840 find_string_form (node); 22841 if (node->form == DW_FORM_GNU_str_index && node->refcount > 0) 22842 { 22843 gcc_assert (node->index == NO_INDEX_ASSIGNED); 22844 node->index = *index; 22845 *index += 1; 22846 } 22847 return 1; 22848} 22849 22850/* A helper function for output_indirect_strings called through 22851 htab_traverse. Output the offset to a string and update the 22852 current offset. */ 22853 22854int 22855output_index_string_offset (indirect_string_node **h, unsigned int *offset) 22856{ 22857 indirect_string_node *node = *h; 22858 22859 if (node->form == DW_FORM_GNU_str_index && node->refcount > 0) 22860 { 22861 /* Assert that this node has been assigned an index. */ 22862 gcc_assert (node->index != NO_INDEX_ASSIGNED 22863 && node->index != NOT_INDEXED); 22864 dw2_asm_output_data (DWARF_OFFSET_SIZE, *offset, 22865 "indexed string 0x%x: %s", node->index, node->str); 22866 *offset += strlen (node->str) + 1; 22867 } 22868 return 1; 22869} 22870 22871/* A helper function for dwarf2out_finish called through 22872 htab_traverse. Output the indexed string. */ 22873 22874int 22875output_index_string (indirect_string_node **h, unsigned int *cur_idx) 22876{ 22877 struct indirect_string_node *node = *h; 22878 22879 if (node->form == DW_FORM_GNU_str_index && node->refcount > 0) 22880 { 22881 /* Assert that the strings are output in the same order as their 22882 indexes were assigned. */ 22883 gcc_assert (*cur_idx == node->index); 22884 assemble_string (node->str, strlen (node->str) + 1); 22885 *cur_idx += 1; 22886 } 22887 return 1; 22888} 22889 22890/* A helper function for dwarf2out_finish called through 22891 htab_traverse. Emit one queued .debug_str string. */ 22892 22893int 22894output_indirect_string (indirect_string_node **h, void *) 22895{ 22896 struct indirect_string_node *node = *h; 22897 22898 node->form = find_string_form (node); 22899 if (node->form == DW_FORM_strp && node->refcount > 0) 22900 { 22901 ASM_OUTPUT_LABEL (asm_out_file, node->label); 22902 assemble_string (node->str, strlen (node->str) + 1); 22903 } 22904 22905 return 1; 22906} 22907 22908/* Output the indexed string table. */ 22909 22910static void 22911output_indirect_strings (void) 22912{ 22913 switch_to_section (debug_str_section); 22914 if (!dwarf_split_debug_info) 22915 debug_str_hash->traverse<void *, output_indirect_string> (NULL); 22916 else 22917 { 22918 unsigned int offset = 0; 22919 unsigned int cur_idx = 0; 22920 22921 skeleton_debug_str_hash->traverse<void *, output_indirect_string> (NULL); 22922 22923 switch_to_section (debug_str_offsets_section); 22924 debug_str_hash->traverse_noresize 22925 <unsigned int *, output_index_string_offset> (&offset); 22926 switch_to_section (debug_str_dwo_section); 22927 debug_str_hash->traverse_noresize<unsigned int *, output_index_string> 22928 (&cur_idx); 22929 } 22930} 22931 22932/* Callback for htab_traverse to assign an index to an entry in the 22933 table, and to write that entry to the .debug_addr section. */ 22934 22935int 22936output_addr_table_entry (addr_table_entry **slot, unsigned int *cur_index) 22937{ 22938 addr_table_entry *entry = *slot; 22939 22940 if (entry->refcount == 0) 22941 { 22942 gcc_assert (entry->index == NO_INDEX_ASSIGNED 22943 || entry->index == NOT_INDEXED); 22944 return 1; 22945 } 22946 22947 gcc_assert (entry->index == *cur_index); 22948 (*cur_index)++; 22949 22950 switch (entry->kind) 22951 { 22952 case ate_kind_rtx: 22953 dw2_asm_output_addr_rtx (DWARF2_ADDR_SIZE, entry->addr.rtl, 22954 "0x%x", entry->index); 22955 break; 22956 case ate_kind_rtx_dtprel: 22957 gcc_assert (targetm.asm_out.output_dwarf_dtprel); 22958 targetm.asm_out.output_dwarf_dtprel (asm_out_file, 22959 DWARF2_ADDR_SIZE, 22960 entry->addr.rtl); 22961 fputc ('\n', asm_out_file); 22962 break; 22963 case ate_kind_label: 22964 dw2_asm_output_addr (DWARF2_ADDR_SIZE, entry->addr.label, 22965 "0x%x", entry->index); 22966 break; 22967 default: 22968 gcc_unreachable (); 22969 } 22970 return 1; 22971} 22972 22973/* Produce the .debug_addr section. */ 22974 22975static void 22976output_addr_table (void) 22977{ 22978 unsigned int index = 0; 22979 if (addr_index_table == NULL || addr_index_table->size () == 0) 22980 return; 22981 22982 switch_to_section (debug_addr_section); 22983 addr_index_table 22984 ->traverse_noresize<unsigned int *, output_addr_table_entry> (&index); 22985} 22986 22987#if ENABLE_ASSERT_CHECKING 22988/* Verify that all marks are clear. */ 22989 22990static void 22991verify_marks_clear (dw_die_ref die) 22992{ 22993 dw_die_ref c; 22994 22995 gcc_assert (! die->die_mark); 22996 FOR_EACH_CHILD (die, c, verify_marks_clear (c)); 22997} 22998#endif /* ENABLE_ASSERT_CHECKING */ 22999 23000/* Clear the marks for a die and its children. 23001 Be cool if the mark isn't set. */ 23002 23003static void 23004prune_unmark_dies (dw_die_ref die) 23005{ 23006 dw_die_ref c; 23007 23008 if (die->die_mark) 23009 die->die_mark = 0; 23010 FOR_EACH_CHILD (die, c, prune_unmark_dies (c)); 23011} 23012 23013/* Given DIE that we're marking as used, find any other dies 23014 it references as attributes and mark them as used. */ 23015 23016static void 23017prune_unused_types_walk_attribs (dw_die_ref die) 23018{ 23019 dw_attr_ref a; 23020 unsigned ix; 23021 23022 FOR_EACH_VEC_SAFE_ELT (die->die_attr, ix, a) 23023 { 23024 if (a->dw_attr_val.val_class == dw_val_class_die_ref) 23025 { 23026 /* A reference to another DIE. 23027 Make sure that it will get emitted. 23028 If it was broken out into a comdat group, don't follow it. */ 23029 if (! AT_ref (a)->comdat_type_p 23030 || a->dw_attr == DW_AT_specification) 23031 prune_unused_types_mark (a->dw_attr_val.v.val_die_ref.die, 1); 23032 } 23033 /* Set the string's refcount to 0 so that prune_unused_types_mark 23034 accounts properly for it. */ 23035 if (AT_class (a) == dw_val_class_str) 23036 a->dw_attr_val.v.val_str->refcount = 0; 23037 } 23038} 23039 23040/* Mark the generic parameters and arguments children DIEs of DIE. */ 23041 23042static void 23043prune_unused_types_mark_generic_parms_dies (dw_die_ref die) 23044{ 23045 dw_die_ref c; 23046 23047 if (die == NULL || die->die_child == NULL) 23048 return; 23049 c = die->die_child; 23050 do 23051 { 23052 if (is_template_parameter (c)) 23053 prune_unused_types_mark (c, 1); 23054 c = c->die_sib; 23055 } while (c && c != die->die_child); 23056} 23057 23058/* Mark DIE as being used. If DOKIDS is true, then walk down 23059 to DIE's children. */ 23060 23061static void 23062prune_unused_types_mark (dw_die_ref die, int dokids) 23063{ 23064 dw_die_ref c; 23065 23066 if (die->die_mark == 0) 23067 { 23068 /* We haven't done this node yet. Mark it as used. */ 23069 die->die_mark = 1; 23070 /* If this is the DIE of a generic type instantiation, 23071 mark the children DIEs that describe its generic parms and 23072 args. */ 23073 prune_unused_types_mark_generic_parms_dies (die); 23074 23075 /* We also have to mark its parents as used. 23076 (But we don't want to mark our parent's kids due to this, 23077 unless it is a class.) */ 23078 if (die->die_parent) 23079 prune_unused_types_mark (die->die_parent, 23080 class_scope_p (die->die_parent)); 23081 23082 /* Mark any referenced nodes. */ 23083 prune_unused_types_walk_attribs (die); 23084 23085 /* If this node is a specification, 23086 also mark the definition, if it exists. */ 23087 if (get_AT_flag (die, DW_AT_declaration) && die->die_definition) 23088 prune_unused_types_mark (die->die_definition, 1); 23089 } 23090 23091 if (dokids && die->die_mark != 2) 23092 { 23093 /* We need to walk the children, but haven't done so yet. 23094 Remember that we've walked the kids. */ 23095 die->die_mark = 2; 23096 23097 /* If this is an array type, we need to make sure our 23098 kids get marked, even if they're types. If we're 23099 breaking out types into comdat sections, do this 23100 for all type definitions. */ 23101 if (die->die_tag == DW_TAG_array_type 23102 || (use_debug_types 23103 && is_type_die (die) && ! is_declaration_die (die))) 23104 FOR_EACH_CHILD (die, c, prune_unused_types_mark (c, 1)); 23105 else 23106 FOR_EACH_CHILD (die, c, prune_unused_types_walk (c)); 23107 } 23108} 23109 23110/* For local classes, look if any static member functions were emitted 23111 and if so, mark them. */ 23112 23113static void 23114prune_unused_types_walk_local_classes (dw_die_ref die) 23115{ 23116 dw_die_ref c; 23117 23118 if (die->die_mark == 2) 23119 return; 23120 23121 switch (die->die_tag) 23122 { 23123 case DW_TAG_structure_type: 23124 case DW_TAG_union_type: 23125 case DW_TAG_class_type: 23126 break; 23127 23128 case DW_TAG_subprogram: 23129 if (!get_AT_flag (die, DW_AT_declaration) 23130 || die->die_definition != NULL) 23131 prune_unused_types_mark (die, 1); 23132 return; 23133 23134 default: 23135 return; 23136 } 23137 23138 /* Mark children. */ 23139 FOR_EACH_CHILD (die, c, prune_unused_types_walk_local_classes (c)); 23140} 23141 23142/* Walk the tree DIE and mark types that we actually use. */ 23143 23144static void 23145prune_unused_types_walk (dw_die_ref die) 23146{ 23147 dw_die_ref c; 23148 23149 /* Don't do anything if this node is already marked and 23150 children have been marked as well. */ 23151 if (die->die_mark == 2) 23152 return; 23153 23154 switch (die->die_tag) 23155 { 23156 case DW_TAG_structure_type: 23157 case DW_TAG_union_type: 23158 case DW_TAG_class_type: 23159 if (die->die_perennial_p) 23160 break; 23161 23162 for (c = die->die_parent; c; c = c->die_parent) 23163 if (c->die_tag == DW_TAG_subprogram) 23164 break; 23165 23166 /* Finding used static member functions inside of classes 23167 is needed just for local classes, because for other classes 23168 static member function DIEs with DW_AT_specification 23169 are emitted outside of the DW_TAG_*_type. If we ever change 23170 it, we'd need to call this even for non-local classes. */ 23171 if (c) 23172 prune_unused_types_walk_local_classes (die); 23173 23174 /* It's a type node --- don't mark it. */ 23175 return; 23176 23177 case DW_TAG_const_type: 23178 case DW_TAG_packed_type: 23179 case DW_TAG_pointer_type: 23180 case DW_TAG_reference_type: 23181 case DW_TAG_rvalue_reference_type: 23182 case DW_TAG_volatile_type: 23183 case DW_TAG_typedef: 23184 case DW_TAG_array_type: 23185 case DW_TAG_interface_type: 23186 case DW_TAG_friend: 23187 case DW_TAG_variant_part: 23188 case DW_TAG_enumeration_type: 23189 case DW_TAG_subroutine_type: 23190 case DW_TAG_string_type: 23191 case DW_TAG_set_type: 23192 case DW_TAG_subrange_type: 23193 case DW_TAG_ptr_to_member_type: 23194 case DW_TAG_file_type: 23195 if (die->die_perennial_p) 23196 break; 23197 23198 /* It's a type node --- don't mark it. */ 23199 return; 23200 23201 default: 23202 /* Mark everything else. */ 23203 break; 23204 } 23205 23206 if (die->die_mark == 0) 23207 { 23208 die->die_mark = 1; 23209 23210 /* Now, mark any dies referenced from here. */ 23211 prune_unused_types_walk_attribs (die); 23212 } 23213 23214 die->die_mark = 2; 23215 23216 /* Mark children. */ 23217 FOR_EACH_CHILD (die, c, prune_unused_types_walk (c)); 23218} 23219 23220/* Increment the string counts on strings referred to from DIE's 23221 attributes. */ 23222 23223static void 23224prune_unused_types_update_strings (dw_die_ref die) 23225{ 23226 dw_attr_ref a; 23227 unsigned ix; 23228 23229 FOR_EACH_VEC_SAFE_ELT (die->die_attr, ix, a) 23230 if (AT_class (a) == dw_val_class_str) 23231 { 23232 struct indirect_string_node *s = a->dw_attr_val.v.val_str; 23233 s->refcount++; 23234 /* Avoid unnecessarily putting strings that are used less than 23235 twice in the hash table. */ 23236 if (s->refcount 23237 == ((DEBUG_STR_SECTION_FLAGS & SECTION_MERGE) ? 1 : 2)) 23238 { 23239 indirect_string_node **slot 23240 = debug_str_hash->find_slot_with_hash (s->str, 23241 htab_hash_string (s->str), 23242 INSERT); 23243 gcc_assert (*slot == NULL); 23244 *slot = s; 23245 } 23246 } 23247} 23248 23249/* Remove from the tree DIE any dies that aren't marked. */ 23250 23251static void 23252prune_unused_types_prune (dw_die_ref die) 23253{ 23254 dw_die_ref c; 23255 23256 gcc_assert (die->die_mark); 23257 prune_unused_types_update_strings (die); 23258 23259 if (! die->die_child) 23260 return; 23261 23262 c = die->die_child; 23263 do { 23264 dw_die_ref prev = c; 23265 for (c = c->die_sib; ! c->die_mark; c = c->die_sib) 23266 if (c == die->die_child) 23267 { 23268 /* No marked children between 'prev' and the end of the list. */ 23269 if (prev == c) 23270 /* No marked children at all. */ 23271 die->die_child = NULL; 23272 else 23273 { 23274 prev->die_sib = c->die_sib; 23275 die->die_child = prev; 23276 } 23277 return; 23278 } 23279 23280 if (c != prev->die_sib) 23281 prev->die_sib = c; 23282 prune_unused_types_prune (c); 23283 } while (c != die->die_child); 23284} 23285 23286/* Remove dies representing declarations that we never use. */ 23287 23288static void 23289prune_unused_types (void) 23290{ 23291 unsigned int i; 23292 limbo_die_node *node; 23293 comdat_type_node *ctnode; 23294 pubname_ref pub; 23295 dw_die_ref base_type; 23296 23297#if ENABLE_ASSERT_CHECKING 23298 /* All the marks should already be clear. */ 23299 verify_marks_clear (comp_unit_die ()); 23300 for (node = limbo_die_list; node; node = node->next) 23301 verify_marks_clear (node->die); 23302 for (ctnode = comdat_type_list; ctnode; ctnode = ctnode->next) 23303 verify_marks_clear (ctnode->root_die); 23304#endif /* ENABLE_ASSERT_CHECKING */ 23305 23306 /* Mark types that are used in global variables. */ 23307 premark_types_used_by_global_vars (); 23308 23309 /* Set the mark on nodes that are actually used. */ 23310 prune_unused_types_walk (comp_unit_die ()); 23311 for (node = limbo_die_list; node; node = node->next) 23312 prune_unused_types_walk (node->die); 23313 for (ctnode = comdat_type_list; ctnode; ctnode = ctnode->next) 23314 { 23315 prune_unused_types_walk (ctnode->root_die); 23316 prune_unused_types_mark (ctnode->type_die, 1); 23317 } 23318 23319 /* Also set the mark on nodes referenced from the pubname_table. Enumerators 23320 are unusual in that they are pubnames that are the children of pubtypes. 23321 They should only be marked via their parent DW_TAG_enumeration_type die, 23322 not as roots in themselves. */ 23323 FOR_EACH_VEC_ELT (*pubname_table, i, pub) 23324 if (pub->die->die_tag != DW_TAG_enumerator) 23325 prune_unused_types_mark (pub->die, 1); 23326 for (i = 0; base_types.iterate (i, &base_type); i++) 23327 prune_unused_types_mark (base_type, 1); 23328 23329 if (debug_str_hash) 23330 debug_str_hash->empty (); 23331 if (skeleton_debug_str_hash) 23332 skeleton_debug_str_hash->empty (); 23333 prune_unused_types_prune (comp_unit_die ()); 23334 for (node = limbo_die_list; node; node = node->next) 23335 prune_unused_types_prune (node->die); 23336 for (ctnode = comdat_type_list; ctnode; ctnode = ctnode->next) 23337 prune_unused_types_prune (ctnode->root_die); 23338 23339 /* Leave the marks clear. */ 23340 prune_unmark_dies (comp_unit_die ()); 23341 for (node = limbo_die_list; node; node = node->next) 23342 prune_unmark_dies (node->die); 23343 for (ctnode = comdat_type_list; ctnode; ctnode = ctnode->next) 23344 prune_unmark_dies (ctnode->root_die); 23345} 23346 23347/* Set the parameter to true if there are any relative pathnames in 23348 the file table. */ 23349int 23350file_table_relative_p (dwarf_file_data **slot, bool *p) 23351{ 23352 struct dwarf_file_data *d = *slot; 23353 if (!IS_ABSOLUTE_PATH (d->filename)) 23354 { 23355 *p = true; 23356 return 0; 23357 } 23358 return 1; 23359} 23360 23361/* Helpers to manipulate hash table of comdat type units. */ 23362 23363struct comdat_type_hasher : typed_noop_remove <comdat_type_node> 23364{ 23365 typedef comdat_type_node value_type; 23366 typedef comdat_type_node compare_type; 23367 static inline hashval_t hash (const value_type *); 23368 static inline bool equal (const value_type *, const compare_type *); 23369}; 23370 23371inline hashval_t 23372comdat_type_hasher::hash (const value_type *type_node) 23373{ 23374 hashval_t h; 23375 memcpy (&h, type_node->signature, sizeof (h)); 23376 return h; 23377} 23378 23379inline bool 23380comdat_type_hasher::equal (const value_type *type_node_1, 23381 const compare_type *type_node_2) 23382{ 23383 return (! memcmp (type_node_1->signature, type_node_2->signature, 23384 DWARF_TYPE_SIGNATURE_SIZE)); 23385} 23386 23387/* Move a DW_AT_{,MIPS_}linkage_name attribute just added to dw_die_ref 23388 to the location it would have been added, should we know its 23389 DECL_ASSEMBLER_NAME when we added other attributes. This will 23390 probably improve compactness of debug info, removing equivalent 23391 abbrevs, and hide any differences caused by deferring the 23392 computation of the assembler name, triggered by e.g. PCH. */ 23393 23394static inline void 23395move_linkage_attr (dw_die_ref die) 23396{ 23397 unsigned ix = vec_safe_length (die->die_attr); 23398 dw_attr_node linkage = (*die->die_attr)[ix - 1]; 23399 23400 gcc_assert (linkage.dw_attr == DW_AT_linkage_name 23401 || linkage.dw_attr == DW_AT_MIPS_linkage_name); 23402 23403 while (--ix > 0) 23404 { 23405 dw_attr_node *prev = &(*die->die_attr)[ix - 1]; 23406 23407 if (prev->dw_attr == DW_AT_decl_line || prev->dw_attr == DW_AT_name) 23408 break; 23409 } 23410 23411 if (ix != vec_safe_length (die->die_attr) - 1) 23412 { 23413 die->die_attr->pop (); 23414 die->die_attr->quick_insert (ix, linkage); 23415 } 23416} 23417 23418/* Helper function for resolve_addr, mark DW_TAG_base_type nodes 23419 referenced from typed stack ops and count how often they are used. */ 23420 23421static void 23422mark_base_types (dw_loc_descr_ref loc) 23423{ 23424 dw_die_ref base_type = NULL; 23425 23426 for (; loc; loc = loc->dw_loc_next) 23427 { 23428 switch (loc->dw_loc_opc) 23429 { 23430 case DW_OP_GNU_regval_type: 23431 case DW_OP_GNU_deref_type: 23432 base_type = loc->dw_loc_oprnd2.v.val_die_ref.die; 23433 break; 23434 case DW_OP_GNU_convert: 23435 case DW_OP_GNU_reinterpret: 23436 if (loc->dw_loc_oprnd1.val_class == dw_val_class_unsigned_const) 23437 continue; 23438 /* FALLTHRU */ 23439 case DW_OP_GNU_const_type: 23440 base_type = loc->dw_loc_oprnd1.v.val_die_ref.die; 23441 break; 23442 case DW_OP_GNU_entry_value: 23443 mark_base_types (loc->dw_loc_oprnd1.v.val_loc); 23444 continue; 23445 default: 23446 continue; 23447 } 23448 gcc_assert (base_type->die_parent == comp_unit_die ()); 23449 if (base_type->die_mark) 23450 base_type->die_mark++; 23451 else 23452 { 23453 base_types.safe_push (base_type); 23454 base_type->die_mark = 1; 23455 } 23456 } 23457} 23458 23459/* Comparison function for sorting marked base types. */ 23460 23461static int 23462base_type_cmp (const void *x, const void *y) 23463{ 23464 dw_die_ref dx = *(const dw_die_ref *) x; 23465 dw_die_ref dy = *(const dw_die_ref *) y; 23466 unsigned int byte_size1, byte_size2; 23467 unsigned int encoding1, encoding2; 23468 if (dx->die_mark > dy->die_mark) 23469 return -1; 23470 if (dx->die_mark < dy->die_mark) 23471 return 1; 23472 byte_size1 = get_AT_unsigned (dx, DW_AT_byte_size); 23473 byte_size2 = get_AT_unsigned (dy, DW_AT_byte_size); 23474 if (byte_size1 < byte_size2) 23475 return 1; 23476 if (byte_size1 > byte_size2) 23477 return -1; 23478 encoding1 = get_AT_unsigned (dx, DW_AT_encoding); 23479 encoding2 = get_AT_unsigned (dy, DW_AT_encoding); 23480 if (encoding1 < encoding2) 23481 return 1; 23482 if (encoding1 > encoding2) 23483 return -1; 23484 return 0; 23485} 23486 23487/* Move base types marked by mark_base_types as early as possible 23488 in the CU, sorted by decreasing usage count both to make the 23489 uleb128 references as small as possible and to make sure they 23490 will have die_offset already computed by calc_die_sizes when 23491 sizes of typed stack loc ops is computed. */ 23492 23493static void 23494move_marked_base_types (void) 23495{ 23496 unsigned int i; 23497 dw_die_ref base_type, die, c; 23498 23499 if (base_types.is_empty ()) 23500 return; 23501 23502 /* Sort by decreasing usage count, they will be added again in that 23503 order later on. */ 23504 base_types.qsort (base_type_cmp); 23505 die = comp_unit_die (); 23506 c = die->die_child; 23507 do 23508 { 23509 dw_die_ref prev = c; 23510 c = c->die_sib; 23511 while (c->die_mark) 23512 { 23513 remove_child_with_prev (c, prev); 23514 /* As base types got marked, there must be at least 23515 one node other than DW_TAG_base_type. */ 23516 gcc_assert (c != c->die_sib); 23517 c = c->die_sib; 23518 } 23519 } 23520 while (c != die->die_child); 23521 gcc_assert (die->die_child); 23522 c = die->die_child; 23523 for (i = 0; base_types.iterate (i, &base_type); i++) 23524 { 23525 base_type->die_mark = 0; 23526 base_type->die_sib = c->die_sib; 23527 c->die_sib = base_type; 23528 c = base_type; 23529 } 23530} 23531 23532/* Helper function for resolve_addr, attempt to resolve 23533 one CONST_STRING, return true if successful. Similarly verify that 23534 SYMBOL_REFs refer to variables emitted in the current CU. */ 23535 23536static bool 23537resolve_one_addr (rtx *addr) 23538{ 23539 rtx rtl = *addr; 23540 23541 if (GET_CODE (rtl) == CONST_STRING) 23542 { 23543 size_t len = strlen (XSTR (rtl, 0)) + 1; 23544 tree t = build_string (len, XSTR (rtl, 0)); 23545 tree tlen = size_int (len - 1); 23546 TREE_TYPE (t) 23547 = build_array_type (char_type_node, build_index_type (tlen)); 23548 rtl = lookup_constant_def (t); 23549 if (!rtl || !MEM_P (rtl)) 23550 return false; 23551 rtl = XEXP (rtl, 0); 23552 if (GET_CODE (rtl) == SYMBOL_REF 23553 && SYMBOL_REF_DECL (rtl) 23554 && !TREE_ASM_WRITTEN (SYMBOL_REF_DECL (rtl))) 23555 return false; 23556 vec_safe_push (used_rtx_array, rtl); 23557 *addr = rtl; 23558 return true; 23559 } 23560 23561 if (GET_CODE (rtl) == SYMBOL_REF 23562 && SYMBOL_REF_DECL (rtl)) 23563 { 23564 if (TREE_CONSTANT_POOL_ADDRESS_P (rtl)) 23565 { 23566 if (!TREE_ASM_WRITTEN (DECL_INITIAL (SYMBOL_REF_DECL (rtl)))) 23567 return false; 23568 } 23569 else if (!TREE_ASM_WRITTEN (SYMBOL_REF_DECL (rtl))) 23570 return false; 23571 } 23572 23573 if (GET_CODE (rtl) == CONST) 23574 { 23575 subrtx_ptr_iterator::array_type array; 23576 FOR_EACH_SUBRTX_PTR (iter, array, &XEXP (rtl, 0), ALL) 23577 if (!resolve_one_addr (*iter)) 23578 return false; 23579 } 23580 23581 return true; 23582} 23583 23584/* For STRING_CST, return SYMBOL_REF of its constant pool entry, 23585 if possible, and create DW_TAG_dwarf_procedure that can be referenced 23586 from DW_OP_GNU_implicit_pointer if the string hasn't been seen yet. */ 23587 23588static rtx 23589string_cst_pool_decl (tree t) 23590{ 23591 rtx rtl = output_constant_def (t, 1); 23592 unsigned char *array; 23593 dw_loc_descr_ref l; 23594 tree decl; 23595 size_t len; 23596 dw_die_ref ref; 23597 23598 if (!rtl || !MEM_P (rtl)) 23599 return NULL_RTX; 23600 rtl = XEXP (rtl, 0); 23601 if (GET_CODE (rtl) != SYMBOL_REF 23602 || SYMBOL_REF_DECL (rtl) == NULL_TREE) 23603 return NULL_RTX; 23604 23605 decl = SYMBOL_REF_DECL (rtl); 23606 if (!lookup_decl_die (decl)) 23607 { 23608 len = TREE_STRING_LENGTH (t); 23609 vec_safe_push (used_rtx_array, rtl); 23610 ref = new_die (DW_TAG_dwarf_procedure, comp_unit_die (), decl); 23611 array = ggc_vec_alloc<unsigned char> (len); 23612 memcpy (array, TREE_STRING_POINTER (t), len); 23613 l = new_loc_descr (DW_OP_implicit_value, len, 0); 23614 l->dw_loc_oprnd2.val_class = dw_val_class_vec; 23615 l->dw_loc_oprnd2.v.val_vec.length = len; 23616 l->dw_loc_oprnd2.v.val_vec.elt_size = 1; 23617 l->dw_loc_oprnd2.v.val_vec.array = array; 23618 add_AT_loc (ref, DW_AT_location, l); 23619 equate_decl_number_to_die (decl, ref); 23620 } 23621 return rtl; 23622} 23623 23624/* Helper function of resolve_addr_in_expr. LOC is 23625 a DW_OP_addr followed by DW_OP_stack_value, either at the start 23626 of exprloc or after DW_OP_{,bit_}piece, and val_addr can't be 23627 resolved. Replace it (both DW_OP_addr and DW_OP_stack_value) 23628 with DW_OP_GNU_implicit_pointer if possible 23629 and return true, if unsuccessful, return false. */ 23630 23631static bool 23632optimize_one_addr_into_implicit_ptr (dw_loc_descr_ref loc) 23633{ 23634 rtx rtl = loc->dw_loc_oprnd1.v.val_addr; 23635 HOST_WIDE_INT offset = 0; 23636 dw_die_ref ref = NULL; 23637 tree decl; 23638 23639 if (GET_CODE (rtl) == CONST 23640 && GET_CODE (XEXP (rtl, 0)) == PLUS 23641 && CONST_INT_P (XEXP (XEXP (rtl, 0), 1))) 23642 { 23643 offset = INTVAL (XEXP (XEXP (rtl, 0), 1)); 23644 rtl = XEXP (XEXP (rtl, 0), 0); 23645 } 23646 if (GET_CODE (rtl) == CONST_STRING) 23647 { 23648 size_t len = strlen (XSTR (rtl, 0)) + 1; 23649 tree t = build_string (len, XSTR (rtl, 0)); 23650 tree tlen = size_int (len - 1); 23651 23652 TREE_TYPE (t) 23653 = build_array_type (char_type_node, build_index_type (tlen)); 23654 rtl = string_cst_pool_decl (t); 23655 if (!rtl) 23656 return false; 23657 } 23658 if (GET_CODE (rtl) == SYMBOL_REF && SYMBOL_REF_DECL (rtl)) 23659 { 23660 decl = SYMBOL_REF_DECL (rtl); 23661 if (TREE_CODE (decl) == VAR_DECL && !DECL_EXTERNAL (decl)) 23662 { 23663 ref = lookup_decl_die (decl); 23664 if (ref && (get_AT (ref, DW_AT_location) 23665 || get_AT (ref, DW_AT_const_value))) 23666 { 23667 loc->dw_loc_opc = DW_OP_GNU_implicit_pointer; 23668 loc->dw_loc_oprnd1.val_class = dw_val_class_die_ref; 23669 loc->dw_loc_oprnd1.val_entry = NULL; 23670 loc->dw_loc_oprnd1.v.val_die_ref.die = ref; 23671 loc->dw_loc_oprnd1.v.val_die_ref.external = 0; 23672 loc->dw_loc_next = loc->dw_loc_next->dw_loc_next; 23673 loc->dw_loc_oprnd2.v.val_int = offset; 23674 return true; 23675 } 23676 } 23677 } 23678 return false; 23679} 23680 23681/* Helper function for resolve_addr, handle one location 23682 expression, return false if at least one CONST_STRING or SYMBOL_REF in 23683 the location list couldn't be resolved. */ 23684 23685static bool 23686resolve_addr_in_expr (dw_loc_descr_ref loc) 23687{ 23688 dw_loc_descr_ref keep = NULL; 23689 for (dw_loc_descr_ref prev = NULL; loc; prev = loc, loc = loc->dw_loc_next) 23690 switch (loc->dw_loc_opc) 23691 { 23692 case DW_OP_addr: 23693 if (!resolve_one_addr (&loc->dw_loc_oprnd1.v.val_addr)) 23694 { 23695 if ((prev == NULL 23696 || prev->dw_loc_opc == DW_OP_piece 23697 || prev->dw_loc_opc == DW_OP_bit_piece) 23698 && loc->dw_loc_next 23699 && loc->dw_loc_next->dw_loc_opc == DW_OP_stack_value 23700 && !dwarf_strict 23701 && optimize_one_addr_into_implicit_ptr (loc)) 23702 break; 23703 return false; 23704 } 23705 break; 23706 case DW_OP_GNU_addr_index: 23707 case DW_OP_GNU_const_index: 23708 if (loc->dw_loc_opc == DW_OP_GNU_addr_index 23709 || (loc->dw_loc_opc == DW_OP_GNU_const_index && loc->dtprel)) 23710 { 23711 rtx rtl = loc->dw_loc_oprnd1.val_entry->addr.rtl; 23712 if (!resolve_one_addr (&rtl)) 23713 return false; 23714 remove_addr_table_entry (loc->dw_loc_oprnd1.val_entry); 23715 loc->dw_loc_oprnd1.val_entry = 23716 add_addr_table_entry (rtl, ate_kind_rtx); 23717 } 23718 break; 23719 case DW_OP_const4u: 23720 case DW_OP_const8u: 23721 if (loc->dtprel 23722 && !resolve_one_addr (&loc->dw_loc_oprnd1.v.val_addr)) 23723 return false; 23724 break; 23725 case DW_OP_plus_uconst: 23726 if (size_of_loc_descr (loc) 23727 > size_of_int_loc_descriptor (loc->dw_loc_oprnd1.v.val_unsigned) 23728 + 1 23729 && loc->dw_loc_oprnd1.v.val_unsigned > 0) 23730 { 23731 dw_loc_descr_ref repl 23732 = int_loc_descriptor (loc->dw_loc_oprnd1.v.val_unsigned); 23733 add_loc_descr (&repl, new_loc_descr (DW_OP_plus, 0, 0)); 23734 add_loc_descr (&repl, loc->dw_loc_next); 23735 *loc = *repl; 23736 } 23737 break; 23738 case DW_OP_implicit_value: 23739 if (loc->dw_loc_oprnd2.val_class == dw_val_class_addr 23740 && !resolve_one_addr (&loc->dw_loc_oprnd2.v.val_addr)) 23741 return false; 23742 break; 23743 case DW_OP_GNU_implicit_pointer: 23744 case DW_OP_GNU_parameter_ref: 23745 if (loc->dw_loc_oprnd1.val_class == dw_val_class_decl_ref) 23746 { 23747 dw_die_ref ref 23748 = lookup_decl_die (loc->dw_loc_oprnd1.v.val_decl_ref); 23749 if (ref == NULL) 23750 return false; 23751 loc->dw_loc_oprnd1.val_class = dw_val_class_die_ref; 23752 loc->dw_loc_oprnd1.v.val_die_ref.die = ref; 23753 loc->dw_loc_oprnd1.v.val_die_ref.external = 0; 23754 } 23755 break; 23756 case DW_OP_GNU_const_type: 23757 case DW_OP_GNU_regval_type: 23758 case DW_OP_GNU_deref_type: 23759 case DW_OP_GNU_convert: 23760 case DW_OP_GNU_reinterpret: 23761 while (loc->dw_loc_next 23762 && loc->dw_loc_next->dw_loc_opc == DW_OP_GNU_convert) 23763 { 23764 dw_die_ref base1, base2; 23765 unsigned enc1, enc2, size1, size2; 23766 if (loc->dw_loc_opc == DW_OP_GNU_regval_type 23767 || loc->dw_loc_opc == DW_OP_GNU_deref_type) 23768 base1 = loc->dw_loc_oprnd2.v.val_die_ref.die; 23769 else if (loc->dw_loc_oprnd1.val_class 23770 == dw_val_class_unsigned_const) 23771 break; 23772 else 23773 base1 = loc->dw_loc_oprnd1.v.val_die_ref.die; 23774 if (loc->dw_loc_next->dw_loc_oprnd1.val_class 23775 == dw_val_class_unsigned_const) 23776 break; 23777 base2 = loc->dw_loc_next->dw_loc_oprnd1.v.val_die_ref.die; 23778 gcc_assert (base1->die_tag == DW_TAG_base_type 23779 && base2->die_tag == DW_TAG_base_type); 23780 enc1 = get_AT_unsigned (base1, DW_AT_encoding); 23781 enc2 = get_AT_unsigned (base2, DW_AT_encoding); 23782 size1 = get_AT_unsigned (base1, DW_AT_byte_size); 23783 size2 = get_AT_unsigned (base2, DW_AT_byte_size); 23784 if (size1 == size2 23785 && (((enc1 == DW_ATE_unsigned || enc1 == DW_ATE_signed) 23786 && (enc2 == DW_ATE_unsigned || enc2 == DW_ATE_signed) 23787 && loc != keep) 23788 || enc1 == enc2)) 23789 { 23790 /* Optimize away next DW_OP_GNU_convert after 23791 adjusting LOC's base type die reference. */ 23792 if (loc->dw_loc_opc == DW_OP_GNU_regval_type 23793 || loc->dw_loc_opc == DW_OP_GNU_deref_type) 23794 loc->dw_loc_oprnd2.v.val_die_ref.die = base2; 23795 else 23796 loc->dw_loc_oprnd1.v.val_die_ref.die = base2; 23797 loc->dw_loc_next = loc->dw_loc_next->dw_loc_next; 23798 continue; 23799 } 23800 /* Don't change integer DW_OP_GNU_convert after e.g. floating 23801 point typed stack entry. */ 23802 else if (enc1 != DW_ATE_unsigned && enc1 != DW_ATE_signed) 23803 keep = loc->dw_loc_next; 23804 break; 23805 } 23806 break; 23807 default: 23808 break; 23809 } 23810 return true; 23811} 23812 23813/* Helper function of resolve_addr. DIE had DW_AT_location of 23814 DW_OP_addr alone, which referred to DECL in DW_OP_addr's operand 23815 and DW_OP_addr couldn't be resolved. resolve_addr has already 23816 removed the DW_AT_location attribute. This function attempts to 23817 add a new DW_AT_location attribute with DW_OP_GNU_implicit_pointer 23818 to it or DW_AT_const_value attribute, if possible. */ 23819 23820static void 23821optimize_location_into_implicit_ptr (dw_die_ref die, tree decl) 23822{ 23823 if (TREE_CODE (decl) != VAR_DECL 23824 || lookup_decl_die (decl) != die 23825 || DECL_EXTERNAL (decl) 23826 || !TREE_STATIC (decl) 23827 || DECL_INITIAL (decl) == NULL_TREE 23828 || DECL_P (DECL_INITIAL (decl)) 23829 || get_AT (die, DW_AT_const_value)) 23830 return; 23831 23832 tree init = DECL_INITIAL (decl); 23833 HOST_WIDE_INT offset = 0; 23834 /* For variables that have been optimized away and thus 23835 don't have a memory location, see if we can emit 23836 DW_AT_const_value instead. */ 23837 if (tree_add_const_value_attribute (die, init)) 23838 return; 23839 if (dwarf_strict) 23840 return; 23841 /* If init is ADDR_EXPR or POINTER_PLUS_EXPR of ADDR_EXPR, 23842 and ADDR_EXPR refers to a decl that has DW_AT_location or 23843 DW_AT_const_value (but isn't addressable, otherwise 23844 resolving the original DW_OP_addr wouldn't fail), see if 23845 we can add DW_OP_GNU_implicit_pointer. */ 23846 STRIP_NOPS (init); 23847 if (TREE_CODE (init) == POINTER_PLUS_EXPR 23848 && tree_fits_shwi_p (TREE_OPERAND (init, 1))) 23849 { 23850 offset = tree_to_shwi (TREE_OPERAND (init, 1)); 23851 init = TREE_OPERAND (init, 0); 23852 STRIP_NOPS (init); 23853 } 23854 if (TREE_CODE (init) != ADDR_EXPR) 23855 return; 23856 if ((TREE_CODE (TREE_OPERAND (init, 0)) == STRING_CST 23857 && !TREE_ASM_WRITTEN (TREE_OPERAND (init, 0))) 23858 || (TREE_CODE (TREE_OPERAND (init, 0)) == VAR_DECL 23859 && !DECL_EXTERNAL (TREE_OPERAND (init, 0)) 23860 && TREE_OPERAND (init, 0) != decl)) 23861 { 23862 dw_die_ref ref; 23863 dw_loc_descr_ref l; 23864 23865 if (TREE_CODE (TREE_OPERAND (init, 0)) == STRING_CST) 23866 { 23867 rtx rtl = string_cst_pool_decl (TREE_OPERAND (init, 0)); 23868 if (!rtl) 23869 return; 23870 decl = SYMBOL_REF_DECL (rtl); 23871 } 23872 else 23873 decl = TREE_OPERAND (init, 0); 23874 ref = lookup_decl_die (decl); 23875 if (ref == NULL 23876 || (!get_AT (ref, DW_AT_location) 23877 && !get_AT (ref, DW_AT_const_value))) 23878 return; 23879 l = new_loc_descr (DW_OP_GNU_implicit_pointer, 0, offset); 23880 l->dw_loc_oprnd1.val_class = dw_val_class_die_ref; 23881 l->dw_loc_oprnd1.v.val_die_ref.die = ref; 23882 l->dw_loc_oprnd1.v.val_die_ref.external = 0; 23883 add_AT_loc (die, DW_AT_location, l); 23884 } 23885} 23886 23887/* Resolve DW_OP_addr and DW_AT_const_value CONST_STRING arguments to 23888 an address in .rodata section if the string literal is emitted there, 23889 or remove the containing location list or replace DW_AT_const_value 23890 with DW_AT_location and empty location expression, if it isn't found 23891 in .rodata. Similarly for SYMBOL_REFs, keep only those that refer 23892 to something that has been emitted in the current CU. */ 23893 23894static void 23895resolve_addr (dw_die_ref die) 23896{ 23897 dw_die_ref c; 23898 dw_attr_ref a; 23899 dw_loc_list_ref *curr, *start, loc; 23900 unsigned ix; 23901 23902 FOR_EACH_VEC_SAFE_ELT (die->die_attr, ix, a) 23903 switch (AT_class (a)) 23904 { 23905 case dw_val_class_loc_list: 23906 start = curr = AT_loc_list_ptr (a); 23907 loc = *curr; 23908 gcc_assert (loc); 23909 /* The same list can be referenced more than once. See if we have 23910 already recorded the result from a previous pass. */ 23911 if (loc->replaced) 23912 *curr = loc->dw_loc_next; 23913 else if (!loc->resolved_addr) 23914 { 23915 /* As things stand, we do not expect or allow one die to 23916 reference a suffix of another die's location list chain. 23917 References must be identical or completely separate. 23918 There is therefore no need to cache the result of this 23919 pass on any list other than the first; doing so 23920 would lead to unnecessary writes. */ 23921 while (*curr) 23922 { 23923 gcc_assert (!(*curr)->replaced && !(*curr)->resolved_addr); 23924 if (!resolve_addr_in_expr ((*curr)->expr)) 23925 { 23926 dw_loc_list_ref next = (*curr)->dw_loc_next; 23927 dw_loc_descr_ref l = (*curr)->expr; 23928 23929 if (next && (*curr)->ll_symbol) 23930 { 23931 gcc_assert (!next->ll_symbol); 23932 next->ll_symbol = (*curr)->ll_symbol; 23933 } 23934 if (dwarf_split_debug_info) 23935 remove_loc_list_addr_table_entries (l); 23936 *curr = next; 23937 } 23938 else 23939 { 23940 mark_base_types ((*curr)->expr); 23941 curr = &(*curr)->dw_loc_next; 23942 } 23943 } 23944 if (loc == *start) 23945 loc->resolved_addr = 1; 23946 else 23947 { 23948 loc->replaced = 1; 23949 loc->dw_loc_next = *start; 23950 } 23951 } 23952 if (!*start) 23953 { 23954 remove_AT (die, a->dw_attr); 23955 ix--; 23956 } 23957 break; 23958 case dw_val_class_loc: 23959 { 23960 dw_loc_descr_ref l = AT_loc (a); 23961 /* For -gdwarf-2 don't attempt to optimize 23962 DW_AT_data_member_location containing 23963 DW_OP_plus_uconst - older consumers might 23964 rely on it being that op instead of a more complex, 23965 but shorter, location description. */ 23966 if ((dwarf_version > 2 23967 || a->dw_attr != DW_AT_data_member_location 23968 || l == NULL 23969 || l->dw_loc_opc != DW_OP_plus_uconst 23970 || l->dw_loc_next != NULL) 23971 && !resolve_addr_in_expr (l)) 23972 { 23973 if (dwarf_split_debug_info) 23974 remove_loc_list_addr_table_entries (l); 23975 if (l != NULL 23976 && l->dw_loc_next == NULL 23977 && l->dw_loc_opc == DW_OP_addr 23978 && GET_CODE (l->dw_loc_oprnd1.v.val_addr) == SYMBOL_REF 23979 && SYMBOL_REF_DECL (l->dw_loc_oprnd1.v.val_addr) 23980 && a->dw_attr == DW_AT_location) 23981 { 23982 tree decl = SYMBOL_REF_DECL (l->dw_loc_oprnd1.v.val_addr); 23983 remove_AT (die, a->dw_attr); 23984 ix--; 23985 optimize_location_into_implicit_ptr (die, decl); 23986 break; 23987 } 23988 remove_AT (die, a->dw_attr); 23989 ix--; 23990 } 23991 else 23992 mark_base_types (l); 23993 } 23994 break; 23995 case dw_val_class_addr: 23996 if (a->dw_attr == DW_AT_const_value 23997 && !resolve_one_addr (&a->dw_attr_val.v.val_addr)) 23998 { 23999 if (AT_index (a) != NOT_INDEXED) 24000 remove_addr_table_entry (a->dw_attr_val.val_entry); 24001 remove_AT (die, a->dw_attr); 24002 ix--; 24003 } 24004 if (die->die_tag == DW_TAG_GNU_call_site 24005 && a->dw_attr == DW_AT_abstract_origin) 24006 { 24007 tree tdecl = SYMBOL_REF_DECL (a->dw_attr_val.v.val_addr); 24008 dw_die_ref tdie = lookup_decl_die (tdecl); 24009 dw_die_ref cdie; 24010 if (tdie == NULL 24011 && DECL_EXTERNAL (tdecl) 24012 && DECL_ABSTRACT_ORIGIN (tdecl) == NULL_TREE 24013 && (cdie = lookup_context_die (DECL_CONTEXT (tdecl)))) 24014 { 24015 /* Creating a full DIE for tdecl is overly expensive and 24016 at this point even wrong when in the LTO phase 24017 as it can end up generating new type DIEs we didn't 24018 output and thus optimize_external_refs will crash. */ 24019 tdie = new_die (DW_TAG_subprogram, cdie, NULL_TREE); 24020 add_AT_flag (tdie, DW_AT_external, 1); 24021 add_AT_flag (tdie, DW_AT_declaration, 1); 24022 add_linkage_attr (tdie, tdecl); 24023 add_name_and_src_coords_attributes (tdie, tdecl); 24024 equate_decl_number_to_die (tdecl, tdie); 24025 } 24026 if (tdie) 24027 { 24028 a->dw_attr_val.val_class = dw_val_class_die_ref; 24029 a->dw_attr_val.v.val_die_ref.die = tdie; 24030 a->dw_attr_val.v.val_die_ref.external = 0; 24031 } 24032 else 24033 { 24034 if (AT_index (a) != NOT_INDEXED) 24035 remove_addr_table_entry (a->dw_attr_val.val_entry); 24036 remove_AT (die, a->dw_attr); 24037 ix--; 24038 } 24039 } 24040 break; 24041 default: 24042 break; 24043 } 24044 24045 FOR_EACH_CHILD (die, c, resolve_addr (c)); 24046} 24047 24048/* Helper routines for optimize_location_lists. 24049 This pass tries to share identical local lists in .debug_loc 24050 section. */ 24051 24052/* Iteratively hash operands of LOC opcode into HSTATE. */ 24053 24054static void 24055hash_loc_operands (dw_loc_descr_ref loc, inchash::hash &hstate) 24056{ 24057 dw_val_ref val1 = &loc->dw_loc_oprnd1; 24058 dw_val_ref val2 = &loc->dw_loc_oprnd2; 24059 24060 switch (loc->dw_loc_opc) 24061 { 24062 case DW_OP_const4u: 24063 case DW_OP_const8u: 24064 if (loc->dtprel) 24065 goto hash_addr; 24066 /* FALLTHRU */ 24067 case DW_OP_const1u: 24068 case DW_OP_const1s: 24069 case DW_OP_const2u: 24070 case DW_OP_const2s: 24071 case DW_OP_const4s: 24072 case DW_OP_const8s: 24073 case DW_OP_constu: 24074 case DW_OP_consts: 24075 case DW_OP_pick: 24076 case DW_OP_plus_uconst: 24077 case DW_OP_breg0: 24078 case DW_OP_breg1: 24079 case DW_OP_breg2: 24080 case DW_OP_breg3: 24081 case DW_OP_breg4: 24082 case DW_OP_breg5: 24083 case DW_OP_breg6: 24084 case DW_OP_breg7: 24085 case DW_OP_breg8: 24086 case DW_OP_breg9: 24087 case DW_OP_breg10: 24088 case DW_OP_breg11: 24089 case DW_OP_breg12: 24090 case DW_OP_breg13: 24091 case DW_OP_breg14: 24092 case DW_OP_breg15: 24093 case DW_OP_breg16: 24094 case DW_OP_breg17: 24095 case DW_OP_breg18: 24096 case DW_OP_breg19: 24097 case DW_OP_breg20: 24098 case DW_OP_breg21: 24099 case DW_OP_breg22: 24100 case DW_OP_breg23: 24101 case DW_OP_breg24: 24102 case DW_OP_breg25: 24103 case DW_OP_breg26: 24104 case DW_OP_breg27: 24105 case DW_OP_breg28: 24106 case DW_OP_breg29: 24107 case DW_OP_breg30: 24108 case DW_OP_breg31: 24109 case DW_OP_regx: 24110 case DW_OP_fbreg: 24111 case DW_OP_piece: 24112 case DW_OP_deref_size: 24113 case DW_OP_xderef_size: 24114 hstate.add_object (val1->v.val_int); 24115 break; 24116 case DW_OP_skip: 24117 case DW_OP_bra: 24118 { 24119 int offset; 24120 24121 gcc_assert (val1->val_class == dw_val_class_loc); 24122 offset = val1->v.val_loc->dw_loc_addr - (loc->dw_loc_addr + 3); 24123 hstate.add_object (offset); 24124 } 24125 break; 24126 case DW_OP_implicit_value: 24127 hstate.add_object (val1->v.val_unsigned); 24128 switch (val2->val_class) 24129 { 24130 case dw_val_class_const: 24131 hstate.add_object (val2->v.val_int); 24132 break; 24133 case dw_val_class_vec: 24134 { 24135 unsigned int elt_size = val2->v.val_vec.elt_size; 24136 unsigned int len = val2->v.val_vec.length; 24137 24138 hstate.add_int (elt_size); 24139 hstate.add_int (len); 24140 hstate.add (val2->v.val_vec.array, len * elt_size); 24141 } 24142 break; 24143 case dw_val_class_const_double: 24144 hstate.add_object (val2->v.val_double.low); 24145 hstate.add_object (val2->v.val_double.high); 24146 break; 24147 case dw_val_class_wide_int: 24148 hstate.add (val2->v.val_wide->get_val (), 24149 get_full_len (*val2->v.val_wide) 24150 * HOST_BITS_PER_WIDE_INT / HOST_BITS_PER_CHAR); 24151 break; 24152 case dw_val_class_addr: 24153 inchash::add_rtx (val2->v.val_addr, hstate); 24154 break; 24155 default: 24156 gcc_unreachable (); 24157 } 24158 break; 24159 case DW_OP_bregx: 24160 case DW_OP_bit_piece: 24161 hstate.add_object (val1->v.val_int); 24162 hstate.add_object (val2->v.val_int); 24163 break; 24164 case DW_OP_addr: 24165 hash_addr: 24166 if (loc->dtprel) 24167 { 24168 unsigned char dtprel = 0xd1; 24169 hstate.add_object (dtprel); 24170 } 24171 inchash::add_rtx (val1->v.val_addr, hstate); 24172 break; 24173 case DW_OP_GNU_addr_index: 24174 case DW_OP_GNU_const_index: 24175 { 24176 if (loc->dtprel) 24177 { 24178 unsigned char dtprel = 0xd1; 24179 hstate.add_object (dtprel); 24180 } 24181 inchash::add_rtx (val1->val_entry->addr.rtl, hstate); 24182 } 24183 break; 24184 case DW_OP_GNU_implicit_pointer: 24185 hstate.add_int (val2->v.val_int); 24186 break; 24187 case DW_OP_GNU_entry_value: 24188 hstate.add_object (val1->v.val_loc); 24189 break; 24190 case DW_OP_GNU_regval_type: 24191 case DW_OP_GNU_deref_type: 24192 { 24193 unsigned int byte_size 24194 = get_AT_unsigned (val2->v.val_die_ref.die, DW_AT_byte_size); 24195 unsigned int encoding 24196 = get_AT_unsigned (val2->v.val_die_ref.die, DW_AT_encoding); 24197 hstate.add_object (val1->v.val_int); 24198 hstate.add_object (byte_size); 24199 hstate.add_object (encoding); 24200 } 24201 break; 24202 case DW_OP_GNU_convert: 24203 case DW_OP_GNU_reinterpret: 24204 if (val1->val_class == dw_val_class_unsigned_const) 24205 { 24206 hstate.add_object (val1->v.val_unsigned); 24207 break; 24208 } 24209 /* FALLTHRU */ 24210 case DW_OP_GNU_const_type: 24211 { 24212 unsigned int byte_size 24213 = get_AT_unsigned (val1->v.val_die_ref.die, DW_AT_byte_size); 24214 unsigned int encoding 24215 = get_AT_unsigned (val1->v.val_die_ref.die, DW_AT_encoding); 24216 hstate.add_object (byte_size); 24217 hstate.add_object (encoding); 24218 if (loc->dw_loc_opc != DW_OP_GNU_const_type) 24219 break; 24220 hstate.add_object (val2->val_class); 24221 switch (val2->val_class) 24222 { 24223 case dw_val_class_const: 24224 hstate.add_object (val2->v.val_int); 24225 break; 24226 case dw_val_class_vec: 24227 { 24228 unsigned int elt_size = val2->v.val_vec.elt_size; 24229 unsigned int len = val2->v.val_vec.length; 24230 24231 hstate.add_object (elt_size); 24232 hstate.add_object (len); 24233 hstate.add (val2->v.val_vec.array, len * elt_size); 24234 } 24235 break; 24236 case dw_val_class_const_double: 24237 hstate.add_object (val2->v.val_double.low); 24238 hstate.add_object (val2->v.val_double.high); 24239 break; 24240 case dw_val_class_wide_int: 24241 hstate.add (val2->v.val_wide->get_val (), 24242 get_full_len (*val2->v.val_wide) 24243 * HOST_BITS_PER_WIDE_INT / HOST_BITS_PER_CHAR); 24244 break; 24245 default: 24246 gcc_unreachable (); 24247 } 24248 } 24249 break; 24250 24251 default: 24252 /* Other codes have no operands. */ 24253 break; 24254 } 24255} 24256 24257/* Iteratively hash the whole DWARF location expression LOC into HSTATE. */ 24258 24259static inline void 24260hash_locs (dw_loc_descr_ref loc, inchash::hash &hstate) 24261{ 24262 dw_loc_descr_ref l; 24263 bool sizes_computed = false; 24264 /* Compute sizes, so that DW_OP_skip/DW_OP_bra can be checksummed. */ 24265 size_of_locs (loc); 24266 24267 for (l = loc; l != NULL; l = l->dw_loc_next) 24268 { 24269 enum dwarf_location_atom opc = l->dw_loc_opc; 24270 hstate.add_object (opc); 24271 if ((opc == DW_OP_skip || opc == DW_OP_bra) && !sizes_computed) 24272 { 24273 size_of_locs (loc); 24274 sizes_computed = true; 24275 } 24276 hash_loc_operands (l, hstate); 24277 } 24278} 24279 24280/* Compute hash of the whole location list LIST_HEAD. */ 24281 24282static inline void 24283hash_loc_list (dw_loc_list_ref list_head) 24284{ 24285 dw_loc_list_ref curr = list_head; 24286 inchash::hash hstate; 24287 24288 for (curr = list_head; curr != NULL; curr = curr->dw_loc_next) 24289 { 24290 hstate.add (curr->begin, strlen (curr->begin) + 1); 24291 hstate.add (curr->end, strlen (curr->end) + 1); 24292 if (curr->section) 24293 hstate.add (curr->section, strlen (curr->section) + 1); 24294 hash_locs (curr->expr, hstate); 24295 } 24296 list_head->hash = hstate.end (); 24297} 24298 24299/* Return true if X and Y opcodes have the same operands. */ 24300 24301static inline bool 24302compare_loc_operands (dw_loc_descr_ref x, dw_loc_descr_ref y) 24303{ 24304 dw_val_ref valx1 = &x->dw_loc_oprnd1; 24305 dw_val_ref valx2 = &x->dw_loc_oprnd2; 24306 dw_val_ref valy1 = &y->dw_loc_oprnd1; 24307 dw_val_ref valy2 = &y->dw_loc_oprnd2; 24308 24309 switch (x->dw_loc_opc) 24310 { 24311 case DW_OP_const4u: 24312 case DW_OP_const8u: 24313 if (x->dtprel) 24314 goto hash_addr; 24315 /* FALLTHRU */ 24316 case DW_OP_const1u: 24317 case DW_OP_const1s: 24318 case DW_OP_const2u: 24319 case DW_OP_const2s: 24320 case DW_OP_const4s: 24321 case DW_OP_const8s: 24322 case DW_OP_constu: 24323 case DW_OP_consts: 24324 case DW_OP_pick: 24325 case DW_OP_plus_uconst: 24326 case DW_OP_breg0: 24327 case DW_OP_breg1: 24328 case DW_OP_breg2: 24329 case DW_OP_breg3: 24330 case DW_OP_breg4: 24331 case DW_OP_breg5: 24332 case DW_OP_breg6: 24333 case DW_OP_breg7: 24334 case DW_OP_breg8: 24335 case DW_OP_breg9: 24336 case DW_OP_breg10: 24337 case DW_OP_breg11: 24338 case DW_OP_breg12: 24339 case DW_OP_breg13: 24340 case DW_OP_breg14: 24341 case DW_OP_breg15: 24342 case DW_OP_breg16: 24343 case DW_OP_breg17: 24344 case DW_OP_breg18: 24345 case DW_OP_breg19: 24346 case DW_OP_breg20: 24347 case DW_OP_breg21: 24348 case DW_OP_breg22: 24349 case DW_OP_breg23: 24350 case DW_OP_breg24: 24351 case DW_OP_breg25: 24352 case DW_OP_breg26: 24353 case DW_OP_breg27: 24354 case DW_OP_breg28: 24355 case DW_OP_breg29: 24356 case DW_OP_breg30: 24357 case DW_OP_breg31: 24358 case DW_OP_regx: 24359 case DW_OP_fbreg: 24360 case DW_OP_piece: 24361 case DW_OP_deref_size: 24362 case DW_OP_xderef_size: 24363 return valx1->v.val_int == valy1->v.val_int; 24364 case DW_OP_skip: 24365 case DW_OP_bra: 24366 /* If splitting debug info, the use of DW_OP_GNU_addr_index 24367 can cause irrelevant differences in dw_loc_addr. */ 24368 gcc_assert (valx1->val_class == dw_val_class_loc 24369 && valy1->val_class == dw_val_class_loc 24370 && (dwarf_split_debug_info 24371 || x->dw_loc_addr == y->dw_loc_addr)); 24372 return valx1->v.val_loc->dw_loc_addr == valy1->v.val_loc->dw_loc_addr; 24373 case DW_OP_implicit_value: 24374 if (valx1->v.val_unsigned != valy1->v.val_unsigned 24375 || valx2->val_class != valy2->val_class) 24376 return false; 24377 switch (valx2->val_class) 24378 { 24379 case dw_val_class_const: 24380 return valx2->v.val_int == valy2->v.val_int; 24381 case dw_val_class_vec: 24382 return valx2->v.val_vec.elt_size == valy2->v.val_vec.elt_size 24383 && valx2->v.val_vec.length == valy2->v.val_vec.length 24384 && memcmp (valx2->v.val_vec.array, valy2->v.val_vec.array, 24385 valx2->v.val_vec.elt_size 24386 * valx2->v.val_vec.length) == 0; 24387 case dw_val_class_const_double: 24388 return valx2->v.val_double.low == valy2->v.val_double.low 24389 && valx2->v.val_double.high == valy2->v.val_double.high; 24390 case dw_val_class_wide_int: 24391 return *valx2->v.val_wide == *valy2->v.val_wide; 24392 case dw_val_class_addr: 24393 return rtx_equal_p (valx2->v.val_addr, valy2->v.val_addr); 24394 default: 24395 gcc_unreachable (); 24396 } 24397 case DW_OP_bregx: 24398 case DW_OP_bit_piece: 24399 return valx1->v.val_int == valy1->v.val_int 24400 && valx2->v.val_int == valy2->v.val_int; 24401 case DW_OP_addr: 24402 hash_addr: 24403 return rtx_equal_p (valx1->v.val_addr, valy1->v.val_addr); 24404 case DW_OP_GNU_addr_index: 24405 case DW_OP_GNU_const_index: 24406 { 24407 rtx ax1 = valx1->val_entry->addr.rtl; 24408 rtx ay1 = valy1->val_entry->addr.rtl; 24409 return rtx_equal_p (ax1, ay1); 24410 } 24411 case DW_OP_GNU_implicit_pointer: 24412 return valx1->val_class == dw_val_class_die_ref 24413 && valx1->val_class == valy1->val_class 24414 && valx1->v.val_die_ref.die == valy1->v.val_die_ref.die 24415 && valx2->v.val_int == valy2->v.val_int; 24416 case DW_OP_GNU_entry_value: 24417 return compare_loc_operands (valx1->v.val_loc, valy1->v.val_loc); 24418 case DW_OP_GNU_const_type: 24419 if (valx1->v.val_die_ref.die != valy1->v.val_die_ref.die 24420 || valx2->val_class != valy2->val_class) 24421 return false; 24422 switch (valx2->val_class) 24423 { 24424 case dw_val_class_const: 24425 return valx2->v.val_int == valy2->v.val_int; 24426 case dw_val_class_vec: 24427 return valx2->v.val_vec.elt_size == valy2->v.val_vec.elt_size 24428 && valx2->v.val_vec.length == valy2->v.val_vec.length 24429 && memcmp (valx2->v.val_vec.array, valy2->v.val_vec.array, 24430 valx2->v.val_vec.elt_size 24431 * valx2->v.val_vec.length) == 0; 24432 case dw_val_class_const_double: 24433 return valx2->v.val_double.low == valy2->v.val_double.low 24434 && valx2->v.val_double.high == valy2->v.val_double.high; 24435 case dw_val_class_wide_int: 24436 return *valx2->v.val_wide == *valy2->v.val_wide; 24437 default: 24438 gcc_unreachable (); 24439 } 24440 case DW_OP_GNU_regval_type: 24441 case DW_OP_GNU_deref_type: 24442 return valx1->v.val_int == valy1->v.val_int 24443 && valx2->v.val_die_ref.die == valy2->v.val_die_ref.die; 24444 case DW_OP_GNU_convert: 24445 case DW_OP_GNU_reinterpret: 24446 if (valx1->val_class != valy1->val_class) 24447 return false; 24448 if (valx1->val_class == dw_val_class_unsigned_const) 24449 return valx1->v.val_unsigned == valy1->v.val_unsigned; 24450 return valx1->v.val_die_ref.die == valy1->v.val_die_ref.die; 24451 case DW_OP_GNU_parameter_ref: 24452 return valx1->val_class == dw_val_class_die_ref 24453 && valx1->val_class == valy1->val_class 24454 && valx1->v.val_die_ref.die == valy1->v.val_die_ref.die; 24455 default: 24456 /* Other codes have no operands. */ 24457 return true; 24458 } 24459} 24460 24461/* Return true if DWARF location expressions X and Y are the same. */ 24462 24463static inline bool 24464compare_locs (dw_loc_descr_ref x, dw_loc_descr_ref y) 24465{ 24466 for (; x != NULL && y != NULL; x = x->dw_loc_next, y = y->dw_loc_next) 24467 if (x->dw_loc_opc != y->dw_loc_opc 24468 || x->dtprel != y->dtprel 24469 || !compare_loc_operands (x, y)) 24470 break; 24471 return x == NULL && y == NULL; 24472} 24473 24474/* Hashtable helpers. */ 24475 24476struct loc_list_hasher : typed_noop_remove <dw_loc_list_struct> 24477{ 24478 typedef dw_loc_list_struct value_type; 24479 typedef dw_loc_list_struct compare_type; 24480 static inline hashval_t hash (const value_type *); 24481 static inline bool equal (const value_type *, const compare_type *); 24482}; 24483 24484/* Return precomputed hash of location list X. */ 24485 24486inline hashval_t 24487loc_list_hasher::hash (const value_type *x) 24488{ 24489 return x->hash; 24490} 24491 24492/* Return true if location lists A and B are the same. */ 24493 24494inline bool 24495loc_list_hasher::equal (const value_type *a, const compare_type *b) 24496{ 24497 if (a == b) 24498 return 1; 24499 if (a->hash != b->hash) 24500 return 0; 24501 for (; a != NULL && b != NULL; a = a->dw_loc_next, b = b->dw_loc_next) 24502 if (strcmp (a->begin, b->begin) != 0 24503 || strcmp (a->end, b->end) != 0 24504 || (a->section == NULL) != (b->section == NULL) 24505 || (a->section && strcmp (a->section, b->section) != 0) 24506 || !compare_locs (a->expr, b->expr)) 24507 break; 24508 return a == NULL && b == NULL; 24509} 24510 24511typedef hash_table<loc_list_hasher> loc_list_hash_type; 24512 24513 24514/* Recursively optimize location lists referenced from DIE 24515 children and share them whenever possible. */ 24516 24517static void 24518optimize_location_lists_1 (dw_die_ref die, loc_list_hash_type *htab) 24519{ 24520 dw_die_ref c; 24521 dw_attr_ref a; 24522 unsigned ix; 24523 dw_loc_list_struct **slot; 24524 24525 FOR_EACH_VEC_SAFE_ELT (die->die_attr, ix, a) 24526 if (AT_class (a) == dw_val_class_loc_list) 24527 { 24528 dw_loc_list_ref list = AT_loc_list (a); 24529 /* TODO: perform some optimizations here, before hashing 24530 it and storing into the hash table. */ 24531 hash_loc_list (list); 24532 slot = htab->find_slot_with_hash (list, list->hash, INSERT); 24533 if (*slot == NULL) 24534 *slot = list; 24535 else 24536 a->dw_attr_val.v.val_loc_list = *slot; 24537 } 24538 24539 FOR_EACH_CHILD (die, c, optimize_location_lists_1 (c, htab)); 24540} 24541 24542 24543/* Recursively assign each location list a unique index into the debug_addr 24544 section. */ 24545 24546static void 24547index_location_lists (dw_die_ref die) 24548{ 24549 dw_die_ref c; 24550 dw_attr_ref a; 24551 unsigned ix; 24552 24553 FOR_EACH_VEC_SAFE_ELT (die->die_attr, ix, a) 24554 if (AT_class (a) == dw_val_class_loc_list) 24555 { 24556 dw_loc_list_ref list = AT_loc_list (a); 24557 dw_loc_list_ref curr; 24558 for (curr = list; curr != NULL; curr = curr->dw_loc_next) 24559 { 24560 /* Don't index an entry that has already been indexed 24561 or won't be output. */ 24562 if (curr->begin_entry != NULL 24563 || (strcmp (curr->begin, curr->end) == 0 && !curr->force)) 24564 continue; 24565 24566 curr->begin_entry 24567 = add_addr_table_entry (xstrdup (curr->begin), 24568 ate_kind_label); 24569 } 24570 } 24571 24572 FOR_EACH_CHILD (die, c, index_location_lists (c)); 24573} 24574 24575/* Optimize location lists referenced from DIE 24576 children and share them whenever possible. */ 24577 24578static void 24579optimize_location_lists (dw_die_ref die) 24580{ 24581 loc_list_hash_type htab (500); 24582 optimize_location_lists_1 (die, &htab); 24583} 24584 24585/* Output stuff that dwarf requires at the end of every file, 24586 and generate the DWARF-2 debugging info. */ 24587 24588static void 24589dwarf2out_finish (const char *filename) 24590{ 24591 limbo_die_node *node, *next_node; 24592 comdat_type_node *ctnode; 24593 unsigned int i; 24594 dw_die_ref main_comp_unit_die; 24595 24596 /* PCH might result in DW_AT_producer string being restored from the 24597 header compilation, so always fill it with empty string initially 24598 and overwrite only here. */ 24599 dw_attr_ref producer = get_AT (comp_unit_die (), DW_AT_producer); 24600 producer_string = gen_producer_string (); 24601 producer->dw_attr_val.v.val_str->refcount--; 24602 producer->dw_attr_val.v.val_str = find_AT_string (producer_string); 24603 24604 gen_scheduled_generic_parms_dies (); 24605 gen_remaining_tmpl_value_param_die_attribute (); 24606 24607 /* Add the name for the main input file now. We delayed this from 24608 dwarf2out_init to avoid complications with PCH. 24609 For LTO produced units use a fixed artificial name to avoid 24610 leaking tempfile names into the dwarf. */ 24611 if (!in_lto_p) 24612 add_name_attribute (comp_unit_die (), remap_debug_filename (filename)); 24613 else 24614 add_name_attribute (comp_unit_die (), "<artificial>"); 24615 if (!IS_ABSOLUTE_PATH (filename) || targetm.force_at_comp_dir) 24616 add_comp_dir_attribute (comp_unit_die ()); 24617 else if (get_AT (comp_unit_die (), DW_AT_comp_dir) == NULL) 24618 { 24619 bool p = false; 24620 file_table->traverse<bool *, file_table_relative_p> (&p); 24621 if (p) 24622 add_comp_dir_attribute (comp_unit_die ()); 24623 } 24624 24625 if (deferred_locations_list) 24626 for (i = 0; i < deferred_locations_list->length (); i++) 24627 { 24628 add_location_or_const_value_attribute ( 24629 (*deferred_locations_list)[i].die, 24630 (*deferred_locations_list)[i].variable, 24631 false, 24632 DW_AT_location); 24633 } 24634 24635 /* Traverse the limbo die list, and add parent/child links. The only 24636 dies without parents that should be here are concrete instances of 24637 inline functions, and the comp_unit_die. We can ignore the comp_unit_die. 24638 For concrete instances, we can get the parent die from the abstract 24639 instance. */ 24640 for (node = limbo_die_list; node; node = next_node) 24641 { 24642 dw_die_ref die = node->die; 24643 next_node = node->next; 24644 24645 if (die->die_parent == NULL) 24646 { 24647 dw_die_ref origin = get_AT_ref (die, DW_AT_abstract_origin); 24648 24649 if (origin && origin->die_parent) 24650 add_child_die (origin->die_parent, die); 24651 else if (is_cu_die (die)) 24652 ; 24653 else if (seen_error ()) 24654 /* It's OK to be confused by errors in the input. */ 24655 add_child_die (comp_unit_die (), die); 24656 else 24657 { 24658 /* In certain situations, the lexical block containing a 24659 nested function can be optimized away, which results 24660 in the nested function die being orphaned. Likewise 24661 with the return type of that nested function. Force 24662 this to be a child of the containing function. 24663 24664 It may happen that even the containing function got fully 24665 inlined and optimized out. In that case we are lost and 24666 assign the empty child. This should not be big issue as 24667 the function is likely unreachable too. */ 24668 gcc_assert (node->created_for); 24669 24670 if (DECL_P (node->created_for)) 24671 origin = get_context_die (DECL_CONTEXT (node->created_for)); 24672 else if (TYPE_P (node->created_for)) 24673 origin = scope_die_for (node->created_for, comp_unit_die ()); 24674 else 24675 origin = comp_unit_die (); 24676 24677 add_child_die (origin, die); 24678 } 24679 } 24680 } 24681 24682 limbo_die_list = NULL; 24683 24684#if ENABLE_ASSERT_CHECKING 24685 { 24686 dw_die_ref die = comp_unit_die (), c; 24687 FOR_EACH_CHILD (die, c, gcc_assert (! c->die_mark)); 24688 } 24689#endif 24690 resolve_addr (comp_unit_die ()); 24691 move_marked_base_types (); 24692 24693 for (node = deferred_asm_name; node; node = node->next) 24694 { 24695 tree decl = node->created_for; 24696 /* When generating LTO bytecode we can not generate new assembler 24697 names at this point and all important decls got theirs via 24698 free-lang-data. */ 24699 if (((!flag_generate_lto && !flag_generate_offload) 24700 || DECL_ASSEMBLER_NAME_SET_P (decl)) 24701 && DECL_ASSEMBLER_NAME (decl) != DECL_NAME (decl)) 24702 { 24703 add_linkage_attr (node->die, decl); 24704 move_linkage_attr (node->die); 24705 } 24706 } 24707 24708 deferred_asm_name = NULL; 24709 24710 /* Walk through the list of incomplete types again, trying once more to 24711 emit full debugging info for them. */ 24712 retry_incomplete_types (); 24713 24714 if (flag_eliminate_unused_debug_types) 24715 prune_unused_types (); 24716 24717 /* Generate separate COMDAT sections for type DIEs. */ 24718 if (use_debug_types) 24719 { 24720 break_out_comdat_types (comp_unit_die ()); 24721 24722 /* Each new type_unit DIE was added to the limbo die list when created. 24723 Since these have all been added to comdat_type_list, clear the 24724 limbo die list. */ 24725 limbo_die_list = NULL; 24726 24727 /* For each new comdat type unit, copy declarations for incomplete 24728 types to make the new unit self-contained (i.e., no direct 24729 references to the main compile unit). */ 24730 for (ctnode = comdat_type_list; ctnode != NULL; ctnode = ctnode->next) 24731 copy_decls_for_unworthy_types (ctnode->root_die); 24732 copy_decls_for_unworthy_types (comp_unit_die ()); 24733 24734 /* In the process of copying declarations from one unit to another, 24735 we may have left some declarations behind that are no longer 24736 referenced. Prune them. */ 24737 prune_unused_types (); 24738 } 24739 24740 /* Generate separate CUs for each of the include files we've seen. 24741 They will go into limbo_die_list. */ 24742 if (flag_eliminate_dwarf2_dups) 24743 break_out_includes (comp_unit_die ()); 24744 24745 /* Traverse the DIE's and add add sibling attributes to those DIE's 24746 that have children. */ 24747 add_sibling_attributes (comp_unit_die ()); 24748 for (node = limbo_die_list; node; node = node->next) 24749 add_sibling_attributes (node->die); 24750 for (ctnode = comdat_type_list; ctnode != NULL; ctnode = ctnode->next) 24751 add_sibling_attributes (ctnode->root_die); 24752 24753 /* When splitting DWARF info, we put some attributes in the 24754 skeleton compile_unit DIE that remains in the .o, while 24755 most attributes go in the DWO compile_unit_die. */ 24756 if (dwarf_split_debug_info) 24757 main_comp_unit_die = gen_compile_unit_die (NULL); 24758 else 24759 main_comp_unit_die = comp_unit_die (); 24760 24761 /* Output a terminator label for the .text section. */ 24762 switch_to_section (text_section); 24763 targetm.asm_out.internal_label (asm_out_file, TEXT_END_LABEL, 0); 24764 if (cold_text_section) 24765 { 24766 switch_to_section (cold_text_section); 24767 targetm.asm_out.internal_label (asm_out_file, COLD_END_LABEL, 0); 24768 } 24769 24770 /* We can only use the low/high_pc attributes if all of the code was 24771 in .text. */ 24772 if (!have_multiple_function_sections 24773 || (dwarf_version < 3 && dwarf_strict)) 24774 { 24775 /* Don't add if the CU has no associated code. */ 24776 if (text_section_used) 24777 add_AT_low_high_pc (main_comp_unit_die, text_section_label, 24778 text_end_label, true); 24779 } 24780 else 24781 { 24782 unsigned fde_idx; 24783 dw_fde_ref fde; 24784 bool range_list_added = false; 24785 24786 if (text_section_used) 24787 add_ranges_by_labels (main_comp_unit_die, text_section_label, 24788 text_end_label, &range_list_added, true); 24789 if (cold_text_section_used) 24790 add_ranges_by_labels (main_comp_unit_die, cold_text_section_label, 24791 cold_end_label, &range_list_added, true); 24792 24793 FOR_EACH_VEC_ELT (*fde_vec, fde_idx, fde) 24794 { 24795 if (DECL_IGNORED_P (fde->decl)) 24796 continue; 24797 if (!fde->in_std_section) 24798 add_ranges_by_labels (main_comp_unit_die, fde->dw_fde_begin, 24799 fde->dw_fde_end, &range_list_added, 24800 true); 24801 if (fde->dw_fde_second_begin && !fde->second_in_std_section) 24802 add_ranges_by_labels (main_comp_unit_die, fde->dw_fde_second_begin, 24803 fde->dw_fde_second_end, &range_list_added, 24804 true); 24805 } 24806 24807 if (range_list_added) 24808 { 24809 /* We need to give .debug_loc and .debug_ranges an appropriate 24810 "base address". Use zero so that these addresses become 24811 absolute. Historically, we've emitted the unexpected 24812 DW_AT_entry_pc instead of DW_AT_low_pc for this purpose. 24813 Emit both to give time for other tools to adapt. */ 24814 add_AT_addr (main_comp_unit_die, DW_AT_low_pc, const0_rtx, true); 24815 if (! dwarf_strict && dwarf_version < 4) 24816 add_AT_addr (main_comp_unit_die, DW_AT_entry_pc, const0_rtx, true); 24817 24818 add_ranges (NULL); 24819 } 24820 } 24821 24822 if (debug_info_level >= DINFO_LEVEL_TERSE) 24823 add_AT_lineptr (main_comp_unit_die, DW_AT_stmt_list, 24824 debug_line_section_label); 24825 24826 if (have_macinfo) 24827 add_AT_macptr (comp_unit_die (), 24828 dwarf_strict ? DW_AT_macro_info : DW_AT_GNU_macros, 24829 macinfo_section_label); 24830 24831 if (dwarf_split_debug_info) 24832 { 24833 /* optimize_location_lists calculates the size of the lists, 24834 so index them first, and assign indices to the entries. 24835 Although optimize_location_lists will remove entries from 24836 the table, it only does so for duplicates, and therefore 24837 only reduces ref_counts to 1. */ 24838 index_location_lists (comp_unit_die ()); 24839 24840 if (addr_index_table != NULL) 24841 { 24842 unsigned int index = 0; 24843 addr_index_table 24844 ->traverse_noresize<unsigned int *, index_addr_table_entry> 24845 (&index); 24846 } 24847 } 24848 24849 if (have_location_lists) 24850 optimize_location_lists (comp_unit_die ()); 24851 24852 save_macinfo_strings (); 24853 24854 if (dwarf_split_debug_info) 24855 { 24856 unsigned int index = 0; 24857 24858 /* Add attributes common to skeleton compile_units and 24859 type_units. Because these attributes include strings, it 24860 must be done before freezing the string table. Top-level 24861 skeleton die attrs are added when the skeleton type unit is 24862 created, so ensure it is created by this point. */ 24863 add_top_level_skeleton_die_attrs (main_comp_unit_die); 24864 debug_str_hash->traverse_noresize<unsigned int *, index_string> (&index); 24865 } 24866 24867 /* Output all of the compilation units. We put the main one last so that 24868 the offsets are available to output_pubnames. */ 24869 for (node = limbo_die_list; node; node = node->next) 24870 output_comp_unit (node->die, 0); 24871 24872 hash_table<comdat_type_hasher> comdat_type_table (100); 24873 for (ctnode = comdat_type_list; ctnode != NULL; ctnode = ctnode->next) 24874 { 24875 comdat_type_node **slot = comdat_type_table.find_slot (ctnode, INSERT); 24876 24877 /* Don't output duplicate types. */ 24878 if (*slot != HTAB_EMPTY_ENTRY) 24879 continue; 24880 24881 /* Add a pointer to the line table for the main compilation unit 24882 so that the debugger can make sense of DW_AT_decl_file 24883 attributes. */ 24884 if (debug_info_level >= DINFO_LEVEL_TERSE) 24885 add_AT_lineptr (ctnode->root_die, DW_AT_stmt_list, 24886 (!dwarf_split_debug_info 24887 ? debug_line_section_label 24888 : debug_skeleton_line_section_label)); 24889 24890 output_comdat_type_unit (ctnode); 24891 *slot = ctnode; 24892 } 24893 24894 /* The AT_pubnames attribute needs to go in all skeleton dies, including 24895 both the main_cu and all skeleton TUs. Making this call unconditional 24896 would end up either adding a second copy of the AT_pubnames attribute, or 24897 requiring a special case in add_top_level_skeleton_die_attrs. */ 24898 if (!dwarf_split_debug_info) 24899 add_AT_pubnames (comp_unit_die ()); 24900 24901 if (dwarf_split_debug_info) 24902 { 24903 int mark; 24904 unsigned char checksum[16]; 24905 struct md5_ctx ctx; 24906 24907 /* Compute a checksum of the comp_unit to use as the dwo_id. */ 24908 md5_init_ctx (&ctx); 24909 mark = 0; 24910 die_checksum (comp_unit_die (), &ctx, &mark); 24911 unmark_all_dies (comp_unit_die ()); 24912 md5_finish_ctx (&ctx, checksum); 24913 24914 /* Use the first 8 bytes of the checksum as the dwo_id, 24915 and add it to both comp-unit DIEs. */ 24916 add_AT_data8 (main_comp_unit_die, DW_AT_GNU_dwo_id, checksum); 24917 add_AT_data8 (comp_unit_die (), DW_AT_GNU_dwo_id, checksum); 24918 24919 /* Add the base offset of the ranges table to the skeleton 24920 comp-unit DIE. */ 24921 if (ranges_table_in_use) 24922 add_AT_lineptr (main_comp_unit_die, DW_AT_GNU_ranges_base, 24923 ranges_section_label); 24924 24925 switch_to_section (debug_addr_section); 24926 ASM_OUTPUT_LABEL (asm_out_file, debug_addr_section_label); 24927 output_addr_table (); 24928 } 24929 24930 /* Output the main compilation unit if non-empty or if .debug_macinfo 24931 or .debug_macro will be emitted. */ 24932 output_comp_unit (comp_unit_die (), have_macinfo); 24933 24934 if (dwarf_split_debug_info && info_section_emitted) 24935 output_skeleton_debug_sections (main_comp_unit_die); 24936 24937 /* Output the abbreviation table. */ 24938 if (abbrev_die_table_in_use != 1) 24939 { 24940 switch_to_section (debug_abbrev_section); 24941 ASM_OUTPUT_LABEL (asm_out_file, abbrev_section_label); 24942 output_abbrev_section (); 24943 } 24944 24945 /* Output location list section if necessary. */ 24946 if (have_location_lists) 24947 { 24948 /* Output the location lists info. */ 24949 switch_to_section (debug_loc_section); 24950 ASM_OUTPUT_LABEL (asm_out_file, loc_section_label); 24951 output_location_lists (comp_unit_die ()); 24952 } 24953 24954 output_pubtables (); 24955 24956 /* Output the address range information if a CU (.debug_info section) 24957 was emitted. We output an empty table even if we had no functions 24958 to put in it. This because the consumer has no way to tell the 24959 difference between an empty table that we omitted and failure to 24960 generate a table that would have contained data. */ 24961 if (info_section_emitted) 24962 { 24963 unsigned long aranges_length = size_of_aranges (); 24964 24965 switch_to_section (debug_aranges_section); 24966 output_aranges (aranges_length); 24967 } 24968 24969 /* Output ranges section if necessary. */ 24970 if (ranges_table_in_use) 24971 { 24972 switch_to_section (debug_ranges_section); 24973 ASM_OUTPUT_LABEL (asm_out_file, ranges_section_label); 24974 output_ranges (); 24975 } 24976 24977 /* Have to end the macro section. */ 24978 if (have_macinfo) 24979 { 24980 switch_to_section (debug_macinfo_section); 24981 ASM_OUTPUT_LABEL (asm_out_file, macinfo_section_label); 24982 output_macinfo (); 24983 dw2_asm_output_data (1, 0, "End compilation unit"); 24984 } 24985 24986 /* Output the source line correspondence table. We must do this 24987 even if there is no line information. Otherwise, on an empty 24988 translation unit, we will generate a present, but empty, 24989 .debug_info section. IRIX 6.5 `nm' will then complain when 24990 examining the file. This is done late so that any filenames 24991 used by the debug_info section are marked as 'used'. */ 24992 switch_to_section (debug_line_section); 24993 ASM_OUTPUT_LABEL (asm_out_file, debug_line_section_label); 24994 if (! DWARF2_ASM_LINE_DEBUG_INFO) 24995 output_line_info (false); 24996 24997 if (dwarf_split_debug_info && info_section_emitted) 24998 { 24999 switch_to_section (debug_skeleton_line_section); 25000 ASM_OUTPUT_LABEL (asm_out_file, debug_skeleton_line_section_label); 25001 output_line_info (true); 25002 } 25003 25004 /* If we emitted any indirect strings, output the string table too. */ 25005 if (debug_str_hash || skeleton_debug_str_hash) 25006 output_indirect_strings (); 25007} 25008 25009/* Reset all state within dwarf2out.c so that we can rerun the compiler 25010 within the same process. For use by toplev::finalize. */ 25011 25012void 25013dwarf2out_c_finalize (void) 25014{ 25015 last_var_location_insn = NULL; 25016 cached_next_real_insn = NULL; 25017 used_rtx_array = NULL; 25018 incomplete_types = NULL; 25019 decl_scope_table = NULL; 25020 debug_info_section = NULL; 25021 debug_skeleton_info_section = NULL; 25022 debug_abbrev_section = NULL; 25023 debug_skeleton_abbrev_section = NULL; 25024 debug_aranges_section = NULL; 25025 debug_addr_section = NULL; 25026 debug_macinfo_section = NULL; 25027 debug_line_section = NULL; 25028 debug_skeleton_line_section = NULL; 25029 debug_loc_section = NULL; 25030 debug_pubnames_section = NULL; 25031 debug_pubtypes_section = NULL; 25032 debug_str_section = NULL; 25033 debug_str_dwo_section = NULL; 25034 debug_str_offsets_section = NULL; 25035 debug_ranges_section = NULL; 25036 debug_frame_section = NULL; 25037 fde_vec = NULL; 25038 debug_str_hash = NULL; 25039 skeleton_debug_str_hash = NULL; 25040 dw2_string_counter = 0; 25041 have_multiple_function_sections = false; 25042 text_section_used = false; 25043 cold_text_section_used = false; 25044 cold_text_section = NULL; 25045 current_unit_personality = NULL; 25046 25047 deferred_locations_list = NULL; 25048 25049 next_die_offset = 0; 25050 single_comp_unit_die = NULL; 25051 comdat_type_list = NULL; 25052 limbo_die_list = NULL; 25053 deferred_asm_name = NULL; 25054 file_table = NULL; 25055 decl_die_table = NULL; 25056 common_block_die_table = NULL; 25057 decl_loc_table = NULL; 25058 call_arg_locations = NULL; 25059 call_arg_loc_last = NULL; 25060 call_site_count = -1; 25061 tail_call_site_count = -1; 25062 //block_map = NULL; 25063 cached_dw_loc_list_table = NULL; 25064 abbrev_die_table = NULL; 25065 abbrev_die_table_allocated = 0; 25066 abbrev_die_table_in_use = 0; 25067 line_info_label_num = 0; 25068 cur_line_info_table = NULL; 25069 text_section_line_info = NULL; 25070 cold_text_section_line_info = NULL; 25071 separate_line_info = NULL; 25072 info_section_emitted = false; 25073 pubname_table = NULL; 25074 pubtype_table = NULL; 25075 macinfo_table = NULL; 25076 ranges_table = NULL; 25077 ranges_table_allocated = 0; 25078 ranges_table_in_use = 0; 25079 ranges_by_label = 0; 25080 ranges_by_label_allocated = 0; 25081 ranges_by_label_in_use = 0; 25082 have_location_lists = false; 25083 loclabel_num = 0; 25084 poc_label_num = 0; 25085 last_emitted_file = NULL; 25086 label_num = 0; 25087 file_table_last_lookup = NULL; 25088 tmpl_value_parm_die_table = NULL; 25089 generic_type_instances = NULL; 25090 frame_pointer_fb_offset = 0; 25091 frame_pointer_fb_offset_valid = false; 25092 base_types.release (); 25093 XDELETEVEC (producer_string); 25094 producer_string = NULL; 25095} 25096 25097#include "gt-dwarf2out.h" 25098