1 /* dwarf.c -- display DWARF contents of a BFD binary file 2 Copyright (C) 2005-2020 Free Software Foundation, Inc. 3 4 This file is part of GNU Binutils. 5 6 This program is free software; you can redistribute it and/or modify 7 it under the terms of the GNU General Public License as published by 8 the Free Software Foundation; either version 3 of the License, or 9 (at your option) any later version. 10 11 This program is distributed in the hope that it will be useful, 12 but WITHOUT ANY WARRANTY; without even the implied warranty of 13 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the 14 GNU General Public License for more details. 15 16 You should have received a copy of the GNU General Public License 17 along with this program; if not, write to the Free Software 18 Foundation, Inc., 51 Franklin Street - Fifth Floor, Boston, MA 19 02110-1301, USA. */ 20 21 #include "sysdep.h" 22 #include "libiberty.h" 23 #include "bfd.h" 24 #include "bfd_stdint.h" 25 #include "bucomm.h" 26 #include "elfcomm.h" 27 #include "elf/common.h" 28 #include "dwarf2.h" 29 #include "dwarf.h" 30 #include "gdb/gdb-index.h" 31 #include "filenames.h" 32 #include "safe-ctype.h" 33 #include <assert.h> 34 35 #ifdef HAVE_LIBDEBUGINFOD 36 #include <elfutils/debuginfod.h> 37 #endif 38 39 #undef MAX 40 #undef MIN 41 #define MAX(a, b) ((a) > (b) ? (a) : (b)) 42 #define MIN(a, b) ((a) < (b) ? (a) : (b)) 43 44 static const char *regname (unsigned int regno, int row); 45 static const char *regname_internal_by_table_only (unsigned int regno); 46 47 static int have_frame_base; 48 static int need_base_address; 49 50 static unsigned int num_debug_info_entries = 0; 51 static unsigned int alloc_num_debug_info_entries = 0; 52 static debug_info *debug_information = NULL; 53 /* Special value for num_debug_info_entries to indicate 54 that the .debug_info section could not be loaded/parsed. */ 55 #define DEBUG_INFO_UNAVAILABLE (unsigned int) -1 56 57 /* A .debug_info section can contain multiple links to separate 58 DWO object files. We use these structures to record these links. */ 59 typedef enum dwo_type 60 { 61 DWO_NAME, 62 DWO_DIR, 63 DWO_ID 64 } dwo_type; 65 66 typedef struct dwo_info 67 { 68 dwo_type type; 69 const char * value; 70 struct dwo_info * next; 71 } dwo_info; 72 73 static dwo_info * first_dwo_info = NULL; 74 static bfd_boolean need_dwo_info; 75 76 separate_info * first_separate_info = NULL; 77 78 unsigned int eh_addr_size; 79 80 int do_debug_info; 81 int do_debug_abbrevs; 82 int do_debug_lines; 83 int do_debug_pubnames; 84 int do_debug_pubtypes; 85 int do_debug_aranges; 86 int do_debug_ranges; 87 int do_debug_frames; 88 int do_debug_frames_interp; 89 int do_debug_macinfo; 90 int do_debug_str; 91 int do_debug_loc; 92 int do_gdb_index; 93 int do_trace_info; 94 int do_trace_abbrevs; 95 int do_trace_aranges; 96 int do_debug_addr; 97 int do_debug_cu_index; 98 int do_wide; 99 int do_debug_links; 100 int do_follow_links; 101 102 int dwarf_cutoff_level = -1; 103 unsigned long dwarf_start_die; 104 105 int dwarf_check = 0; 106 107 /* Convenient constant, to avoid having to cast -1 to dwarf_vma when 108 testing whether e.g. a locview list is present. */ 109 static const dwarf_vma vm1 = -1; 110 111 /* Collection of CU/TU section sets from .debug_cu_index and .debug_tu_index 112 sections. For version 1 package files, each set is stored in SHNDX_POOL 113 as a zero-terminated list of section indexes comprising one set of debug 114 sections from a .dwo file. */ 115 116 static unsigned int *shndx_pool = NULL; 117 static unsigned int shndx_pool_size = 0; 118 static unsigned int shndx_pool_used = 0; 119 120 /* For version 2 package files, each set contains an array of section offsets 121 and an array of section sizes, giving the offset and size of the 122 contribution from a CU or TU within one of the debug sections. 123 When displaying debug info from a package file, we need to use these 124 tables to locate the corresponding contributions to each section. */ 125 126 struct cu_tu_set 127 { 128 uint64_t signature; 129 dwarf_vma section_offsets[DW_SECT_MAX]; 130 size_t section_sizes[DW_SECT_MAX]; 131 }; 132 133 static int cu_count = 0; 134 static int tu_count = 0; 135 static struct cu_tu_set *cu_sets = NULL; 136 static struct cu_tu_set *tu_sets = NULL; 137 138 static bfd_boolean load_cu_tu_indexes (void *); 139 140 /* An array that indicates for a given level of CU nesting whether 141 the latest DW_AT_type seen for that level was a signed type or 142 an unsigned type. */ 143 #define MAX_CU_NESTING (1 << 8) 144 static bfd_boolean level_type_signed[MAX_CU_NESTING]; 145 146 /* Values for do_debug_lines. */ 147 #define FLAG_DEBUG_LINES_RAW 1 148 #define FLAG_DEBUG_LINES_DECODED 2 149 150 static unsigned int 151 size_of_encoded_value (int encoding) 152 { 153 switch (encoding & 0x7) 154 { 155 default: /* ??? */ 156 case 0: return eh_addr_size; 157 case 2: return 2; 158 case 3: return 4; 159 case 4: return 8; 160 } 161 } 162 163 static dwarf_vma 164 get_encoded_value (unsigned char **pdata, 165 int encoding, 166 struct dwarf_section *section, 167 unsigned char * end) 168 { 169 unsigned char * data = * pdata; 170 unsigned int size = size_of_encoded_value (encoding); 171 dwarf_vma val; 172 173 if (data + size >= end) 174 { 175 warn (_("Encoded value extends past end of section\n")); 176 * pdata = end; 177 return 0; 178 } 179 180 /* PR 17512: file: 002-829853-0.004. */ 181 if (size > 8) 182 { 183 warn (_("Encoded size of %d is too large to read\n"), size); 184 * pdata = end; 185 return 0; 186 } 187 188 /* PR 17512: file: 1085-5603-0.004. */ 189 if (size == 0) 190 { 191 warn (_("Encoded size of 0 is too small to read\n")); 192 * pdata = end; 193 return 0; 194 } 195 196 if (encoding & DW_EH_PE_signed) 197 val = byte_get_signed (data, size); 198 else 199 val = byte_get (data, size); 200 201 if ((encoding & 0x70) == DW_EH_PE_pcrel) 202 val += section->address + (data - section->start); 203 204 * pdata = data + size; 205 return val; 206 } 207 208 #if defined HAVE_LONG_LONG && SIZEOF_LONG_LONG > SIZEOF_LONG 209 # ifndef __MINGW32__ 210 # define DWARF_VMA_FMT "ll" 211 # define DWARF_VMA_FMT_LONG "%16.16llx" 212 # else 213 # define DWARF_VMA_FMT "I64" 214 # define DWARF_VMA_FMT_LONG "%016I64x" 215 # endif 216 #else 217 # define DWARF_VMA_FMT "l" 218 # define DWARF_VMA_FMT_LONG "%16.16lx" 219 #endif 220 221 /* Convert a dwarf vma value into a string. Returns a pointer to a static 222 buffer containing the converted VALUE. The value is converted according 223 to the printf formating character FMTCH. If NUM_BYTES is non-zero then 224 it specifies the maximum number of bytes to be displayed in the converted 225 value and FMTCH is ignored - hex is always used. */ 226 227 static const char * 228 dwarf_vmatoa_1 (const char *fmtch, dwarf_vma value, unsigned num_bytes) 229 { 230 /* As dwarf_vmatoa is used more then once in a printf call 231 for output, we are cycling through an fixed array of pointers 232 for return address. */ 233 static int buf_pos = 0; 234 static struct dwarf_vmatoa_buf 235 { 236 char place[64]; 237 } buf[16]; 238 char *ret; 239 240 ret = buf[buf_pos++].place; 241 buf_pos %= ARRAY_SIZE (buf); 242 243 if (num_bytes) 244 { 245 /* Printf does not have a way of specifying a maximum field width for an 246 integer value, so we print the full value into a buffer and then select 247 the precision we need. */ 248 snprintf (ret, sizeof (buf[0].place), DWARF_VMA_FMT_LONG, value); 249 if (num_bytes > 8) 250 num_bytes = 8; 251 return ret + (16 - 2 * num_bytes); 252 } 253 else 254 { 255 char fmt[32]; 256 257 if (fmtch) 258 sprintf (fmt, "%%%s%s", DWARF_VMA_FMT, fmtch); 259 else 260 sprintf (fmt, "%%%s", DWARF_VMA_FMT); 261 snprintf (ret, sizeof (buf[0].place), fmt, value); 262 return ret; 263 } 264 } 265 266 static inline const char * 267 dwarf_vmatoa (const char * fmtch, dwarf_vma value) 268 { 269 return dwarf_vmatoa_1 (fmtch, value, 0); 270 } 271 272 /* Print a dwarf_vma value (typically an address, offset or length) in 273 hexadecimal format, followed by a space. The length of the VALUE (and 274 hence the precision displayed) is determined by the NUM_BYTES parameter. */ 275 276 static void 277 print_dwarf_vma (dwarf_vma value, unsigned num_bytes) 278 { 279 printf ("%s ", dwarf_vmatoa_1 (NULL, value, num_bytes)); 280 } 281 282 /* Print a view number in hexadecimal value, with the same width 283 print_dwarf_vma would have printed it with the same num_bytes. 284 Print blanks for zero view, unless force is nonzero. */ 285 286 static void 287 print_dwarf_view (dwarf_vma value, unsigned num_bytes, int force) 288 { 289 int len; 290 if (!num_bytes) 291 len = 4; 292 else 293 len = num_bytes * 2; 294 295 assert (value == (unsigned long) value); 296 if (value || force) 297 printf ("v%0*lx ", len - 1, (unsigned long) value); 298 else 299 printf ("%*s", len + 1, ""); 300 } 301 302 /* Format a 64-bit value, given as two 32-bit values, in hex. 303 For reentrancy, this uses a buffer provided by the caller. */ 304 305 static const char * 306 dwarf_vmatoa64 (dwarf_vma hvalue, dwarf_vma lvalue, char *buf, 307 unsigned int buf_len) 308 { 309 int len = 0; 310 311 if (hvalue == 0) 312 snprintf (buf, buf_len, "%" DWARF_VMA_FMT "x", lvalue); 313 else 314 { 315 len = snprintf (buf, buf_len, "%" DWARF_VMA_FMT "x", hvalue); 316 snprintf (buf + len, buf_len - len, 317 "%08" DWARF_VMA_FMT "x", lvalue); 318 } 319 320 return buf; 321 } 322 323 /* Read in a LEB128 encoded value starting at address DATA. 324 If SIGN is true, return a signed LEB128 value. 325 If LENGTH_RETURN is not NULL, return in it the number of bytes read. 326 If STATUS_RETURN in not NULL, return with bit 0 (LSB) set if the 327 terminating byte was not found and with bit 1 set if the value 328 overflows a dwarf_vma. 329 No bytes will be read at address END or beyond. */ 330 331 dwarf_vma 332 read_leb128 (unsigned char *data, 333 const unsigned char *const end, 334 bfd_boolean sign, 335 unsigned int *length_return, 336 int *status_return) 337 { 338 dwarf_vma result = 0; 339 unsigned int num_read = 0; 340 unsigned int shift = 0; 341 int status = 1; 342 343 while (data < end) 344 { 345 unsigned char byte = *data++; 346 bfd_boolean cont = (byte & 0x80) ? TRUE : FALSE; 347 348 byte &= 0x7f; 349 num_read++; 350 351 if (shift < sizeof (result) * 8) 352 { 353 result |= ((dwarf_vma) byte) << shift; 354 if (sign) 355 { 356 if ((((dwarf_signed_vma) result >> shift) & 0x7f) != byte) 357 /* Overflow. */ 358 status |= 2; 359 } 360 else if ((result >> shift) != byte) 361 { 362 /* Overflow. */ 363 status |= 2; 364 } 365 366 shift += 7; 367 } 368 else if (byte != 0) 369 { 370 status |= 2; 371 } 372 373 if (!cont) 374 { 375 status &= ~1; 376 if (sign && (shift < 8 * sizeof (result)) && (byte & 0x40)) 377 result |= -((dwarf_vma) 1 << shift); 378 break; 379 } 380 } 381 382 if (length_return != NULL) 383 *length_return = num_read; 384 if (status_return != NULL) 385 *status_return = status; 386 387 return result; 388 } 389 390 /* Read AMOUNT bytes from PTR and store them in VAL as an unsigned value. 391 Checks to make sure that the read will not reach or pass END 392 and that VAL is big enough to hold AMOUNT bytes. */ 393 #define SAFE_BYTE_GET(VAL, PTR, AMOUNT, END) \ 394 do \ 395 { \ 396 unsigned int amount = (AMOUNT); \ 397 if (sizeof (VAL) < amount) \ 398 { \ 399 error (ngettext ("internal error: attempt to read %d byte " \ 400 "of data in to %d sized variable", \ 401 "internal error: attempt to read %d bytes " \ 402 "of data in to %d sized variable", \ 403 amount), \ 404 amount, (int) sizeof (VAL)); \ 405 amount = sizeof (VAL); \ 406 } \ 407 if (((PTR) + amount) >= (END)) \ 408 { \ 409 if ((PTR) < (END)) \ 410 amount = (END) - (PTR); \ 411 else \ 412 amount = 0; \ 413 } \ 414 if (amount == 0 || amount > 8) \ 415 VAL = 0; \ 416 else \ 417 VAL = byte_get ((PTR), amount); \ 418 } \ 419 while (0) 420 421 /* Like SAFE_BYTE_GET, but also increments PTR by AMOUNT. */ 422 #define SAFE_BYTE_GET_AND_INC(VAL, PTR, AMOUNT, END) \ 423 do \ 424 { \ 425 SAFE_BYTE_GET (VAL, PTR, AMOUNT, END); \ 426 PTR += AMOUNT; \ 427 } \ 428 while (0) 429 430 /* Like SAFE_BYTE_GET, but reads a signed value. */ 431 #define SAFE_SIGNED_BYTE_GET(VAL, PTR, AMOUNT, END) \ 432 do \ 433 { \ 434 unsigned int amount = (AMOUNT); \ 435 if (((PTR) + amount) >= (END)) \ 436 { \ 437 if ((PTR) < (END)) \ 438 amount = (END) - (PTR); \ 439 else \ 440 amount = 0; \ 441 } \ 442 if (amount) \ 443 VAL = byte_get_signed ((PTR), amount); \ 444 else \ 445 VAL = 0; \ 446 } \ 447 while (0) 448 449 /* Like SAFE_SIGNED_BYTE_GET, but also increments PTR by AMOUNT. */ 450 #define SAFE_SIGNED_BYTE_GET_AND_INC(VAL, PTR, AMOUNT, END) \ 451 do \ 452 { \ 453 SAFE_SIGNED_BYTE_GET (VAL, PTR, AMOUNT, END); \ 454 PTR += AMOUNT; \ 455 } \ 456 while (0) 457 458 #define SAFE_BYTE_GET64(PTR, HIGH, LOW, END) \ 459 do \ 460 { \ 461 if (((PTR) + 8) <= (END)) \ 462 { \ 463 byte_get_64 ((PTR), (HIGH), (LOW)); \ 464 } \ 465 else \ 466 { \ 467 * (LOW) = * (HIGH) = 0; \ 468 } \ 469 } \ 470 while (0) 471 472 typedef struct State_Machine_Registers 473 { 474 dwarf_vma address; 475 unsigned int view; 476 unsigned int file; 477 unsigned int line; 478 unsigned int column; 479 int is_stmt; 480 int basic_block; 481 unsigned char op_index; 482 unsigned char end_sequence; 483 /* This variable hold the number of the last entry seen 484 in the File Table. */ 485 unsigned int last_file_entry; 486 } SMR; 487 488 static SMR state_machine_regs; 489 490 static void 491 reset_state_machine (int is_stmt) 492 { 493 state_machine_regs.address = 0; 494 state_machine_regs.view = 0; 495 state_machine_regs.op_index = 0; 496 state_machine_regs.file = 1; 497 state_machine_regs.line = 1; 498 state_machine_regs.column = 0; 499 state_machine_regs.is_stmt = is_stmt; 500 state_machine_regs.basic_block = 0; 501 state_machine_regs.end_sequence = 0; 502 state_machine_regs.last_file_entry = 0; 503 } 504 505 /* Handled an extend line op. 506 Returns the number of bytes read. */ 507 508 static size_t 509 process_extended_line_op (unsigned char * data, 510 int is_stmt, 511 unsigned char * end) 512 { 513 unsigned char op_code; 514 size_t len, header_len; 515 unsigned char *name; 516 unsigned char *orig_data = data; 517 dwarf_vma adr, val; 518 519 READ_ULEB (len, data, end); 520 header_len = data - orig_data; 521 522 if (len == 0 || data == end || len > (size_t) (end - data)) 523 { 524 warn (_("Badly formed extended line op encountered!\n")); 525 return header_len; 526 } 527 528 op_code = *data++; 529 530 printf (_(" Extended opcode %d: "), op_code); 531 532 switch (op_code) 533 { 534 case DW_LNE_end_sequence: 535 printf (_("End of Sequence\n\n")); 536 reset_state_machine (is_stmt); 537 break; 538 539 case DW_LNE_set_address: 540 /* PR 17512: file: 002-100480-0.004. */ 541 if (len - 1 > 8) 542 { 543 warn (_("Length (%lu) of DW_LNE_set_address op is too long\n"), 544 (unsigned long) len - 1); 545 adr = 0; 546 } 547 else 548 SAFE_BYTE_GET (adr, data, len - 1, end); 549 printf (_("set Address to 0x%s\n"), dwarf_vmatoa ("x", adr)); 550 state_machine_regs.address = adr; 551 state_machine_regs.view = 0; 552 state_machine_regs.op_index = 0; 553 break; 554 555 case DW_LNE_define_file: 556 printf (_("define new File Table entry\n")); 557 printf (_(" Entry\tDir\tTime\tSize\tName\n")); 558 printf (" %d\t", ++state_machine_regs.last_file_entry); 559 560 { 561 size_t l; 562 563 name = data; 564 l = strnlen ((char *) data, end - data); 565 data += l + 1; 566 READ_ULEB (val, data, end); 567 printf ("%s\t", dwarf_vmatoa ("u", val)); 568 READ_ULEB (val, data, end); 569 printf ("%s\t", dwarf_vmatoa ("u", val)); 570 READ_ULEB (val, data, end); 571 printf ("%s\t", dwarf_vmatoa ("u", val)); 572 printf ("%.*s\n\n", (int) l, name); 573 } 574 575 if (((size_t) (data - orig_data) != len + header_len) || data == end) 576 warn (_("DW_LNE_define_file: Bad opcode length\n")); 577 break; 578 579 case DW_LNE_set_discriminator: 580 READ_ULEB (val, data, end); 581 printf (_("set Discriminator to %s\n"), dwarf_vmatoa ("u", val)); 582 break; 583 584 /* HP extensions. */ 585 case DW_LNE_HP_negate_is_UV_update: 586 printf ("DW_LNE_HP_negate_is_UV_update\n"); 587 break; 588 case DW_LNE_HP_push_context: 589 printf ("DW_LNE_HP_push_context\n"); 590 break; 591 case DW_LNE_HP_pop_context: 592 printf ("DW_LNE_HP_pop_context\n"); 593 break; 594 case DW_LNE_HP_set_file_line_column: 595 printf ("DW_LNE_HP_set_file_line_column\n"); 596 break; 597 case DW_LNE_HP_set_routine_name: 598 printf ("DW_LNE_HP_set_routine_name\n"); 599 break; 600 case DW_LNE_HP_set_sequence: 601 printf ("DW_LNE_HP_set_sequence\n"); 602 break; 603 case DW_LNE_HP_negate_post_semantics: 604 printf ("DW_LNE_HP_negate_post_semantics\n"); 605 break; 606 case DW_LNE_HP_negate_function_exit: 607 printf ("DW_LNE_HP_negate_function_exit\n"); 608 break; 609 case DW_LNE_HP_negate_front_end_logical: 610 printf ("DW_LNE_HP_negate_front_end_logical\n"); 611 break; 612 case DW_LNE_HP_define_proc: 613 printf ("DW_LNE_HP_define_proc\n"); 614 break; 615 case DW_LNE_HP_source_file_correlation: 616 { 617 unsigned char *edata = data + len - 1; 618 619 printf ("DW_LNE_HP_source_file_correlation\n"); 620 621 while (data < edata) 622 { 623 unsigned int opc; 624 625 READ_ULEB (opc, data, edata); 626 627 switch (opc) 628 { 629 case DW_LNE_HP_SFC_formfeed: 630 printf (" DW_LNE_HP_SFC_formfeed\n"); 631 break; 632 case DW_LNE_HP_SFC_set_listing_line: 633 READ_ULEB (val, data, edata); 634 printf (" DW_LNE_HP_SFC_set_listing_line (%s)\n", 635 dwarf_vmatoa ("u", val)); 636 break; 637 case DW_LNE_HP_SFC_associate: 638 printf (" DW_LNE_HP_SFC_associate "); 639 READ_ULEB (val, data, edata); 640 printf ("(%s", dwarf_vmatoa ("u", val)); 641 READ_ULEB (val, data, edata); 642 printf (",%s", dwarf_vmatoa ("u", val)); 643 READ_ULEB (val, data, edata); 644 printf (",%s)\n", dwarf_vmatoa ("u", val)); 645 break; 646 default: 647 printf (_(" UNKNOWN DW_LNE_HP_SFC opcode (%u)\n"), opc); 648 data = edata; 649 break; 650 } 651 } 652 } 653 break; 654 655 default: 656 { 657 unsigned int rlen = len - 1; 658 659 if (op_code >= DW_LNE_lo_user 660 /* The test against DW_LNW_hi_user is redundant due to 661 the limited range of the unsigned char data type used 662 for op_code. */ 663 /*&& op_code <= DW_LNE_hi_user*/) 664 printf (_("user defined: ")); 665 else 666 printf (_("UNKNOWN: ")); 667 printf (_("length %d ["), rlen); 668 for (; rlen; rlen--) 669 printf (" %02x", *data++); 670 printf ("]\n"); 671 } 672 break; 673 } 674 675 return len + header_len; 676 } 677 678 static const unsigned char * 679 fetch_indirect_string (dwarf_vma offset) 680 { 681 struct dwarf_section *section = &debug_displays [str].section; 682 const unsigned char * ret; 683 684 if (section->start == NULL) 685 return (const unsigned char *) _("<no .debug_str section>"); 686 687 if (offset >= section->size) 688 { 689 warn (_("DW_FORM_strp offset too big: %s\n"), 690 dwarf_vmatoa ("x", offset)); 691 return (const unsigned char *) _("<offset is too big>"); 692 } 693 694 ret = section->start + offset; 695 /* Unfortunately we cannot rely upon the .debug_str section ending with a 696 NUL byte. Since our caller is expecting to receive a well formed C 697 string we test for the lack of a terminating byte here. */ 698 if (strnlen ((const char *) ret, section->size - offset) 699 == section->size - offset) 700 ret = (const unsigned char *) 701 _("<no NUL byte at end of .debug_str section>"); 702 703 return ret; 704 } 705 706 static const unsigned char * 707 fetch_indirect_line_string (dwarf_vma offset) 708 { 709 struct dwarf_section *section = &debug_displays [line_str].section; 710 const unsigned char * ret; 711 712 if (section->start == NULL) 713 return (const unsigned char *) _("<no .debug_line_str section>"); 714 715 if (offset >= section->size) 716 { 717 warn (_("DW_FORM_line_strp offset too big: %s\n"), 718 dwarf_vmatoa ("x", offset)); 719 return (const unsigned char *) _("<offset is too big>"); 720 } 721 722 ret = section->start + offset; 723 /* Unfortunately we cannot rely upon the .debug_line_str section ending 724 with a NUL byte. Since our caller is expecting to receive a well formed 725 C string we test for the lack of a terminating byte here. */ 726 if (strnlen ((const char *) ret, section->size - offset) 727 == section->size - offset) 728 ret = (const unsigned char *) 729 _("<no NUL byte at end of .debug_line_str section>"); 730 731 return ret; 732 } 733 734 static const char * 735 fetch_indexed_string (dwarf_vma idx, struct cu_tu_set *this_set, 736 dwarf_vma offset_size, bfd_boolean dwo) 737 { 738 enum dwarf_section_display_enum str_sec_idx = dwo ? str_dwo : str; 739 enum dwarf_section_display_enum idx_sec_idx = dwo ? str_index_dwo : str_index; 740 struct dwarf_section *index_section = &debug_displays [idx_sec_idx].section; 741 struct dwarf_section *str_section = &debug_displays [str_sec_idx].section; 742 dwarf_vma index_offset = idx * offset_size; 743 dwarf_vma str_offset; 744 const char * ret; 745 746 if (index_section->start == NULL) 747 return (dwo ? _("<no .debug_str_offsets.dwo section>") 748 : _("<no .debug_str_offsets section>")); 749 750 if (this_set != NULL) 751 index_offset += this_set->section_offsets [DW_SECT_STR_OFFSETS]; 752 if (index_offset >= index_section->size) 753 { 754 warn (_("DW_FORM_GNU_str_index offset too big: %s\n"), 755 dwarf_vmatoa ("x", index_offset)); 756 return _("<index offset is too big>"); 757 } 758 759 if (str_section->start == NULL) 760 return (dwo ? _("<no .debug_str.dwo section>") 761 : _("<no .debug_str section>")); 762 763 str_offset = byte_get (index_section->start + index_offset, offset_size); 764 str_offset -= str_section->address; 765 if (str_offset >= str_section->size) 766 { 767 warn (_("DW_FORM_GNU_str_index indirect offset too big: %s\n"), 768 dwarf_vmatoa ("x", str_offset)); 769 return _("<indirect index offset is too big>"); 770 } 771 772 ret = (const char *) str_section->start + str_offset; 773 /* Unfortunately we cannot rely upon str_section ending with a NUL byte. 774 Since our caller is expecting to receive a well formed C string we test 775 for the lack of a terminating byte here. */ 776 if (strnlen (ret, str_section->size - str_offset) 777 == str_section->size - str_offset) 778 ret = (const char *) _("<no NUL byte at end of section>"); 779 780 return ret; 781 } 782 783 static const char * 784 fetch_indexed_value (dwarf_vma offset, dwarf_vma bytes) 785 { 786 struct dwarf_section *section = &debug_displays [debug_addr].section; 787 788 if (section->start == NULL) 789 return (_("<no .debug_addr section>")); 790 791 if (offset + bytes > section->size) 792 { 793 warn (_("Offset into section %s too big: %s\n"), 794 section->name, dwarf_vmatoa ("x", offset)); 795 return "<offset too big>"; 796 } 797 798 return dwarf_vmatoa ("x", byte_get (section->start + offset, bytes)); 799 } 800 801 802 /* FIXME: There are better and more efficient ways to handle 803 these structures. For now though, I just want something that 804 is simple to implement. */ 805 typedef struct abbrev_attr 806 { 807 unsigned long attribute; 808 unsigned long form; 809 bfd_signed_vma implicit_const; 810 struct abbrev_attr *next; 811 } 812 abbrev_attr; 813 814 typedef struct abbrev_entry 815 { 816 unsigned long entry; 817 unsigned long tag; 818 int children; 819 struct abbrev_attr *first_attr; 820 struct abbrev_attr *last_attr; 821 struct abbrev_entry *next; 822 } 823 abbrev_entry; 824 825 static abbrev_entry *first_abbrev = NULL; 826 static abbrev_entry *last_abbrev = NULL; 827 828 static void 829 free_abbrevs (void) 830 { 831 abbrev_entry *abbrv; 832 833 for (abbrv = first_abbrev; abbrv;) 834 { 835 abbrev_entry *next_abbrev = abbrv->next; 836 abbrev_attr *attr; 837 838 for (attr = abbrv->first_attr; attr;) 839 { 840 abbrev_attr *next_attr = attr->next; 841 842 free (attr); 843 attr = next_attr; 844 } 845 846 free (abbrv); 847 abbrv = next_abbrev; 848 } 849 850 last_abbrev = first_abbrev = NULL; 851 } 852 853 static void 854 add_abbrev (unsigned long number, unsigned long tag, int children) 855 { 856 abbrev_entry *entry; 857 858 entry = (abbrev_entry *) malloc (sizeof (*entry)); 859 if (entry == NULL) 860 /* ugg */ 861 return; 862 863 entry->entry = number; 864 entry->tag = tag; 865 entry->children = children; 866 entry->first_attr = NULL; 867 entry->last_attr = NULL; 868 entry->next = NULL; 869 870 if (first_abbrev == NULL) 871 first_abbrev = entry; 872 else 873 last_abbrev->next = entry; 874 875 last_abbrev = entry; 876 } 877 878 static void 879 add_abbrev_attr (unsigned long attribute, unsigned long form, 880 bfd_signed_vma implicit_const) 881 { 882 abbrev_attr *attr; 883 884 attr = (abbrev_attr *) malloc (sizeof (*attr)); 885 if (attr == NULL) 886 /* ugg */ 887 return; 888 889 attr->attribute = attribute; 890 attr->form = form; 891 attr->implicit_const = implicit_const; 892 attr->next = NULL; 893 894 if (last_abbrev->first_attr == NULL) 895 last_abbrev->first_attr = attr; 896 else 897 last_abbrev->last_attr->next = attr; 898 899 last_abbrev->last_attr = attr; 900 } 901 902 /* Processes the (partial) contents of a .debug_abbrev section. 903 Returns NULL if the end of the section was encountered. 904 Returns the address after the last byte read if the end of 905 an abbreviation set was found. */ 906 907 static unsigned char * 908 process_abbrev_section (unsigned char *start, unsigned char *end) 909 { 910 if (first_abbrev != NULL) 911 return NULL; 912 913 while (start < end) 914 { 915 unsigned long entry; 916 unsigned long tag; 917 unsigned long attribute; 918 int children; 919 920 READ_ULEB (entry, start, end); 921 922 /* A single zero is supposed to end the section according 923 to the standard. If there's more, then signal that to 924 the caller. */ 925 if (start == end) 926 return NULL; 927 if (entry == 0) 928 return start; 929 930 READ_ULEB (tag, start, end); 931 if (start == end) 932 return NULL; 933 934 children = *start++; 935 936 add_abbrev (entry, tag, children); 937 938 do 939 { 940 unsigned long form; 941 /* Initialize it due to a false compiler warning. */ 942 bfd_signed_vma implicit_const = -1; 943 944 READ_ULEB (attribute, start, end); 945 if (start == end) 946 break; 947 948 READ_ULEB (form, start, end); 949 if (start == end) 950 break; 951 952 if (form == DW_FORM_implicit_const) 953 { 954 READ_SLEB (implicit_const, start, end); 955 if (start == end) 956 break; 957 } 958 959 add_abbrev_attr (attribute, form, implicit_const); 960 } 961 while (attribute != 0); 962 } 963 964 /* Report the missing single zero which ends the section. */ 965 error (_(".debug_abbrev section not zero terminated\n")); 966 967 return NULL; 968 } 969 970 static const char * 971 get_TAG_name (unsigned long tag) 972 { 973 const char *name = get_DW_TAG_name ((unsigned int) tag); 974 975 if (name == NULL) 976 { 977 static char buffer[100]; 978 979 if (tag >= DW_TAG_lo_user && tag <= DW_TAG_hi_user) 980 snprintf (buffer, sizeof (buffer), _("User TAG value: %#lx"), tag); 981 else 982 snprintf (buffer, sizeof (buffer), _("Unknown TAG value: %#lx"), tag); 983 return buffer; 984 } 985 986 return name; 987 } 988 989 static const char * 990 get_FORM_name (unsigned long form) 991 { 992 const char *name; 993 994 if (form == 0) 995 return "DW_FORM value: 0"; 996 997 name = get_DW_FORM_name (form); 998 if (name == NULL) 999 { 1000 static char buffer[100]; 1001 1002 snprintf (buffer, sizeof (buffer), _("Unknown FORM value: %lx"), form); 1003 return buffer; 1004 } 1005 1006 return name; 1007 } 1008 1009 static const char * 1010 get_IDX_name (unsigned long idx) 1011 { 1012 const char *name = get_DW_IDX_name ((unsigned int) idx); 1013 1014 if (name == NULL) 1015 { 1016 static char buffer[100]; 1017 1018 snprintf (buffer, sizeof (buffer), _("Unknown IDX value: %lx"), idx); 1019 return buffer; 1020 } 1021 1022 return name; 1023 } 1024 1025 static unsigned char * 1026 display_block (unsigned char *data, 1027 dwarf_vma length, 1028 const unsigned char * const end, char delimiter) 1029 { 1030 dwarf_vma maxlen; 1031 1032 printf (_("%c%s byte block: "), delimiter, dwarf_vmatoa ("u", length)); 1033 if (data > end) 1034 return (unsigned char *) end; 1035 1036 maxlen = (dwarf_vma) (end - data); 1037 length = length > maxlen ? maxlen : length; 1038 1039 while (length --) 1040 printf ("%lx ", (unsigned long) byte_get (data++, 1)); 1041 1042 return data; 1043 } 1044 1045 static int 1046 decode_location_expression (unsigned char * data, 1047 unsigned int pointer_size, 1048 unsigned int offset_size, 1049 int dwarf_version, 1050 dwarf_vma length, 1051 dwarf_vma cu_offset, 1052 struct dwarf_section * section) 1053 { 1054 unsigned op; 1055 dwarf_vma uvalue; 1056 dwarf_signed_vma svalue; 1057 unsigned char *end = data + length; 1058 int need_frame_base = 0; 1059 1060 while (data < end) 1061 { 1062 op = *data++; 1063 1064 switch (op) 1065 { 1066 case DW_OP_addr: 1067 SAFE_BYTE_GET_AND_INC (uvalue, data, pointer_size, end); 1068 printf ("DW_OP_addr: %s", dwarf_vmatoa ("x", uvalue)); 1069 break; 1070 case DW_OP_deref: 1071 printf ("DW_OP_deref"); 1072 break; 1073 case DW_OP_const1u: 1074 SAFE_BYTE_GET_AND_INC (uvalue, data, 1, end); 1075 printf ("DW_OP_const1u: %lu", (unsigned long) uvalue); 1076 break; 1077 case DW_OP_const1s: 1078 SAFE_SIGNED_BYTE_GET_AND_INC (svalue, data, 1, end); 1079 printf ("DW_OP_const1s: %ld", (long) svalue); 1080 break; 1081 case DW_OP_const2u: 1082 SAFE_BYTE_GET_AND_INC (uvalue, data, 2, end); 1083 printf ("DW_OP_const2u: %lu", (unsigned long) uvalue); 1084 break; 1085 case DW_OP_const2s: 1086 SAFE_SIGNED_BYTE_GET_AND_INC (svalue, data, 2, end); 1087 printf ("DW_OP_const2s: %ld", (long) svalue); 1088 break; 1089 case DW_OP_const4u: 1090 SAFE_BYTE_GET_AND_INC (uvalue, data, 4, end); 1091 printf ("DW_OP_const4u: %lu", (unsigned long) uvalue); 1092 break; 1093 case DW_OP_const4s: 1094 SAFE_SIGNED_BYTE_GET_AND_INC (svalue, data, 4, end); 1095 printf ("DW_OP_const4s: %ld", (long) svalue); 1096 break; 1097 case DW_OP_const8u: 1098 SAFE_BYTE_GET_AND_INC (uvalue, data, 4, end); 1099 printf ("DW_OP_const8u: %lu ", (unsigned long) uvalue); 1100 SAFE_BYTE_GET_AND_INC (uvalue, data, 4, end); 1101 printf ("%lu", (unsigned long) uvalue); 1102 break; 1103 case DW_OP_const8s: 1104 SAFE_SIGNED_BYTE_GET_AND_INC (svalue, data, 4, end); 1105 printf ("DW_OP_const8s: %ld ", (long) svalue); 1106 SAFE_SIGNED_BYTE_GET_AND_INC (svalue, data, 4, end); 1107 printf ("%ld", (long) svalue); 1108 break; 1109 case DW_OP_constu: 1110 READ_ULEB (uvalue, data, end); 1111 printf ("DW_OP_constu: %s", dwarf_vmatoa ("u", uvalue)); 1112 break; 1113 case DW_OP_consts: 1114 READ_SLEB (svalue, data, end); 1115 printf ("DW_OP_consts: %s", dwarf_vmatoa ("d", svalue)); 1116 break; 1117 case DW_OP_dup: 1118 printf ("DW_OP_dup"); 1119 break; 1120 case DW_OP_drop: 1121 printf ("DW_OP_drop"); 1122 break; 1123 case DW_OP_over: 1124 printf ("DW_OP_over"); 1125 break; 1126 case DW_OP_pick: 1127 SAFE_BYTE_GET_AND_INC (uvalue, data, 1, end); 1128 printf ("DW_OP_pick: %ld", (unsigned long) uvalue); 1129 break; 1130 case DW_OP_swap: 1131 printf ("DW_OP_swap"); 1132 break; 1133 case DW_OP_rot: 1134 printf ("DW_OP_rot"); 1135 break; 1136 case DW_OP_xderef: 1137 printf ("DW_OP_xderef"); 1138 break; 1139 case DW_OP_abs: 1140 printf ("DW_OP_abs"); 1141 break; 1142 case DW_OP_and: 1143 printf ("DW_OP_and"); 1144 break; 1145 case DW_OP_div: 1146 printf ("DW_OP_div"); 1147 break; 1148 case DW_OP_minus: 1149 printf ("DW_OP_minus"); 1150 break; 1151 case DW_OP_mod: 1152 printf ("DW_OP_mod"); 1153 break; 1154 case DW_OP_mul: 1155 printf ("DW_OP_mul"); 1156 break; 1157 case DW_OP_neg: 1158 printf ("DW_OP_neg"); 1159 break; 1160 case DW_OP_not: 1161 printf ("DW_OP_not"); 1162 break; 1163 case DW_OP_or: 1164 printf ("DW_OP_or"); 1165 break; 1166 case DW_OP_plus: 1167 printf ("DW_OP_plus"); 1168 break; 1169 case DW_OP_plus_uconst: 1170 READ_ULEB (uvalue, data, end); 1171 printf ("DW_OP_plus_uconst: %s", dwarf_vmatoa ("u", uvalue)); 1172 break; 1173 case DW_OP_shl: 1174 printf ("DW_OP_shl"); 1175 break; 1176 case DW_OP_shr: 1177 printf ("DW_OP_shr"); 1178 break; 1179 case DW_OP_shra: 1180 printf ("DW_OP_shra"); 1181 break; 1182 case DW_OP_xor: 1183 printf ("DW_OP_xor"); 1184 break; 1185 case DW_OP_bra: 1186 SAFE_SIGNED_BYTE_GET_AND_INC (svalue, data, 2, end); 1187 printf ("DW_OP_bra: %ld", (long) svalue); 1188 break; 1189 case DW_OP_eq: 1190 printf ("DW_OP_eq"); 1191 break; 1192 case DW_OP_ge: 1193 printf ("DW_OP_ge"); 1194 break; 1195 case DW_OP_gt: 1196 printf ("DW_OP_gt"); 1197 break; 1198 case DW_OP_le: 1199 printf ("DW_OP_le"); 1200 break; 1201 case DW_OP_lt: 1202 printf ("DW_OP_lt"); 1203 break; 1204 case DW_OP_ne: 1205 printf ("DW_OP_ne"); 1206 break; 1207 case DW_OP_skip: 1208 SAFE_SIGNED_BYTE_GET_AND_INC (svalue, data, 2, end); 1209 printf ("DW_OP_skip: %ld", (long) svalue); 1210 break; 1211 1212 case DW_OP_lit0: 1213 case DW_OP_lit1: 1214 case DW_OP_lit2: 1215 case DW_OP_lit3: 1216 case DW_OP_lit4: 1217 case DW_OP_lit5: 1218 case DW_OP_lit6: 1219 case DW_OP_lit7: 1220 case DW_OP_lit8: 1221 case DW_OP_lit9: 1222 case DW_OP_lit10: 1223 case DW_OP_lit11: 1224 case DW_OP_lit12: 1225 case DW_OP_lit13: 1226 case DW_OP_lit14: 1227 case DW_OP_lit15: 1228 case DW_OP_lit16: 1229 case DW_OP_lit17: 1230 case DW_OP_lit18: 1231 case DW_OP_lit19: 1232 case DW_OP_lit20: 1233 case DW_OP_lit21: 1234 case DW_OP_lit22: 1235 case DW_OP_lit23: 1236 case DW_OP_lit24: 1237 case DW_OP_lit25: 1238 case DW_OP_lit26: 1239 case DW_OP_lit27: 1240 case DW_OP_lit28: 1241 case DW_OP_lit29: 1242 case DW_OP_lit30: 1243 case DW_OP_lit31: 1244 printf ("DW_OP_lit%d", op - DW_OP_lit0); 1245 break; 1246 1247 case DW_OP_reg0: 1248 case DW_OP_reg1: 1249 case DW_OP_reg2: 1250 case DW_OP_reg3: 1251 case DW_OP_reg4: 1252 case DW_OP_reg5: 1253 case DW_OP_reg6: 1254 case DW_OP_reg7: 1255 case DW_OP_reg8: 1256 case DW_OP_reg9: 1257 case DW_OP_reg10: 1258 case DW_OP_reg11: 1259 case DW_OP_reg12: 1260 case DW_OP_reg13: 1261 case DW_OP_reg14: 1262 case DW_OP_reg15: 1263 case DW_OP_reg16: 1264 case DW_OP_reg17: 1265 case DW_OP_reg18: 1266 case DW_OP_reg19: 1267 case DW_OP_reg20: 1268 case DW_OP_reg21: 1269 case DW_OP_reg22: 1270 case DW_OP_reg23: 1271 case DW_OP_reg24: 1272 case DW_OP_reg25: 1273 case DW_OP_reg26: 1274 case DW_OP_reg27: 1275 case DW_OP_reg28: 1276 case DW_OP_reg29: 1277 case DW_OP_reg30: 1278 case DW_OP_reg31: 1279 printf ("DW_OP_reg%d (%s)", op - DW_OP_reg0, 1280 regname (op - DW_OP_reg0, 1)); 1281 break; 1282 1283 case DW_OP_breg0: 1284 case DW_OP_breg1: 1285 case DW_OP_breg2: 1286 case DW_OP_breg3: 1287 case DW_OP_breg4: 1288 case DW_OP_breg5: 1289 case DW_OP_breg6: 1290 case DW_OP_breg7: 1291 case DW_OP_breg8: 1292 case DW_OP_breg9: 1293 case DW_OP_breg10: 1294 case DW_OP_breg11: 1295 case DW_OP_breg12: 1296 case DW_OP_breg13: 1297 case DW_OP_breg14: 1298 case DW_OP_breg15: 1299 case DW_OP_breg16: 1300 case DW_OP_breg17: 1301 case DW_OP_breg18: 1302 case DW_OP_breg19: 1303 case DW_OP_breg20: 1304 case DW_OP_breg21: 1305 case DW_OP_breg22: 1306 case DW_OP_breg23: 1307 case DW_OP_breg24: 1308 case DW_OP_breg25: 1309 case DW_OP_breg26: 1310 case DW_OP_breg27: 1311 case DW_OP_breg28: 1312 case DW_OP_breg29: 1313 case DW_OP_breg30: 1314 case DW_OP_breg31: 1315 READ_SLEB (svalue, data, end); 1316 printf ("DW_OP_breg%d (%s): %s", op - DW_OP_breg0, 1317 regname (op - DW_OP_breg0, 1), dwarf_vmatoa ("d", svalue)); 1318 break; 1319 1320 case DW_OP_regx: 1321 READ_ULEB (uvalue, data, end); 1322 printf ("DW_OP_regx: %s (%s)", 1323 dwarf_vmatoa ("u", uvalue), regname (uvalue, 1)); 1324 break; 1325 case DW_OP_fbreg: 1326 need_frame_base = 1; 1327 READ_SLEB (svalue, data, end); 1328 printf ("DW_OP_fbreg: %s", dwarf_vmatoa ("d", svalue)); 1329 break; 1330 case DW_OP_bregx: 1331 READ_ULEB (uvalue, data, end); 1332 READ_SLEB (svalue, data, end); 1333 printf ("DW_OP_bregx: %s (%s) %s", 1334 dwarf_vmatoa ("u", uvalue), regname (uvalue, 1), 1335 dwarf_vmatoa ("d", svalue)); 1336 break; 1337 case DW_OP_piece: 1338 READ_ULEB (uvalue, data, end); 1339 printf ("DW_OP_piece: %s", dwarf_vmatoa ("u", uvalue)); 1340 break; 1341 case DW_OP_deref_size: 1342 SAFE_BYTE_GET_AND_INC (uvalue, data, 1, end); 1343 printf ("DW_OP_deref_size: %ld", (long) uvalue); 1344 break; 1345 case DW_OP_xderef_size: 1346 SAFE_BYTE_GET_AND_INC (uvalue, data, 1, end); 1347 printf ("DW_OP_xderef_size: %ld", (long) uvalue); 1348 break; 1349 case DW_OP_nop: 1350 printf ("DW_OP_nop"); 1351 break; 1352 1353 /* DWARF 3 extensions. */ 1354 case DW_OP_push_object_address: 1355 printf ("DW_OP_push_object_address"); 1356 break; 1357 case DW_OP_call2: 1358 /* FIXME: Strictly speaking for 64-bit DWARF3 files 1359 this ought to be an 8-byte wide computation. */ 1360 SAFE_SIGNED_BYTE_GET_AND_INC (svalue, data, 2, end); 1361 printf ("DW_OP_call2: <0x%s>", 1362 dwarf_vmatoa ("x", svalue + cu_offset)); 1363 break; 1364 case DW_OP_call4: 1365 /* FIXME: Strictly speaking for 64-bit DWARF3 files 1366 this ought to be an 8-byte wide computation. */ 1367 SAFE_SIGNED_BYTE_GET_AND_INC (svalue, data, 4, end); 1368 printf ("DW_OP_call4: <0x%s>", 1369 dwarf_vmatoa ("x", svalue + cu_offset)); 1370 break; 1371 case DW_OP_call_ref: 1372 /* FIXME: Strictly speaking for 64-bit DWARF3 files 1373 this ought to be an 8-byte wide computation. */ 1374 if (dwarf_version == -1) 1375 { 1376 printf (_("(DW_OP_call_ref in frame info)")); 1377 /* No way to tell where the next op is, so just bail. */ 1378 return need_frame_base; 1379 } 1380 if (dwarf_version == 2) 1381 { 1382 SAFE_BYTE_GET_AND_INC (uvalue, data, pointer_size, end); 1383 } 1384 else 1385 { 1386 SAFE_BYTE_GET_AND_INC (uvalue, data, offset_size, end); 1387 } 1388 printf ("DW_OP_call_ref: <0x%s>", dwarf_vmatoa ("x", uvalue)); 1389 break; 1390 case DW_OP_form_tls_address: 1391 printf ("DW_OP_form_tls_address"); 1392 break; 1393 case DW_OP_call_frame_cfa: 1394 printf ("DW_OP_call_frame_cfa"); 1395 break; 1396 case DW_OP_bit_piece: 1397 printf ("DW_OP_bit_piece: "); 1398 READ_ULEB (uvalue, data, end); 1399 printf (_("size: %s "), dwarf_vmatoa ("u", uvalue)); 1400 READ_ULEB (uvalue, data, end); 1401 printf (_("offset: %s "), dwarf_vmatoa ("u", uvalue)); 1402 break; 1403 1404 /* DWARF 4 extensions. */ 1405 case DW_OP_stack_value: 1406 printf ("DW_OP_stack_value"); 1407 break; 1408 1409 case DW_OP_implicit_value: 1410 printf ("DW_OP_implicit_value"); 1411 READ_ULEB (uvalue, data, end); 1412 data = display_block (data, uvalue, end, ' '); 1413 break; 1414 1415 /* GNU extensions. */ 1416 case DW_OP_GNU_push_tls_address: 1417 printf (_("DW_OP_GNU_push_tls_address or DW_OP_HP_unknown")); 1418 break; 1419 case DW_OP_GNU_uninit: 1420 printf ("DW_OP_GNU_uninit"); 1421 /* FIXME: Is there data associated with this OP ? */ 1422 break; 1423 case DW_OP_GNU_encoded_addr: 1424 { 1425 int encoding = 0; 1426 dwarf_vma addr; 1427 1428 if (data < end) 1429 encoding = *data++; 1430 addr = get_encoded_value (&data, encoding, section, end); 1431 1432 printf ("DW_OP_GNU_encoded_addr: fmt:%02x addr:", encoding); 1433 print_dwarf_vma (addr, pointer_size); 1434 } 1435 break; 1436 case DW_OP_implicit_pointer: 1437 case DW_OP_GNU_implicit_pointer: 1438 /* FIXME: Strictly speaking for 64-bit DWARF3 files 1439 this ought to be an 8-byte wide computation. */ 1440 if (dwarf_version == -1) 1441 { 1442 printf (_("(%s in frame info)"), 1443 (op == DW_OP_implicit_pointer 1444 ? "DW_OP_implicit_pointer" 1445 : "DW_OP_GNU_implicit_pointer")); 1446 /* No way to tell where the next op is, so just bail. */ 1447 return need_frame_base; 1448 } 1449 if (dwarf_version == 2) 1450 { 1451 SAFE_BYTE_GET_AND_INC (uvalue, data, pointer_size, end); 1452 } 1453 else 1454 { 1455 SAFE_BYTE_GET_AND_INC (uvalue, data, offset_size, end); 1456 } 1457 READ_SLEB (svalue, data, end); 1458 printf ("%s: <0x%s> %s", 1459 (op == DW_OP_implicit_pointer 1460 ? "DW_OP_implicit_pointer" : "DW_OP_GNU_implicit_pointer"), 1461 dwarf_vmatoa ("x", uvalue), 1462 dwarf_vmatoa ("d", svalue)); 1463 break; 1464 case DW_OP_entry_value: 1465 case DW_OP_GNU_entry_value: 1466 READ_ULEB (uvalue, data, end); 1467 /* PR 17531: file: 0cc9cd00. */ 1468 if (uvalue > (dwarf_vma) (end - data)) 1469 uvalue = end - data; 1470 printf ("%s: (", (op == DW_OP_entry_value ? "DW_OP_entry_value" 1471 : "DW_OP_GNU_entry_value")); 1472 if (decode_location_expression (data, pointer_size, offset_size, 1473 dwarf_version, uvalue, 1474 cu_offset, section)) 1475 need_frame_base = 1; 1476 putchar (')'); 1477 data += uvalue; 1478 if (data > end) 1479 data = end; 1480 break; 1481 case DW_OP_const_type: 1482 case DW_OP_GNU_const_type: 1483 READ_ULEB (uvalue, data, end); 1484 printf ("%s: <0x%s> ", 1485 (op == DW_OP_const_type ? "DW_OP_const_type" 1486 : "DW_OP_GNU_const_type"), 1487 dwarf_vmatoa ("x", cu_offset + uvalue)); 1488 SAFE_BYTE_GET_AND_INC (uvalue, data, 1, end); 1489 data = display_block (data, uvalue, end, ' '); 1490 break; 1491 case DW_OP_regval_type: 1492 case DW_OP_GNU_regval_type: 1493 READ_ULEB (uvalue, data, end); 1494 printf ("%s: %s (%s)", 1495 (op == DW_OP_regval_type ? "DW_OP_regval_type" 1496 : "DW_OP_GNU_regval_type"), 1497 dwarf_vmatoa ("u", uvalue), regname (uvalue, 1)); 1498 READ_ULEB (uvalue, data, end); 1499 printf (" <0x%s>", dwarf_vmatoa ("x", cu_offset + uvalue)); 1500 break; 1501 case DW_OP_deref_type: 1502 case DW_OP_GNU_deref_type: 1503 SAFE_BYTE_GET_AND_INC (uvalue, data, 1, end); 1504 printf ("%s: %ld", 1505 (op == DW_OP_deref_type ? "DW_OP_deref_type" 1506 : "DW_OP_GNU_deref_type"), 1507 (long) uvalue); 1508 READ_ULEB (uvalue, data, end); 1509 printf (" <0x%s>", dwarf_vmatoa ("x", cu_offset + uvalue)); 1510 break; 1511 case DW_OP_convert: 1512 case DW_OP_GNU_convert: 1513 READ_ULEB (uvalue, data, end); 1514 printf ("%s <0x%s>", 1515 (op == DW_OP_convert ? "DW_OP_convert" : "DW_OP_GNU_convert"), 1516 dwarf_vmatoa ("x", uvalue ? cu_offset + uvalue : 0)); 1517 break; 1518 case DW_OP_reinterpret: 1519 case DW_OP_GNU_reinterpret: 1520 READ_ULEB (uvalue, data, end); 1521 printf ("%s <0x%s>", 1522 (op == DW_OP_reinterpret ? "DW_OP_reinterpret" 1523 : "DW_OP_GNU_reinterpret"), 1524 dwarf_vmatoa ("x", uvalue ? cu_offset + uvalue : 0)); 1525 break; 1526 case DW_OP_GNU_parameter_ref: 1527 SAFE_BYTE_GET_AND_INC (uvalue, data, 4, end); 1528 printf ("DW_OP_GNU_parameter_ref: <0x%s>", 1529 dwarf_vmatoa ("x", cu_offset + uvalue)); 1530 break; 1531 case DW_OP_GNU_addr_index: 1532 READ_ULEB (uvalue, data, end); 1533 printf ("DW_OP_GNU_addr_index <0x%s>", dwarf_vmatoa ("x", uvalue)); 1534 break; 1535 case DW_OP_GNU_const_index: 1536 READ_ULEB (uvalue, data, end); 1537 printf ("DW_OP_GNU_const_index <0x%s>", dwarf_vmatoa ("x", uvalue)); 1538 break; 1539 case DW_OP_GNU_variable_value: 1540 /* FIXME: Strictly speaking for 64-bit DWARF3 files 1541 this ought to be an 8-byte wide computation. */ 1542 if (dwarf_version == -1) 1543 { 1544 printf (_("(DW_OP_GNU_variable_value in frame info)")); 1545 /* No way to tell where the next op is, so just bail. */ 1546 return need_frame_base; 1547 } 1548 if (dwarf_version == 2) 1549 { 1550 SAFE_BYTE_GET_AND_INC (uvalue, data, pointer_size, end); 1551 } 1552 else 1553 { 1554 SAFE_BYTE_GET_AND_INC (uvalue, data, offset_size, end); 1555 } 1556 printf ("DW_OP_GNU_variable_value: <0x%s>", dwarf_vmatoa ("x", uvalue)); 1557 break; 1558 1559 /* HP extensions. */ 1560 case DW_OP_HP_is_value: 1561 printf ("DW_OP_HP_is_value"); 1562 /* FIXME: Is there data associated with this OP ? */ 1563 break; 1564 case DW_OP_HP_fltconst4: 1565 printf ("DW_OP_HP_fltconst4"); 1566 /* FIXME: Is there data associated with this OP ? */ 1567 break; 1568 case DW_OP_HP_fltconst8: 1569 printf ("DW_OP_HP_fltconst8"); 1570 /* FIXME: Is there data associated with this OP ? */ 1571 break; 1572 case DW_OP_HP_mod_range: 1573 printf ("DW_OP_HP_mod_range"); 1574 /* FIXME: Is there data associated with this OP ? */ 1575 break; 1576 case DW_OP_HP_unmod_range: 1577 printf ("DW_OP_HP_unmod_range"); 1578 /* FIXME: Is there data associated with this OP ? */ 1579 break; 1580 case DW_OP_HP_tls: 1581 printf ("DW_OP_HP_tls"); 1582 /* FIXME: Is there data associated with this OP ? */ 1583 break; 1584 1585 /* PGI (STMicroelectronics) extensions. */ 1586 case DW_OP_PGI_omp_thread_num: 1587 /* Pushes the thread number for the current thread as it would be 1588 returned by the standard OpenMP library function: 1589 omp_get_thread_num(). The "current thread" is the thread for 1590 which the expression is being evaluated. */ 1591 printf ("DW_OP_PGI_omp_thread_num"); 1592 break; 1593 1594 default: 1595 if (op >= DW_OP_lo_user 1596 && op <= DW_OP_hi_user) 1597 printf (_("(User defined location op 0x%x)"), op); 1598 else 1599 printf (_("(Unknown location op 0x%x)"), op); 1600 /* No way to tell where the next op is, so just bail. */ 1601 return need_frame_base; 1602 } 1603 1604 /* Separate the ops. */ 1605 if (data < end) 1606 printf ("; "); 1607 } 1608 1609 return need_frame_base; 1610 } 1611 1612 /* Find the CU or TU set corresponding to the given CU_OFFSET. 1613 This is used for DWARF package files. */ 1614 1615 static struct cu_tu_set * 1616 find_cu_tu_set_v2 (dwarf_vma cu_offset, int do_types) 1617 { 1618 struct cu_tu_set *p; 1619 unsigned int nsets; 1620 unsigned int dw_sect; 1621 1622 if (do_types) 1623 { 1624 p = tu_sets; 1625 nsets = tu_count; 1626 dw_sect = DW_SECT_TYPES; 1627 } 1628 else 1629 { 1630 p = cu_sets; 1631 nsets = cu_count; 1632 dw_sect = DW_SECT_INFO; 1633 } 1634 while (nsets > 0) 1635 { 1636 if (p->section_offsets [dw_sect] == cu_offset) 1637 return p; 1638 p++; 1639 nsets--; 1640 } 1641 return NULL; 1642 } 1643 1644 /* Add INC to HIGH_BITS:LOW_BITS. */ 1645 static void 1646 add64 (dwarf_vma * high_bits, dwarf_vma * low_bits, dwarf_vma inc) 1647 { 1648 dwarf_vma tmp = * low_bits; 1649 1650 tmp += inc; 1651 1652 /* FIXME: There is probably a better way of handling this: 1653 1654 We need to cope with dwarf_vma being a 32-bit or 64-bit 1655 type. Plus regardless of its size LOW_BITS is meant to 1656 only hold 32-bits, so if there is overflow or wrap around 1657 we must propagate into HIGH_BITS. */ 1658 if (tmp < * low_bits) 1659 { 1660 ++ * high_bits; 1661 } 1662 else if (sizeof (tmp) > 8 1663 && (tmp >> 31) > 1) 1664 { 1665 ++ * high_bits; 1666 tmp &= 0xFFFFFFFF; 1667 } 1668 1669 * low_bits = tmp; 1670 } 1671 1672 static const char * 1673 fetch_alt_indirect_string (dwarf_vma offset) 1674 { 1675 separate_info * i; 1676 1677 if (! do_follow_links) 1678 return ""; 1679 1680 if (first_separate_info == NULL) 1681 return _("<no links available>"); 1682 1683 for (i = first_separate_info; i != NULL; i = i->next) 1684 { 1685 struct dwarf_section * section; 1686 const char * ret; 1687 1688 if (! load_debug_section (separate_debug_str, i->handle)) 1689 continue; 1690 1691 section = &debug_displays [separate_debug_str].section; 1692 1693 if (section->start == NULL) 1694 continue; 1695 1696 if (offset >= section->size) 1697 continue; 1698 1699 ret = (const char *) (section->start + offset); 1700 /* Unfortunately we cannot rely upon the .debug_str section ending with a 1701 NUL byte. Since our caller is expecting to receive a well formed C 1702 string we test for the lack of a terminating byte here. */ 1703 if (strnlen ((const char *) ret, section->size - offset) 1704 == section->size - offset) 1705 return _("<no NUL byte at end of alt .debug_str section>"); 1706 1707 return ret; 1708 } 1709 1710 warn (_("DW_FORM_GNU_strp_alt offset (%s) too big or no string sections available\n"), 1711 dwarf_vmatoa ("x", offset)); 1712 return _("<offset is too big>"); 1713 } 1714 1715 static const char * 1716 get_AT_name (unsigned long attribute) 1717 { 1718 const char *name; 1719 1720 if (attribute == 0) 1721 return "DW_AT value: 0"; 1722 1723 /* One value is shared by the MIPS and HP extensions: */ 1724 if (attribute == DW_AT_MIPS_fde) 1725 return "DW_AT_MIPS_fde or DW_AT_HP_unmodifiable"; 1726 1727 name = get_DW_AT_name (attribute); 1728 1729 if (name == NULL) 1730 { 1731 static char buffer[100]; 1732 1733 snprintf (buffer, sizeof (buffer), _("Unknown AT value: %lx"), 1734 attribute); 1735 return buffer; 1736 } 1737 1738 return name; 1739 } 1740 1741 static void 1742 add_dwo_info (const char * field, dwo_type type) 1743 { 1744 dwo_info * dwinfo = xmalloc (sizeof * dwinfo); 1745 1746 dwinfo->type = type; 1747 dwinfo->value = field; 1748 dwinfo->next = first_dwo_info; 1749 first_dwo_info = dwinfo; 1750 } 1751 1752 static void 1753 add_dwo_name (const char * name) 1754 { 1755 add_dwo_info (name, DWO_NAME); 1756 } 1757 1758 static void 1759 add_dwo_dir (const char * dir) 1760 { 1761 add_dwo_info (dir, DWO_DIR); 1762 } 1763 1764 static void 1765 add_dwo_id (const char * id) 1766 { 1767 add_dwo_info (id, DWO_ID); 1768 } 1769 1770 static void 1771 free_dwo_info (void) 1772 { 1773 dwo_info * dwinfo; 1774 dwo_info * next; 1775 1776 for (dwinfo = first_dwo_info; dwinfo != NULL; dwinfo = next) 1777 { 1778 next = dwinfo->next; 1779 free (dwinfo); 1780 } 1781 first_dwo_info = NULL; 1782 } 1783 1784 /* Ensure that START + UVALUE is less than END. 1785 Return an adjusted UVALUE if necessary to ensure this relationship. */ 1786 1787 static inline dwarf_vma 1788 check_uvalue (const unsigned char * start, 1789 dwarf_vma uvalue, 1790 const unsigned char * end) 1791 { 1792 dwarf_vma max_uvalue = end - start; 1793 1794 /* See PR 17512: file: 008-103549-0.001:0.1. 1795 and PR 24829 for examples of where these tests are triggered. */ 1796 if (uvalue > max_uvalue) 1797 { 1798 warn (_("Corrupt attribute block length: %lx\n"), (long) uvalue); 1799 uvalue = max_uvalue; 1800 } 1801 1802 return uvalue; 1803 } 1804 1805 static unsigned char * 1806 skip_attr_bytes (unsigned long form, 1807 unsigned char * data, 1808 unsigned const char * end, 1809 dwarf_vma pointer_size, 1810 dwarf_vma offset_size, 1811 int dwarf_version, 1812 dwarf_vma * value_return) 1813 { 1814 dwarf_signed_vma svalue; 1815 dwarf_vma uvalue = 0; 1816 1817 * value_return = 0; 1818 1819 switch (form) 1820 { 1821 case DW_FORM_ref_addr: 1822 if (dwarf_version == 2) 1823 SAFE_BYTE_GET_AND_INC (uvalue, data, pointer_size, end); 1824 else if (dwarf_version == 3 || dwarf_version == 4) 1825 SAFE_BYTE_GET_AND_INC (uvalue, data, offset_size, end); 1826 else 1827 return NULL; 1828 break; 1829 1830 case DW_FORM_addr: 1831 SAFE_BYTE_GET_AND_INC (uvalue, data, pointer_size, end); 1832 break; 1833 1834 case DW_FORM_strp: 1835 case DW_FORM_line_strp: 1836 case DW_FORM_sec_offset: 1837 case DW_FORM_GNU_ref_alt: 1838 case DW_FORM_GNU_strp_alt: 1839 SAFE_BYTE_GET_AND_INC (uvalue, data, offset_size, end); 1840 break; 1841 1842 case DW_FORM_flag_present: 1843 uvalue = 1; 1844 break; 1845 1846 case DW_FORM_ref1: 1847 case DW_FORM_flag: 1848 case DW_FORM_data1: 1849 SAFE_BYTE_GET_AND_INC (uvalue, data, 1, end); 1850 break; 1851 1852 case DW_FORM_ref2: 1853 case DW_FORM_data2: 1854 SAFE_BYTE_GET_AND_INC (uvalue, data, 2, end); 1855 break; 1856 1857 case DW_FORM_ref4: 1858 case DW_FORM_data4: 1859 SAFE_BYTE_GET_AND_INC (uvalue, data, 4, end); 1860 break; 1861 1862 case DW_FORM_sdata: 1863 READ_SLEB (svalue, data, end); 1864 uvalue = svalue; 1865 break; 1866 1867 case DW_FORM_ref_udata: 1868 case DW_FORM_udata: 1869 case DW_FORM_GNU_str_index: 1870 case DW_FORM_GNU_addr_index: 1871 READ_ULEB (uvalue, data, end); 1872 break; 1873 1874 case DW_FORM_ref8: 1875 case DW_FORM_data8: 1876 data += 8; 1877 break; 1878 1879 case DW_FORM_data16: 1880 data += 16; 1881 break; 1882 1883 case DW_FORM_string: 1884 data += strnlen ((char *) data, end - data) + 1; 1885 break; 1886 1887 case DW_FORM_block: 1888 case DW_FORM_exprloc: 1889 READ_ULEB (uvalue, data, end); 1890 break; 1891 1892 case DW_FORM_block1: 1893 SAFE_BYTE_GET (uvalue, data, 1, end); 1894 data += 1 + uvalue; 1895 break; 1896 1897 case DW_FORM_block2: 1898 SAFE_BYTE_GET (uvalue, data, 2, end); 1899 data += 2 + uvalue; 1900 break; 1901 1902 case DW_FORM_block4: 1903 SAFE_BYTE_GET (uvalue, data, 4, end); 1904 data += 4 + uvalue; 1905 break; 1906 1907 case DW_FORM_ref_sig8: 1908 data += 8; 1909 break; 1910 1911 case DW_FORM_indirect: 1912 /* FIXME: Handle this form. */ 1913 default: 1914 return NULL; 1915 } 1916 1917 * value_return = uvalue; 1918 if (data > end) 1919 data = (unsigned char *) end; 1920 return data; 1921 } 1922 1923 /* Return IS_SIGNED set to TRUE if the type at 1924 DATA can be determined to be a signed type. */ 1925 1926 static void 1927 get_type_signedness (unsigned char * start, 1928 unsigned char * data, 1929 unsigned const char * end, 1930 dwarf_vma pointer_size, 1931 dwarf_vma offset_size, 1932 int dwarf_version, 1933 bfd_boolean * is_signed, 1934 bfd_boolean is_nested) 1935 { 1936 unsigned long abbrev_number; 1937 abbrev_entry * entry; 1938 abbrev_attr * attr; 1939 1940 * is_signed = FALSE; 1941 1942 READ_ULEB (abbrev_number, data, end); 1943 1944 for (entry = first_abbrev; 1945 entry != NULL && entry->entry != abbrev_number; 1946 entry = entry->next) 1947 continue; 1948 1949 if (entry == NULL) 1950 /* FIXME: Issue a warning ? */ 1951 return; 1952 1953 for (attr = entry->first_attr; 1954 attr != NULL && attr->attribute; 1955 attr = attr->next) 1956 { 1957 dwarf_vma uvalue = 0; 1958 1959 data = skip_attr_bytes (attr->form, data, end, pointer_size, 1960 offset_size, dwarf_version, & uvalue); 1961 if (data == NULL) 1962 return; 1963 1964 switch (attr->attribute) 1965 { 1966 #if 0 /* FIXME: It would be nice to print the name of the type, 1967 but this would mean updating a lot of binutils tests. */ 1968 case DW_AT_name: 1969 if (attr->form == DW_FORM_strp) 1970 printf ("%s", fetch_indirect_string (uvalue)); 1971 break; 1972 #endif 1973 case DW_AT_type: 1974 /* Recurse. */ 1975 if (is_nested) 1976 { 1977 /* FIXME: Warn - or is this expected ? 1978 NB/ We need to avoid infinite recursion. */ 1979 return; 1980 } 1981 if (uvalue >= (size_t) (end - start)) 1982 return; 1983 get_type_signedness (start, start + uvalue, end, pointer_size, 1984 offset_size, dwarf_version, is_signed, TRUE); 1985 break; 1986 1987 case DW_AT_encoding: 1988 /* Determine signness. */ 1989 switch (uvalue) 1990 { 1991 case DW_ATE_address: 1992 /* FIXME - some architectures have signed addresses. */ 1993 case DW_ATE_boolean: 1994 case DW_ATE_unsigned: 1995 case DW_ATE_unsigned_char: 1996 case DW_ATE_unsigned_fixed: 1997 * is_signed = FALSE; 1998 break; 1999 2000 default: 2001 case DW_ATE_complex_float: 2002 case DW_ATE_float: 2003 case DW_ATE_signed: 2004 case DW_ATE_signed_char: 2005 case DW_ATE_imaginary_float: 2006 case DW_ATE_decimal_float: 2007 case DW_ATE_signed_fixed: 2008 * is_signed = TRUE; 2009 break; 2010 } 2011 break; 2012 } 2013 } 2014 } 2015 2016 static void 2017 read_and_print_leb128 (unsigned char * data, 2018 unsigned int * bytes_read, 2019 unsigned const char * end, 2020 bfd_boolean is_signed) 2021 { 2022 int status; 2023 dwarf_vma val = read_leb128 (data, end, is_signed, bytes_read, &status); 2024 if (status != 0) 2025 report_leb_status (status); 2026 else 2027 printf ("%s", dwarf_vmatoa (is_signed ? "d" : "u", val)); 2028 } 2029 2030 static void 2031 display_discr_list (unsigned long form, 2032 dwarf_vma uvalue, 2033 unsigned char * data, 2034 unsigned const char * end, 2035 int level) 2036 { 2037 if (uvalue == 0) 2038 { 2039 printf ("[default]"); 2040 return; 2041 } 2042 2043 switch (form) 2044 { 2045 case DW_FORM_block: 2046 case DW_FORM_block1: 2047 case DW_FORM_block2: 2048 case DW_FORM_block4: 2049 /* Move data pointer back to the start of the byte array. */ 2050 data -= uvalue; 2051 break; 2052 default: 2053 printf ("<corrupt>\n"); 2054 warn (_("corrupt discr_list - not using a block form\n")); 2055 return; 2056 } 2057 2058 if (uvalue < 2) 2059 { 2060 printf ("<corrupt>\n"); 2061 warn (_("corrupt discr_list - block not long enough\n")); 2062 return; 2063 } 2064 2065 bfd_boolean is_signed = 2066 (level > 0 && level <= MAX_CU_NESTING) 2067 ? level_type_signed [level - 1] : FALSE; 2068 2069 printf ("("); 2070 while (uvalue) 2071 { 2072 unsigned char discriminant; 2073 unsigned int bytes_read; 2074 2075 SAFE_BYTE_GET (discriminant, data, 1, end); 2076 -- uvalue; 2077 data ++; 2078 2079 assert (uvalue > 0); 2080 switch (discriminant) 2081 { 2082 case DW_DSC_label: 2083 printf ("label "); 2084 read_and_print_leb128 (data, & bytes_read, end, is_signed); 2085 assert (bytes_read <= uvalue && bytes_read > 0); 2086 uvalue -= bytes_read; 2087 data += bytes_read; 2088 break; 2089 2090 case DW_DSC_range: 2091 printf ("range "); 2092 read_and_print_leb128 (data, & bytes_read, end, is_signed); 2093 assert (bytes_read <= uvalue && bytes_read > 0); 2094 uvalue -= bytes_read; 2095 data += bytes_read; 2096 2097 printf (".."); 2098 read_and_print_leb128 (data, & bytes_read, end, is_signed); 2099 assert (bytes_read <= uvalue && bytes_read > 0); 2100 uvalue -= bytes_read; 2101 data += bytes_read; 2102 break; 2103 2104 default: 2105 printf ("<corrupt>\n"); 2106 warn (_("corrupt discr_list - unrecognised discriminant byte %#x\n"), 2107 discriminant); 2108 return; 2109 } 2110 2111 if (uvalue) 2112 printf (", "); 2113 } 2114 2115 if (is_signed) 2116 printf (")(signed)"); 2117 else 2118 printf (")(unsigned)"); 2119 } 2120 2121 static unsigned char * 2122 read_and_display_attr_value (unsigned long attribute, 2123 unsigned long form, 2124 dwarf_signed_vma implicit_const, 2125 unsigned char * start, 2126 unsigned char * data, 2127 unsigned char * end, 2128 dwarf_vma cu_offset, 2129 dwarf_vma pointer_size, 2130 dwarf_vma offset_size, 2131 int dwarf_version, 2132 debug_info * debug_info_p, 2133 int do_loc, 2134 struct dwarf_section * section, 2135 struct cu_tu_set * this_set, 2136 char delimiter, 2137 int level) 2138 { 2139 dwarf_signed_vma svalue; 2140 dwarf_vma uvalue = 0; 2141 unsigned char * block_start = NULL; 2142 unsigned char * orig_data = data; 2143 2144 if (data > end || (data == end && form != DW_FORM_flag_present)) 2145 { 2146 warn (_("Corrupt attribute\n")); 2147 return data; 2148 } 2149 2150 switch (form) 2151 { 2152 default: 2153 break; 2154 2155 case DW_FORM_ref_addr: 2156 if (dwarf_version == 2) 2157 SAFE_BYTE_GET_AND_INC (uvalue, data, pointer_size, end); 2158 else if (dwarf_version == 3 || dwarf_version == 4) 2159 SAFE_BYTE_GET_AND_INC (uvalue, data, offset_size, end); 2160 else 2161 error (_("Internal error: DWARF version is not 2, 3 or 4.\n")); 2162 2163 break; 2164 2165 case DW_FORM_addr: 2166 SAFE_BYTE_GET_AND_INC (uvalue, data, pointer_size, end); 2167 break; 2168 2169 case DW_FORM_strp: 2170 case DW_FORM_line_strp: 2171 case DW_FORM_sec_offset: 2172 case DW_FORM_GNU_ref_alt: 2173 case DW_FORM_GNU_strp_alt: 2174 SAFE_BYTE_GET_AND_INC (uvalue, data, offset_size, end); 2175 break; 2176 2177 case DW_FORM_flag_present: 2178 uvalue = 1; 2179 break; 2180 2181 case DW_FORM_ref1: 2182 case DW_FORM_flag: 2183 case DW_FORM_data1: 2184 SAFE_BYTE_GET_AND_INC (uvalue, data, 1, end); 2185 break; 2186 2187 case DW_FORM_ref2: 2188 case DW_FORM_data2: 2189 SAFE_BYTE_GET_AND_INC (uvalue, data, 2, end); 2190 break; 2191 2192 case DW_FORM_ref4: 2193 case DW_FORM_data4: 2194 SAFE_BYTE_GET_AND_INC (uvalue, data, 4, end); 2195 break; 2196 2197 case DW_FORM_sdata: 2198 READ_SLEB (svalue, data, end); 2199 uvalue = svalue; 2200 break; 2201 2202 case DW_FORM_GNU_str_index: 2203 case DW_FORM_ref_udata: 2204 case DW_FORM_udata: 2205 case DW_FORM_GNU_addr_index: 2206 READ_ULEB (uvalue, data, end); 2207 break; 2208 2209 case DW_FORM_indirect: 2210 READ_ULEB (form, data, end); 2211 if (!do_loc) 2212 printf ("%c%s", delimiter, get_FORM_name (form)); 2213 if (form == DW_FORM_implicit_const) 2214 READ_SLEB (implicit_const, data, end); 2215 return read_and_display_attr_value (attribute, form, implicit_const, 2216 start, data, end, 2217 cu_offset, pointer_size, 2218 offset_size, dwarf_version, 2219 debug_info_p, do_loc, 2220 section, this_set, delimiter, level); 2221 } 2222 2223 switch (form) 2224 { 2225 case DW_FORM_ref_addr: 2226 if (!do_loc) 2227 printf ("%c<0x%s>", delimiter, dwarf_vmatoa ("x",uvalue)); 2228 break; 2229 2230 case DW_FORM_GNU_ref_alt: 2231 if (!do_loc) 2232 printf ("%c<alt 0x%s>", delimiter, dwarf_vmatoa ("x",uvalue)); 2233 /* FIXME: Follow the reference... */ 2234 break; 2235 2236 case DW_FORM_ref1: 2237 case DW_FORM_ref2: 2238 case DW_FORM_ref4: 2239 case DW_FORM_ref_udata: 2240 if (!do_loc) 2241 printf ("%c<0x%s>", delimiter, dwarf_vmatoa ("x", uvalue + cu_offset)); 2242 break; 2243 2244 case DW_FORM_data4: 2245 case DW_FORM_addr: 2246 case DW_FORM_sec_offset: 2247 if (!do_loc) 2248 printf ("%c0x%s", delimiter, dwarf_vmatoa ("x", uvalue)); 2249 break; 2250 2251 case DW_FORM_flag_present: 2252 case DW_FORM_flag: 2253 case DW_FORM_data1: 2254 case DW_FORM_data2: 2255 case DW_FORM_sdata: 2256 case DW_FORM_udata: 2257 if (!do_loc) 2258 printf ("%c%s", delimiter, dwarf_vmatoa ("d", uvalue)); 2259 break; 2260 2261 case DW_FORM_implicit_const: 2262 if (!do_loc) 2263 printf ("%c%s", delimiter, dwarf_vmatoa ("d", implicit_const)); 2264 break; 2265 2266 case DW_FORM_ref8: 2267 case DW_FORM_data8: 2268 if (!do_loc) 2269 { 2270 dwarf_vma high_bits; 2271 dwarf_vma utmp; 2272 char buf[64]; 2273 2274 SAFE_BYTE_GET64 (data, &high_bits, &uvalue, end); 2275 utmp = uvalue; 2276 if (form == DW_FORM_ref8) 2277 add64 (& high_bits, & utmp, cu_offset); 2278 printf ("%c0x%s", delimiter, 2279 dwarf_vmatoa64 (high_bits, utmp, buf, sizeof (buf))); 2280 } 2281 2282 if ((do_loc || do_debug_loc || do_debug_ranges) 2283 && num_debug_info_entries == 0) 2284 { 2285 if (sizeof (uvalue) == 8) 2286 SAFE_BYTE_GET (uvalue, data, 8, end); 2287 else 2288 error (_("DW_FORM_data8 is unsupported when sizeof (dwarf_vma) != 8\n")); 2289 } 2290 2291 data += 8; 2292 break; 2293 2294 case DW_FORM_data16: 2295 if (!do_loc) 2296 { 2297 dwarf_vma left_high_bits, left_low_bits; 2298 dwarf_vma right_high_bits, right_low_bits; 2299 2300 SAFE_BYTE_GET64 (data, &left_high_bits, &left_low_bits, end); 2301 SAFE_BYTE_GET64 (data + 8, &right_high_bits, &right_low_bits, end); 2302 if (byte_get == byte_get_little_endian) 2303 { 2304 /* Swap them. */ 2305 left_high_bits ^= right_high_bits; 2306 right_high_bits ^= left_high_bits; 2307 left_high_bits ^= right_high_bits; 2308 left_low_bits ^= right_low_bits; 2309 right_low_bits ^= left_low_bits; 2310 left_low_bits ^= right_low_bits; 2311 } 2312 printf (" 0x%08" DWARF_VMA_FMT "x%08" DWARF_VMA_FMT "x" 2313 "%08" DWARF_VMA_FMT "x%08" DWARF_VMA_FMT "x", 2314 left_high_bits, left_low_bits, right_high_bits, 2315 right_low_bits); 2316 } 2317 data += 16; 2318 break; 2319 2320 case DW_FORM_string: 2321 if (!do_loc) 2322 printf ("%c%.*s", delimiter, (int) (end - data), data); 2323 data += strnlen ((char *) data, end - data) + 1; 2324 break; 2325 2326 case DW_FORM_block: 2327 case DW_FORM_exprloc: 2328 READ_ULEB (uvalue, data, end); 2329 do_block: 2330 block_start = data; 2331 if (block_start >= end) 2332 { 2333 warn (_("Block ends prematurely\n")); 2334 uvalue = 0; 2335 block_start = end; 2336 } 2337 2338 uvalue = check_uvalue (block_start, uvalue, end); 2339 2340 if (do_loc) 2341 data = block_start + uvalue; 2342 else 2343 data = display_block (block_start, uvalue, end, delimiter); 2344 break; 2345 2346 case DW_FORM_block1: 2347 SAFE_BYTE_GET_AND_INC (uvalue, data, 1, end); 2348 goto do_block; 2349 2350 case DW_FORM_block2: 2351 SAFE_BYTE_GET_AND_INC (uvalue, data, 2, end); 2352 goto do_block; 2353 2354 case DW_FORM_block4: 2355 SAFE_BYTE_GET_AND_INC (uvalue, data, 4, end); 2356 goto do_block; 2357 2358 case DW_FORM_strp: 2359 if (!do_loc) 2360 printf (_("%c(indirect string, offset: 0x%s): %s"), delimiter, 2361 dwarf_vmatoa ("x", uvalue), 2362 fetch_indirect_string (uvalue)); 2363 break; 2364 2365 case DW_FORM_line_strp: 2366 if (!do_loc) 2367 printf (_("%c(indirect line string, offset: 0x%s): %s"), delimiter, 2368 dwarf_vmatoa ("x", uvalue), 2369 fetch_indirect_line_string (uvalue)); 2370 break; 2371 2372 case DW_FORM_GNU_str_index: 2373 if (!do_loc) 2374 { 2375 const char * suffix = strrchr (section->name, '.'); 2376 bfd_boolean dwo = (suffix && strcmp (suffix, ".dwo") == 0) ? TRUE : FALSE; 2377 2378 printf (_("%c(indexed string: 0x%s): %s"), delimiter, 2379 dwarf_vmatoa ("x", uvalue), 2380 fetch_indexed_string (uvalue, this_set, offset_size, dwo)); 2381 } 2382 break; 2383 2384 case DW_FORM_GNU_strp_alt: 2385 if (!do_loc) 2386 { 2387 printf (_("%c(alt indirect string, offset: 0x%s) %s"), delimiter, 2388 dwarf_vmatoa ("x", uvalue), 2389 fetch_alt_indirect_string (uvalue)); 2390 } 2391 break; 2392 2393 case DW_FORM_indirect: 2394 /* Handled above. */ 2395 break; 2396 2397 case DW_FORM_ref_sig8: 2398 if (!do_loc) 2399 { 2400 dwarf_vma high_bits; 2401 char buf[64]; 2402 2403 SAFE_BYTE_GET64 (data, &high_bits, &uvalue, end); 2404 printf ("%csignature: 0x%s", delimiter, 2405 dwarf_vmatoa64 (high_bits, uvalue, buf, sizeof (buf))); 2406 } 2407 data += 8; 2408 break; 2409 2410 case DW_FORM_GNU_addr_index: 2411 if (!do_loc) 2412 printf (_("%c(addr_index: 0x%s): %s"), delimiter, 2413 dwarf_vmatoa ("x", uvalue), 2414 fetch_indexed_value (uvalue * pointer_size, pointer_size)); 2415 break; 2416 2417 default: 2418 warn (_("Unrecognized form: %lu\n"), form); 2419 break; 2420 } 2421 2422 if ((do_loc || do_debug_loc || do_debug_ranges) 2423 && num_debug_info_entries == 0 2424 && debug_info_p != NULL) 2425 { 2426 switch (attribute) 2427 { 2428 case DW_AT_frame_base: 2429 have_frame_base = 1; 2430 /* Fall through. */ 2431 case DW_AT_location: 2432 case DW_AT_GNU_locviews: 2433 case DW_AT_string_length: 2434 case DW_AT_return_addr: 2435 case DW_AT_data_member_location: 2436 case DW_AT_vtable_elem_location: 2437 case DW_AT_segment: 2438 case DW_AT_static_link: 2439 case DW_AT_use_location: 2440 case DW_AT_call_value: 2441 case DW_AT_GNU_call_site_value: 2442 case DW_AT_call_data_value: 2443 case DW_AT_GNU_call_site_data_value: 2444 case DW_AT_call_target: 2445 case DW_AT_GNU_call_site_target: 2446 case DW_AT_call_target_clobbered: 2447 case DW_AT_GNU_call_site_target_clobbered: 2448 if ((dwarf_version < 4 2449 && (form == DW_FORM_data4 || form == DW_FORM_data8)) 2450 || form == DW_FORM_sec_offset) 2451 { 2452 /* Process location list. */ 2453 unsigned int lmax = debug_info_p->max_loc_offsets; 2454 unsigned int num = debug_info_p->num_loc_offsets; 2455 2456 if (lmax == 0 || num >= lmax) 2457 { 2458 lmax += 1024; 2459 debug_info_p->loc_offsets = (dwarf_vma *) 2460 xcrealloc (debug_info_p->loc_offsets, 2461 lmax, sizeof (*debug_info_p->loc_offsets)); 2462 debug_info_p->loc_views = (dwarf_vma *) 2463 xcrealloc (debug_info_p->loc_views, 2464 lmax, sizeof (*debug_info_p->loc_views)); 2465 debug_info_p->have_frame_base = (int *) 2466 xcrealloc (debug_info_p->have_frame_base, 2467 lmax, sizeof (*debug_info_p->have_frame_base)); 2468 debug_info_p->max_loc_offsets = lmax; 2469 } 2470 if (this_set != NULL) 2471 uvalue += this_set->section_offsets [DW_SECT_LOC]; 2472 debug_info_p->have_frame_base [num] = have_frame_base; 2473 if (attribute != DW_AT_GNU_locviews) 2474 { 2475 /* Corrupt DWARF info can produce more offsets than views. 2476 See PR 23062 for an example. */ 2477 if (debug_info_p->num_loc_offsets 2478 > debug_info_p->num_loc_views) 2479 warn (_("More location offset attributes than DW_AT_GNU_locview attributes\n")); 2480 else 2481 { 2482 debug_info_p->loc_offsets [num] = uvalue; 2483 debug_info_p->num_loc_offsets++; 2484 } 2485 } 2486 else 2487 { 2488 assert (debug_info_p->num_loc_views <= num); 2489 num = debug_info_p->num_loc_views; 2490 if (num > debug_info_p->num_loc_offsets) 2491 warn (_("More DW_AT_GNU_locview attributes than location offset attributes\n")); 2492 else 2493 { 2494 debug_info_p->loc_views [num] = uvalue; 2495 debug_info_p->num_loc_views++; 2496 } 2497 } 2498 } 2499 break; 2500 2501 case DW_AT_low_pc: 2502 if (need_base_address) 2503 debug_info_p->base_address = uvalue; 2504 break; 2505 2506 case DW_AT_GNU_addr_base: 2507 debug_info_p->addr_base = uvalue; 2508 break; 2509 2510 case DW_AT_GNU_ranges_base: 2511 debug_info_p->ranges_base = uvalue; 2512 break; 2513 2514 case DW_AT_ranges: 2515 if ((dwarf_version < 4 2516 && (form == DW_FORM_data4 || form == DW_FORM_data8)) 2517 || form == DW_FORM_sec_offset) 2518 { 2519 /* Process range list. */ 2520 unsigned int lmax = debug_info_p->max_range_lists; 2521 unsigned int num = debug_info_p->num_range_lists; 2522 2523 if (lmax == 0 || num >= lmax) 2524 { 2525 lmax += 1024; 2526 debug_info_p->range_lists = (dwarf_vma *) 2527 xcrealloc (debug_info_p->range_lists, 2528 lmax, sizeof (*debug_info_p->range_lists)); 2529 debug_info_p->max_range_lists = lmax; 2530 } 2531 debug_info_p->range_lists [num] = uvalue; 2532 debug_info_p->num_range_lists++; 2533 } 2534 break; 2535 2536 case DW_AT_GNU_dwo_name: 2537 case DW_AT_dwo_name: 2538 if (need_dwo_info) 2539 switch (form) 2540 { 2541 case DW_FORM_strp: 2542 add_dwo_name ((const char *) fetch_indirect_string (uvalue)); 2543 break; 2544 case DW_FORM_GNU_str_index: 2545 add_dwo_name (fetch_indexed_string (uvalue, this_set, offset_size, FALSE)); 2546 break; 2547 case DW_FORM_string: 2548 add_dwo_name ((const char *) orig_data); 2549 break; 2550 default: 2551 warn (_("Unsupported form (%s) for attribute %s\n"), 2552 get_FORM_name (form), get_AT_name (attribute)); 2553 break; 2554 } 2555 break; 2556 2557 case DW_AT_comp_dir: 2558 /* FIXME: Also extract a build-id in a CU/TU. */ 2559 if (need_dwo_info) 2560 switch (form) 2561 { 2562 case DW_FORM_strp: 2563 add_dwo_dir ((const char *) fetch_indirect_string (uvalue)); 2564 break; 2565 case DW_FORM_line_strp: 2566 add_dwo_dir ((const char *) fetch_indirect_line_string (uvalue)); 2567 break; 2568 case DW_FORM_GNU_str_index: 2569 add_dwo_dir (fetch_indexed_string (uvalue, this_set, offset_size, FALSE)); 2570 break; 2571 case DW_FORM_string: 2572 add_dwo_dir ((const char *) orig_data); 2573 break; 2574 default: 2575 warn (_("Unsupported form (%s) for attribute %s\n"), 2576 get_FORM_name (form), get_AT_name (attribute)); 2577 break; 2578 } 2579 break; 2580 2581 case DW_AT_GNU_dwo_id: 2582 if (need_dwo_info) 2583 switch (form) 2584 { 2585 case DW_FORM_data8: 2586 /* FIXME: Record the length of the ID as well ? */ 2587 add_dwo_id ((const char *) (data - 8)); 2588 break; 2589 default: 2590 warn (_("Unsupported form (%s) for attribute %s\n"), 2591 get_FORM_name (form), get_AT_name (attribute)); 2592 break; 2593 } 2594 break; 2595 2596 default: 2597 break; 2598 } 2599 } 2600 2601 if (do_loc || attribute == 0) 2602 return data; 2603 2604 /* For some attributes we can display further information. */ 2605 switch (attribute) 2606 { 2607 case DW_AT_type: 2608 if (level >= 0 && level < MAX_CU_NESTING 2609 && uvalue < (size_t) (end - start)) 2610 { 2611 bfd_boolean is_signed = FALSE; 2612 2613 get_type_signedness (start, start + uvalue, end, pointer_size, 2614 offset_size, dwarf_version, & is_signed, FALSE); 2615 level_type_signed[level] = is_signed; 2616 } 2617 break; 2618 2619 case DW_AT_inline: 2620 printf ("\t"); 2621 switch (uvalue) 2622 { 2623 case DW_INL_not_inlined: 2624 printf (_("(not inlined)")); 2625 break; 2626 case DW_INL_inlined: 2627 printf (_("(inlined)")); 2628 break; 2629 case DW_INL_declared_not_inlined: 2630 printf (_("(declared as inline but ignored)")); 2631 break; 2632 case DW_INL_declared_inlined: 2633 printf (_("(declared as inline and inlined)")); 2634 break; 2635 default: 2636 printf (_(" (Unknown inline attribute value: %s)"), 2637 dwarf_vmatoa ("x", uvalue)); 2638 break; 2639 } 2640 break; 2641 2642 case DW_AT_language: 2643 printf ("\t"); 2644 switch (uvalue) 2645 { 2646 /* Ordered by the numeric value of these constants. */ 2647 case DW_LANG_C89: printf ("(ANSI C)"); break; 2648 case DW_LANG_C: printf ("(non-ANSI C)"); break; 2649 case DW_LANG_Ada83: printf ("(Ada)"); break; 2650 case DW_LANG_C_plus_plus: printf ("(C++)"); break; 2651 case DW_LANG_Cobol74: printf ("(Cobol 74)"); break; 2652 case DW_LANG_Cobol85: printf ("(Cobol 85)"); break; 2653 case DW_LANG_Fortran77: printf ("(FORTRAN 77)"); break; 2654 case DW_LANG_Fortran90: printf ("(Fortran 90)"); break; 2655 case DW_LANG_Pascal83: printf ("(ANSI Pascal)"); break; 2656 case DW_LANG_Modula2: printf ("(Modula 2)"); break; 2657 /* DWARF 2.1 values. */ 2658 case DW_LANG_Java: printf ("(Java)"); break; 2659 case DW_LANG_C99: printf ("(ANSI C99)"); break; 2660 case DW_LANG_Ada95: printf ("(ADA 95)"); break; 2661 case DW_LANG_Fortran95: printf ("(Fortran 95)"); break; 2662 /* DWARF 3 values. */ 2663 case DW_LANG_PLI: printf ("(PLI)"); break; 2664 case DW_LANG_ObjC: printf ("(Objective C)"); break; 2665 case DW_LANG_ObjC_plus_plus: printf ("(Objective C++)"); break; 2666 case DW_LANG_UPC: printf ("(Unified Parallel C)"); break; 2667 case DW_LANG_D: printf ("(D)"); break; 2668 /* DWARF 4 values. */ 2669 case DW_LANG_Python: printf ("(Python)"); break; 2670 /* DWARF 5 values. */ 2671 case DW_LANG_OpenCL: printf ("(OpenCL)"); break; 2672 case DW_LANG_Go: printf ("(Go)"); break; 2673 case DW_LANG_Modula3: printf ("(Modula 3)"); break; 2674 case DW_LANG_Haskell: printf ("(Haskell)"); break; 2675 case DW_LANG_C_plus_plus_03: printf ("(C++03)"); break; 2676 case DW_LANG_C_plus_plus_11: printf ("(C++11)"); break; 2677 case DW_LANG_OCaml: printf ("(OCaml)"); break; 2678 case DW_LANG_Rust: printf ("(Rust)"); break; 2679 case DW_LANG_C11: printf ("(C11)"); break; 2680 case DW_LANG_Swift: printf ("(Swift)"); break; 2681 case DW_LANG_Julia: printf ("(Julia)"); break; 2682 case DW_LANG_Dylan: printf ("(Dylan)"); break; 2683 case DW_LANG_C_plus_plus_14: printf ("(C++14)"); break; 2684 case DW_LANG_Fortran03: printf ("(Fortran 03)"); break; 2685 case DW_LANG_Fortran08: printf ("(Fortran 08)"); break; 2686 case DW_LANG_RenderScript: printf ("(RenderScript)"); break; 2687 /* MIPS extension. */ 2688 case DW_LANG_Mips_Assembler: printf ("(MIPS assembler)"); break; 2689 /* UPC extension. */ 2690 case DW_LANG_Upc: printf ("(Unified Parallel C)"); break; 2691 default: 2692 if (uvalue >= DW_LANG_lo_user && uvalue <= DW_LANG_hi_user) 2693 printf (_("(implementation defined: %s)"), 2694 dwarf_vmatoa ("x", uvalue)); 2695 else 2696 printf (_("(Unknown: %s)"), dwarf_vmatoa ("x", uvalue)); 2697 break; 2698 } 2699 break; 2700 2701 case DW_AT_encoding: 2702 printf ("\t"); 2703 switch (uvalue) 2704 { 2705 case DW_ATE_void: printf ("(void)"); break; 2706 case DW_ATE_address: printf ("(machine address)"); break; 2707 case DW_ATE_boolean: printf ("(boolean)"); break; 2708 case DW_ATE_complex_float: printf ("(complex float)"); break; 2709 case DW_ATE_float: printf ("(float)"); break; 2710 case DW_ATE_signed: printf ("(signed)"); break; 2711 case DW_ATE_signed_char: printf ("(signed char)"); break; 2712 case DW_ATE_unsigned: printf ("(unsigned)"); break; 2713 case DW_ATE_unsigned_char: printf ("(unsigned char)"); break; 2714 /* DWARF 2.1 values: */ 2715 case DW_ATE_imaginary_float: printf ("(imaginary float)"); break; 2716 case DW_ATE_decimal_float: printf ("(decimal float)"); break; 2717 /* DWARF 3 values: */ 2718 case DW_ATE_packed_decimal: printf ("(packed_decimal)"); break; 2719 case DW_ATE_numeric_string: printf ("(numeric_string)"); break; 2720 case DW_ATE_edited: printf ("(edited)"); break; 2721 case DW_ATE_signed_fixed: printf ("(signed_fixed)"); break; 2722 case DW_ATE_unsigned_fixed: printf ("(unsigned_fixed)"); break; 2723 /* DWARF 4 values: */ 2724 case DW_ATE_UTF: printf ("(unicode string)"); break; 2725 /* DWARF 5 values: */ 2726 case DW_ATE_UCS: printf ("(UCS)"); break; 2727 case DW_ATE_ASCII: printf ("(ASCII)"); break; 2728 2729 /* HP extensions: */ 2730 case DW_ATE_HP_float80: printf ("(HP_float80)"); break; 2731 case DW_ATE_HP_complex_float80: printf ("(HP_complex_float80)"); break; 2732 case DW_ATE_HP_float128: printf ("(HP_float128)"); break; 2733 case DW_ATE_HP_complex_float128:printf ("(HP_complex_float128)"); break; 2734 case DW_ATE_HP_floathpintel: printf ("(HP_floathpintel)"); break; 2735 case DW_ATE_HP_imaginary_float80: printf ("(HP_imaginary_float80)"); break; 2736 case DW_ATE_HP_imaginary_float128: printf ("(HP_imaginary_float128)"); break; 2737 2738 default: 2739 if (uvalue >= DW_ATE_lo_user 2740 && uvalue <= DW_ATE_hi_user) 2741 printf (_("(user defined type)")); 2742 else 2743 printf (_("(unknown type)")); 2744 break; 2745 } 2746 break; 2747 2748 case DW_AT_accessibility: 2749 printf ("\t"); 2750 switch (uvalue) 2751 { 2752 case DW_ACCESS_public: printf ("(public)"); break; 2753 case DW_ACCESS_protected: printf ("(protected)"); break; 2754 case DW_ACCESS_private: printf ("(private)"); break; 2755 default: 2756 printf (_("(unknown accessibility)")); 2757 break; 2758 } 2759 break; 2760 2761 case DW_AT_visibility: 2762 printf ("\t"); 2763 switch (uvalue) 2764 { 2765 case DW_VIS_local: printf ("(local)"); break; 2766 case DW_VIS_exported: printf ("(exported)"); break; 2767 case DW_VIS_qualified: printf ("(qualified)"); break; 2768 default: printf (_("(unknown visibility)")); break; 2769 } 2770 break; 2771 2772 case DW_AT_endianity: 2773 printf ("\t"); 2774 switch (uvalue) 2775 { 2776 case DW_END_default: printf ("(default)"); break; 2777 case DW_END_big: printf ("(big)"); break; 2778 case DW_END_little: printf ("(little)"); break; 2779 default: 2780 if (uvalue >= DW_END_lo_user && uvalue <= DW_END_hi_user) 2781 printf (_("(user specified)")); 2782 else 2783 printf (_("(unknown endianity)")); 2784 break; 2785 } 2786 break; 2787 2788 case DW_AT_virtuality: 2789 printf ("\t"); 2790 switch (uvalue) 2791 { 2792 case DW_VIRTUALITY_none: printf ("(none)"); break; 2793 case DW_VIRTUALITY_virtual: printf ("(virtual)"); break; 2794 case DW_VIRTUALITY_pure_virtual:printf ("(pure_virtual)"); break; 2795 default: printf (_("(unknown virtuality)")); break; 2796 } 2797 break; 2798 2799 case DW_AT_identifier_case: 2800 printf ("\t"); 2801 switch (uvalue) 2802 { 2803 case DW_ID_case_sensitive: printf ("(case_sensitive)"); break; 2804 case DW_ID_up_case: printf ("(up_case)"); break; 2805 case DW_ID_down_case: printf ("(down_case)"); break; 2806 case DW_ID_case_insensitive: printf ("(case_insensitive)"); break; 2807 default: printf (_("(unknown case)")); break; 2808 } 2809 break; 2810 2811 case DW_AT_calling_convention: 2812 printf ("\t"); 2813 switch (uvalue) 2814 { 2815 case DW_CC_normal: printf ("(normal)"); break; 2816 case DW_CC_program: printf ("(program)"); break; 2817 case DW_CC_nocall: printf ("(nocall)"); break; 2818 case DW_CC_pass_by_reference: printf ("(pass by ref)"); break; 2819 case DW_CC_pass_by_value: printf ("(pass by value)"); break; 2820 case DW_CC_GNU_renesas_sh: printf ("(Rensas SH)"); break; 2821 case DW_CC_GNU_borland_fastcall_i386: printf ("(Borland fastcall i386)"); break; 2822 default: 2823 if (uvalue >= DW_CC_lo_user 2824 && uvalue <= DW_CC_hi_user) 2825 printf (_("(user defined)")); 2826 else 2827 printf (_("(unknown convention)")); 2828 } 2829 break; 2830 2831 case DW_AT_ordering: 2832 printf ("\t"); 2833 switch (uvalue) 2834 { 2835 case 255: 2836 case -1: printf (_("(undefined)")); break; 2837 case 0: printf ("(row major)"); break; 2838 case 1: printf ("(column major)"); break; 2839 } 2840 break; 2841 2842 case DW_AT_decimal_sign: 2843 printf ("\t"); 2844 switch (uvalue) 2845 { 2846 case DW_DS_unsigned: printf (_("(unsigned)")); break; 2847 case DW_DS_leading_overpunch: printf (_("(leading overpunch)")); break; 2848 case DW_DS_trailing_overpunch: printf (_("(trailing overpunch)")); break; 2849 case DW_DS_leading_separate: printf (_("(leading separate)")); break; 2850 case DW_DS_trailing_separate: printf (_("(trailing separate)")); break; 2851 default: printf (_("(unrecognised)")); break; 2852 } 2853 break; 2854 2855 case DW_AT_defaulted: 2856 printf ("\t"); 2857 switch (uvalue) 2858 { 2859 case DW_DEFAULTED_no: printf (_("(no)")); break; 2860 case DW_DEFAULTED_in_class: printf (_("(in class)")); break; 2861 case DW_DEFAULTED_out_of_class: printf (_("(out of class)")); break; 2862 default: printf (_("(unrecognised)")); break; 2863 } 2864 break; 2865 2866 case DW_AT_discr_list: 2867 printf ("\t"); 2868 display_discr_list (form, uvalue, data, end, level); 2869 break; 2870 2871 case DW_AT_frame_base: 2872 have_frame_base = 1; 2873 /* Fall through. */ 2874 case DW_AT_location: 2875 case DW_AT_string_length: 2876 case DW_AT_return_addr: 2877 case DW_AT_data_member_location: 2878 case DW_AT_vtable_elem_location: 2879 case DW_AT_segment: 2880 case DW_AT_static_link: 2881 case DW_AT_use_location: 2882 case DW_AT_call_value: 2883 case DW_AT_GNU_call_site_value: 2884 case DW_AT_call_data_value: 2885 case DW_AT_GNU_call_site_data_value: 2886 case DW_AT_call_target: 2887 case DW_AT_GNU_call_site_target: 2888 case DW_AT_call_target_clobbered: 2889 case DW_AT_GNU_call_site_target_clobbered: 2890 if ((dwarf_version < 4 2891 && (form == DW_FORM_data4 || form == DW_FORM_data8)) 2892 || form == DW_FORM_sec_offset) 2893 printf (_(" (location list)")); 2894 /* Fall through. */ 2895 case DW_AT_allocated: 2896 case DW_AT_associated: 2897 case DW_AT_data_location: 2898 case DW_AT_stride: 2899 case DW_AT_upper_bound: 2900 case DW_AT_lower_bound: 2901 if (block_start) 2902 { 2903 int need_frame_base; 2904 2905 printf ("\t("); 2906 need_frame_base = decode_location_expression (block_start, 2907 pointer_size, 2908 offset_size, 2909 dwarf_version, 2910 uvalue, 2911 cu_offset, section); 2912 printf (")"); 2913 if (need_frame_base && !have_frame_base) 2914 printf (_(" [without DW_AT_frame_base]")); 2915 } 2916 break; 2917 2918 case DW_AT_data_bit_offset: 2919 case DW_AT_byte_size: 2920 case DW_AT_bit_size: 2921 case DW_AT_string_length_byte_size: 2922 case DW_AT_string_length_bit_size: 2923 case DW_AT_bit_stride: 2924 if (form == DW_FORM_exprloc) 2925 { 2926 printf ("\t("); 2927 (void) decode_location_expression (block_start, pointer_size, 2928 offset_size, dwarf_version, 2929 uvalue, cu_offset, section); 2930 printf (")"); 2931 } 2932 break; 2933 2934 case DW_AT_import: 2935 { 2936 if (form == DW_FORM_ref_sig8 2937 || form == DW_FORM_GNU_ref_alt) 2938 break; 2939 2940 if (form == DW_FORM_ref1 2941 || form == DW_FORM_ref2 2942 || form == DW_FORM_ref4 2943 || form == DW_FORM_ref_udata) 2944 uvalue += cu_offset; 2945 2946 if (uvalue >= section->size) 2947 warn (_("Offset %s used as value for DW_AT_import attribute of DIE at offset 0x%lx is too big.\n"), 2948 dwarf_vmatoa ("x", uvalue), 2949 (unsigned long) (orig_data - section->start)); 2950 else 2951 { 2952 unsigned long abbrev_number; 2953 abbrev_entry *entry; 2954 unsigned char *p = section->start + uvalue; 2955 2956 READ_ULEB (abbrev_number, p, end); 2957 2958 printf (_("\t[Abbrev Number: %ld"), abbrev_number); 2959 /* Don't look up abbrev for DW_FORM_ref_addr, as it very often will 2960 use different abbrev table, and we don't track .debug_info chunks 2961 yet. */ 2962 if (form != DW_FORM_ref_addr) 2963 { 2964 for (entry = first_abbrev; entry != NULL; entry = entry->next) 2965 if (entry->entry == abbrev_number) 2966 break; 2967 if (entry != NULL) 2968 printf (" (%s)", get_TAG_name (entry->tag)); 2969 } 2970 printf ("]"); 2971 } 2972 } 2973 break; 2974 2975 default: 2976 break; 2977 } 2978 2979 return data; 2980 } 2981 2982 static unsigned char * 2983 read_and_display_attr (unsigned long attribute, 2984 unsigned long form, 2985 dwarf_signed_vma implicit_const, 2986 unsigned char * start, 2987 unsigned char * data, 2988 unsigned char * end, 2989 dwarf_vma cu_offset, 2990 dwarf_vma pointer_size, 2991 dwarf_vma offset_size, 2992 int dwarf_version, 2993 debug_info * debug_info_p, 2994 int do_loc, 2995 struct dwarf_section * section, 2996 struct cu_tu_set * this_set, 2997 int level) 2998 { 2999 if (!do_loc) 3000 printf (" %-18s:", get_AT_name (attribute)); 3001 data = read_and_display_attr_value (attribute, form, implicit_const, 3002 start, data, end, 3003 cu_offset, pointer_size, offset_size, 3004 dwarf_version, debug_info_p, 3005 do_loc, section, this_set, ' ', level); 3006 if (!do_loc) 3007 printf ("\n"); 3008 return data; 3009 } 3010 3011 /* Like load_debug_section, but if the ordinary call fails, and we are 3012 following debug links, then attempt to load the requested section 3013 from one of the separate debug info files. */ 3014 3015 static bfd_boolean 3016 load_debug_section_with_follow (enum dwarf_section_display_enum sec_enum, 3017 void * handle) 3018 { 3019 if (load_debug_section (sec_enum, handle)) 3020 { 3021 if (debug_displays[sec_enum].section.filename == NULL) 3022 { 3023 /* See if we can associate a filename with this section. */ 3024 separate_info * i; 3025 3026 for (i = first_separate_info; i != NULL; i = i->next) 3027 if (i->handle == handle) 3028 { 3029 debug_displays[sec_enum].section.filename = i->filename; 3030 break; 3031 } 3032 } 3033 3034 return TRUE; 3035 } 3036 3037 if (do_follow_links) 3038 { 3039 separate_info * i; 3040 3041 for (i = first_separate_info; i != NULL; i = i->next) 3042 { 3043 if (load_debug_section (sec_enum, i->handle)) 3044 { 3045 debug_displays[sec_enum].section.filename = i->filename; 3046 3047 /* FIXME: We should check to see if any of the remaining debug info 3048 files also contain this section, and, umm, do something about it. */ 3049 return TRUE; 3050 } 3051 } 3052 } 3053 3054 return FALSE; 3055 } 3056 3057 static void 3058 introduce (struct dwarf_section * section, bfd_boolean raw) 3059 { 3060 if (raw) 3061 { 3062 if (do_follow_links && section->filename) 3063 printf (_("Raw dump of debug contents of section %s (loaded from %s):\n\n"), 3064 section->name, section->filename); 3065 else 3066 printf (_("Raw dump of debug contents of section %s:\n\n"), section->name); 3067 } 3068 else 3069 { 3070 if (do_follow_links && section->filename) 3071 printf (_("Contents of the %s section (loaded from %s):\n\n"), 3072 section->name, section->filename); 3073 else 3074 printf (_("Contents of the %s section:\n\n"), section->name); 3075 } 3076 } 3077 3078 /* Process the contents of a .debug_info section. 3079 If do_loc is TRUE then we are scanning for location lists and dwo tags 3080 and we do not want to display anything to the user. 3081 If do_types is TRUE, we are processing a .debug_types section instead of 3082 a .debug_info section. 3083 The information displayed is restricted by the values in DWARF_START_DIE 3084 and DWARF_CUTOFF_LEVEL. 3085 Returns TRUE upon success. Otherwise an error or warning message is 3086 printed and FALSE is returned. */ 3087 3088 static bfd_boolean 3089 process_debug_info (struct dwarf_section * section, 3090 void * file, 3091 enum dwarf_section_display_enum abbrev_sec, 3092 bfd_boolean do_loc, 3093 bfd_boolean do_types) 3094 { 3095 unsigned char *start = section->start; 3096 unsigned char *end = start + section->size; 3097 unsigned char *section_begin; 3098 unsigned int unit; 3099 unsigned int num_units = 0; 3100 3101 if ((do_loc || do_debug_loc || do_debug_ranges) 3102 && num_debug_info_entries == 0 3103 && ! do_types) 3104 { 3105 dwarf_vma length; 3106 3107 /* First scan the section to get the number of comp units. */ 3108 for (section_begin = start, num_units = 0; section_begin < end; 3109 num_units ++) 3110 { 3111 /* Read the first 4 bytes. For a 32-bit DWARF section, this 3112 will be the length. For a 64-bit DWARF section, it'll be 3113 the escape code 0xffffffff followed by an 8 byte length. */ 3114 SAFE_BYTE_GET (length, section_begin, 4, end); 3115 3116 if (length == 0xffffffff) 3117 { 3118 SAFE_BYTE_GET (length, section_begin + 4, 8, end); 3119 section_begin += length + 12; 3120 } 3121 else if (length >= 0xfffffff0 && length < 0xffffffff) 3122 { 3123 warn (_("Reserved length value (0x%s) found in section %s\n"), 3124 dwarf_vmatoa ("x", length), section->name); 3125 return FALSE; 3126 } 3127 else 3128 section_begin += length + 4; 3129 3130 /* Negative values are illegal, they may even cause infinite 3131 looping. This can happen if we can't accurately apply 3132 relocations to an object file, or if the file is corrupt. */ 3133 if ((signed long) length <= 0 || section_begin < start) 3134 { 3135 warn (_("Corrupt unit length (0x%s) found in section %s\n"), 3136 dwarf_vmatoa ("x", length), section->name); 3137 return FALSE; 3138 } 3139 } 3140 3141 if (num_units == 0) 3142 { 3143 error (_("No comp units in %s section ?\n"), section->name); 3144 return FALSE; 3145 } 3146 3147 /* Then allocate an array to hold the information. */ 3148 debug_information = (debug_info *) cmalloc (num_units, 3149 sizeof (* debug_information)); 3150 if (debug_information == NULL) 3151 { 3152 error (_("Not enough memory for a debug info array of %u entries\n"), 3153 num_units); 3154 alloc_num_debug_info_entries = num_debug_info_entries = 0; 3155 return FALSE; 3156 } 3157 3158 /* PR 17531: file: 92ca3797. 3159 We cannot rely upon the debug_information array being initialised 3160 before it is used. A corrupt file could easily contain references 3161 to a unit for which information has not been made available. So 3162 we ensure that the array is zeroed here. */ 3163 memset (debug_information, 0, num_units * sizeof (*debug_information)); 3164 3165 alloc_num_debug_info_entries = num_units; 3166 } 3167 3168 if (!do_loc) 3169 { 3170 load_debug_section_with_follow (str, file); 3171 load_debug_section_with_follow (line_str, file); 3172 load_debug_section_with_follow (str_dwo, file); 3173 load_debug_section_with_follow (str_index, file); 3174 load_debug_section_with_follow (str_index_dwo, file); 3175 load_debug_section_with_follow (debug_addr, file); 3176 } 3177 3178 load_debug_section_with_follow (abbrev_sec, file); 3179 if (debug_displays [abbrev_sec].section.start == NULL) 3180 { 3181 warn (_("Unable to locate %s section!\n"), 3182 debug_displays [abbrev_sec].section.uncompressed_name); 3183 return FALSE; 3184 } 3185 3186 if (!do_loc && dwarf_start_die == 0) 3187 introduce (section, FALSE); 3188 3189 for (section_begin = start, unit = 0; start < end; unit++) 3190 { 3191 DWARF2_Internal_CompUnit compunit; 3192 unsigned char *hdrptr; 3193 unsigned char *tags; 3194 int level, last_level, saved_level; 3195 dwarf_vma cu_offset; 3196 unsigned long sec_off; 3197 unsigned int offset_size; 3198 unsigned int initial_length_size; 3199 dwarf_vma signature_high = 0; 3200 dwarf_vma signature_low = 0; 3201 dwarf_vma type_offset = 0; 3202 struct cu_tu_set *this_set; 3203 dwarf_vma abbrev_base; 3204 size_t abbrev_size; 3205 3206 hdrptr = start; 3207 3208 SAFE_BYTE_GET_AND_INC (compunit.cu_length, hdrptr, 4, end); 3209 3210 if (compunit.cu_length == 0xffffffff) 3211 { 3212 SAFE_BYTE_GET_AND_INC (compunit.cu_length, hdrptr, 8, end); 3213 offset_size = 8; 3214 initial_length_size = 12; 3215 } 3216 else 3217 { 3218 offset_size = 4; 3219 initial_length_size = 4; 3220 } 3221 3222 SAFE_BYTE_GET_AND_INC (compunit.cu_version, hdrptr, 2, end); 3223 3224 cu_offset = start - section_begin; 3225 3226 this_set = find_cu_tu_set_v2 (cu_offset, do_types); 3227 3228 if (compunit.cu_version < 5) 3229 { 3230 compunit.cu_unit_type = DW_UT_compile; 3231 /* Initialize it due to a false compiler warning. */ 3232 compunit.cu_pointer_size = -1; 3233 } 3234 else 3235 { 3236 SAFE_BYTE_GET_AND_INC (compunit.cu_unit_type, hdrptr, 1, end); 3237 do_types = (compunit.cu_unit_type == DW_UT_type); 3238 3239 SAFE_BYTE_GET_AND_INC (compunit.cu_pointer_size, hdrptr, 1, end); 3240 } 3241 3242 SAFE_BYTE_GET_AND_INC (compunit.cu_abbrev_offset, hdrptr, offset_size, end); 3243 3244 if (this_set == NULL) 3245 { 3246 abbrev_base = 0; 3247 abbrev_size = debug_displays [abbrev_sec].section.size; 3248 } 3249 else 3250 { 3251 abbrev_base = this_set->section_offsets [DW_SECT_ABBREV]; 3252 abbrev_size = this_set->section_sizes [DW_SECT_ABBREV]; 3253 } 3254 3255 if (compunit.cu_version < 5) 3256 SAFE_BYTE_GET_AND_INC (compunit.cu_pointer_size, hdrptr, 1, end); 3257 3258 /* PR 17512: file: 001-108546-0.001:0.1. */ 3259 if (compunit.cu_pointer_size < 2 || compunit.cu_pointer_size > 8) 3260 { 3261 warn (_("Invalid pointer size (%d) in compunit header, using %d instead\n"), 3262 compunit.cu_pointer_size, offset_size); 3263 compunit.cu_pointer_size = offset_size; 3264 } 3265 3266 if (do_types) 3267 { 3268 SAFE_BYTE_GET64 (hdrptr, &signature_high, &signature_low, end); 3269 hdrptr += 8; 3270 SAFE_BYTE_GET_AND_INC (type_offset, hdrptr, offset_size, end); 3271 } 3272 3273 if (dwarf_start_die > (cu_offset + compunit.cu_length 3274 + initial_length_size)) 3275 { 3276 start = section_begin + cu_offset + compunit.cu_length 3277 + initial_length_size; 3278 continue; 3279 } 3280 3281 if ((do_loc || do_debug_loc || do_debug_ranges) 3282 && num_debug_info_entries == 0 3283 && ! do_types) 3284 { 3285 debug_information [unit].cu_offset = cu_offset; 3286 debug_information [unit].pointer_size 3287 = compunit.cu_pointer_size; 3288 debug_information [unit].offset_size = offset_size; 3289 debug_information [unit].dwarf_version = compunit.cu_version; 3290 debug_information [unit].base_address = 0; 3291 debug_information [unit].addr_base = DEBUG_INFO_UNAVAILABLE; 3292 debug_information [unit].ranges_base = DEBUG_INFO_UNAVAILABLE; 3293 debug_information [unit].loc_offsets = NULL; 3294 debug_information [unit].have_frame_base = NULL; 3295 debug_information [unit].max_loc_offsets = 0; 3296 debug_information [unit].num_loc_offsets = 0; 3297 debug_information [unit].range_lists = NULL; 3298 debug_information [unit].max_range_lists= 0; 3299 debug_information [unit].num_range_lists = 0; 3300 } 3301 3302 if (!do_loc && dwarf_start_die == 0) 3303 { 3304 printf (_(" Compilation Unit @ offset 0x%s:\n"), 3305 dwarf_vmatoa ("x", cu_offset)); 3306 printf (_(" Length: 0x%s (%s)\n"), 3307 dwarf_vmatoa ("x", compunit.cu_length), 3308 offset_size == 8 ? "64-bit" : "32-bit"); 3309 printf (_(" Version: %d\n"), compunit.cu_version); 3310 printf (_(" Abbrev Offset: 0x%s\n"), 3311 dwarf_vmatoa ("x", compunit.cu_abbrev_offset)); 3312 printf (_(" Pointer Size: %d\n"), compunit.cu_pointer_size); 3313 if (do_types) 3314 { 3315 char buf[64]; 3316 3317 printf (_(" Signature: 0x%s\n"), 3318 dwarf_vmatoa64 (signature_high, signature_low, 3319 buf, sizeof (buf))); 3320 printf (_(" Type Offset: 0x%s\n"), 3321 dwarf_vmatoa ("x", type_offset)); 3322 } 3323 if (this_set != NULL) 3324 { 3325 dwarf_vma *offsets = this_set->section_offsets; 3326 size_t *sizes = this_set->section_sizes; 3327 3328 printf (_(" Section contributions:\n")); 3329 printf (_(" .debug_abbrev.dwo: 0x%s 0x%s\n"), 3330 dwarf_vmatoa ("x", offsets [DW_SECT_ABBREV]), 3331 dwarf_vmatoa ("x", sizes [DW_SECT_ABBREV])); 3332 printf (_(" .debug_line.dwo: 0x%s 0x%s\n"), 3333 dwarf_vmatoa ("x", offsets [DW_SECT_LINE]), 3334 dwarf_vmatoa ("x", sizes [DW_SECT_LINE])); 3335 printf (_(" .debug_loc.dwo: 0x%s 0x%s\n"), 3336 dwarf_vmatoa ("x", offsets [DW_SECT_LOC]), 3337 dwarf_vmatoa ("x", sizes [DW_SECT_LOC])); 3338 printf (_(" .debug_str_offsets.dwo: 0x%s 0x%s\n"), 3339 dwarf_vmatoa ("x", offsets [DW_SECT_STR_OFFSETS]), 3340 dwarf_vmatoa ("x", sizes [DW_SECT_STR_OFFSETS])); 3341 } 3342 } 3343 3344 sec_off = cu_offset + initial_length_size; 3345 if (sec_off + compunit.cu_length < sec_off 3346 || sec_off + compunit.cu_length > section->size) 3347 { 3348 warn (_("Debug info is corrupted, %s header at %#lx has length %s\n"), 3349 section->name, 3350 (unsigned long) cu_offset, 3351 dwarf_vmatoa ("x", compunit.cu_length)); 3352 num_units = unit; 3353 break; 3354 } 3355 3356 tags = hdrptr; 3357 start += compunit.cu_length + initial_length_size; 3358 3359 if (compunit.cu_version < 2 || compunit.cu_version > 5) 3360 { 3361 warn (_("CU at offset %s contains corrupt or " 3362 "unsupported version number: %d.\n"), 3363 dwarf_vmatoa ("x", cu_offset), compunit.cu_version); 3364 continue; 3365 } 3366 3367 if (compunit.cu_unit_type != DW_UT_compile 3368 && compunit.cu_unit_type != DW_UT_type) 3369 { 3370 warn (_("CU at offset %s contains corrupt or " 3371 "unsupported unit type: %d.\n"), 3372 dwarf_vmatoa ("x", cu_offset), compunit.cu_unit_type); 3373 continue; 3374 } 3375 3376 free_abbrevs (); 3377 3378 /* Process the abbrevs used by this compilation unit. */ 3379 if (compunit.cu_abbrev_offset >= abbrev_size) 3380 warn (_("Debug info is corrupted, abbrev offset (%lx) is larger than abbrev section size (%lx)\n"), 3381 (unsigned long) compunit.cu_abbrev_offset, 3382 (unsigned long) abbrev_size); 3383 /* PR 17531: file:4bcd9ce9. */ 3384 else if ((abbrev_base + abbrev_size) 3385 > debug_displays [abbrev_sec].section.size) 3386 warn (_("Debug info is corrupted, abbrev size (%lx) is larger than abbrev section size (%lx)\n"), 3387 (unsigned long) abbrev_base + abbrev_size, 3388 (unsigned long) debug_displays [abbrev_sec].section.size); 3389 else 3390 process_abbrev_section 3391 (((unsigned char *) debug_displays [abbrev_sec].section.start 3392 + abbrev_base + compunit.cu_abbrev_offset), 3393 ((unsigned char *) debug_displays [abbrev_sec].section.start 3394 + abbrev_base + abbrev_size)); 3395 3396 level = 0; 3397 last_level = level; 3398 saved_level = -1; 3399 while (tags < start) 3400 { 3401 unsigned long abbrev_number; 3402 unsigned long die_offset; 3403 abbrev_entry *entry; 3404 abbrev_attr *attr; 3405 int do_printing = 1; 3406 3407 die_offset = tags - section_begin; 3408 3409 READ_ULEB (abbrev_number, tags, start); 3410 3411 /* A null DIE marks the end of a list of siblings or it may also be 3412 a section padding. */ 3413 if (abbrev_number == 0) 3414 { 3415 /* Check if it can be a section padding for the last CU. */ 3416 if (level == 0 && start == end) 3417 { 3418 unsigned char *chk; 3419 3420 for (chk = tags; chk < start; chk++) 3421 if (*chk != 0) 3422 break; 3423 if (chk == start) 3424 break; 3425 } 3426 3427 if (!do_loc && die_offset >= dwarf_start_die 3428 && (dwarf_cutoff_level == -1 3429 || level < dwarf_cutoff_level)) 3430 printf (_(" <%d><%lx>: Abbrev Number: 0\n"), 3431 level, die_offset); 3432 3433 --level; 3434 if (level < 0) 3435 { 3436 static unsigned num_bogus_warns = 0; 3437 3438 if (num_bogus_warns < 3) 3439 { 3440 warn (_("Bogus end-of-siblings marker detected at offset %lx in %s section\n"), 3441 die_offset, section->name); 3442 num_bogus_warns ++; 3443 if (num_bogus_warns == 3) 3444 warn (_("Further warnings about bogus end-of-sibling markers suppressed\n")); 3445 } 3446 } 3447 if (dwarf_start_die != 0 && level < saved_level) 3448 return TRUE; 3449 continue; 3450 } 3451 3452 if (!do_loc) 3453 { 3454 if (dwarf_start_die != 0 && die_offset < dwarf_start_die) 3455 do_printing = 0; 3456 else 3457 { 3458 if (dwarf_start_die != 0 && die_offset == dwarf_start_die) 3459 saved_level = level; 3460 do_printing = (dwarf_cutoff_level == -1 3461 || level < dwarf_cutoff_level); 3462 if (do_printing) 3463 printf (_(" <%d><%lx>: Abbrev Number: %lu"), 3464 level, die_offset, abbrev_number); 3465 else if (dwarf_cutoff_level == -1 3466 || last_level < dwarf_cutoff_level) 3467 printf (_(" <%d><%lx>: ...\n"), level, die_offset); 3468 last_level = level; 3469 } 3470 } 3471 3472 /* Scan through the abbreviation list until we reach the 3473 correct entry. */ 3474 for (entry = first_abbrev; 3475 entry && entry->entry != abbrev_number; 3476 entry = entry->next) 3477 continue; 3478 3479 if (entry == NULL) 3480 { 3481 if (!do_loc && do_printing) 3482 { 3483 printf ("\n"); 3484 fflush (stdout); 3485 } 3486 warn (_("DIE at offset 0x%lx refers to abbreviation number %lu which does not exist\n"), 3487 die_offset, abbrev_number); 3488 return FALSE; 3489 } 3490 3491 if (!do_loc && do_printing) 3492 printf (" (%s)\n", get_TAG_name (entry->tag)); 3493 3494 switch (entry->tag) 3495 { 3496 default: 3497 need_base_address = 0; 3498 break; 3499 case DW_TAG_compile_unit: 3500 need_base_address = 1; 3501 need_dwo_info = do_loc; 3502 break; 3503 case DW_TAG_entry_point: 3504 case DW_TAG_subprogram: 3505 need_base_address = 0; 3506 /* Assuming that there is no DW_AT_frame_base. */ 3507 have_frame_base = 0; 3508 break; 3509 } 3510 3511 debug_info *debug_info_p = 3512 (debug_information && unit < alloc_num_debug_info_entries) 3513 ? debug_information + unit : NULL; 3514 3515 assert (!debug_info_p 3516 || (debug_info_p->num_loc_offsets 3517 == debug_info_p->num_loc_views)); 3518 3519 for (attr = entry->first_attr; 3520 attr && attr->attribute; 3521 attr = attr->next) 3522 { 3523 if (! do_loc && do_printing) 3524 /* Show the offset from where the tag was extracted. */ 3525 printf (" <%lx>", (unsigned long)(tags - section_begin)); 3526 tags = read_and_display_attr (attr->attribute, 3527 attr->form, 3528 attr->implicit_const, 3529 section_begin, 3530 tags, 3531 end, 3532 cu_offset, 3533 compunit.cu_pointer_size, 3534 offset_size, 3535 compunit.cu_version, 3536 debug_info_p, 3537 do_loc || ! do_printing, 3538 section, 3539 this_set, 3540 level); 3541 } 3542 3543 /* If a locview attribute appears before a location one, 3544 make sure we don't associate it with an earlier 3545 loclist. */ 3546 if (debug_info_p) 3547 switch (debug_info_p->num_loc_offsets - debug_info_p->num_loc_views) 3548 { 3549 case 1: 3550 debug_info_p->loc_views [debug_info_p->num_loc_views] = vm1; 3551 debug_info_p->num_loc_views++; 3552 assert (debug_info_p->num_loc_views 3553 == debug_info_p->num_loc_offsets); 3554 break; 3555 3556 case 0: 3557 break; 3558 3559 case -1: 3560 warn(_("DIE has locviews without loclist\n")); 3561 debug_info_p->num_loc_views--; 3562 break; 3563 3564 default: 3565 assert (0); 3566 } 3567 3568 if (entry->children) 3569 ++level; 3570 } 3571 } 3572 3573 /* Set num_debug_info_entries here so that it can be used to check if 3574 we need to process .debug_loc and .debug_ranges sections. */ 3575 if ((do_loc || do_debug_loc || do_debug_ranges) 3576 && num_debug_info_entries == 0 3577 && ! do_types) 3578 { 3579 if (num_units > alloc_num_debug_info_entries) 3580 num_debug_info_entries = alloc_num_debug_info_entries; 3581 else 3582 num_debug_info_entries = num_units; 3583 } 3584 3585 if (!do_loc) 3586 printf ("\n"); 3587 3588 return TRUE; 3589 } 3590 3591 /* Locate and scan the .debug_info section in the file and record the pointer 3592 sizes and offsets for the compilation units in it. Usually an executable 3593 will have just one pointer size, but this is not guaranteed, and so we try 3594 not to make any assumptions. Returns zero upon failure, or the number of 3595 compilation units upon success. */ 3596 3597 static unsigned int 3598 load_debug_info (void * file) 3599 { 3600 /* If we have already tried and failed to load the .debug_info 3601 section then do not bother to repeat the task. */ 3602 if (num_debug_info_entries == DEBUG_INFO_UNAVAILABLE) 3603 return 0; 3604 3605 /* If we already have the information there is nothing else to do. */ 3606 if (num_debug_info_entries > 0) 3607 return num_debug_info_entries; 3608 3609 /* If this is a DWARF package file, load the CU and TU indexes. */ 3610 (void) load_cu_tu_indexes (file); 3611 3612 if (load_debug_section_with_follow (info, file) 3613 && process_debug_info (&debug_displays [info].section, file, abbrev, TRUE, FALSE)) 3614 return num_debug_info_entries; 3615 3616 if (load_debug_section_with_follow (info_dwo, file) 3617 && process_debug_info (&debug_displays [info_dwo].section, file, 3618 abbrev_dwo, TRUE, FALSE)) 3619 return num_debug_info_entries; 3620 3621 num_debug_info_entries = DEBUG_INFO_UNAVAILABLE; 3622 return 0; 3623 } 3624 3625 /* Read a DWARF .debug_line section header starting at DATA. 3626 Upon success returns an updated DATA pointer and the LINFO 3627 structure and the END_OF_SEQUENCE pointer will be filled in. 3628 Otherwise returns NULL. */ 3629 3630 static unsigned char * 3631 read_debug_line_header (struct dwarf_section * section, 3632 unsigned char * data, 3633 unsigned char * end, 3634 DWARF2_Internal_LineInfo * linfo, 3635 unsigned char ** end_of_sequence) 3636 { 3637 unsigned char *hdrptr; 3638 unsigned int initial_length_size; 3639 unsigned char address_size, segment_selector_size; 3640 3641 /* Extract information from the Line Number Program Header. 3642 (section 6.2.4 in the Dwarf3 doc). */ 3643 hdrptr = data; 3644 3645 /* Get and check the length of the block. */ 3646 SAFE_BYTE_GET_AND_INC (linfo->li_length, hdrptr, 4, end); 3647 3648 if (linfo->li_length == 0xffffffff) 3649 { 3650 /* This section is 64-bit DWARF 3. */ 3651 SAFE_BYTE_GET_AND_INC (linfo->li_length, hdrptr, 8, end); 3652 linfo->li_offset_size = 8; 3653 initial_length_size = 12; 3654 } 3655 else 3656 { 3657 linfo->li_offset_size = 4; 3658 initial_length_size = 4; 3659 } 3660 3661 if (linfo->li_length + initial_length_size > section->size) 3662 { 3663 /* If the length field has a relocation against it, then we should 3664 not complain if it is inaccurate (and probably negative). This 3665 happens in object files when the .debug_line section is actually 3666 comprised of several different .debug_line.* sections, (some of 3667 which may be removed by linker garbage collection), and a relocation 3668 is used to compute the correct length once that is done. */ 3669 if (reloc_at (section, (hdrptr - section->start) - linfo->li_offset_size)) 3670 { 3671 linfo->li_length = (end - data) - initial_length_size; 3672 } 3673 else 3674 { 3675 warn (_("The length field (0x%lx) in the debug_line header is wrong - the section is too small\n"), 3676 (long) linfo->li_length); 3677 return NULL; 3678 } 3679 } 3680 3681 /* Get and check the version number. */ 3682 SAFE_BYTE_GET_AND_INC (linfo->li_version, hdrptr, 2, end); 3683 3684 if (linfo->li_version != 2 3685 && linfo->li_version != 3 3686 && linfo->li_version != 4 3687 && linfo->li_version != 5) 3688 { 3689 warn (_("Only DWARF version 2, 3, 4 and 5 line info " 3690 "is currently supported.\n")); 3691 return NULL; 3692 } 3693 3694 if (linfo->li_version >= 5) 3695 { 3696 SAFE_BYTE_GET_AND_INC (address_size, hdrptr, 1, end); 3697 3698 SAFE_BYTE_GET_AND_INC (segment_selector_size, hdrptr, 1, end); 3699 if (segment_selector_size != 0) 3700 { 3701 warn (_("The %s section contains " 3702 "unsupported segment selector size: %d.\n"), 3703 section->name, segment_selector_size); 3704 return 0; 3705 } 3706 } 3707 3708 SAFE_BYTE_GET_AND_INC (linfo->li_prologue_length, hdrptr, 3709 linfo->li_offset_size, end); 3710 SAFE_BYTE_GET_AND_INC (linfo->li_min_insn_length, hdrptr, 1, end); 3711 3712 if (linfo->li_version >= 4) 3713 { 3714 SAFE_BYTE_GET_AND_INC (linfo->li_max_ops_per_insn, hdrptr, 1, end); 3715 3716 if (linfo->li_max_ops_per_insn == 0) 3717 { 3718 warn (_("Invalid maximum operations per insn.\n")); 3719 return NULL; 3720 } 3721 } 3722 else 3723 linfo->li_max_ops_per_insn = 1; 3724 3725 SAFE_BYTE_GET_AND_INC (linfo->li_default_is_stmt, hdrptr, 1, end); 3726 SAFE_SIGNED_BYTE_GET_AND_INC (linfo->li_line_base, hdrptr, 1, end); 3727 SAFE_BYTE_GET_AND_INC (linfo->li_line_range, hdrptr, 1, end); 3728 SAFE_BYTE_GET_AND_INC (linfo->li_opcode_base, hdrptr, 1, end); 3729 3730 * end_of_sequence = data + linfo->li_length + initial_length_size; 3731 /* PR 17512: file:002-117414-0.004. */ 3732 if (* end_of_sequence > end) 3733 { 3734 warn (_("Line length %s extends beyond end of section\n"), 3735 dwarf_vmatoa ("u", linfo->li_length)); 3736 * end_of_sequence = end; 3737 return NULL; 3738 } 3739 3740 return hdrptr; 3741 } 3742 3743 static unsigned char * 3744 display_formatted_table (unsigned char * data, 3745 unsigned char * start, 3746 unsigned char * end, 3747 const DWARF2_Internal_LineInfo * linfo, 3748 struct dwarf_section * section, 3749 bfd_boolean is_dir) 3750 { 3751 unsigned char *format_start, format_count, *format, formati; 3752 dwarf_vma data_count, datai; 3753 unsigned int namepass, last_entry = 0; 3754 3755 SAFE_BYTE_GET_AND_INC (format_count, data, 1, end); 3756 format_start = data; 3757 for (formati = 0; formati < format_count; formati++) 3758 { 3759 SKIP_ULEB (data, end); 3760 SKIP_ULEB (data, end); 3761 if (data == end) 3762 { 3763 if (is_dir) 3764 warn (_("Corrupt directory format table entry\n")); 3765 else 3766 warn (_("Corrupt file name format table entry\n")); 3767 return data; 3768 } 3769 } 3770 3771 READ_ULEB (data_count, data, end); 3772 if (data == end) 3773 { 3774 if (is_dir) 3775 warn (_("Corrupt directory list\n")); 3776 else 3777 warn (_("Corrupt file name list\n")); 3778 return data; 3779 } 3780 3781 if (data_count == 0) 3782 { 3783 if (is_dir) 3784 printf (_("\n The Directory Table is empty.\n")); 3785 else 3786 printf (_("\n The File Name Table is empty.\n")); 3787 return data; 3788 } 3789 3790 if (is_dir) 3791 printf (_("\n The Directory Table (offset 0x%lx):\n"), 3792 (long) (data - start)); 3793 else 3794 printf (_("\n The File Name Table (offset 0x%lx):\n"), 3795 (long) (data - start)); 3796 3797 printf (_(" Entry")); 3798 /* Delay displaying name as the last entry for better screen layout. */ 3799 for (namepass = 0; namepass < 2; namepass++) 3800 { 3801 format = format_start; 3802 for (formati = 0; formati < format_count; formati++) 3803 { 3804 dwarf_vma content_type; 3805 3806 READ_ULEB (content_type, format, end); 3807 if ((content_type == DW_LNCT_path) == (namepass == 1)) 3808 switch (content_type) 3809 { 3810 case DW_LNCT_path: 3811 printf (_("\tName")); 3812 break; 3813 case DW_LNCT_directory_index: 3814 printf (_("\tDir")); 3815 break; 3816 case DW_LNCT_timestamp: 3817 printf (_("\tTime")); 3818 break; 3819 case DW_LNCT_size: 3820 printf (_("\tSize")); 3821 break; 3822 case DW_LNCT_MD5: 3823 printf (_("\tMD5")); 3824 break; 3825 default: 3826 printf (_("\t(Unknown format content type %s)"), 3827 dwarf_vmatoa ("u", content_type)); 3828 } 3829 SKIP_ULEB (format, end); 3830 } 3831 } 3832 putchar ('\n'); 3833 3834 for (datai = 0; datai < data_count; datai++) 3835 { 3836 unsigned char *datapass = data; 3837 3838 printf (" %d", last_entry++); 3839 /* Delay displaying name as the last entry for better screen layout. */ 3840 for (namepass = 0; namepass < 2; namepass++) 3841 { 3842 format = format_start; 3843 data = datapass; 3844 for (formati = 0; formati < format_count; formati++) 3845 { 3846 dwarf_vma content_type, form; 3847 3848 READ_ULEB (content_type, format, end); 3849 READ_ULEB (form, format, end); 3850 data = read_and_display_attr_value (0, form, 0, start, data, end, 3851 0, 0, linfo->li_offset_size, 3852 linfo->li_version, NULL, 3853 ((content_type == DW_LNCT_path) != (namepass == 1)), 3854 section, NULL, '\t', -1); 3855 } 3856 } 3857 if (data == end) 3858 { 3859 if (is_dir) 3860 warn (_("Corrupt directory entries list\n")); 3861 else 3862 warn (_("Corrupt file name entries list\n")); 3863 return data; 3864 } 3865 putchar ('\n'); 3866 } 3867 return data; 3868 } 3869 3870 static int 3871 display_debug_lines_raw (struct dwarf_section * section, 3872 unsigned char * data, 3873 unsigned char * end, 3874 void * file) 3875 { 3876 unsigned char *start = section->start; 3877 int verbose_view = 0; 3878 3879 introduce (section, TRUE); 3880 3881 while (data < end) 3882 { 3883 static DWARF2_Internal_LineInfo saved_linfo; 3884 DWARF2_Internal_LineInfo linfo; 3885 unsigned char *standard_opcodes; 3886 unsigned char *end_of_sequence; 3887 int i; 3888 3889 if (const_strneq (section->name, ".debug_line.") 3890 /* Note: the following does not apply to .debug_line.dwo sections. 3891 These are full debug_line sections. */ 3892 && strcmp (section->name, ".debug_line.dwo") != 0) 3893 { 3894 /* Sections named .debug_line.<foo> are fragments of a .debug_line 3895 section containing just the Line Number Statements. They are 3896 created by the assembler and intended to be used alongside gcc's 3897 -ffunction-sections command line option. When the linker's 3898 garbage collection decides to discard a .text.<foo> section it 3899 can then also discard the line number information in .debug_line.<foo>. 3900 3901 Since the section is a fragment it does not have the details 3902 needed to fill out a LineInfo structure, so instead we use the 3903 details from the last full debug_line section that we processed. */ 3904 end_of_sequence = end; 3905 standard_opcodes = NULL; 3906 linfo = saved_linfo; 3907 /* PR 17531: file: 0522b371. */ 3908 if (linfo.li_line_range == 0) 3909 { 3910 warn (_("Partial .debug_line. section encountered without a prior full .debug_line section\n")); 3911 return 0; 3912 } 3913 reset_state_machine (linfo.li_default_is_stmt); 3914 } 3915 else 3916 { 3917 unsigned char * hdrptr; 3918 3919 if ((hdrptr = read_debug_line_header (section, data, end, & linfo, 3920 & end_of_sequence)) == NULL) 3921 return 0; 3922 3923 printf (_(" Offset: 0x%lx\n"), (long)(data - start)); 3924 printf (_(" Length: %ld\n"), (long) linfo.li_length); 3925 printf (_(" DWARF Version: %d\n"), linfo.li_version); 3926 printf (_(" Prologue Length: %d\n"), (int) linfo.li_prologue_length); 3927 printf (_(" Minimum Instruction Length: %d\n"), linfo.li_min_insn_length); 3928 if (linfo.li_version >= 4) 3929 printf (_(" Maximum Ops per Instruction: %d\n"), linfo.li_max_ops_per_insn); 3930 printf (_(" Initial value of 'is_stmt': %d\n"), linfo.li_default_is_stmt); 3931 printf (_(" Line Base: %d\n"), linfo.li_line_base); 3932 printf (_(" Line Range: %d\n"), linfo.li_line_range); 3933 printf (_(" Opcode Base: %d\n"), linfo.li_opcode_base); 3934 3935 /* PR 17512: file: 1665-6428-0.004. */ 3936 if (linfo.li_line_range == 0) 3937 { 3938 warn (_("Line range of 0 is invalid, using 1 instead\n")); 3939 linfo.li_line_range = 1; 3940 } 3941 3942 reset_state_machine (linfo.li_default_is_stmt); 3943 3944 /* Display the contents of the Opcodes table. */ 3945 standard_opcodes = hdrptr; 3946 3947 /* PR 17512: file: 002-417945-0.004. */ 3948 if (standard_opcodes + linfo.li_opcode_base >= end) 3949 { 3950 warn (_("Line Base extends beyond end of section\n")); 3951 return 0; 3952 } 3953 3954 printf (_("\n Opcodes:\n")); 3955 3956 for (i = 1; i < linfo.li_opcode_base; i++) 3957 printf (ngettext (" Opcode %d has %d arg\n", 3958 " Opcode %d has %d args\n", 3959 standard_opcodes[i - 1]), 3960 i, standard_opcodes[i - 1]); 3961 3962 /* Display the contents of the Directory table. */ 3963 data = standard_opcodes + linfo.li_opcode_base - 1; 3964 3965 if (linfo.li_version >= 5) 3966 { 3967 load_debug_section_with_follow (line_str, file); 3968 3969 data = display_formatted_table (data, start, end, &linfo, section, 3970 TRUE); 3971 data = display_formatted_table (data, start, end, &linfo, section, 3972 FALSE); 3973 } 3974 else 3975 { 3976 if (*data == 0) 3977 printf (_("\n The Directory Table is empty.\n")); 3978 else 3979 { 3980 unsigned int last_dir_entry = 0; 3981 3982 printf (_("\n The Directory Table (offset 0x%lx):\n"), 3983 (long)(data - start)); 3984 3985 while (data < end && *data != 0) 3986 { 3987 printf (" %d\t%.*s\n", ++last_dir_entry, (int) (end - data), data); 3988 3989 data += strnlen ((char *) data, end - data) + 1; 3990 } 3991 3992 /* PR 17512: file: 002-132094-0.004. */ 3993 if (data >= end - 1) 3994 break; 3995 } 3996 3997 /* Skip the NUL at the end of the table. */ 3998 data++; 3999 4000 /* Display the contents of the File Name table. */ 4001 if (*data == 0) 4002 printf (_("\n The File Name Table is empty.\n")); 4003 else 4004 { 4005 printf (_("\n The File Name Table (offset 0x%lx):\n"), 4006 (long)(data - start)); 4007 printf (_(" Entry\tDir\tTime\tSize\tName\n")); 4008 4009 while (data < end && *data != 0) 4010 { 4011 unsigned char *name; 4012 dwarf_vma val; 4013 4014 printf (" %d\t", ++state_machine_regs.last_file_entry); 4015 name = data; 4016 data += strnlen ((char *) data, end - data) + 1; 4017 4018 READ_ULEB (val, data, end); 4019 printf ("%s\t", dwarf_vmatoa ("u", val)); 4020 READ_ULEB (val, data, end); 4021 printf ("%s\t", dwarf_vmatoa ("u", val)); 4022 READ_ULEB (val, data, end); 4023 printf ("%s\t", dwarf_vmatoa ("u", val)); 4024 printf ("%.*s\n", (int)(end - name), name); 4025 4026 if (data == end) 4027 { 4028 warn (_("Corrupt file name table entry\n")); 4029 break; 4030 } 4031 } 4032 } 4033 4034 /* Skip the NUL at the end of the table. */ 4035 data++; 4036 } 4037 4038 putchar ('\n'); 4039 saved_linfo = linfo; 4040 } 4041 4042 /* Now display the statements. */ 4043 if (data >= end_of_sequence) 4044 printf (_(" No Line Number Statements.\n")); 4045 else 4046 { 4047 printf (_(" Line Number Statements:\n")); 4048 4049 while (data < end_of_sequence) 4050 { 4051 unsigned char op_code; 4052 dwarf_signed_vma adv; 4053 dwarf_vma uladv; 4054 4055 printf (" [0x%08lx]", (long)(data - start)); 4056 4057 op_code = *data++; 4058 4059 if (op_code >= linfo.li_opcode_base) 4060 { 4061 op_code -= linfo.li_opcode_base; 4062 uladv = (op_code / linfo.li_line_range); 4063 if (linfo.li_max_ops_per_insn == 1) 4064 { 4065 uladv *= linfo.li_min_insn_length; 4066 state_machine_regs.address += uladv; 4067 if (uladv) 4068 state_machine_regs.view = 0; 4069 printf (_(" Special opcode %d: " 4070 "advance Address by %s to 0x%s%s"), 4071 op_code, dwarf_vmatoa ("u", uladv), 4072 dwarf_vmatoa ("x", state_machine_regs.address), 4073 verbose_view && uladv 4074 ? _(" (reset view)") : ""); 4075 } 4076 else 4077 { 4078 unsigned addrdelta 4079 = ((state_machine_regs.op_index + uladv) 4080 / linfo.li_max_ops_per_insn) 4081 * linfo.li_min_insn_length; 4082 4083 state_machine_regs.address += addrdelta; 4084 state_machine_regs.op_index 4085 = (state_machine_regs.op_index + uladv) 4086 % linfo.li_max_ops_per_insn; 4087 if (addrdelta) 4088 state_machine_regs.view = 0; 4089 printf (_(" Special opcode %d: " 4090 "advance Address by %s to 0x%s[%d]%s"), 4091 op_code, dwarf_vmatoa ("u", uladv), 4092 dwarf_vmatoa ("x", state_machine_regs.address), 4093 state_machine_regs.op_index, 4094 verbose_view && addrdelta 4095 ? _(" (reset view)") : ""); 4096 } 4097 adv = (op_code % linfo.li_line_range) + linfo.li_line_base; 4098 state_machine_regs.line += adv; 4099 printf (_(" and Line by %s to %d"), 4100 dwarf_vmatoa ("d", adv), state_machine_regs.line); 4101 if (verbose_view || state_machine_regs.view) 4102 printf (_(" (view %u)\n"), state_machine_regs.view); 4103 else 4104 putchar ('\n'); 4105 state_machine_regs.view++; 4106 } 4107 else 4108 switch (op_code) 4109 { 4110 case DW_LNS_extended_op: 4111 data += process_extended_line_op (data, 4112 linfo.li_default_is_stmt, 4113 end); 4114 break; 4115 4116 case DW_LNS_copy: 4117 printf (_(" Copy")); 4118 if (verbose_view || state_machine_regs.view) 4119 printf (_(" (view %u)\n"), state_machine_regs.view); 4120 else 4121 putchar ('\n'); 4122 state_machine_regs.view++; 4123 break; 4124 4125 case DW_LNS_advance_pc: 4126 READ_ULEB (uladv, data, end); 4127 if (linfo.li_max_ops_per_insn == 1) 4128 { 4129 uladv *= linfo.li_min_insn_length; 4130 state_machine_regs.address += uladv; 4131 if (uladv) 4132 state_machine_regs.view = 0; 4133 printf (_(" Advance PC by %s to 0x%s%s\n"), 4134 dwarf_vmatoa ("u", uladv), 4135 dwarf_vmatoa ("x", state_machine_regs.address), 4136 verbose_view && uladv 4137 ? _(" (reset view)") : ""); 4138 } 4139 else 4140 { 4141 unsigned addrdelta 4142 = ((state_machine_regs.op_index + uladv) 4143 / linfo.li_max_ops_per_insn) 4144 * linfo.li_min_insn_length; 4145 state_machine_regs.address 4146 += addrdelta; 4147 state_machine_regs.op_index 4148 = (state_machine_regs.op_index + uladv) 4149 % linfo.li_max_ops_per_insn; 4150 if (addrdelta) 4151 state_machine_regs.view = 0; 4152 printf (_(" Advance PC by %s to 0x%s[%d]%s\n"), 4153 dwarf_vmatoa ("u", uladv), 4154 dwarf_vmatoa ("x", state_machine_regs.address), 4155 state_machine_regs.op_index, 4156 verbose_view && addrdelta 4157 ? _(" (reset view)") : ""); 4158 } 4159 break; 4160 4161 case DW_LNS_advance_line: 4162 READ_SLEB (adv, data, end); 4163 state_machine_regs.line += adv; 4164 printf (_(" Advance Line by %s to %d\n"), 4165 dwarf_vmatoa ("d", adv), 4166 state_machine_regs.line); 4167 break; 4168 4169 case DW_LNS_set_file: 4170 READ_ULEB (uladv, data, end); 4171 printf (_(" Set File Name to entry %s in the File Name Table\n"), 4172 dwarf_vmatoa ("u", uladv)); 4173 state_machine_regs.file = uladv; 4174 break; 4175 4176 case DW_LNS_set_column: 4177 READ_ULEB (uladv, data, end); 4178 printf (_(" Set column to %s\n"), 4179 dwarf_vmatoa ("u", uladv)); 4180 state_machine_regs.column = uladv; 4181 break; 4182 4183 case DW_LNS_negate_stmt: 4184 adv = state_machine_regs.is_stmt; 4185 adv = ! adv; 4186 printf (_(" Set is_stmt to %s\n"), dwarf_vmatoa ("d", adv)); 4187 state_machine_regs.is_stmt = adv; 4188 break; 4189 4190 case DW_LNS_set_basic_block: 4191 printf (_(" Set basic block\n")); 4192 state_machine_regs.basic_block = 1; 4193 break; 4194 4195 case DW_LNS_const_add_pc: 4196 uladv = ((255 - linfo.li_opcode_base) / linfo.li_line_range); 4197 if (linfo.li_max_ops_per_insn) 4198 { 4199 uladv *= linfo.li_min_insn_length; 4200 state_machine_regs.address += uladv; 4201 if (uladv) 4202 state_machine_regs.view = 0; 4203 printf (_(" Advance PC by constant %s to 0x%s%s\n"), 4204 dwarf_vmatoa ("u", uladv), 4205 dwarf_vmatoa ("x", state_machine_regs.address), 4206 verbose_view && uladv 4207 ? _(" (reset view)") : ""); 4208 } 4209 else 4210 { 4211 unsigned addrdelta 4212 = ((state_machine_regs.op_index + uladv) 4213 / linfo.li_max_ops_per_insn) 4214 * linfo.li_min_insn_length; 4215 state_machine_regs.address 4216 += addrdelta; 4217 state_machine_regs.op_index 4218 = (state_machine_regs.op_index + uladv) 4219 % linfo.li_max_ops_per_insn; 4220 if (addrdelta) 4221 state_machine_regs.view = 0; 4222 printf (_(" Advance PC by constant %s to 0x%s[%d]%s\n"), 4223 dwarf_vmatoa ("u", uladv), 4224 dwarf_vmatoa ("x", state_machine_regs.address), 4225 state_machine_regs.op_index, 4226 verbose_view && addrdelta 4227 ? _(" (reset view)") : ""); 4228 } 4229 break; 4230 4231 case DW_LNS_fixed_advance_pc: 4232 SAFE_BYTE_GET_AND_INC (uladv, data, 2, end); 4233 state_machine_regs.address += uladv; 4234 state_machine_regs.op_index = 0; 4235 printf (_(" Advance PC by fixed size amount %s to 0x%s\n"), 4236 dwarf_vmatoa ("u", uladv), 4237 dwarf_vmatoa ("x", state_machine_regs.address)); 4238 /* Do NOT reset view. */ 4239 break; 4240 4241 case DW_LNS_set_prologue_end: 4242 printf (_(" Set prologue_end to true\n")); 4243 break; 4244 4245 case DW_LNS_set_epilogue_begin: 4246 printf (_(" Set epilogue_begin to true\n")); 4247 break; 4248 4249 case DW_LNS_set_isa: 4250 READ_ULEB (uladv, data, end); 4251 printf (_(" Set ISA to %s\n"), dwarf_vmatoa ("u", uladv)); 4252 break; 4253 4254 default: 4255 printf (_(" Unknown opcode %d with operands: "), op_code); 4256 4257 if (standard_opcodes != NULL) 4258 for (i = standard_opcodes[op_code - 1]; i > 0 ; --i) 4259 { 4260 READ_ULEB (uladv, data, end); 4261 printf ("0x%s%s", dwarf_vmatoa ("x", uladv), 4262 i == 1 ? "" : ", "); 4263 } 4264 putchar ('\n'); 4265 break; 4266 } 4267 } 4268 putchar ('\n'); 4269 } 4270 } 4271 4272 return 1; 4273 } 4274 4275 typedef struct 4276 { 4277 unsigned char *name; 4278 unsigned int directory_index; 4279 unsigned int modification_date; 4280 unsigned int length; 4281 } File_Entry; 4282 4283 /* Output a decoded representation of the .debug_line section. */ 4284 4285 static int 4286 display_debug_lines_decoded (struct dwarf_section * section, 4287 unsigned char * start, 4288 unsigned char * data, 4289 unsigned char * end, 4290 void * fileptr) 4291 { 4292 static DWARF2_Internal_LineInfo saved_linfo; 4293 4294 introduce (section, FALSE); 4295 4296 while (data < end) 4297 { 4298 /* This loop amounts to one iteration per compilation unit. */ 4299 DWARF2_Internal_LineInfo linfo; 4300 unsigned char *standard_opcodes; 4301 unsigned char *end_of_sequence; 4302 int i; 4303 File_Entry *file_table = NULL; 4304 unsigned int n_files = 0; 4305 unsigned char **directory_table = NULL; 4306 dwarf_vma n_directories = 0; 4307 4308 if (const_strneq (section->name, ".debug_line.") 4309 /* Note: the following does not apply to .debug_line.dwo sections. 4310 These are full debug_line sections. */ 4311 && strcmp (section->name, ".debug_line.dwo") != 0) 4312 { 4313 /* See comment in display_debug_lines_raw(). */ 4314 end_of_sequence = end; 4315 standard_opcodes = NULL; 4316 linfo = saved_linfo; 4317 /* PR 17531: file: 0522b371. */ 4318 if (linfo.li_line_range == 0) 4319 { 4320 warn (_("Partial .debug_line. section encountered without a prior full .debug_line section\n")); 4321 return 0; 4322 } 4323 reset_state_machine (linfo.li_default_is_stmt); 4324 } 4325 else 4326 { 4327 unsigned char *hdrptr; 4328 4329 if ((hdrptr = read_debug_line_header (section, data, end, & linfo, 4330 & end_of_sequence)) == NULL) 4331 return 0; 4332 4333 /* PR 17531: file: 0522b371. */ 4334 if (linfo.li_line_range == 0) 4335 { 4336 warn (_("Line range of 0 is invalid, using 1 instead\n")); 4337 linfo.li_line_range = 1; 4338 } 4339 reset_state_machine (linfo.li_default_is_stmt); 4340 4341 /* Save a pointer to the contents of the Opcodes table. */ 4342 standard_opcodes = hdrptr; 4343 4344 /* Traverse the Directory table just to count entries. */ 4345 data = standard_opcodes + linfo.li_opcode_base - 1; 4346 /* PR 20440 */ 4347 if (data >= end) 4348 { 4349 warn (_("opcode base of %d extends beyond end of section\n"), 4350 linfo.li_opcode_base); 4351 return 0; 4352 } 4353 4354 if (linfo.li_version >= 5) 4355 { 4356 unsigned char *format_start, format_count, *format; 4357 dwarf_vma formati, entryi; 4358 4359 load_debug_section_with_follow (line_str, fileptr); 4360 4361 /* Skip directories format. */ 4362 SAFE_BYTE_GET_AND_INC (format_count, data, 1, end); 4363 format_start = data; 4364 for (formati = 0; formati < format_count; formati++) 4365 { 4366 SKIP_ULEB (data, end); 4367 SKIP_ULEB (data, end); 4368 } 4369 4370 READ_ULEB (n_directories, data, end); 4371 if (data == end) 4372 { 4373 warn (_("Corrupt directories list\n")); 4374 break; 4375 } 4376 4377 directory_table = (unsigned char **) 4378 xmalloc (n_directories * sizeof (unsigned char *)); 4379 4380 for (entryi = 0; entryi < n_directories; entryi++) 4381 { 4382 unsigned char **pathp = &directory_table[entryi]; 4383 4384 format = format_start; 4385 for (formati = 0; formati < format_count; formati++) 4386 { 4387 dwarf_vma content_type, form; 4388 dwarf_vma uvalue; 4389 4390 READ_ULEB (content_type, format, end); 4391 READ_ULEB (form, format, end); 4392 if (data == end) 4393 { 4394 warn (_("Corrupt directories list\n")); 4395 break; 4396 } 4397 switch (content_type) 4398 { 4399 case DW_LNCT_path: 4400 switch (form) 4401 { 4402 case DW_FORM_string: 4403 *pathp = data; 4404 break; 4405 case DW_FORM_line_strp: 4406 SAFE_BYTE_GET (uvalue, data, linfo.li_offset_size, 4407 end); 4408 /* Remove const by the cast. */ 4409 *pathp = (unsigned char *) 4410 fetch_indirect_line_string (uvalue); 4411 break; 4412 } 4413 break; 4414 } 4415 data = read_and_display_attr_value (0, form, 0, start, 4416 data, end, 0, 0, 4417 linfo.li_offset_size, 4418 linfo.li_version, 4419 NULL, 1, section, 4420 NULL, '\t', -1); 4421 } 4422 if (data == end) 4423 { 4424 warn (_("Corrupt directories list\n")); 4425 break; 4426 } 4427 } 4428 4429 /* Skip files format. */ 4430 SAFE_BYTE_GET_AND_INC (format_count, data, 1, end); 4431 format_start = data; 4432 for (formati = 0; formati < format_count; formati++) 4433 { 4434 SKIP_ULEB (data, end); 4435 SKIP_ULEB (data, end); 4436 } 4437 4438 READ_ULEB (n_files, data, end); 4439 if (data == end) 4440 { 4441 warn (_("Corrupt file name list\n")); 4442 break; 4443 } 4444 4445 file_table = (File_Entry *) xcalloc (1, n_files 4446 * sizeof (File_Entry)); 4447 4448 for (entryi = 0; entryi < n_files; entryi++) 4449 { 4450 File_Entry *file = &file_table[entryi]; 4451 4452 format = format_start; 4453 for (formati = 0; formati < format_count; formati++) 4454 { 4455 dwarf_vma content_type, form; 4456 dwarf_vma uvalue; 4457 unsigned char *tmp; 4458 4459 READ_ULEB (content_type, format, end); 4460 READ_ULEB (form, format, end); 4461 if (data == end) 4462 { 4463 warn (_("Corrupt file name list\n")); 4464 break; 4465 } 4466 switch (content_type) 4467 { 4468 case DW_LNCT_path: 4469 switch (form) 4470 { 4471 case DW_FORM_string: 4472 file->name = data; 4473 break; 4474 case DW_FORM_line_strp: 4475 SAFE_BYTE_GET (uvalue, data, linfo.li_offset_size, 4476 end); 4477 /* Remove const by the cast. */ 4478 file->name = (unsigned char *) 4479 fetch_indirect_line_string (uvalue); 4480 break; 4481 } 4482 break; 4483 case DW_LNCT_directory_index: 4484 switch (form) 4485 { 4486 case DW_FORM_data1: 4487 SAFE_BYTE_GET (file->directory_index, data, 1, 4488 end); 4489 break; 4490 case DW_FORM_data2: 4491 SAFE_BYTE_GET (file->directory_index, data, 2, 4492 end); 4493 break; 4494 case DW_FORM_udata: 4495 tmp = data; 4496 READ_ULEB (file->directory_index, tmp, end); 4497 break; 4498 } 4499 break; 4500 } 4501 data = read_and_display_attr_value (0, form, 0, start, 4502 data, end, 0, 0, 4503 linfo.li_offset_size, 4504 linfo.li_version, 4505 NULL, 1, section, 4506 NULL, '\t', -1); 4507 } 4508 if (data == end) 4509 { 4510 warn (_("Corrupt file name list\n")); 4511 break; 4512 } 4513 } 4514 } 4515 else 4516 { 4517 if (*data != 0) 4518 { 4519 unsigned char *ptr_directory_table = data; 4520 4521 while (data < end && *data != 0) 4522 { 4523 data += strnlen ((char *) data, end - data) + 1; 4524 n_directories++; 4525 } 4526 4527 /* PR 20440 */ 4528 if (data >= end) 4529 { 4530 warn (_("directory table ends unexpectedly\n")); 4531 n_directories = 0; 4532 break; 4533 } 4534 4535 /* Go through the directory table again to save the directories. */ 4536 directory_table = (unsigned char **) 4537 xmalloc (n_directories * sizeof (unsigned char *)); 4538 4539 i = 0; 4540 while (*ptr_directory_table != 0) 4541 { 4542 directory_table[i] = ptr_directory_table; 4543 ptr_directory_table += strnlen ((char *) ptr_directory_table, 4544 ptr_directory_table - end) + 1; 4545 i++; 4546 } 4547 } 4548 /* Skip the NUL at the end of the table. */ 4549 data++; 4550 4551 /* Traverse the File Name table just to count the entries. */ 4552 if (data < end && *data != 0) 4553 { 4554 unsigned char *ptr_file_name_table = data; 4555 4556 while (data < end && *data != 0) 4557 { 4558 /* Skip Name, directory index, last modification 4559 time and length of file. */ 4560 data += strnlen ((char *) data, end - data) + 1; 4561 SKIP_ULEB (data, end); 4562 SKIP_ULEB (data, end); 4563 SKIP_ULEB (data, end); 4564 n_files++; 4565 } 4566 4567 if (data >= end) 4568 { 4569 warn (_("file table ends unexpectedly\n")); 4570 n_files = 0; 4571 break; 4572 } 4573 4574 /* Go through the file table again to save the strings. */ 4575 file_table = (File_Entry *) xmalloc (n_files * sizeof (File_Entry)); 4576 4577 i = 0; 4578 while (*ptr_file_name_table != 0) 4579 { 4580 file_table[i].name = ptr_file_name_table; 4581 ptr_file_name_table += strnlen ((char *) ptr_file_name_table, 4582 end - ptr_file_name_table) + 1; 4583 4584 /* We are not interested in directory, time or size. */ 4585 READ_ULEB (file_table[i].directory_index, 4586 ptr_file_name_table, end); 4587 READ_ULEB (file_table[i].modification_date, 4588 ptr_file_name_table, end); 4589 READ_ULEB (file_table[i].length, 4590 ptr_file_name_table, end); 4591 i++; 4592 } 4593 i = 0; 4594 } 4595 4596 /* Skip the NUL at the end of the table. */ 4597 data++; 4598 } 4599 4600 /* Print the Compilation Unit's name and a header. */ 4601 if (file_table == NULL) 4602 ; 4603 else if (directory_table == NULL) 4604 printf (_("CU: %s:\n"), file_table[0].name); 4605 else 4606 { 4607 unsigned int ix = file_table[0].directory_index; 4608 const char *directory; 4609 4610 if (ix == 0) 4611 directory = "."; 4612 /* PR 20439 */ 4613 else if (n_directories == 0) 4614 directory = _("<unknown>"); 4615 else if (ix > n_directories) 4616 { 4617 warn (_("directory index %u > number of directories %s\n"), 4618 ix, dwarf_vmatoa ("u", n_directories)); 4619 directory = _("<corrupt>"); 4620 } 4621 else 4622 directory = (char *) directory_table[ix - 1]; 4623 4624 if (do_wide || strlen (directory) < 76) 4625 printf (_("CU: %s/%s:\n"), directory, file_table[0].name); 4626 else 4627 printf ("%s:\n", file_table[0].name); 4628 } 4629 4630 printf (_("File name Line number Starting address View Stmt\n")); 4631 saved_linfo = linfo; 4632 } 4633 4634 /* This loop iterates through the Dwarf Line Number Program. */ 4635 while (data < end_of_sequence) 4636 { 4637 unsigned char op_code; 4638 int xop; 4639 int adv; 4640 unsigned long int uladv; 4641 int is_special_opcode = 0; 4642 4643 op_code = *data++; 4644 xop = op_code; 4645 4646 if (op_code >= linfo.li_opcode_base) 4647 { 4648 op_code -= linfo.li_opcode_base; 4649 uladv = (op_code / linfo.li_line_range); 4650 if (linfo.li_max_ops_per_insn == 1) 4651 { 4652 uladv *= linfo.li_min_insn_length; 4653 state_machine_regs.address += uladv; 4654 if (uladv) 4655 state_machine_regs.view = 0; 4656 } 4657 else 4658 { 4659 unsigned addrdelta 4660 = ((state_machine_regs.op_index + uladv) 4661 / linfo.li_max_ops_per_insn) 4662 * linfo.li_min_insn_length; 4663 state_machine_regs.address 4664 += addrdelta; 4665 state_machine_regs.op_index 4666 = (state_machine_regs.op_index + uladv) 4667 % linfo.li_max_ops_per_insn; 4668 if (addrdelta) 4669 state_machine_regs.view = 0; 4670 } 4671 4672 adv = (op_code % linfo.li_line_range) + linfo.li_line_base; 4673 state_machine_regs.line += adv; 4674 is_special_opcode = 1; 4675 /* Increment view after printing this row. */ 4676 } 4677 else 4678 switch (op_code) 4679 { 4680 case DW_LNS_extended_op: 4681 { 4682 unsigned int ext_op_code_len; 4683 unsigned char ext_op_code; 4684 unsigned char *op_code_end; 4685 unsigned char *op_code_data = data; 4686 4687 READ_ULEB (ext_op_code_len, op_code_data, end_of_sequence); 4688 op_code_end = op_code_data + ext_op_code_len; 4689 if (ext_op_code_len == 0 || op_code_end > end_of_sequence) 4690 { 4691 warn (_("Badly formed extended line op encountered!\n")); 4692 break; 4693 } 4694 ext_op_code = *op_code_data++; 4695 xop = ext_op_code; 4696 xop = -xop; 4697 4698 switch (ext_op_code) 4699 { 4700 case DW_LNE_end_sequence: 4701 /* Reset stuff after printing this row. */ 4702 break; 4703 case DW_LNE_set_address: 4704 SAFE_BYTE_GET_AND_INC (state_machine_regs.address, 4705 op_code_data, 4706 op_code_end - op_code_data, 4707 op_code_end); 4708 state_machine_regs.op_index = 0; 4709 state_machine_regs.view = 0; 4710 break; 4711 case DW_LNE_define_file: 4712 file_table = (File_Entry *) xrealloc 4713 (file_table, (n_files + 1) * sizeof (File_Entry)); 4714 4715 ++state_machine_regs.last_file_entry; 4716 /* Source file name. */ 4717 file_table[n_files].name = op_code_data; 4718 op_code_data += strlen ((char *) op_code_data) + 1; 4719 /* Directory index. */ 4720 READ_ULEB (file_table[n_files].directory_index, 4721 op_code_data, op_code_end); 4722 /* Last modification time. */ 4723 READ_ULEB (file_table[n_files].modification_date, 4724 op_code_data, op_code_end); 4725 /* File length. */ 4726 READ_ULEB (file_table[n_files].length, 4727 op_code_data, op_code_end); 4728 n_files++; 4729 break; 4730 4731 case DW_LNE_set_discriminator: 4732 case DW_LNE_HP_set_sequence: 4733 /* Simply ignored. */ 4734 break; 4735 4736 default: 4737 printf (_("UNKNOWN (%u): length %ld\n"), 4738 ext_op_code, (long int) (op_code_data - data)); 4739 break; 4740 } 4741 data = op_code_end; 4742 break; 4743 } 4744 case DW_LNS_copy: 4745 /* Increment view after printing this row. */ 4746 break; 4747 4748 case DW_LNS_advance_pc: 4749 READ_ULEB (uladv, data, end); 4750 if (linfo.li_max_ops_per_insn == 1) 4751 { 4752 uladv *= linfo.li_min_insn_length; 4753 state_machine_regs.address += uladv; 4754 if (uladv) 4755 state_machine_regs.view = 0; 4756 } 4757 else 4758 { 4759 unsigned addrdelta 4760 = ((state_machine_regs.op_index + uladv) 4761 / linfo.li_max_ops_per_insn) 4762 * linfo.li_min_insn_length; 4763 state_machine_regs.address 4764 += addrdelta; 4765 state_machine_regs.op_index 4766 = (state_machine_regs.op_index + uladv) 4767 % linfo.li_max_ops_per_insn; 4768 if (addrdelta) 4769 state_machine_regs.view = 0; 4770 } 4771 break; 4772 4773 case DW_LNS_advance_line: 4774 READ_SLEB (adv, data, end); 4775 state_machine_regs.line += adv; 4776 break; 4777 4778 case DW_LNS_set_file: 4779 READ_ULEB (uladv, data, end); 4780 state_machine_regs.file = uladv; 4781 4782 { 4783 unsigned file = state_machine_regs.file - 1; 4784 unsigned dir; 4785 4786 if (file_table == NULL || n_files == 0) 4787 printf (_("\n [Use file table entry %d]\n"), file); 4788 /* PR 20439 */ 4789 else if (file >= n_files) 4790 { 4791 warn (_("file index %u > number of files %u\n"), file + 1, n_files); 4792 printf (_("\n <over large file table index %u>"), file); 4793 } 4794 else if ((dir = file_table[file].directory_index) == 0) 4795 /* If directory index is 0, that means current directory. */ 4796 printf ("\n./%s:[++]\n", file_table[file].name); 4797 else if (directory_table == NULL || n_directories == 0) 4798 printf (_("\n [Use file %s in directory table entry %d]\n"), 4799 file_table[file].name, dir); 4800 /* PR 20439 */ 4801 else if (dir > n_directories) 4802 { 4803 warn (_("directory index %u > number of directories %s\n"), 4804 dir, dwarf_vmatoa ("u", n_directories)); 4805 printf (_("\n <over large directory table entry %u>\n"), dir); 4806 } 4807 else 4808 printf ("\n%s/%s:\n", 4809 /* The directory index starts counting at 1. */ 4810 directory_table[dir - 1], file_table[file].name); 4811 } 4812 break; 4813 4814 case DW_LNS_set_column: 4815 READ_ULEB (uladv, data, end); 4816 state_machine_regs.column = uladv; 4817 break; 4818 4819 case DW_LNS_negate_stmt: 4820 adv = state_machine_regs.is_stmt; 4821 adv = ! adv; 4822 state_machine_regs.is_stmt = adv; 4823 break; 4824 4825 case DW_LNS_set_basic_block: 4826 state_machine_regs.basic_block = 1; 4827 break; 4828 4829 case DW_LNS_const_add_pc: 4830 uladv = ((255 - linfo.li_opcode_base) / linfo.li_line_range); 4831 if (linfo.li_max_ops_per_insn == 1) 4832 { 4833 uladv *= linfo.li_min_insn_length; 4834 state_machine_regs.address += uladv; 4835 if (uladv) 4836 state_machine_regs.view = 0; 4837 } 4838 else 4839 { 4840 unsigned addrdelta 4841 = ((state_machine_regs.op_index + uladv) 4842 / linfo.li_max_ops_per_insn) 4843 * linfo.li_min_insn_length; 4844 state_machine_regs.address 4845 += addrdelta; 4846 state_machine_regs.op_index 4847 = (state_machine_regs.op_index + uladv) 4848 % linfo.li_max_ops_per_insn; 4849 if (addrdelta) 4850 state_machine_regs.view = 0; 4851 } 4852 break; 4853 4854 case DW_LNS_fixed_advance_pc: 4855 SAFE_BYTE_GET_AND_INC (uladv, data, 2, end); 4856 state_machine_regs.address += uladv; 4857 state_machine_regs.op_index = 0; 4858 /* Do NOT reset view. */ 4859 break; 4860 4861 case DW_LNS_set_prologue_end: 4862 break; 4863 4864 case DW_LNS_set_epilogue_begin: 4865 break; 4866 4867 case DW_LNS_set_isa: 4868 READ_ULEB (uladv, data, end); 4869 printf (_(" Set ISA to %lu\n"), uladv); 4870 break; 4871 4872 default: 4873 printf (_(" Unknown opcode %d with operands: "), op_code); 4874 4875 if (standard_opcodes != NULL) 4876 for (i = standard_opcodes[op_code - 1]; i > 0 ; --i) 4877 { 4878 dwarf_vma val; 4879 4880 READ_ULEB (val, data, end); 4881 printf ("0x%s%s", dwarf_vmatoa ("x", val), 4882 i == 1 ? "" : ", "); 4883 } 4884 putchar ('\n'); 4885 break; 4886 } 4887 4888 /* Only Special opcodes, DW_LNS_copy and DW_LNE_end_sequence adds a row 4889 to the DWARF address/line matrix. */ 4890 if ((is_special_opcode) || (xop == -DW_LNE_end_sequence) 4891 || (xop == DW_LNS_copy)) 4892 { 4893 const unsigned int MAX_FILENAME_LENGTH = 35; 4894 char *fileName; 4895 char *newFileName = NULL; 4896 size_t fileNameLength; 4897 4898 if (file_table) 4899 { 4900 unsigned indx = state_machine_regs.file - 1; 4901 /* PR 20439 */ 4902 if (indx >= n_files) 4903 { 4904 warn (_("corrupt file index %u encountered\n"), indx); 4905 fileName = _("<corrupt>"); 4906 } 4907 else 4908 fileName = (char *) file_table[indx].name; 4909 } 4910 else 4911 fileName = _("<unknown>"); 4912 4913 fileNameLength = strlen (fileName); 4914 4915 if ((fileNameLength > MAX_FILENAME_LENGTH) && (!do_wide)) 4916 { 4917 newFileName = (char *) xmalloc (MAX_FILENAME_LENGTH + 1); 4918 /* Truncate file name */ 4919 strncpy (newFileName, 4920 fileName + fileNameLength - MAX_FILENAME_LENGTH, 4921 MAX_FILENAME_LENGTH + 1); 4922 } 4923 else 4924 { 4925 newFileName = (char *) xmalloc (fileNameLength + 1); 4926 strncpy (newFileName, fileName, fileNameLength + 1); 4927 } 4928 4929 if (!do_wide || (fileNameLength <= MAX_FILENAME_LENGTH)) 4930 { 4931 if (linfo.li_max_ops_per_insn == 1) 4932 printf ("%-35s %11d %#18" DWARF_VMA_FMT "x", 4933 newFileName, state_machine_regs.line, 4934 state_machine_regs.address); 4935 else 4936 printf ("%-35s %11d %#18" DWARF_VMA_FMT "x[%d]", 4937 newFileName, state_machine_regs.line, 4938 state_machine_regs.address, 4939 state_machine_regs.op_index); 4940 } 4941 else 4942 { 4943 if (linfo.li_max_ops_per_insn == 1) 4944 printf ("%s %11d %#18" DWARF_VMA_FMT "x", 4945 newFileName, state_machine_regs.line, 4946 state_machine_regs.address); 4947 else 4948 printf ("%s %11d %#18" DWARF_VMA_FMT "x[%d]", 4949 newFileName, state_machine_regs.line, 4950 state_machine_regs.address, 4951 state_machine_regs.op_index); 4952 } 4953 4954 if (state_machine_regs.view) 4955 printf (" %6u", state_machine_regs.view); 4956 else 4957 printf (" "); 4958 4959 if (state_machine_regs.is_stmt) 4960 printf (" x"); 4961 4962 putchar ('\n'); 4963 state_machine_regs.view++; 4964 4965 if (xop == -DW_LNE_end_sequence) 4966 { 4967 reset_state_machine (linfo.li_default_is_stmt); 4968 putchar ('\n'); 4969 } 4970 4971 free (newFileName); 4972 } 4973 } 4974 4975 if (file_table) 4976 { 4977 free (file_table); 4978 file_table = NULL; 4979 n_files = 0; 4980 } 4981 4982 if (directory_table) 4983 { 4984 free (directory_table); 4985 directory_table = NULL; 4986 n_directories = 0; 4987 } 4988 4989 putchar ('\n'); 4990 } 4991 4992 return 1; 4993 } 4994 4995 static int 4996 display_debug_lines (struct dwarf_section *section, void *file) 4997 { 4998 unsigned char *data = section->start; 4999 unsigned char *end = data + section->size; 5000 int retValRaw = 1; 5001 int retValDecoded = 1; 5002 5003 if (do_debug_lines == 0) 5004 do_debug_lines |= FLAG_DEBUG_LINES_RAW; 5005 5006 if (do_debug_lines & FLAG_DEBUG_LINES_RAW) 5007 retValRaw = display_debug_lines_raw (section, data, end, file); 5008 5009 if (do_debug_lines & FLAG_DEBUG_LINES_DECODED) 5010 retValDecoded = display_debug_lines_decoded (section, data, data, end, file); 5011 5012 if (!retValRaw || !retValDecoded) 5013 return 0; 5014 5015 return 1; 5016 } 5017 5018 static debug_info * 5019 find_debug_info_for_offset (unsigned long offset) 5020 { 5021 unsigned int i; 5022 5023 if (num_debug_info_entries == DEBUG_INFO_UNAVAILABLE) 5024 return NULL; 5025 5026 for (i = 0; i < num_debug_info_entries; i++) 5027 if (debug_information[i].cu_offset == offset) 5028 return debug_information + i; 5029 5030 return NULL; 5031 } 5032 5033 static const char * 5034 get_gdb_index_symbol_kind_name (gdb_index_symbol_kind kind) 5035 { 5036 /* See gdb/gdb-index.h. */ 5037 static const char * const kinds[] = 5038 { 5039 N_ ("no info"), 5040 N_ ("type"), 5041 N_ ("variable"), 5042 N_ ("function"), 5043 N_ ("other"), 5044 N_ ("unused5"), 5045 N_ ("unused6"), 5046 N_ ("unused7") 5047 }; 5048 5049 return _ (kinds[kind]); 5050 } 5051 5052 static int 5053 display_debug_pubnames_worker (struct dwarf_section *section, 5054 void *file ATTRIBUTE_UNUSED, 5055 int is_gnu) 5056 { 5057 DWARF2_Internal_PubNames names; 5058 unsigned char *start = section->start; 5059 unsigned char *end = start + section->size; 5060 5061 /* It does not matter if this load fails, 5062 we test for that later on. */ 5063 load_debug_info (file); 5064 5065 introduce (section, FALSE); 5066 5067 while (start < end) 5068 { 5069 unsigned char *data; 5070 unsigned long sec_off; 5071 unsigned int offset_size, initial_length_size; 5072 5073 SAFE_BYTE_GET_AND_INC (names.pn_length, start, 4, end); 5074 if (names.pn_length == 0xffffffff) 5075 { 5076 SAFE_BYTE_GET_AND_INC (names.pn_length, start, 8, end); 5077 offset_size = 8; 5078 initial_length_size = 12; 5079 } 5080 else 5081 { 5082 offset_size = 4; 5083 initial_length_size = 4; 5084 } 5085 5086 sec_off = start - section->start; 5087 if (sec_off + names.pn_length < sec_off 5088 || sec_off + names.pn_length > section->size) 5089 { 5090 warn (_("Debug info is corrupted, %s header at %#lx has length %s\n"), 5091 section->name, 5092 sec_off - initial_length_size, 5093 dwarf_vmatoa ("x", names.pn_length)); 5094 break; 5095 } 5096 5097 data = start; 5098 start += names.pn_length; 5099 5100 SAFE_BYTE_GET_AND_INC (names.pn_version, data, 2, end); 5101 SAFE_BYTE_GET_AND_INC (names.pn_offset, data, offset_size, end); 5102 5103 if (num_debug_info_entries != DEBUG_INFO_UNAVAILABLE 5104 && num_debug_info_entries > 0 5105 && find_debug_info_for_offset (names.pn_offset) == NULL) 5106 warn (_(".debug_info offset of 0x%lx in %s section does not point to a CU header.\n"), 5107 (unsigned long) names.pn_offset, section->name); 5108 5109 SAFE_BYTE_GET_AND_INC (names.pn_size, data, offset_size, end); 5110 5111 printf (_(" Length: %ld\n"), 5112 (long) names.pn_length); 5113 printf (_(" Version: %d\n"), 5114 names.pn_version); 5115 printf (_(" Offset into .debug_info section: 0x%lx\n"), 5116 (unsigned long) names.pn_offset); 5117 printf (_(" Size of area in .debug_info section: %ld\n"), 5118 (long) names.pn_size); 5119 5120 if (names.pn_version != 2 && names.pn_version != 3) 5121 { 5122 static int warned = 0; 5123 5124 if (! warned) 5125 { 5126 warn (_("Only DWARF 2 and 3 pubnames are currently supported\n")); 5127 warned = 1; 5128 } 5129 5130 continue; 5131 } 5132 5133 if (is_gnu) 5134 printf (_("\n Offset Kind Name\n")); 5135 else 5136 printf (_("\n Offset\tName\n")); 5137 5138 while (1) 5139 { 5140 bfd_size_type maxprint; 5141 dwarf_vma offset; 5142 5143 SAFE_BYTE_GET (offset, data, offset_size, end); 5144 5145 if (offset == 0) 5146 break; 5147 5148 data += offset_size; 5149 if (data >= end) 5150 break; 5151 maxprint = (end - data) - 1; 5152 5153 if (is_gnu) 5154 { 5155 unsigned int kind_data; 5156 gdb_index_symbol_kind kind; 5157 const char *kind_name; 5158 int is_static; 5159 5160 SAFE_BYTE_GET (kind_data, data, 1, end); 5161 data++; 5162 maxprint --; 5163 /* GCC computes the kind as the upper byte in the CU index 5164 word, and then right shifts it by the CU index size. 5165 Left shift KIND to where the gdb-index.h accessor macros 5166 can use it. */ 5167 kind_data <<= GDB_INDEX_CU_BITSIZE; 5168 kind = GDB_INDEX_SYMBOL_KIND_VALUE (kind_data); 5169 kind_name = get_gdb_index_symbol_kind_name (kind); 5170 is_static = GDB_INDEX_SYMBOL_STATIC_VALUE (kind_data); 5171 printf (" %-6lx %s,%-10s %.*s\n", 5172 (unsigned long) offset, is_static ? _("s") : _("g"), 5173 kind_name, (int) maxprint, data); 5174 } 5175 else 5176 printf (" %-6lx\t%.*s\n", 5177 (unsigned long) offset, (int) maxprint, data); 5178 5179 data += strnlen ((char *) data, maxprint) + 1; 5180 if (data >= end) 5181 break; 5182 } 5183 } 5184 5185 printf ("\n"); 5186 return 1; 5187 } 5188 5189 static int 5190 display_debug_pubnames (struct dwarf_section *section, void *file) 5191 { 5192 return display_debug_pubnames_worker (section, file, 0); 5193 } 5194 5195 static int 5196 display_debug_gnu_pubnames (struct dwarf_section *section, void *file) 5197 { 5198 return display_debug_pubnames_worker (section, file, 1); 5199 } 5200 5201 static int 5202 display_debug_macinfo (struct dwarf_section *section, 5203 void *file ATTRIBUTE_UNUSED) 5204 { 5205 unsigned char *start = section->start; 5206 unsigned char *end = start + section->size; 5207 unsigned char *curr = start; 5208 enum dwarf_macinfo_record_type op; 5209 5210 introduce (section, FALSE); 5211 5212 while (curr < end) 5213 { 5214 unsigned int lineno; 5215 const unsigned char *string; 5216 5217 op = (enum dwarf_macinfo_record_type) *curr; 5218 curr++; 5219 5220 switch (op) 5221 { 5222 case DW_MACINFO_start_file: 5223 { 5224 unsigned int filenum; 5225 5226 READ_ULEB (lineno, curr, end); 5227 READ_ULEB (filenum, curr, end); 5228 printf (_(" DW_MACINFO_start_file - lineno: %d filenum: %d\n"), 5229 lineno, filenum); 5230 } 5231 break; 5232 5233 case DW_MACINFO_end_file: 5234 printf (_(" DW_MACINFO_end_file\n")); 5235 break; 5236 5237 case DW_MACINFO_define: 5238 READ_ULEB (lineno, curr, end); 5239 string = curr; 5240 curr += strnlen ((char *) string, end - string) + 1; 5241 printf (_(" DW_MACINFO_define - lineno : %d macro : %s\n"), 5242 lineno, string); 5243 break; 5244 5245 case DW_MACINFO_undef: 5246 READ_ULEB (lineno, curr, end); 5247 string = curr; 5248 curr += strnlen ((char *) string, end - string) + 1; 5249 printf (_(" DW_MACINFO_undef - lineno : %d macro : %s\n"), 5250 lineno, string); 5251 break; 5252 5253 case DW_MACINFO_vendor_ext: 5254 { 5255 unsigned int constant; 5256 5257 READ_ULEB (constant, curr, end); 5258 string = curr; 5259 curr += strnlen ((char *) string, end - string) + 1; 5260 printf (_(" DW_MACINFO_vendor_ext - constant : %d string : %s\n"), 5261 constant, string); 5262 } 5263 break; 5264 } 5265 } 5266 5267 return 1; 5268 } 5269 5270 /* Given LINE_OFFSET into the .debug_line section, attempt to return 5271 filename and dirname corresponding to file name table entry with index 5272 FILEIDX. Return NULL on failure. */ 5273 5274 static unsigned char * 5275 get_line_filename_and_dirname (dwarf_vma line_offset, 5276 dwarf_vma fileidx, 5277 unsigned char **dir_name) 5278 { 5279 struct dwarf_section *section = &debug_displays [line].section; 5280 unsigned char *hdrptr, *dirtable, *file_name; 5281 unsigned int offset_size, initial_length_size; 5282 unsigned int version, opcode_base; 5283 dwarf_vma length, diridx; 5284 const unsigned char * end; 5285 5286 *dir_name = NULL; 5287 if (section->start == NULL 5288 || line_offset >= section->size 5289 || fileidx == 0) 5290 return NULL; 5291 5292 hdrptr = section->start + line_offset; 5293 end = section->start + section->size; 5294 5295 SAFE_BYTE_GET_AND_INC (length, hdrptr, 4, end); 5296 if (length == 0xffffffff) 5297 { 5298 /* This section is 64-bit DWARF 3. */ 5299 SAFE_BYTE_GET_AND_INC (length, hdrptr, 8, end); 5300 offset_size = 8; 5301 initial_length_size = 12; 5302 } 5303 else 5304 { 5305 offset_size = 4; 5306 initial_length_size = 4; 5307 } 5308 if (length + initial_length_size < length 5309 || length + initial_length_size > section->size) 5310 return NULL; 5311 5312 SAFE_BYTE_GET_AND_INC (version, hdrptr, 2, end); 5313 if (version != 2 && version != 3 && version != 4) 5314 return NULL; 5315 hdrptr += offset_size + 1;/* Skip prologue_length and min_insn_length. */ 5316 if (version >= 4) 5317 hdrptr++; /* Skip max_ops_per_insn. */ 5318 hdrptr += 3; /* Skip default_is_stmt, line_base, line_range. */ 5319 5320 SAFE_BYTE_GET_AND_INC (opcode_base, hdrptr, 1, end); 5321 if (opcode_base == 0) 5322 return NULL; 5323 5324 hdrptr += opcode_base - 1; 5325 if (hdrptr >= end) 5326 return NULL; 5327 5328 dirtable = hdrptr; 5329 /* Skip over dirname table. */ 5330 while (*hdrptr != '\0') 5331 { 5332 hdrptr += strnlen ((char *) hdrptr, end - hdrptr) + 1; 5333 if (hdrptr >= end) 5334 return NULL; 5335 } 5336 hdrptr++; /* Skip the NUL at the end of the table. */ 5337 5338 /* Now skip over preceding filename table entries. */ 5339 for (; hdrptr < end && *hdrptr != '\0' && fileidx > 1; fileidx--) 5340 { 5341 hdrptr += strnlen ((char *) hdrptr, end - hdrptr) + 1; 5342 SKIP_ULEB (hdrptr, end); 5343 SKIP_ULEB (hdrptr, end); 5344 SKIP_ULEB (hdrptr, end); 5345 } 5346 if (hdrptr >= end || *hdrptr == '\0') 5347 return NULL; 5348 5349 file_name = hdrptr; 5350 hdrptr += strnlen ((char *) hdrptr, end - hdrptr) + 1; 5351 if (hdrptr >= end) 5352 return NULL; 5353 READ_ULEB (diridx, hdrptr, end); 5354 if (diridx == 0) 5355 return file_name; 5356 for (; dirtable < end && *dirtable != '\0' && diridx > 1; diridx--) 5357 dirtable += strnlen ((char *) dirtable, end - dirtable) + 1; 5358 if (dirtable >= end || *dirtable == '\0') 5359 return NULL; 5360 *dir_name = dirtable; 5361 return file_name; 5362 } 5363 5364 static int 5365 display_debug_macro (struct dwarf_section *section, 5366 void *file) 5367 { 5368 unsigned char *start = section->start; 5369 unsigned char *end = start + section->size; 5370 unsigned char *curr = start; 5371 unsigned char *extended_op_buf[256]; 5372 5373 load_debug_section_with_follow (str, file); 5374 load_debug_section_with_follow (line, file); 5375 5376 introduce (section, FALSE); 5377 5378 while (curr < end) 5379 { 5380 unsigned int lineno, version, flags; 5381 unsigned int offset_size = 4; 5382 const unsigned char *string; 5383 dwarf_vma line_offset = 0, sec_offset = curr - start, offset; 5384 unsigned char **extended_ops = NULL; 5385 5386 SAFE_BYTE_GET_AND_INC (version, curr, 2, end); 5387 if (version != 4 && version != 5) 5388 { 5389 error (_("Only GNU extension to DWARF 4 or 5 of %s is currently supported.\n"), 5390 section->name); 5391 return 0; 5392 } 5393 5394 SAFE_BYTE_GET_AND_INC (flags, curr, 1, end); 5395 if (flags & 1) 5396 offset_size = 8; 5397 printf (_(" Offset: 0x%lx\n"), 5398 (unsigned long) sec_offset); 5399 printf (_(" Version: %d\n"), version); 5400 printf (_(" Offset size: %d\n"), offset_size); 5401 if (flags & 2) 5402 { 5403 SAFE_BYTE_GET_AND_INC (line_offset, curr, offset_size, end); 5404 printf (_(" Offset into .debug_line: 0x%lx\n"), 5405 (unsigned long) line_offset); 5406 } 5407 if (flags & 4) 5408 { 5409 unsigned int i, count, op; 5410 dwarf_vma nargs, n; 5411 5412 SAFE_BYTE_GET_AND_INC (count, curr, 1, end); 5413 5414 memset (extended_op_buf, 0, sizeof (extended_op_buf)); 5415 extended_ops = extended_op_buf; 5416 if (count) 5417 { 5418 printf (_(" Extension opcode arguments:\n")); 5419 for (i = 0; i < count; i++) 5420 { 5421 SAFE_BYTE_GET_AND_INC (op, curr, 1, end); 5422 extended_ops[op] = curr; 5423 READ_ULEB (nargs, curr, end); 5424 if (nargs == 0) 5425 printf (_(" DW_MACRO_%02x has no arguments\n"), op); 5426 else 5427 { 5428 printf (_(" DW_MACRO_%02x arguments: "), op); 5429 for (n = 0; n < nargs; n++) 5430 { 5431 unsigned int form; 5432 5433 SAFE_BYTE_GET_AND_INC (form, curr, 1, end); 5434 printf ("%s%s", get_FORM_name (form), 5435 n == nargs - 1 ? "\n" : ", "); 5436 switch (form) 5437 { 5438 case DW_FORM_data1: 5439 case DW_FORM_data2: 5440 case DW_FORM_data4: 5441 case DW_FORM_data8: 5442 case DW_FORM_sdata: 5443 case DW_FORM_udata: 5444 case DW_FORM_block: 5445 case DW_FORM_block1: 5446 case DW_FORM_block2: 5447 case DW_FORM_block4: 5448 case DW_FORM_flag: 5449 case DW_FORM_string: 5450 case DW_FORM_strp: 5451 case DW_FORM_sec_offset: 5452 break; 5453 default: 5454 error (_("Invalid extension opcode form %s\n"), 5455 get_FORM_name (form)); 5456 return 0; 5457 } 5458 } 5459 } 5460 } 5461 } 5462 } 5463 printf ("\n"); 5464 5465 while (1) 5466 { 5467 unsigned int op; 5468 5469 if (curr >= end) 5470 { 5471 error (_(".debug_macro section not zero terminated\n")); 5472 return 0; 5473 } 5474 5475 SAFE_BYTE_GET_AND_INC (op, curr, 1, end); 5476 if (op == 0) 5477 break; 5478 5479 switch (op) 5480 { 5481 case DW_MACRO_start_file: 5482 { 5483 unsigned int filenum; 5484 unsigned char *file_name = NULL, *dir_name = NULL; 5485 5486 READ_ULEB (lineno, curr, end); 5487 READ_ULEB (filenum, curr, end); 5488 5489 if ((flags & 2) == 0) 5490 error (_("DW_MACRO_start_file used, but no .debug_line offset provided.\n")); 5491 else 5492 file_name 5493 = get_line_filename_and_dirname (line_offset, filenum, 5494 &dir_name); 5495 if (file_name == NULL) 5496 printf (_(" DW_MACRO_start_file - lineno: %d filenum: %d\n"), 5497 lineno, filenum); 5498 else 5499 printf (_(" DW_MACRO_start_file - lineno: %d filenum: %d filename: %s%s%s\n"), 5500 lineno, filenum, 5501 dir_name != NULL ? (const char *) dir_name : "", 5502 dir_name != NULL ? "/" : "", file_name); 5503 } 5504 break; 5505 5506 case DW_MACRO_end_file: 5507 printf (_(" DW_MACRO_end_file\n")); 5508 break; 5509 5510 case DW_MACRO_define: 5511 READ_ULEB (lineno, curr, end); 5512 string = curr; 5513 curr += strnlen ((char *) string, end - string) + 1; 5514 printf (_(" DW_MACRO_define - lineno : %d macro : %s\n"), 5515 lineno, string); 5516 break; 5517 5518 case DW_MACRO_undef: 5519 READ_ULEB (lineno, curr, end); 5520 string = curr; 5521 curr += strnlen ((char *) string, end - string) + 1; 5522 printf (_(" DW_MACRO_undef - lineno : %d macro : %s\n"), 5523 lineno, string); 5524 break; 5525 5526 case DW_MACRO_define_strp: 5527 READ_ULEB (lineno, curr, end); 5528 SAFE_BYTE_GET_AND_INC (offset, curr, offset_size, end); 5529 string = fetch_indirect_string (offset); 5530 printf (_(" DW_MACRO_define_strp - lineno : %d macro : %s\n"), 5531 lineno, string); 5532 break; 5533 5534 case DW_MACRO_undef_strp: 5535 READ_ULEB (lineno, curr, end); 5536 SAFE_BYTE_GET_AND_INC (offset, curr, offset_size, end); 5537 string = fetch_indirect_string (offset); 5538 printf (_(" DW_MACRO_undef_strp - lineno : %d macro : %s\n"), 5539 lineno, string); 5540 break; 5541 5542 case DW_MACRO_import: 5543 SAFE_BYTE_GET_AND_INC (offset, curr, offset_size, end); 5544 printf (_(" DW_MACRO_import - offset : 0x%lx\n"), 5545 (unsigned long) offset); 5546 break; 5547 5548 case DW_MACRO_define_sup: 5549 READ_ULEB (lineno, curr, end); 5550 SAFE_BYTE_GET_AND_INC (offset, curr, offset_size, end); 5551 printf (_(" DW_MACRO_define_sup - lineno : %d macro offset : 0x%lx\n"), 5552 lineno, (unsigned long) offset); 5553 break; 5554 5555 case DW_MACRO_undef_sup: 5556 READ_ULEB (lineno, curr, end); 5557 SAFE_BYTE_GET_AND_INC (offset, curr, offset_size, end); 5558 printf (_(" DW_MACRO_undef_sup - lineno : %d macro offset : 0x%lx\n"), 5559 lineno, (unsigned long) offset); 5560 break; 5561 5562 case DW_MACRO_import_sup: 5563 SAFE_BYTE_GET_AND_INC (offset, curr, offset_size, end); 5564 printf (_(" DW_MACRO_import_sup - offset : 0x%lx\n"), 5565 (unsigned long) offset); 5566 break; 5567 5568 default: 5569 if (extended_ops == NULL || extended_ops[op] == NULL) 5570 { 5571 error (_(" Unknown macro opcode %02x seen\n"), op); 5572 return 0; 5573 } 5574 else 5575 { 5576 /* Skip over unhandled opcodes. */ 5577 dwarf_vma nargs, n; 5578 unsigned char *desc = extended_ops[op]; 5579 READ_ULEB (nargs, desc, end); 5580 if (nargs == 0) 5581 { 5582 printf (_(" DW_MACRO_%02x\n"), op); 5583 break; 5584 } 5585 printf (_(" DW_MACRO_%02x -"), op); 5586 for (n = 0; n < nargs; n++) 5587 { 5588 int val; 5589 5590 /* DW_FORM_implicit_const is not expected here. */ 5591 SAFE_BYTE_GET_AND_INC (val, desc, 1, end); 5592 curr 5593 = read_and_display_attr_value (0, val, 0, 5594 start, curr, end, 0, 0, offset_size, 5595 version, NULL, 0, NULL, 5596 NULL, ' ', -1); 5597 if (n != nargs - 1) 5598 printf (","); 5599 } 5600 printf ("\n"); 5601 } 5602 break; 5603 } 5604 } 5605 5606 printf ("\n"); 5607 } 5608 5609 return 1; 5610 } 5611 5612 static int 5613 display_debug_abbrev (struct dwarf_section *section, 5614 void *file ATTRIBUTE_UNUSED) 5615 { 5616 abbrev_entry *entry; 5617 unsigned char *start = section->start; 5618 unsigned char *end = start + section->size; 5619 5620 introduce (section, FALSE); 5621 5622 do 5623 { 5624 unsigned char *last; 5625 5626 free_abbrevs (); 5627 5628 last = start; 5629 start = process_abbrev_section (start, end); 5630 5631 if (first_abbrev == NULL) 5632 continue; 5633 5634 printf (_(" Number TAG (0x%lx)\n"), (long) (last - section->start)); 5635 5636 for (entry = first_abbrev; entry; entry = entry->next) 5637 { 5638 abbrev_attr *attr; 5639 5640 printf (" %ld %s [%s]\n", 5641 entry->entry, 5642 get_TAG_name (entry->tag), 5643 entry->children ? _("has children") : _("no children")); 5644 5645 for (attr = entry->first_attr; attr; attr = attr->next) 5646 { 5647 printf (" %-18s %s", 5648 get_AT_name (attr->attribute), 5649 get_FORM_name (attr->form)); 5650 if (attr->form == DW_FORM_implicit_const) 5651 printf (": %" BFD_VMA_FMT "d", attr->implicit_const); 5652 putchar ('\n'); 5653 } 5654 } 5655 } 5656 while (start); 5657 5658 printf ("\n"); 5659 5660 return 1; 5661 } 5662 5663 /* Return true when ADDR is the maximum address, when addresses are 5664 POINTER_SIZE bytes long. */ 5665 5666 static bfd_boolean 5667 is_max_address (dwarf_vma addr, unsigned int pointer_size) 5668 { 5669 dwarf_vma mask = ~(~(dwarf_vma) 1 << (pointer_size * 8 - 1)); 5670 return ((addr & mask) == mask); 5671 } 5672 5673 /* Display a view pair list starting at *VSTART_PTR and ending at 5674 VLISTEND within SECTION. */ 5675 5676 static void 5677 display_view_pair_list (struct dwarf_section *section, 5678 unsigned char **vstart_ptr, 5679 unsigned int debug_info_entry, 5680 unsigned char *vlistend) 5681 { 5682 unsigned char *vstart = *vstart_ptr; 5683 unsigned char *section_end = section->start + section->size; 5684 unsigned int pointer_size = debug_information [debug_info_entry].pointer_size; 5685 5686 if (vlistend < section_end) 5687 section_end = vlistend; 5688 5689 putchar ('\n'); 5690 5691 while (vstart < section_end) 5692 { 5693 dwarf_vma off = vstart - section->start; 5694 dwarf_vma vbegin, vend; 5695 5696 READ_ULEB (vbegin, vstart, section_end); 5697 if (vstart == section_end) 5698 break; 5699 5700 READ_ULEB (vend, vstart, section_end); 5701 printf (" %8.8lx ", (unsigned long) off); 5702 5703 print_dwarf_view (vbegin, pointer_size, 1); 5704 print_dwarf_view (vend, pointer_size, 1); 5705 printf (_("location view pair\n")); 5706 } 5707 5708 putchar ('\n'); 5709 *vstart_ptr = vstart; 5710 } 5711 5712 /* Display a location list from a normal (ie, non-dwo) .debug_loc section. */ 5713 5714 static void 5715 display_loc_list (struct dwarf_section *section, 5716 unsigned char **start_ptr, 5717 unsigned int debug_info_entry, 5718 dwarf_vma offset, 5719 dwarf_vma base_address, 5720 unsigned char **vstart_ptr, 5721 int has_frame_base) 5722 { 5723 unsigned char *start = *start_ptr, *vstart = *vstart_ptr; 5724 unsigned char *section_end = section->start + section->size; 5725 unsigned long cu_offset; 5726 unsigned int pointer_size; 5727 unsigned int offset_size; 5728 int dwarf_version; 5729 5730 dwarf_vma begin; 5731 dwarf_vma end; 5732 unsigned short length; 5733 int need_frame_base; 5734 5735 if (debug_info_entry >= num_debug_info_entries) 5736 { 5737 warn (_("No debug information available for loc lists of entry: %u\n"), 5738 debug_info_entry); 5739 return; 5740 } 5741 5742 cu_offset = debug_information [debug_info_entry].cu_offset; 5743 pointer_size = debug_information [debug_info_entry].pointer_size; 5744 offset_size = debug_information [debug_info_entry].offset_size; 5745 dwarf_version = debug_information [debug_info_entry].dwarf_version; 5746 5747 if (pointer_size < 2 || pointer_size > 8) 5748 { 5749 warn (_("Invalid pointer size (%d) in debug info for entry %d\n"), 5750 pointer_size, debug_info_entry); 5751 return; 5752 } 5753 5754 while (1) 5755 { 5756 dwarf_vma off = offset + (start - *start_ptr); 5757 dwarf_vma vbegin = vm1, vend = vm1; 5758 5759 if (start + 2 * pointer_size > section_end) 5760 { 5761 warn (_("Location list starting at offset 0x%lx is not terminated.\n"), 5762 (unsigned long) offset); 5763 break; 5764 } 5765 5766 printf (" %8.8lx ", (unsigned long) off); 5767 5768 SAFE_BYTE_GET_AND_INC (begin, start, pointer_size, section_end); 5769 SAFE_BYTE_GET_AND_INC (end, start, pointer_size, section_end); 5770 5771 if (begin == 0 && end == 0) 5772 { 5773 /* PR 18374: In a object file we can have a location list that 5774 starts with a begin and end of 0 because there are relocations 5775 that need to be applied to the addresses. Actually applying 5776 the relocations now does not help as they will probably resolve 5777 to 0, since the object file has not been fully linked. Real 5778 end of list markers will not have any relocations against them. */ 5779 if (! reloc_at (section, off) 5780 && ! reloc_at (section, off + pointer_size)) 5781 { 5782 printf (_("<End of list>\n")); 5783 break; 5784 } 5785 } 5786 5787 /* Check base address specifiers. */ 5788 if (is_max_address (begin, pointer_size) 5789 && !is_max_address (end, pointer_size)) 5790 { 5791 base_address = end; 5792 print_dwarf_vma (begin, pointer_size); 5793 print_dwarf_vma (end, pointer_size); 5794 printf (_("(base address)\n")); 5795 continue; 5796 } 5797 5798 if (vstart) 5799 { 5800 off = offset + (vstart - *start_ptr); 5801 5802 READ_ULEB (vbegin, vstart, section_end); 5803 print_dwarf_view (vbegin, pointer_size, 1); 5804 5805 READ_ULEB (vend, vstart, section_end); 5806 print_dwarf_view (vend, pointer_size, 1); 5807 5808 printf (_("views at %8.8lx for:\n %*s "), 5809 (unsigned long) off, 8, ""); 5810 } 5811 5812 if (start + 2 > section_end) 5813 { 5814 warn (_("Location list starting at offset 0x%lx is not terminated.\n"), 5815 (unsigned long) offset); 5816 break; 5817 } 5818 5819 SAFE_BYTE_GET_AND_INC (length, start, 2, section_end); 5820 5821 if (start + length > section_end) 5822 { 5823 warn (_("Location list starting at offset 0x%lx is not terminated.\n"), 5824 (unsigned long) offset); 5825 break; 5826 } 5827 5828 print_dwarf_vma (begin + base_address, pointer_size); 5829 print_dwarf_vma (end + base_address, pointer_size); 5830 5831 putchar ('('); 5832 need_frame_base = decode_location_expression (start, 5833 pointer_size, 5834 offset_size, 5835 dwarf_version, 5836 length, 5837 cu_offset, section); 5838 putchar (')'); 5839 5840 if (need_frame_base && !has_frame_base) 5841 printf (_(" [without DW_AT_frame_base]")); 5842 5843 if (begin == end && vbegin == vend) 5844 fputs (_(" (start == end)"), stdout); 5845 else if (begin > end || (begin == end && vbegin > vend)) 5846 fputs (_(" (start > end)"), stdout); 5847 5848 putchar ('\n'); 5849 5850 start += length; 5851 } 5852 5853 *start_ptr = start; 5854 *vstart_ptr = vstart; 5855 } 5856 5857 /* Display a location list from a normal (ie, non-dwo) .debug_loclists section. */ 5858 5859 static void 5860 display_loclists_list (struct dwarf_section *section, 5861 unsigned char **start_ptr, 5862 unsigned int debug_info_entry, 5863 dwarf_vma offset, 5864 dwarf_vma base_address, 5865 unsigned char **vstart_ptr, 5866 int has_frame_base) 5867 { 5868 unsigned char *start = *start_ptr, *vstart = *vstart_ptr; 5869 unsigned char *section_end = section->start + section->size; 5870 unsigned long cu_offset; 5871 unsigned int pointer_size; 5872 unsigned int offset_size; 5873 int dwarf_version; 5874 5875 /* Initialize it due to a false compiler warning. */ 5876 dwarf_vma begin = -1, vbegin = -1; 5877 dwarf_vma end = -1, vend = -1; 5878 dwarf_vma length; 5879 int need_frame_base; 5880 5881 if (debug_info_entry >= num_debug_info_entries) 5882 { 5883 warn (_("No debug information available for " 5884 "loclists lists of entry: %u\n"), 5885 debug_info_entry); 5886 return; 5887 } 5888 5889 cu_offset = debug_information [debug_info_entry].cu_offset; 5890 pointer_size = debug_information [debug_info_entry].pointer_size; 5891 offset_size = debug_information [debug_info_entry].offset_size; 5892 dwarf_version = debug_information [debug_info_entry].dwarf_version; 5893 5894 if (pointer_size < 2 || pointer_size > 8) 5895 { 5896 warn (_("Invalid pointer size (%d) in debug info for entry %d\n"), 5897 pointer_size, debug_info_entry); 5898 return; 5899 } 5900 5901 while (1) 5902 { 5903 dwarf_vma off = offset + (start - *start_ptr); 5904 enum dwarf_location_list_entry_type llet; 5905 5906 if (start + 1 > section_end) 5907 { 5908 warn (_("Location list starting at offset 0x%lx is not terminated.\n"), 5909 (unsigned long) offset); 5910 break; 5911 } 5912 5913 printf (" %8.8lx ", (unsigned long) off); 5914 5915 SAFE_BYTE_GET_AND_INC (llet, start, 1, section_end); 5916 5917 if (vstart && llet == DW_LLE_offset_pair) 5918 { 5919 off = offset + (vstart - *start_ptr); 5920 5921 READ_ULEB (vbegin, vstart, section_end); 5922 print_dwarf_view (vbegin, pointer_size, 1); 5923 5924 READ_ULEB (vend, vstart, section_end); 5925 print_dwarf_view (vend, pointer_size, 1); 5926 5927 printf (_("views at %8.8lx for:\n %*s "), 5928 (unsigned long) off, 8, ""); 5929 } 5930 5931 switch (llet) 5932 { 5933 case DW_LLE_end_of_list: 5934 printf (_("<End of list>\n")); 5935 break; 5936 case DW_LLE_offset_pair: 5937 READ_ULEB (begin, start, section_end); 5938 READ_ULEB (end, start, section_end); 5939 break; 5940 case DW_LLE_base_address: 5941 SAFE_BYTE_GET_AND_INC (base_address, start, pointer_size, 5942 section_end); 5943 print_dwarf_vma (base_address, pointer_size); 5944 printf (_("(base address)\n")); 5945 break; 5946 #ifdef DW_LLE_view_pair 5947 case DW_LLE_view_pair: 5948 if (vstart) 5949 printf (_("View pair entry in loclist with locviews attribute\n")); 5950 READ_ULEB (vbegin, start, section_end); 5951 print_dwarf_view (vbegin, pointer_size, 1); 5952 5953 READ_ULEB (vend, start, section_end); 5954 print_dwarf_view (vend, pointer_size, 1); 5955 5956 printf (_("views for:\n")); 5957 continue; 5958 #endif 5959 default: 5960 error (_("Invalid location list entry type %d\n"), llet); 5961 return; 5962 } 5963 if (llet == DW_LLE_end_of_list) 5964 break; 5965 if (llet != DW_LLE_offset_pair) 5966 continue; 5967 5968 if (start + 2 > section_end) 5969 { 5970 warn (_("Location list starting at offset 0x%lx is not terminated.\n"), 5971 (unsigned long) offset); 5972 break; 5973 } 5974 5975 READ_ULEB (length, start, section_end); 5976 5977 print_dwarf_vma (begin + base_address, pointer_size); 5978 print_dwarf_vma (end + base_address, pointer_size); 5979 5980 putchar ('('); 5981 need_frame_base = decode_location_expression (start, 5982 pointer_size, 5983 offset_size, 5984 dwarf_version, 5985 length, 5986 cu_offset, section); 5987 putchar (')'); 5988 5989 if (need_frame_base && !has_frame_base) 5990 printf (_(" [without DW_AT_frame_base]")); 5991 5992 if (begin == end && vbegin == vend) 5993 fputs (_(" (start == end)"), stdout); 5994 else if (begin > end || (begin == end && vbegin > vend)) 5995 fputs (_(" (start > end)"), stdout); 5996 5997 putchar ('\n'); 5998 5999 start += length; 6000 vbegin = vend = -1; 6001 } 6002 6003 if (vbegin != vm1 || vend != vm1) 6004 printf (_("Trailing view pair not used in a range")); 6005 6006 *start_ptr = start; 6007 *vstart_ptr = vstart; 6008 } 6009 6010 /* Print a .debug_addr table index in decimal, surrounded by square brackets, 6011 right-adjusted in a field of length LEN, and followed by a space. */ 6012 6013 static void 6014 print_addr_index (unsigned int idx, unsigned int len) 6015 { 6016 static char buf[15]; 6017 snprintf (buf, sizeof (buf), "[%d]", idx); 6018 printf ("%*s ", len, buf); 6019 } 6020 6021 /* Display a location list from a .dwo section. It uses address indexes rather 6022 than embedded addresses. This code closely follows display_loc_list, but the 6023 two are sufficiently different that combining things is very ugly. */ 6024 6025 static void 6026 display_loc_list_dwo (struct dwarf_section *section, 6027 unsigned char **start_ptr, 6028 unsigned int debug_info_entry, 6029 dwarf_vma offset, 6030 unsigned char **vstart_ptr, 6031 int has_frame_base) 6032 { 6033 unsigned char *start = *start_ptr, *vstart = *vstart_ptr; 6034 unsigned char *section_end = section->start + section->size; 6035 unsigned long cu_offset; 6036 unsigned int pointer_size; 6037 unsigned int offset_size; 6038 int dwarf_version; 6039 int entry_type; 6040 unsigned short length; 6041 int need_frame_base; 6042 unsigned int idx; 6043 6044 if (debug_info_entry >= num_debug_info_entries) 6045 { 6046 warn (_("No debug information for loc lists of entry: %u\n"), 6047 debug_info_entry); 6048 return; 6049 } 6050 6051 cu_offset = debug_information [debug_info_entry].cu_offset; 6052 pointer_size = debug_information [debug_info_entry].pointer_size; 6053 offset_size = debug_information [debug_info_entry].offset_size; 6054 dwarf_version = debug_information [debug_info_entry].dwarf_version; 6055 6056 if (pointer_size < 2 || pointer_size > 8) 6057 { 6058 warn (_("Invalid pointer size (%d) in debug info for entry %d\n"), 6059 pointer_size, debug_info_entry); 6060 return; 6061 } 6062 6063 while (1) 6064 { 6065 printf (" %8.8lx ", (unsigned long) (offset + (start - *start_ptr))); 6066 6067 if (start >= section_end) 6068 { 6069 warn (_("Location list starting at offset 0x%lx is not terminated.\n"), 6070 (unsigned long) offset); 6071 break; 6072 } 6073 6074 SAFE_BYTE_GET_AND_INC (entry_type, start, 1, section_end); 6075 6076 if (vstart) 6077 switch (entry_type) 6078 { 6079 default: 6080 break; 6081 6082 case 2: 6083 case 3: 6084 case 4: 6085 { 6086 dwarf_vma view; 6087 dwarf_vma off = offset + (vstart - *start_ptr); 6088 6089 READ_ULEB (view, vstart, section_end); 6090 print_dwarf_view (view, 8, 1); 6091 6092 READ_ULEB (view, vstart, section_end); 6093 print_dwarf_view (view, 8, 1); 6094 6095 printf (_("views at %8.8lx for:\n %*s "), 6096 (unsigned long) off, 8, ""); 6097 6098 } 6099 break; 6100 } 6101 6102 switch (entry_type) 6103 { 6104 case 0: /* A terminating entry. */ 6105 *start_ptr = start; 6106 *vstart_ptr = vstart; 6107 printf (_("<End of list>\n")); 6108 return; 6109 case 1: /* A base-address entry. */ 6110 READ_ULEB (idx, start, section_end); 6111 print_addr_index (idx, 8); 6112 printf ("%*s", 9 + (vstart ? 2 * 6 : 0), ""); 6113 printf (_("(base address selection entry)\n")); 6114 continue; 6115 case 2: /* A start/end entry. */ 6116 READ_ULEB (idx, start, section_end); 6117 print_addr_index (idx, 8); 6118 READ_ULEB (idx, start, section_end); 6119 print_addr_index (idx, 8); 6120 break; 6121 case 3: /* A start/length entry. */ 6122 READ_ULEB (idx, start, section_end); 6123 print_addr_index (idx, 8); 6124 SAFE_BYTE_GET_AND_INC (idx, start, 4, section_end); 6125 printf ("%08x ", idx); 6126 break; 6127 case 4: /* An offset pair entry. */ 6128 SAFE_BYTE_GET_AND_INC (idx, start, 4, section_end); 6129 printf ("%08x ", idx); 6130 SAFE_BYTE_GET_AND_INC (idx, start, 4, section_end); 6131 printf ("%08x ", idx); 6132 break; 6133 default: 6134 warn (_("Unknown location list entry type 0x%x.\n"), entry_type); 6135 *start_ptr = start; 6136 *vstart_ptr = vstart; 6137 return; 6138 } 6139 6140 if (start + 2 > section_end) 6141 { 6142 warn (_("Location list starting at offset 0x%lx is not terminated.\n"), 6143 (unsigned long) offset); 6144 break; 6145 } 6146 6147 SAFE_BYTE_GET_AND_INC (length, start, 2, section_end); 6148 if (start + length > section_end) 6149 { 6150 warn (_("Location list starting at offset 0x%lx is not terminated.\n"), 6151 (unsigned long) offset); 6152 break; 6153 } 6154 6155 putchar ('('); 6156 need_frame_base = decode_location_expression (start, 6157 pointer_size, 6158 offset_size, 6159 dwarf_version, 6160 length, 6161 cu_offset, section); 6162 putchar (')'); 6163 6164 if (need_frame_base && !has_frame_base) 6165 printf (_(" [without DW_AT_frame_base]")); 6166 6167 putchar ('\n'); 6168 6169 start += length; 6170 } 6171 6172 *start_ptr = start; 6173 *vstart_ptr = vstart; 6174 } 6175 6176 /* Sort array of indexes in ascending order of loc_offsets[idx] and 6177 loc_views. */ 6178 6179 static dwarf_vma *loc_offsets, *loc_views; 6180 6181 static int 6182 loc_offsets_compar (const void *ap, const void *bp) 6183 { 6184 dwarf_vma a = loc_offsets[*(const unsigned int *) ap]; 6185 dwarf_vma b = loc_offsets[*(const unsigned int *) bp]; 6186 6187 int ret = (a > b) - (b > a); 6188 if (ret) 6189 return ret; 6190 6191 a = loc_views[*(const unsigned int *) ap]; 6192 b = loc_views[*(const unsigned int *) bp]; 6193 6194 ret = (a > b) - (b > a); 6195 6196 return ret; 6197 } 6198 6199 static int 6200 display_debug_loc (struct dwarf_section *section, void *file) 6201 { 6202 unsigned char *start = section->start, *vstart = NULL; 6203 unsigned long bytes; 6204 unsigned char *section_begin = start; 6205 unsigned int num_loc_list = 0; 6206 unsigned long last_offset = 0; 6207 unsigned long last_view = 0; 6208 unsigned int first = 0; 6209 unsigned int i; 6210 unsigned int j; 6211 int seen_first_offset = 0; 6212 int locs_sorted = 1; 6213 unsigned char *next = start, *vnext = vstart; 6214 unsigned int *array = NULL; 6215 const char *suffix = strrchr (section->name, '.'); 6216 bfd_boolean is_dwo = FALSE; 6217 int is_loclists = strstr (section->name, "debug_loclists") != NULL; 6218 dwarf_vma expected_start = 0; 6219 6220 if (suffix && strcmp (suffix, ".dwo") == 0) 6221 is_dwo = TRUE; 6222 6223 bytes = section->size; 6224 6225 if (bytes == 0) 6226 { 6227 printf (_("\nThe %s section is empty.\n"), section->name); 6228 return 0; 6229 } 6230 6231 if (is_loclists) 6232 { 6233 unsigned char *hdrptr = section_begin; 6234 dwarf_vma ll_length; 6235 unsigned short ll_version; 6236 unsigned char *end = section_begin + section->size; 6237 unsigned char address_size, segment_selector_size; 6238 uint32_t offset_entry_count; 6239 6240 SAFE_BYTE_GET_AND_INC (ll_length, hdrptr, 4, end); 6241 if (ll_length == 0xffffffff) 6242 SAFE_BYTE_GET_AND_INC (ll_length, hdrptr, 8, end); 6243 6244 SAFE_BYTE_GET_AND_INC (ll_version, hdrptr, 2, end); 6245 if (ll_version != 5) 6246 { 6247 warn (_("The %s section contains corrupt or " 6248 "unsupported version number: %d.\n"), 6249 section->name, ll_version); 6250 return 0; 6251 } 6252 6253 SAFE_BYTE_GET_AND_INC (address_size, hdrptr, 1, end); 6254 6255 SAFE_BYTE_GET_AND_INC (segment_selector_size, hdrptr, 1, end); 6256 if (segment_selector_size != 0) 6257 { 6258 warn (_("The %s section contains " 6259 "unsupported segment selector size: %d.\n"), 6260 section->name, segment_selector_size); 6261 return 0; 6262 } 6263 6264 SAFE_BYTE_GET_AND_INC (offset_entry_count, hdrptr, 4, end); 6265 if (offset_entry_count != 0) 6266 { 6267 warn (_("The %s section contains " 6268 "unsupported offset entry count: %d.\n"), 6269 section->name, offset_entry_count); 6270 return 0; 6271 } 6272 6273 expected_start = hdrptr - section_begin; 6274 } 6275 6276 if (load_debug_info (file) == 0) 6277 { 6278 warn (_("Unable to load/parse the .debug_info section, so cannot interpret the %s section.\n"), 6279 section->name); 6280 return 0; 6281 } 6282 6283 /* Check the order of location list in .debug_info section. If 6284 offsets of location lists are in the ascending order, we can 6285 use `debug_information' directly. */ 6286 for (i = 0; i < num_debug_info_entries; i++) 6287 { 6288 unsigned int num; 6289 6290 num = debug_information [i].num_loc_offsets; 6291 if (num > num_loc_list) 6292 num_loc_list = num; 6293 6294 /* Check if we can use `debug_information' directly. */ 6295 if (locs_sorted && num != 0) 6296 { 6297 if (!seen_first_offset) 6298 { 6299 /* This is the first location list. */ 6300 last_offset = debug_information [i].loc_offsets [0]; 6301 last_view = debug_information [i].loc_views [0]; 6302 first = i; 6303 seen_first_offset = 1; 6304 j = 1; 6305 } 6306 else 6307 j = 0; 6308 6309 for (; j < num; j++) 6310 { 6311 if (last_offset > 6312 debug_information [i].loc_offsets [j] 6313 || (last_offset == debug_information [i].loc_offsets [j] 6314 && last_view > debug_information [i].loc_views [j])) 6315 { 6316 locs_sorted = 0; 6317 break; 6318 } 6319 last_offset = debug_information [i].loc_offsets [j]; 6320 last_view = debug_information [i].loc_views [j]; 6321 } 6322 } 6323 } 6324 6325 if (!seen_first_offset) 6326 error (_("No location lists in .debug_info section!\n")); 6327 6328 if (debug_information [first].num_loc_offsets > 0 6329 && debug_information [first].loc_offsets [0] != expected_start 6330 && debug_information [first].loc_views [0] != expected_start) 6331 warn (_("Location lists in %s section start at 0x%s\n"), 6332 section->name, 6333 dwarf_vmatoa ("x", debug_information [first].loc_offsets [0])); 6334 6335 if (!locs_sorted) 6336 array = (unsigned int *) xcmalloc (num_loc_list, sizeof (unsigned int)); 6337 6338 introduce (section, FALSE); 6339 6340 if (reloc_at (section, 0)) 6341 printf (_(" Warning: This section has relocations - addresses seen here may not be accurate.\n\n")); 6342 6343 printf (_(" Offset Begin End Expression\n")); 6344 6345 seen_first_offset = 0; 6346 for (i = first; i < num_debug_info_entries; i++) 6347 { 6348 dwarf_vma offset, voffset; 6349 dwarf_vma base_address; 6350 unsigned int k; 6351 int has_frame_base; 6352 6353 if (!locs_sorted) 6354 { 6355 for (k = 0; k < debug_information [i].num_loc_offsets; k++) 6356 array[k] = k; 6357 loc_offsets = debug_information [i].loc_offsets; 6358 loc_views = debug_information [i].loc_views; 6359 qsort (array, debug_information [i].num_loc_offsets, 6360 sizeof (*array), loc_offsets_compar); 6361 } 6362 6363 int adjacent_view_loclists = 1; 6364 for (k = 0; k < debug_information [i].num_loc_offsets; k++) 6365 { 6366 j = locs_sorted ? k : array[k]; 6367 if (k 6368 && (debug_information [i].loc_offsets [locs_sorted 6369 ? k - 1 : array [k - 1]] 6370 == debug_information [i].loc_offsets [j]) 6371 && (debug_information [i].loc_views [locs_sorted 6372 ? k - 1 : array [k - 1]] 6373 == debug_information [i].loc_views [j])) 6374 continue; 6375 has_frame_base = debug_information [i].have_frame_base [j]; 6376 offset = debug_information [i].loc_offsets [j]; 6377 next = section_begin + offset; 6378 voffset = debug_information [i].loc_views [j]; 6379 if (voffset != vm1) 6380 vnext = section_begin + voffset; 6381 else 6382 vnext = NULL; 6383 base_address = debug_information [i].base_address; 6384 6385 if (vnext && vnext < next) 6386 { 6387 vstart = vnext; 6388 display_view_pair_list (section, &vstart, i, next); 6389 if (start == vnext) 6390 start = vstart; 6391 } 6392 6393 if (!seen_first_offset || !adjacent_view_loclists) 6394 seen_first_offset = 1; 6395 else 6396 { 6397 if (start < next) 6398 warn (_("There is a hole [0x%lx - 0x%lx] in .debug_loc section.\n"), 6399 (unsigned long) (start - section_begin), 6400 (unsigned long) offset); 6401 else if (start > next) 6402 warn (_("There is an overlap [0x%lx - 0x%lx] in .debug_loc section.\n"), 6403 (unsigned long) (start - section_begin), 6404 (unsigned long) offset); 6405 } 6406 start = next; 6407 vstart = vnext; 6408 6409 if (offset >= bytes) 6410 { 6411 warn (_("Offset 0x%lx is bigger than .debug_loc section size.\n"), 6412 (unsigned long) offset); 6413 continue; 6414 } 6415 6416 if (vnext && voffset >= bytes) 6417 { 6418 warn (_("View Offset 0x%lx is bigger than .debug_loc section size.\n"), 6419 (unsigned long) voffset); 6420 continue; 6421 } 6422 6423 if (!is_loclists) 6424 { 6425 if (is_dwo) 6426 display_loc_list_dwo (section, &start, i, offset, 6427 &vstart, has_frame_base); 6428 else 6429 display_loc_list (section, &start, i, offset, base_address, 6430 &vstart, has_frame_base); 6431 } 6432 else 6433 { 6434 if (is_dwo) 6435 warn (_("DWO is not yet supported.\n")); 6436 else 6437 display_loclists_list (section, &start, i, offset, base_address, 6438 &vstart, has_frame_base); 6439 } 6440 6441 /* FIXME: this arrangement is quite simplistic. Nothing 6442 requires locview lists to be adjacent to corresponding 6443 loclists, and a single loclist could be augmented by 6444 different locview lists, and vice-versa, unlikely as it 6445 is that it would make sense to do so. Hopefully we'll 6446 have view pair support built into loclists before we ever 6447 need to address all these possibilities. */ 6448 if (adjacent_view_loclists && vnext 6449 && vnext != start && vstart != next) 6450 { 6451 adjacent_view_loclists = 0; 6452 warn (_("Hole and overlap detection requires adjacent view lists and loclists.\n")); 6453 } 6454 6455 if (vnext && vnext == start) 6456 display_view_pair_list (section, &start, i, vstart); 6457 } 6458 } 6459 6460 if (start < section->start + section->size) 6461 warn (ngettext ("There is %ld unused byte at the end of section %s\n", 6462 "There are %ld unused bytes at the end of section %s\n", 6463 (long) (section->start + section->size - start)), 6464 (long) (section->start + section->size - start), section->name); 6465 putchar ('\n'); 6466 free (array); 6467 return 1; 6468 } 6469 6470 static int 6471 display_debug_str (struct dwarf_section *section, 6472 void *file ATTRIBUTE_UNUSED) 6473 { 6474 unsigned char *start = section->start; 6475 unsigned long bytes = section->size; 6476 dwarf_vma addr = section->address; 6477 6478 if (bytes == 0) 6479 { 6480 printf (_("\nThe %s section is empty.\n"), section->name); 6481 return 0; 6482 } 6483 6484 introduce (section, FALSE); 6485 6486 while (bytes) 6487 { 6488 int j; 6489 int k; 6490 int lbytes; 6491 6492 lbytes = (bytes > 16 ? 16 : bytes); 6493 6494 printf (" 0x%8.8lx ", (unsigned long) addr); 6495 6496 for (j = 0; j < 16; j++) 6497 { 6498 if (j < lbytes) 6499 printf ("%2.2x", start[j]); 6500 else 6501 printf (" "); 6502 6503 if ((j & 3) == 3) 6504 printf (" "); 6505 } 6506 6507 for (j = 0; j < lbytes; j++) 6508 { 6509 k = start[j]; 6510 if (k >= ' ' && k < 0x80) 6511 printf ("%c", k); 6512 else 6513 printf ("."); 6514 } 6515 6516 putchar ('\n'); 6517 6518 start += lbytes; 6519 addr += lbytes; 6520 bytes -= lbytes; 6521 } 6522 6523 putchar ('\n'); 6524 6525 return 1; 6526 } 6527 6528 static int 6529 display_debug_info (struct dwarf_section *section, void *file) 6530 { 6531 return process_debug_info (section, file, section->abbrev_sec, FALSE, FALSE); 6532 } 6533 6534 static int 6535 display_debug_types (struct dwarf_section *section, void *file) 6536 { 6537 return process_debug_info (section, file, section->abbrev_sec, FALSE, TRUE); 6538 } 6539 6540 static int 6541 display_trace_info (struct dwarf_section *section, void *file) 6542 { 6543 return process_debug_info (section, file, section->abbrev_sec, FALSE, TRUE); 6544 } 6545 6546 static int 6547 display_debug_aranges (struct dwarf_section *section, 6548 void *file ATTRIBUTE_UNUSED) 6549 { 6550 unsigned char *start = section->start; 6551 unsigned char *end = start + section->size; 6552 6553 introduce (section, FALSE); 6554 6555 /* It does not matter if this load fails, 6556 we test for that later on. */ 6557 load_debug_info (file); 6558 6559 while (start < end) 6560 { 6561 unsigned char *hdrptr; 6562 DWARF2_Internal_ARange arange; 6563 unsigned char *addr_ranges; 6564 dwarf_vma length; 6565 dwarf_vma address; 6566 unsigned long sec_off; 6567 unsigned char address_size; 6568 int excess; 6569 unsigned int offset_size; 6570 unsigned int initial_length_size; 6571 6572 hdrptr = start; 6573 6574 SAFE_BYTE_GET_AND_INC (arange.ar_length, hdrptr, 4, end); 6575 if (arange.ar_length == 0xffffffff) 6576 { 6577 SAFE_BYTE_GET_AND_INC (arange.ar_length, hdrptr, 8, end); 6578 offset_size = 8; 6579 initial_length_size = 12; 6580 } 6581 else 6582 { 6583 offset_size = 4; 6584 initial_length_size = 4; 6585 } 6586 6587 sec_off = hdrptr - section->start; 6588 if (sec_off + arange.ar_length < sec_off 6589 || sec_off + arange.ar_length > section->size) 6590 { 6591 warn (_("Debug info is corrupted, %s header at %#lx has length %s\n"), 6592 section->name, 6593 sec_off - initial_length_size, 6594 dwarf_vmatoa ("x", arange.ar_length)); 6595 break; 6596 } 6597 6598 SAFE_BYTE_GET_AND_INC (arange.ar_version, hdrptr, 2, end); 6599 SAFE_BYTE_GET_AND_INC (arange.ar_info_offset, hdrptr, offset_size, end); 6600 6601 if (num_debug_info_entries != DEBUG_INFO_UNAVAILABLE 6602 && num_debug_info_entries > 0 6603 && find_debug_info_for_offset (arange.ar_info_offset) == NULL) 6604 warn (_(".debug_info offset of 0x%lx in %s section does not point to a CU header.\n"), 6605 (unsigned long) arange.ar_info_offset, section->name); 6606 6607 SAFE_BYTE_GET_AND_INC (arange.ar_pointer_size, hdrptr, 1, end); 6608 SAFE_BYTE_GET_AND_INC (arange.ar_segment_size, hdrptr, 1, end); 6609 6610 if (arange.ar_version != 2 && arange.ar_version != 3) 6611 { 6612 /* PR 19872: A version number of 0 probably means that there is 6613 padding at the end of the .debug_aranges section. Gold puts 6614 it there when performing an incremental link, for example. 6615 So do not generate a warning in this case. */ 6616 if (arange.ar_version) 6617 warn (_("Only DWARF 2 and 3 aranges are currently supported.\n")); 6618 break; 6619 } 6620 6621 printf (_(" Length: %ld\n"), 6622 (long) arange.ar_length); 6623 printf (_(" Version: %d\n"), arange.ar_version); 6624 printf (_(" Offset into .debug_info: 0x%lx\n"), 6625 (unsigned long) arange.ar_info_offset); 6626 printf (_(" Pointer Size: %d\n"), arange.ar_pointer_size); 6627 printf (_(" Segment Size: %d\n"), arange.ar_segment_size); 6628 6629 address_size = arange.ar_pointer_size + arange.ar_segment_size; 6630 6631 /* PR 17512: file: 001-108546-0.001:0.1. */ 6632 if (address_size == 0 || address_size > 8) 6633 { 6634 error (_("Invalid address size in %s section!\n"), 6635 section->name); 6636 break; 6637 } 6638 6639 /* The DWARF spec does not require that the address size be a power 6640 of two, but we do. This will have to change if we ever encounter 6641 an uneven architecture. */ 6642 if ((address_size & (address_size - 1)) != 0) 6643 { 6644 warn (_("Pointer size + Segment size is not a power of two.\n")); 6645 break; 6646 } 6647 6648 if (address_size > 4) 6649 printf (_("\n Address Length\n")); 6650 else 6651 printf (_("\n Address Length\n")); 6652 6653 addr_ranges = hdrptr; 6654 6655 /* Must pad to an alignment boundary that is twice the address size. */ 6656 excess = (hdrptr - start) % (2 * address_size); 6657 if (excess) 6658 addr_ranges += (2 * address_size) - excess; 6659 6660 start += arange.ar_length + initial_length_size; 6661 6662 while (addr_ranges + 2 * address_size <= start) 6663 { 6664 SAFE_BYTE_GET_AND_INC (address, addr_ranges, address_size, end); 6665 SAFE_BYTE_GET_AND_INC (length, addr_ranges, address_size, end); 6666 6667 printf (" "); 6668 print_dwarf_vma (address, address_size); 6669 print_dwarf_vma (length, address_size); 6670 putchar ('\n'); 6671 } 6672 } 6673 6674 printf ("\n"); 6675 6676 return 1; 6677 } 6678 6679 /* Comparison function for qsort. */ 6680 static int 6681 comp_addr_base (const void * v0, const void * v1) 6682 { 6683 debug_info *info0 = *(debug_info **) v0; 6684 debug_info *info1 = *(debug_info **) v1; 6685 return info0->addr_base - info1->addr_base; 6686 } 6687 6688 /* Display the debug_addr section. */ 6689 static int 6690 display_debug_addr (struct dwarf_section *section, 6691 void *file) 6692 { 6693 debug_info **debug_addr_info; 6694 unsigned char *entry; 6695 unsigned char *end; 6696 unsigned int i; 6697 unsigned int count; 6698 6699 if (section->size == 0) 6700 { 6701 printf (_("\nThe %s section is empty.\n"), section->name); 6702 return 0; 6703 } 6704 6705 if (load_debug_info (file) == 0) 6706 { 6707 warn (_("Unable to load/parse the .debug_info section, so cannot interpret the %s section.\n"), 6708 section->name); 6709 return 0; 6710 } 6711 6712 introduce (section, FALSE); 6713 6714 /* PR 17531: file: cf38d01b. 6715 We use xcalloc because a corrupt file may not have initialised all of the 6716 fields in the debug_info structure, which means that the sort below might 6717 try to move uninitialised data. */ 6718 debug_addr_info = (debug_info **) xcalloc ((num_debug_info_entries + 1), 6719 sizeof (debug_info *)); 6720 6721 count = 0; 6722 for (i = 0; i < num_debug_info_entries; i++) 6723 if (debug_information [i].addr_base != DEBUG_INFO_UNAVAILABLE) 6724 { 6725 /* PR 17531: file: cf38d01b. */ 6726 if (debug_information[i].addr_base >= section->size) 6727 warn (_("Corrupt address base (%lx) found in debug section %u\n"), 6728 (unsigned long) debug_information[i].addr_base, i); 6729 else 6730 debug_addr_info [count++] = debug_information + i; 6731 } 6732 6733 /* Add a sentinel to make iteration convenient. */ 6734 debug_addr_info [count] = (debug_info *) xmalloc (sizeof (debug_info)); 6735 debug_addr_info [count]->addr_base = section->size; 6736 qsort (debug_addr_info, count, sizeof (debug_info *), comp_addr_base); 6737 6738 for (i = 0; i < count; i++) 6739 { 6740 unsigned int idx; 6741 unsigned int address_size = debug_addr_info [i]->pointer_size; 6742 6743 printf (_(" For compilation unit at offset 0x%s:\n"), 6744 dwarf_vmatoa ("x", debug_addr_info [i]->cu_offset)); 6745 6746 printf (_("\tIndex\tAddress\n")); 6747 entry = section->start + debug_addr_info [i]->addr_base; 6748 end = section->start + debug_addr_info [i + 1]->addr_base; 6749 idx = 0; 6750 while (entry < end) 6751 { 6752 dwarf_vma base = byte_get (entry, address_size); 6753 printf (_("\t%d:\t"), idx); 6754 print_dwarf_vma (base, address_size); 6755 printf ("\n"); 6756 entry += address_size; 6757 idx++; 6758 } 6759 } 6760 printf ("\n"); 6761 6762 free (debug_addr_info); 6763 return 1; 6764 } 6765 6766 /* Display the .debug_str_offsets and .debug_str_offsets.dwo sections. */ 6767 6768 static int 6769 display_debug_str_offsets (struct dwarf_section *section, 6770 void *file ATTRIBUTE_UNUSED) 6771 { 6772 if (section->size == 0) 6773 { 6774 printf (_("\nThe %s section is empty.\n"), section->name); 6775 return 0; 6776 } 6777 /* TODO: Dump the contents. This is made somewhat difficult by not knowing 6778 what the offset size is for this section. */ 6779 return 1; 6780 } 6781 6782 /* Each debug_information[x].range_lists[y] gets this representation for 6783 sorting purposes. */ 6784 6785 struct range_entry 6786 { 6787 /* The debug_information[x].range_lists[y] value. */ 6788 dwarf_vma ranges_offset; 6789 6790 /* Original debug_information to find parameters of the data. */ 6791 debug_info *debug_info_p; 6792 }; 6793 6794 /* Sort struct range_entry in ascending order of its RANGES_OFFSET. */ 6795 6796 static int 6797 range_entry_compar (const void *ap, const void *bp) 6798 { 6799 const struct range_entry *a_re = (const struct range_entry *) ap; 6800 const struct range_entry *b_re = (const struct range_entry *) bp; 6801 const dwarf_vma a = a_re->ranges_offset; 6802 const dwarf_vma b = b_re->ranges_offset; 6803 6804 return (a > b) - (b > a); 6805 } 6806 6807 static void 6808 display_debug_ranges_list (unsigned char *start, unsigned char *finish, 6809 unsigned int pointer_size, unsigned long offset, 6810 unsigned long base_address) 6811 { 6812 while (start < finish) 6813 { 6814 dwarf_vma begin; 6815 dwarf_vma end; 6816 6817 SAFE_BYTE_GET_AND_INC (begin, start, pointer_size, finish); 6818 if (start >= finish) 6819 break; 6820 SAFE_SIGNED_BYTE_GET_AND_INC (end, start, pointer_size, finish); 6821 6822 6823 printf (" %8.8lx ", offset); 6824 6825 if (begin == 0 && end == 0) 6826 { 6827 printf (_("<End of list>\n")); 6828 break; 6829 } 6830 6831 /* Check base address specifiers. */ 6832 if (is_max_address (begin, pointer_size) 6833 && !is_max_address (end, pointer_size)) 6834 { 6835 base_address = end; 6836 print_dwarf_vma (begin, pointer_size); 6837 print_dwarf_vma (end, pointer_size); 6838 printf ("(base address)\n"); 6839 continue; 6840 } 6841 6842 print_dwarf_vma (begin + base_address, pointer_size); 6843 print_dwarf_vma (end + base_address, pointer_size); 6844 6845 if (begin == end) 6846 fputs (_("(start == end)"), stdout); 6847 else if (begin > end) 6848 fputs (_("(start > end)"), stdout); 6849 6850 putchar ('\n'); 6851 } 6852 } 6853 6854 static void 6855 display_debug_rnglists_list (unsigned char *start, unsigned char *finish, 6856 unsigned int pointer_size, unsigned long offset, 6857 unsigned long base_address) 6858 { 6859 unsigned char *next = start; 6860 6861 while (1) 6862 { 6863 unsigned long off = offset + (start - next); 6864 enum dwarf_range_list_entry rlet; 6865 /* Initialize it due to a false compiler warning. */ 6866 dwarf_vma begin = -1, length, end = -1; 6867 6868 if (start + 1 > finish) 6869 { 6870 warn (_("Range list starting at offset 0x%lx is not terminated.\n"), 6871 offset); 6872 break; 6873 } 6874 6875 printf (" %8.8lx ", off); 6876 6877 SAFE_BYTE_GET_AND_INC (rlet, start, 1, finish); 6878 6879 switch (rlet) 6880 { 6881 case DW_RLE_end_of_list: 6882 printf (_("<End of list>\n")); 6883 break; 6884 case DW_RLE_base_address: 6885 SAFE_BYTE_GET_AND_INC (base_address, start, pointer_size, finish); 6886 print_dwarf_vma (base_address, pointer_size); 6887 printf (_("(base address)\n")); 6888 break; 6889 case DW_RLE_start_length: 6890 SAFE_BYTE_GET_AND_INC (begin, start, pointer_size, finish); 6891 READ_ULEB (length, start, finish); 6892 end = begin + length; 6893 break; 6894 case DW_RLE_offset_pair: 6895 READ_ULEB (begin, start, finish); 6896 READ_ULEB (end, start, finish); 6897 break; 6898 case DW_RLE_start_end: 6899 SAFE_BYTE_GET_AND_INC (begin, start, pointer_size, finish); 6900 SAFE_BYTE_GET_AND_INC (end, start, pointer_size, finish); 6901 break; 6902 default: 6903 error (_("Invalid range list entry type %d\n"), rlet); 6904 rlet = DW_RLE_end_of_list; 6905 break; 6906 } 6907 if (rlet == DW_RLE_end_of_list) 6908 break; 6909 if (rlet == DW_RLE_base_address) 6910 continue; 6911 6912 print_dwarf_vma (begin + base_address, pointer_size); 6913 print_dwarf_vma (end + base_address, pointer_size); 6914 6915 if (begin == end) 6916 fputs (_("(start == end)"), stdout); 6917 else if (begin > end) 6918 fputs (_("(start > end)"), stdout); 6919 6920 putchar ('\n'); 6921 } 6922 } 6923 6924 static int 6925 display_debug_ranges (struct dwarf_section *section, 6926 void *file ATTRIBUTE_UNUSED) 6927 { 6928 unsigned char *start = section->start; 6929 unsigned char *last_start = start; 6930 unsigned long bytes = section->size; 6931 unsigned char *section_begin = start; 6932 unsigned char *finish = start + bytes; 6933 unsigned int num_range_list, i; 6934 struct range_entry *range_entries, *range_entry_fill; 6935 int is_rnglists = strstr (section->name, "debug_rnglists") != NULL; 6936 /* Initialize it due to a false compiler warning. */ 6937 unsigned char address_size = 0; 6938 6939 if (bytes == 0) 6940 { 6941 printf (_("\nThe %s section is empty.\n"), section->name); 6942 return 0; 6943 } 6944 6945 if (is_rnglists) 6946 { 6947 dwarf_vma initial_length; 6948 unsigned int initial_length_size; 6949 unsigned char segment_selector_size; 6950 unsigned int offset_size, offset_entry_count; 6951 unsigned short version; 6952 6953 /* Get and check the length of the block. */ 6954 SAFE_BYTE_GET_AND_INC (initial_length, start, 4, finish); 6955 6956 if (initial_length == 0xffffffff) 6957 { 6958 /* This section is 64-bit DWARF 3. */ 6959 SAFE_BYTE_GET_AND_INC (initial_length, start, 8, finish); 6960 offset_size = 8; 6961 initial_length_size = 12; 6962 } 6963 else 6964 { 6965 offset_size = 4; 6966 initial_length_size = 4; 6967 } 6968 6969 if (initial_length + initial_length_size > section->size) 6970 { 6971 /* If the length field has a relocation against it, then we should 6972 not complain if it is inaccurate (and probably negative). 6973 It is copied from .debug_line handling code. */ 6974 if (reloc_at (section, (start - section->start) - offset_size)) 6975 { 6976 initial_length = (finish - start) - initial_length_size; 6977 } 6978 else 6979 { 6980 warn (_("The length field (0x%lx) in the debug_rnglists header is wrong - the section is too small\n"), 6981 (long) initial_length); 6982 return 0; 6983 } 6984 } 6985 6986 /* Get and check the version number. */ 6987 SAFE_BYTE_GET_AND_INC (version, start, 2, finish); 6988 6989 if (version != 5) 6990 { 6991 warn (_("Only DWARF version 5 debug_rnglists info " 6992 "is currently supported.\n")); 6993 return 0; 6994 } 6995 6996 SAFE_BYTE_GET_AND_INC (address_size, start, 1, finish); 6997 6998 SAFE_BYTE_GET_AND_INC (segment_selector_size, start, 1, finish); 6999 if (segment_selector_size != 0) 7000 { 7001 warn (_("The %s section contains " 7002 "unsupported segment selector size: %d.\n"), 7003 section->name, segment_selector_size); 7004 return 0; 7005 } 7006 7007 SAFE_BYTE_GET_AND_INC (offset_entry_count, start, 4, finish); 7008 if (offset_entry_count != 0) 7009 { 7010 warn (_("The %s section contains " 7011 "unsupported offset entry count: %u.\n"), 7012 section->name, offset_entry_count); 7013 return 0; 7014 } 7015 } 7016 7017 if (load_debug_info (file) == 0) 7018 { 7019 warn (_("Unable to load/parse the .debug_info section, so cannot interpret the %s section.\n"), 7020 section->name); 7021 return 0; 7022 } 7023 7024 num_range_list = 0; 7025 for (i = 0; i < num_debug_info_entries; i++) 7026 num_range_list += debug_information [i].num_range_lists; 7027 7028 if (num_range_list == 0) 7029 { 7030 /* This can happen when the file was compiled with -gsplit-debug 7031 which removes references to range lists from the primary .o file. */ 7032 printf (_("No range lists in .debug_info section.\n")); 7033 return 1; 7034 } 7035 7036 range_entries = (struct range_entry *) 7037 xmalloc (sizeof (*range_entries) * num_range_list); 7038 range_entry_fill = range_entries; 7039 7040 for (i = 0; i < num_debug_info_entries; i++) 7041 { 7042 debug_info *debug_info_p = &debug_information[i]; 7043 unsigned int j; 7044 7045 for (j = 0; j < debug_info_p->num_range_lists; j++) 7046 { 7047 range_entry_fill->ranges_offset = debug_info_p->range_lists[j]; 7048 range_entry_fill->debug_info_p = debug_info_p; 7049 range_entry_fill++; 7050 } 7051 } 7052 7053 qsort (range_entries, num_range_list, sizeof (*range_entries), 7054 range_entry_compar); 7055 7056 if (dwarf_check != 0 && range_entries[0].ranges_offset != 0) 7057 warn (_("Range lists in %s section start at 0x%lx\n"), 7058 section->name, (unsigned long) range_entries[0].ranges_offset); 7059 7060 introduce (section, FALSE); 7061 7062 printf (_(" Offset Begin End\n")); 7063 7064 for (i = 0; i < num_range_list; i++) 7065 { 7066 struct range_entry *range_entry = &range_entries[i]; 7067 debug_info *debug_info_p = range_entry->debug_info_p; 7068 unsigned int pointer_size; 7069 dwarf_vma offset; 7070 unsigned char *next; 7071 dwarf_vma base_address; 7072 7073 pointer_size = (is_rnglists ? address_size : debug_info_p->pointer_size); 7074 offset = range_entry->ranges_offset; 7075 next = section_begin + offset; 7076 base_address = debug_info_p->base_address; 7077 7078 /* PR 17512: file: 001-101485-0.001:0.1. */ 7079 if (pointer_size < 2 || pointer_size > 8) 7080 { 7081 warn (_("Corrupt pointer size (%d) in debug entry at offset %8.8lx\n"), 7082 pointer_size, (unsigned long) offset); 7083 continue; 7084 } 7085 7086 if (next < section_begin || next >= finish) 7087 { 7088 warn (_("Corrupt offset (%#8.8lx) in range entry %u\n"), 7089 (unsigned long) offset, i); 7090 continue; 7091 } 7092 7093 if (dwarf_check != 0 && i > 0) 7094 { 7095 if (start < next) 7096 warn (_("There is a hole [0x%lx - 0x%lx] in %s section.\n"), 7097 (unsigned long) (start - section_begin), 7098 (unsigned long) (next - section_begin), section->name); 7099 else if (start > next) 7100 { 7101 if (next == last_start) 7102 continue; 7103 warn (_("There is an overlap [0x%lx - 0x%lx] in %s section.\n"), 7104 (unsigned long) (start - section_begin), 7105 (unsigned long) (next - section_begin), section->name); 7106 } 7107 } 7108 7109 start = next; 7110 last_start = next; 7111 7112 (is_rnglists ? display_debug_rnglists_list : display_debug_ranges_list) 7113 (start, finish, pointer_size, offset, base_address); 7114 } 7115 putchar ('\n'); 7116 7117 free (range_entries); 7118 7119 return 1; 7120 } 7121 7122 typedef struct Frame_Chunk 7123 { 7124 struct Frame_Chunk *next; 7125 unsigned char *chunk_start; 7126 unsigned int ncols; 7127 /* DW_CFA_{undefined,same_value,offset,register,unreferenced} */ 7128 short int *col_type; 7129 int *col_offset; 7130 char *augmentation; 7131 unsigned int code_factor; 7132 int data_factor; 7133 dwarf_vma pc_begin; 7134 dwarf_vma pc_range; 7135 unsigned int cfa_reg; 7136 dwarf_vma cfa_offset; 7137 unsigned int ra; 7138 unsigned char fde_encoding; 7139 unsigned char cfa_exp; 7140 unsigned char ptr_size; 7141 unsigned char segment_size; 7142 } 7143 Frame_Chunk; 7144 7145 typedef const char *(*dwarf_regname_lookup_ftype) (unsigned int); 7146 static dwarf_regname_lookup_ftype dwarf_regnames_lookup_func; 7147 static const char *const *dwarf_regnames; 7148 static unsigned int dwarf_regnames_count; 7149 7150 7151 /* A marker for a col_type that means this column was never referenced 7152 in the frame info. */ 7153 #define DW_CFA_unreferenced (-1) 7154 7155 /* Return 0 if no more space is needed, 1 if more space is needed, 7156 -1 for invalid reg. */ 7157 7158 static int 7159 frame_need_space (Frame_Chunk *fc, unsigned int reg) 7160 { 7161 unsigned int prev = fc->ncols; 7162 7163 if (reg < (unsigned int) fc->ncols) 7164 return 0; 7165 7166 if (dwarf_regnames_count > 0 7167 && reg > dwarf_regnames_count) 7168 return -1; 7169 7170 fc->ncols = reg + 1; 7171 /* PR 17512: file: 10450-2643-0.004. 7172 If reg == -1 then this can happen... */ 7173 if (fc->ncols == 0) 7174 return -1; 7175 7176 /* PR 17512: file: 2844a11d. */ 7177 if (fc->ncols > 1024 && dwarf_regnames_count == 0) 7178 { 7179 error (_("Unfeasibly large register number: %u\n"), reg); 7180 fc->ncols = 0; 7181 /* FIXME: 1024 is an arbitrary limit. Increase it if 7182 we ever encounter a valid binary that exceeds it. */ 7183 return -1; 7184 } 7185 7186 fc->col_type = (short int *) xcrealloc (fc->col_type, fc->ncols, 7187 sizeof (short int)); 7188 fc->col_offset = (int *) xcrealloc (fc->col_offset, fc->ncols, sizeof (int)); 7189 /* PR 17512: file:002-10025-0.005. */ 7190 if (fc->col_type == NULL || fc->col_offset == NULL) 7191 { 7192 error (_("Out of memory allocating %u columns in dwarf frame arrays\n"), 7193 fc->ncols); 7194 fc->ncols = 0; 7195 return -1; 7196 } 7197 7198 while (prev < fc->ncols) 7199 { 7200 fc->col_type[prev] = DW_CFA_unreferenced; 7201 fc->col_offset[prev] = 0; 7202 prev++; 7203 } 7204 return 1; 7205 } 7206 7207 static const char *const dwarf_regnames_i386[] = 7208 { 7209 "eax", "ecx", "edx", "ebx", /* 0 - 3 */ 7210 "esp", "ebp", "esi", "edi", /* 4 - 7 */ 7211 "eip", "eflags", NULL, /* 8 - 10 */ 7212 "st0", "st1", "st2", "st3", /* 11 - 14 */ 7213 "st4", "st5", "st6", "st7", /* 15 - 18 */ 7214 NULL, NULL, /* 19 - 20 */ 7215 "xmm0", "xmm1", "xmm2", "xmm3", /* 21 - 24 */ 7216 "xmm4", "xmm5", "xmm6", "xmm7", /* 25 - 28 */ 7217 "mm0", "mm1", "mm2", "mm3", /* 29 - 32 */ 7218 "mm4", "mm5", "mm6", "mm7", /* 33 - 36 */ 7219 "fcw", "fsw", "mxcsr", /* 37 - 39 */ 7220 "es", "cs", "ss", "ds", "fs", "gs", NULL, NULL, /* 40 - 47 */ 7221 "tr", "ldtr", /* 48 - 49 */ 7222 NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL, /* 50 - 57 */ 7223 NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL, /* 58 - 65 */ 7224 NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL, /* 66 - 73 */ 7225 NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL, /* 74 - 81 */ 7226 NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL, /* 82 - 89 */ 7227 NULL, NULL, NULL, /* 90 - 92 */ 7228 "k0", "k1", "k2", "k3", "k4", "k5", "k6", "k7" /* 93 - 100 */ 7229 }; 7230 7231 static const char *const dwarf_regnames_iamcu[] = 7232 { 7233 "eax", "ecx", "edx", "ebx", /* 0 - 3 */ 7234 "esp", "ebp", "esi", "edi", /* 4 - 7 */ 7235 "eip", "eflags", NULL, /* 8 - 10 */ 7236 NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL, /* 11 - 18 */ 7237 NULL, NULL, /* 19 - 20 */ 7238 NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL, /* 21 - 28 */ 7239 NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL, /* 29 - 36 */ 7240 NULL, NULL, NULL, /* 37 - 39 */ 7241 "es", "cs", "ss", "ds", "fs", "gs", NULL, NULL, /* 40 - 47 */ 7242 "tr", "ldtr", /* 48 - 49 */ 7243 NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL, /* 50 - 57 */ 7244 NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL, /* 58 - 65 */ 7245 NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL, /* 66 - 73 */ 7246 NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL, /* 74 - 81 */ 7247 NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL, /* 82 - 89 */ 7248 NULL, NULL, NULL, /* 90 - 92 */ 7249 NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL /* 93 - 100 */ 7250 }; 7251 7252 static void 7253 init_dwarf_regnames_i386 (void) 7254 { 7255 dwarf_regnames = dwarf_regnames_i386; 7256 dwarf_regnames_count = ARRAY_SIZE (dwarf_regnames_i386); 7257 dwarf_regnames_lookup_func = regname_internal_by_table_only; 7258 } 7259 7260 static void 7261 init_dwarf_regnames_iamcu (void) 7262 { 7263 dwarf_regnames = dwarf_regnames_iamcu; 7264 dwarf_regnames_count = ARRAY_SIZE (dwarf_regnames_iamcu); 7265 dwarf_regnames_lookup_func = regname_internal_by_table_only; 7266 } 7267 7268 static const char *const dwarf_regnames_x86_64[] = 7269 { 7270 "rax", "rdx", "rcx", "rbx", 7271 "rsi", "rdi", "rbp", "rsp", 7272 "r8", "r9", "r10", "r11", 7273 "r12", "r13", "r14", "r15", 7274 "rip", 7275 "xmm0", "xmm1", "xmm2", "xmm3", 7276 "xmm4", "xmm5", "xmm6", "xmm7", 7277 "xmm8", "xmm9", "xmm10", "xmm11", 7278 "xmm12", "xmm13", "xmm14", "xmm15", 7279 "st0", "st1", "st2", "st3", 7280 "st4", "st5", "st6", "st7", 7281 "mm0", "mm1", "mm2", "mm3", 7282 "mm4", "mm5", "mm6", "mm7", 7283 "rflags", 7284 "es", "cs", "ss", "ds", "fs", "gs", NULL, NULL, 7285 "fs.base", "gs.base", NULL, NULL, 7286 "tr", "ldtr", 7287 "mxcsr", "fcw", "fsw", 7288 "xmm16", "xmm17", "xmm18", "xmm19", 7289 "xmm20", "xmm21", "xmm22", "xmm23", 7290 "xmm24", "xmm25", "xmm26", "xmm27", 7291 "xmm28", "xmm29", "xmm30", "xmm31", 7292 NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL, /* 83 - 90 */ 7293 NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL, /* 91 - 98 */ 7294 NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL, /* 99 - 106 */ 7295 NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL, /* 107 - 114 */ 7296 NULL, NULL, NULL, /* 115 - 117 */ 7297 "k0", "k1", "k2", "k3", "k4", "k5", "k6", "k7" 7298 }; 7299 7300 static void 7301 init_dwarf_regnames_x86_64 (void) 7302 { 7303 dwarf_regnames = dwarf_regnames_x86_64; 7304 dwarf_regnames_count = ARRAY_SIZE (dwarf_regnames_x86_64); 7305 dwarf_regnames_lookup_func = regname_internal_by_table_only; 7306 } 7307 7308 static const char *const dwarf_regnames_aarch64[] = 7309 { 7310 "x0", "x1", "x2", "x3", "x4", "x5", "x6", "x7", 7311 "x8", "x9", "x10", "x11", "x12", "x13", "x14", "x15", 7312 "x16", "x17", "x18", "x19", "x20", "x21", "x22", "x23", 7313 "x24", "x25", "x26", "x27", "x28", "x29", "x30", "sp", 7314 NULL, "elr", NULL, NULL, NULL, NULL, NULL, NULL, 7315 NULL, NULL, NULL, NULL, NULL, NULL, "vg", "ffr", 7316 "p0", "p1", "p2", "p3", "p4", "p5", "p6", "p7", 7317 "p8", "p9", "p10", "p11", "p12", "p13", "p14", "p15", 7318 "v0", "v1", "v2", "v3", "v4", "v5", "v6", "v7", 7319 "v8", "v9", "v10", "v11", "v12", "v13", "v14", "v15", 7320 "v16", "v17", "v18", "v19", "v20", "v21", "v22", "v23", 7321 "v24", "v25", "v26", "v27", "v28", "v29", "v30", "v31", 7322 "z0", "z1", "z2", "z3", "z4", "z5", "z6", "z7", 7323 "z8", "z9", "z10", "z11", "z12", "z13", "z14", "z15", 7324 "z16", "z17", "z18", "z19", "z20", "z21", "z22", "z23", 7325 "z24", "z25", "z26", "z27", "z28", "z29", "z30", "z31", 7326 }; 7327 7328 static void 7329 init_dwarf_regnames_aarch64 (void) 7330 { 7331 dwarf_regnames = dwarf_regnames_aarch64; 7332 dwarf_regnames_count = ARRAY_SIZE (dwarf_regnames_aarch64); 7333 dwarf_regnames_lookup_func = regname_internal_by_table_only; 7334 } 7335 7336 static const char *const dwarf_regnames_s390[] = 7337 { 7338 /* Avoid saying "r5 (r5)", so omit the names of r0-r15. */ 7339 NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL, 7340 NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL, 7341 "f0", "f2", "f4", "f6", "f1", "f3", "f5", "f7", 7342 "f8", "f10", "f12", "f14", "f9", "f11", "f13", "f15", 7343 "cr0", "cr1", "cr2", "cr3", "cr4", "cr5", "cr6", "cr7", 7344 "cr8", "cr9", "cr10", "cr11", "cr12", "cr13", "cr14", "cr15", 7345 "a0", "a1", "a2", "a3", "a4", "a5", "a6", "a7", 7346 "a8", "a9", "a10", "a11", "a12", "a13", "a14", "a15", 7347 "pswm", "pswa", 7348 NULL, NULL, 7349 "v16", "v18", "v20", "v22", "v17", "v19", "v21", "v23", 7350 "v24", "v26", "v28", "v30", "v25", "v27", "v29", "v31", 7351 }; 7352 7353 static void 7354 init_dwarf_regnames_s390 (void) 7355 { 7356 dwarf_regnames = dwarf_regnames_s390; 7357 dwarf_regnames_count = ARRAY_SIZE (dwarf_regnames_s390); 7358 dwarf_regnames_lookup_func = regname_internal_by_table_only; 7359 } 7360 7361 static const char *const dwarf_regnames_riscv[] = 7362 { 7363 "zero", "ra", "sp", "gp", "tp", "t0", "t1", "t2", /* 0 - 7 */ 7364 "s0", "s1", "a0", "a1", "a2", "a3", "a4", "a5", /* 8 - 15 */ 7365 "a6", "a7", "s2", "s3", "s4", "s5", "s6", "s7", /* 16 - 23 */ 7366 "s8", "s9", "s10", "s11", "t3", "t4", "t5", "t6", /* 24 - 31 */ 7367 "ft0", "ft1", "ft2", "ft3", "ft4", "ft5", "ft6", "ft7", /* 32 - 39 */ 7368 "fs0", "fs1", /* 40 - 41 */ 7369 "fa0", "fa1", "fa2", "fa3", "fa4", "fa5", "fa6", "fa7", /* 42 - 49 */ 7370 "fs2", "fs3", "fs4", "fs5", "fs6", "fs7", "fs8", "fs9", /* 50 - 57 */ 7371 "fs10", "fs11", /* 58 - 59 */ 7372 "ft8", "ft9", "ft10", "ft11" /* 60 - 63 */ 7373 }; 7374 7375 /* A RISC-V replacement for REGNAME_INTERNAL_BY_TABLE_ONLY which handles 7376 the large number of CSRs. */ 7377 7378 static const char * 7379 regname_internal_riscv (unsigned int regno) 7380 { 7381 const char *name = NULL; 7382 7383 /* Lookup in the table first, this covers GPR and FPR. */ 7384 if (regno < ARRAY_SIZE (dwarf_regnames_riscv)) 7385 name = dwarf_regnames_riscv [regno]; 7386 else if (regno >= 4096 && regno <= 8191) 7387 { 7388 /* This might be a CSR, these live in a sparse number space from 4096 7389 to 8191 These numbers are defined in the RISC-V ELF ABI 7390 document. */ 7391 switch (regno) 7392 { 7393 #define DECLARE_CSR(NAME,VALUE) case VALUE + 4096: name = #NAME; break; 7394 #include "opcode/riscv-opc.h" 7395 #undef DECLARE_CSR 7396 7397 default: 7398 { 7399 static char csr_name[10]; 7400 snprintf (csr_name, sizeof (csr_name), "csr%d", (regno - 4096)); 7401 name = csr_name; 7402 } 7403 break; 7404 } 7405 } 7406 7407 return name; 7408 } 7409 7410 static void 7411 init_dwarf_regnames_riscv (void) 7412 { 7413 dwarf_regnames = NULL; 7414 dwarf_regnames_count = 8192; 7415 dwarf_regnames_lookup_func = regname_internal_riscv; 7416 } 7417 7418 void 7419 init_dwarf_regnames_by_elf_machine_code (unsigned int e_machine) 7420 { 7421 dwarf_regnames_lookup_func = NULL; 7422 7423 switch (e_machine) 7424 { 7425 case EM_386: 7426 init_dwarf_regnames_i386 (); 7427 break; 7428 7429 case EM_IAMCU: 7430 init_dwarf_regnames_iamcu (); 7431 break; 7432 7433 case EM_X86_64: 7434 case EM_L1OM: 7435 case EM_K1OM: 7436 init_dwarf_regnames_x86_64 (); 7437 break; 7438 7439 case EM_AARCH64: 7440 init_dwarf_regnames_aarch64 (); 7441 break; 7442 7443 case EM_S390: 7444 init_dwarf_regnames_s390 (); 7445 break; 7446 7447 case EM_RISCV: 7448 init_dwarf_regnames_riscv (); 7449 break; 7450 7451 default: 7452 break; 7453 } 7454 } 7455 7456 /* Initialize the DWARF register name lookup state based on the 7457 architecture and specific machine type of a BFD. */ 7458 7459 void 7460 init_dwarf_regnames_by_bfd_arch_and_mach (enum bfd_architecture arch, 7461 unsigned long mach) 7462 { 7463 dwarf_regnames_lookup_func = NULL; 7464 7465 switch (arch) 7466 { 7467 case bfd_arch_i386: 7468 switch (mach) 7469 { 7470 case bfd_mach_x86_64: 7471 case bfd_mach_x86_64_intel_syntax: 7472 case bfd_mach_x86_64_nacl: 7473 case bfd_mach_x64_32: 7474 case bfd_mach_x64_32_intel_syntax: 7475 case bfd_mach_x64_32_nacl: 7476 init_dwarf_regnames_x86_64 (); 7477 break; 7478 7479 default: 7480 init_dwarf_regnames_i386 (); 7481 break; 7482 } 7483 break; 7484 7485 case bfd_arch_iamcu: 7486 init_dwarf_regnames_iamcu (); 7487 break; 7488 7489 case bfd_arch_aarch64: 7490 init_dwarf_regnames_aarch64(); 7491 break; 7492 7493 case bfd_arch_s390: 7494 init_dwarf_regnames_s390 (); 7495 break; 7496 7497 case bfd_arch_riscv: 7498 init_dwarf_regnames_riscv (); 7499 break; 7500 7501 default: 7502 break; 7503 } 7504 } 7505 7506 static const char * 7507 regname_internal_by_table_only (unsigned int regno) 7508 { 7509 if (dwarf_regnames != NULL 7510 && regno < dwarf_regnames_count 7511 && dwarf_regnames [regno] != NULL) 7512 return dwarf_regnames [regno]; 7513 7514 return NULL; 7515 } 7516 7517 static const char * 7518 regname (unsigned int regno, int name_only_p) 7519 { 7520 static char reg[64]; 7521 7522 const char *name = NULL; 7523 7524 if (dwarf_regnames_lookup_func != NULL) 7525 name = dwarf_regnames_lookup_func (regno); 7526 7527 if (name != NULL) 7528 { 7529 if (name_only_p) 7530 return name; 7531 snprintf (reg, sizeof (reg), "r%d (%s)", regno, name); 7532 } 7533 else 7534 snprintf (reg, sizeof (reg), "r%d", regno); 7535 return reg; 7536 } 7537 7538 static void 7539 frame_display_row (Frame_Chunk *fc, int *need_col_headers, unsigned int *max_regs) 7540 { 7541 unsigned int r; 7542 char tmp[100]; 7543 7544 if (*max_regs != fc->ncols) 7545 *max_regs = fc->ncols; 7546 7547 if (*need_col_headers) 7548 { 7549 static const char *sloc = " LOC"; 7550 7551 *need_col_headers = 0; 7552 7553 printf ("%-*s CFA ", eh_addr_size * 2, sloc); 7554 7555 for (r = 0; r < *max_regs; r++) 7556 if (fc->col_type[r] != DW_CFA_unreferenced) 7557 { 7558 if (r == fc->ra) 7559 printf ("ra "); 7560 else 7561 printf ("%-5s ", regname (r, 1)); 7562 } 7563 7564 printf ("\n"); 7565 } 7566 7567 print_dwarf_vma (fc->pc_begin, eh_addr_size); 7568 if (fc->cfa_exp) 7569 strcpy (tmp, "exp"); 7570 else 7571 sprintf (tmp, "%s%+d", regname (fc->cfa_reg, 1), (int) fc->cfa_offset); 7572 printf ("%-8s ", tmp); 7573 7574 for (r = 0; r < fc->ncols; r++) 7575 { 7576 if (fc->col_type[r] != DW_CFA_unreferenced) 7577 { 7578 switch (fc->col_type[r]) 7579 { 7580 case DW_CFA_undefined: 7581 strcpy (tmp, "u"); 7582 break; 7583 case DW_CFA_same_value: 7584 strcpy (tmp, "s"); 7585 break; 7586 case DW_CFA_offset: 7587 sprintf (tmp, "c%+d", fc->col_offset[r]); 7588 break; 7589 case DW_CFA_val_offset: 7590 sprintf (tmp, "v%+d", fc->col_offset[r]); 7591 break; 7592 case DW_CFA_register: 7593 sprintf (tmp, "%s", regname (fc->col_offset[r], 0)); 7594 break; 7595 case DW_CFA_expression: 7596 strcpy (tmp, "exp"); 7597 break; 7598 case DW_CFA_val_expression: 7599 strcpy (tmp, "vexp"); 7600 break; 7601 default: 7602 strcpy (tmp, "n/a"); 7603 break; 7604 } 7605 printf ("%-5s ", tmp); 7606 } 7607 } 7608 printf ("\n"); 7609 } 7610 7611 #define GET(VAR, N) SAFE_BYTE_GET_AND_INC (VAR, start, N, end) 7612 7613 static unsigned char * 7614 read_cie (unsigned char *start, unsigned char *end, 7615 Frame_Chunk **p_cie, int *p_version, 7616 bfd_size_type *p_aug_len, unsigned char **p_aug) 7617 { 7618 int version; 7619 Frame_Chunk *fc; 7620 unsigned char *augmentation_data = NULL; 7621 bfd_size_type augmentation_data_len = 0; 7622 7623 * p_cie = NULL; 7624 /* PR 17512: file: 001-228113-0.004. */ 7625 if (start >= end) 7626 return end; 7627 7628 fc = (Frame_Chunk *) xmalloc (sizeof (Frame_Chunk)); 7629 memset (fc, 0, sizeof (Frame_Chunk)); 7630 7631 fc->col_type = (short int *) xmalloc (sizeof (short int)); 7632 fc->col_offset = (int *) xmalloc (sizeof (int)); 7633 7634 version = *start++; 7635 7636 fc->augmentation = (char *) start; 7637 /* PR 17512: file: 001-228113-0.004. 7638 Skip past augmentation name, but avoid running off the end of the data. */ 7639 while (start < end) 7640 if (* start ++ == '\0') 7641 break; 7642 if (start == end) 7643 { 7644 warn (_("No terminator for augmentation name\n")); 7645 goto fail; 7646 } 7647 7648 if (strcmp (fc->augmentation, "eh") == 0) 7649 start += eh_addr_size; 7650 7651 if (version >= 4) 7652 { 7653 GET (fc->ptr_size, 1); 7654 if (fc->ptr_size < 1 || fc->ptr_size > 8) 7655 { 7656 warn (_("Invalid pointer size (%d) in CIE data\n"), fc->ptr_size); 7657 goto fail; 7658 } 7659 7660 GET (fc->segment_size, 1); 7661 /* PR 17512: file: e99d2804. */ 7662 if (fc->segment_size > 8 || fc->segment_size + fc->ptr_size > 8) 7663 { 7664 warn (_("Invalid segment size (%d) in CIE data\n"), fc->segment_size); 7665 goto fail; 7666 } 7667 7668 eh_addr_size = fc->ptr_size; 7669 } 7670 else 7671 { 7672 fc->ptr_size = eh_addr_size; 7673 fc->segment_size = 0; 7674 } 7675 7676 READ_ULEB (fc->code_factor, start, end); 7677 READ_SLEB (fc->data_factor, start, end); 7678 7679 if (version == 1) 7680 { 7681 GET (fc->ra, 1); 7682 } 7683 else 7684 { 7685 READ_ULEB (fc->ra, start, end); 7686 } 7687 7688 if (fc->augmentation[0] == 'z') 7689 { 7690 READ_ULEB (augmentation_data_len, start, end); 7691 augmentation_data = start; 7692 /* PR 17512: file: 11042-2589-0.004. */ 7693 if (augmentation_data_len > (bfd_size_type) (end - start)) 7694 { 7695 warn (_("Augmentation data too long: 0x%s, expected at most %#lx\n"), 7696 dwarf_vmatoa ("x", augmentation_data_len), 7697 (unsigned long) (end - start)); 7698 goto fail; 7699 } 7700 start += augmentation_data_len; 7701 } 7702 7703 if (augmentation_data_len) 7704 { 7705 unsigned char *p; 7706 unsigned char *q; 7707 unsigned char *qend; 7708 7709 p = (unsigned char *) fc->augmentation + 1; 7710 q = augmentation_data; 7711 qend = q + augmentation_data_len; 7712 7713 while (p < end && q < qend) 7714 { 7715 if (*p == 'L') 7716 q++; 7717 else if (*p == 'P') 7718 q += 1 + size_of_encoded_value (*q); 7719 else if (*p == 'R') 7720 fc->fde_encoding = *q++; 7721 else if (*p == 'S') 7722 ; 7723 else if (*p == 'B') 7724 ; 7725 else 7726 break; 7727 p++; 7728 } 7729 /* Note - it is OK if this loop terminates with q < qend. 7730 Padding may have been inserted to align the end of the CIE. */ 7731 } 7732 7733 *p_cie = fc; 7734 if (p_version) 7735 *p_version = version; 7736 if (p_aug_len) 7737 { 7738 *p_aug_len = augmentation_data_len; 7739 *p_aug = augmentation_data; 7740 } 7741 return start; 7742 7743 fail: 7744 free (fc->col_offset); 7745 free (fc->col_type); 7746 free (fc); 7747 return end; 7748 } 7749 7750 /* Prints out the contents on the DATA array formatted as unsigned bytes. 7751 If do_wide is not enabled, then formats the output to fit into 80 columns. 7752 PRINTED contains the number of characters already written to the current 7753 output line. */ 7754 7755 static void 7756 display_data (bfd_size_type printed, 7757 const unsigned char * data, 7758 const bfd_size_type len) 7759 { 7760 if (do_wide || len < ((80 - printed) / 3)) 7761 for (printed = 0; printed < len; ++printed) 7762 printf (" %02x", data[printed]); 7763 else 7764 { 7765 for (printed = 0; printed < len; ++printed) 7766 { 7767 if (printed % (80 / 3) == 0) 7768 putchar ('\n'); 7769 printf (" %02x", data[printed]); 7770 } 7771 } 7772 } 7773 7774 /* Prints out the contents on the augmentation data array. 7775 If do_wide is not enabled, then formats the output to fit into 80 columns. */ 7776 7777 static void 7778 display_augmentation_data (const unsigned char * data, const bfd_size_type len) 7779 { 7780 bfd_size_type i; 7781 7782 i = printf (_(" Augmentation data: ")); 7783 display_data (i, data, len); 7784 } 7785 7786 static int 7787 display_debug_frames (struct dwarf_section *section, 7788 void *file ATTRIBUTE_UNUSED) 7789 { 7790 unsigned char *start = section->start; 7791 unsigned char *end = start + section->size; 7792 unsigned char *section_start = start; 7793 Frame_Chunk *chunks = NULL, *forward_refs = NULL; 7794 Frame_Chunk *remembered_state = NULL; 7795 Frame_Chunk *rs; 7796 bfd_boolean is_eh = strcmp (section->name, ".eh_frame") == 0; 7797 unsigned int max_regs = 0; 7798 const char *bad_reg = _("bad register: "); 7799 unsigned int saved_eh_addr_size = eh_addr_size; 7800 7801 introduce (section, FALSE); 7802 7803 while (start < end) 7804 { 7805 unsigned char *saved_start; 7806 unsigned char *block_end; 7807 dwarf_vma length; 7808 dwarf_vma cie_id; 7809 Frame_Chunk *fc; 7810 Frame_Chunk *cie; 7811 int need_col_headers = 1; 7812 unsigned char *augmentation_data = NULL; 7813 bfd_size_type augmentation_data_len = 0; 7814 unsigned int encoded_ptr_size = saved_eh_addr_size; 7815 unsigned int offset_size; 7816 unsigned int initial_length_size; 7817 bfd_boolean all_nops; 7818 static Frame_Chunk fde_fc; 7819 7820 saved_start = start; 7821 7822 SAFE_BYTE_GET_AND_INC (length, start, 4, end); 7823 7824 if (length == 0) 7825 { 7826 printf ("\n%08lx ZERO terminator\n\n", 7827 (unsigned long)(saved_start - section_start)); 7828 /* Skip any zero terminators that directly follow. 7829 A corrupt section size could have loaded a whole 7830 slew of zero filled memory bytes. eg 7831 PR 17512: file: 070-19381-0.004. */ 7832 while (start < end && * start == 0) 7833 ++ start; 7834 continue; 7835 } 7836 7837 if (length == 0xffffffff) 7838 { 7839 SAFE_BYTE_GET_AND_INC (length, start, 8, end); 7840 offset_size = 8; 7841 initial_length_size = 12; 7842 } 7843 else 7844 { 7845 offset_size = 4; 7846 initial_length_size = 4; 7847 } 7848 7849 block_end = saved_start + length + initial_length_size; 7850 if (block_end > end || block_end < start) 7851 { 7852 warn ("Invalid length 0x%s in FDE at %#08lx\n", 7853 dwarf_vmatoa_1 (NULL, length, offset_size), 7854 (unsigned long) (saved_start - section_start)); 7855 block_end = end; 7856 } 7857 7858 SAFE_BYTE_GET_AND_INC (cie_id, start, offset_size, end); 7859 7860 if (is_eh ? (cie_id == 0) : ((offset_size == 4 && cie_id == DW_CIE_ID) 7861 || (offset_size == 8 && cie_id == DW64_CIE_ID))) 7862 { 7863 int version; 7864 unsigned int mreg; 7865 7866 start = read_cie (start, end, &cie, &version, 7867 &augmentation_data_len, &augmentation_data); 7868 /* PR 17512: file: 027-135133-0.005. */ 7869 if (cie == NULL) 7870 break; 7871 7872 fc = cie; 7873 fc->next = chunks; 7874 chunks = fc; 7875 fc->chunk_start = saved_start; 7876 mreg = max_regs > 0 ? max_regs - 1 : 0; 7877 if (mreg < fc->ra) 7878 mreg = fc->ra; 7879 if (frame_need_space (fc, mreg) < 0) 7880 break; 7881 if (fc->fde_encoding) 7882 encoded_ptr_size = size_of_encoded_value (fc->fde_encoding); 7883 7884 printf ("\n%08lx ", (unsigned long) (saved_start - section_start)); 7885 print_dwarf_vma (length, fc->ptr_size); 7886 print_dwarf_vma (cie_id, offset_size); 7887 7888 if (do_debug_frames_interp) 7889 { 7890 printf ("CIE \"%s\" cf=%d df=%d ra=%d\n", fc->augmentation, 7891 fc->code_factor, fc->data_factor, fc->ra); 7892 } 7893 else 7894 { 7895 printf ("CIE\n"); 7896 printf (" Version: %d\n", version); 7897 printf (" Augmentation: \"%s\"\n", fc->augmentation); 7898 if (version >= 4) 7899 { 7900 printf (" Pointer Size: %u\n", fc->ptr_size); 7901 printf (" Segment Size: %u\n", fc->segment_size); 7902 } 7903 printf (" Code alignment factor: %u\n", fc->code_factor); 7904 printf (" Data alignment factor: %d\n", fc->data_factor); 7905 printf (" Return address column: %d\n", fc->ra); 7906 7907 if (augmentation_data_len) 7908 display_augmentation_data (augmentation_data, augmentation_data_len); 7909 7910 putchar ('\n'); 7911 } 7912 } 7913 else 7914 { 7915 unsigned char *look_for; 7916 unsigned long segment_selector; 7917 7918 if (is_eh) 7919 { 7920 dwarf_vma sign = (dwarf_vma) 1 << (offset_size * 8 - 1); 7921 look_for = start - 4 - ((cie_id ^ sign) - sign); 7922 } 7923 else 7924 look_for = section_start + cie_id; 7925 7926 if (look_for <= saved_start) 7927 { 7928 for (cie = chunks; cie ; cie = cie->next) 7929 if (cie->chunk_start == look_for) 7930 break; 7931 } 7932 else 7933 { 7934 for (cie = forward_refs; cie ; cie = cie->next) 7935 if (cie->chunk_start == look_for) 7936 break; 7937 if (!cie) 7938 { 7939 unsigned int off_size; 7940 unsigned char *cie_scan; 7941 7942 cie_scan = look_for; 7943 off_size = 4; 7944 SAFE_BYTE_GET_AND_INC (length, cie_scan, 4, end); 7945 if (length == 0xffffffff) 7946 { 7947 SAFE_BYTE_GET_AND_INC (length, cie_scan, 8, end); 7948 off_size = 8; 7949 } 7950 if (length != 0) 7951 { 7952 dwarf_vma c_id; 7953 7954 SAFE_BYTE_GET_AND_INC (c_id, cie_scan, off_size, end); 7955 if (is_eh 7956 ? c_id == 0 7957 : ((off_size == 4 && c_id == DW_CIE_ID) 7958 || (off_size == 8 && c_id == DW64_CIE_ID))) 7959 { 7960 int version; 7961 unsigned int mreg; 7962 7963 read_cie (cie_scan, end, &cie, &version, 7964 &augmentation_data_len, &augmentation_data); 7965 /* PR 17512: file: 3450-2098-0.004. */ 7966 if (cie == NULL) 7967 { 7968 warn (_("Failed to read CIE information\n")); 7969 break; 7970 } 7971 cie->next = forward_refs; 7972 forward_refs = cie; 7973 cie->chunk_start = look_for; 7974 mreg = max_regs > 0 ? max_regs - 1 : 0; 7975 if (mreg < cie->ra) 7976 mreg = cie->ra; 7977 if (frame_need_space (cie, mreg) < 0) 7978 { 7979 warn (_("Invalid max register\n")); 7980 break; 7981 } 7982 if (cie->fde_encoding) 7983 encoded_ptr_size 7984 = size_of_encoded_value (cie->fde_encoding); 7985 } 7986 } 7987 } 7988 } 7989 7990 fc = &fde_fc; 7991 memset (fc, 0, sizeof (Frame_Chunk)); 7992 7993 if (!cie) 7994 { 7995 warn ("Invalid CIE pointer 0x%s in FDE at %#08lx\n", 7996 dwarf_vmatoa_1 (NULL, cie_id, offset_size), 7997 (unsigned long) (saved_start - section_start)); 7998 fc->ncols = 0; 7999 fc->col_type = (short int *) xmalloc (sizeof (short int)); 8000 fc->col_offset = (int *) xmalloc (sizeof (int)); 8001 if (frame_need_space (fc, max_regs > 0 ? max_regs - 1 : 0) < 0) 8002 { 8003 warn (_("Invalid max register\n")); 8004 break; 8005 } 8006 cie = fc; 8007 fc->augmentation = ""; 8008 fc->fde_encoding = 0; 8009 fc->ptr_size = eh_addr_size; 8010 fc->segment_size = 0; 8011 } 8012 else 8013 { 8014 fc->ncols = cie->ncols; 8015 fc->col_type = (short int *) xcmalloc (fc->ncols, sizeof (short int)); 8016 fc->col_offset = (int *) xcmalloc (fc->ncols, sizeof (int)); 8017 memcpy (fc->col_type, cie->col_type, fc->ncols * sizeof (short int)); 8018 memcpy (fc->col_offset, cie->col_offset, fc->ncols * sizeof (int)); 8019 fc->augmentation = cie->augmentation; 8020 fc->ptr_size = cie->ptr_size; 8021 eh_addr_size = cie->ptr_size; 8022 fc->segment_size = cie->segment_size; 8023 fc->code_factor = cie->code_factor; 8024 fc->data_factor = cie->data_factor; 8025 fc->cfa_reg = cie->cfa_reg; 8026 fc->cfa_offset = cie->cfa_offset; 8027 fc->ra = cie->ra; 8028 if (frame_need_space (fc, max_regs > 0 ? max_regs - 1: 0) < 0) 8029 { 8030 warn (_("Invalid max register\n")); 8031 break; 8032 } 8033 fc->fde_encoding = cie->fde_encoding; 8034 } 8035 8036 if (fc->fde_encoding) 8037 encoded_ptr_size = size_of_encoded_value (fc->fde_encoding); 8038 8039 segment_selector = 0; 8040 if (fc->segment_size) 8041 { 8042 if (fc->segment_size > sizeof (segment_selector)) 8043 { 8044 /* PR 17512: file: 9e196b3e. */ 8045 warn (_("Probably corrupt segment size: %d - using 4 instead\n"), fc->segment_size); 8046 fc->segment_size = 4; 8047 } 8048 SAFE_BYTE_GET_AND_INC (segment_selector, start, fc->segment_size, end); 8049 } 8050 8051 fc->pc_begin = get_encoded_value (&start, fc->fde_encoding, section, end); 8052 8053 /* FIXME: It appears that sometimes the final pc_range value is 8054 encoded in less than encoded_ptr_size bytes. See the x86_64 8055 run of the "objcopy on compressed debug sections" test for an 8056 example of this. */ 8057 SAFE_BYTE_GET_AND_INC (fc->pc_range, start, encoded_ptr_size, end); 8058 8059 if (cie->augmentation[0] == 'z') 8060 { 8061 READ_ULEB (augmentation_data_len, start, end); 8062 augmentation_data = start; 8063 /* PR 17512 file: 722-8446-0.004 and PR 22386. */ 8064 if (augmentation_data_len > (bfd_size_type) (end - start)) 8065 { 8066 warn (_("Augmentation data too long: 0x%s, " 8067 "expected at most %#lx\n"), 8068 dwarf_vmatoa ("x", augmentation_data_len), 8069 (unsigned long) (end - start)); 8070 start = end; 8071 augmentation_data = NULL; 8072 augmentation_data_len = 0; 8073 } 8074 start += augmentation_data_len; 8075 } 8076 8077 printf ("\n%08lx %s %s FDE cie=%08lx pc=", 8078 (unsigned long)(saved_start - section_start), 8079 dwarf_vmatoa_1 (NULL, length, fc->ptr_size), 8080 dwarf_vmatoa_1 (NULL, cie_id, offset_size), 8081 (unsigned long)(cie->chunk_start - section_start)); 8082 8083 if (fc->segment_size) 8084 printf ("%04lx:", segment_selector); 8085 8086 printf ("%s..%s\n", 8087 dwarf_vmatoa_1 (NULL, fc->pc_begin, fc->ptr_size), 8088 dwarf_vmatoa_1 (NULL, fc->pc_begin + fc->pc_range, fc->ptr_size)); 8089 8090 if (! do_debug_frames_interp && augmentation_data_len) 8091 { 8092 display_augmentation_data (augmentation_data, augmentation_data_len); 8093 putchar ('\n'); 8094 } 8095 } 8096 8097 /* At this point, fc is the current chunk, cie (if any) is set, and 8098 we're about to interpret instructions for the chunk. */ 8099 /* ??? At present we need to do this always, since this sizes the 8100 fc->col_type and fc->col_offset arrays, which we write into always. 8101 We should probably split the interpreted and non-interpreted bits 8102 into two different routines, since there's so much that doesn't 8103 really overlap between them. */ 8104 if (1 || do_debug_frames_interp) 8105 { 8106 /* Start by making a pass over the chunk, allocating storage 8107 and taking note of what registers are used. */ 8108 unsigned char *tmp = start; 8109 8110 while (start < block_end) 8111 { 8112 unsigned int reg, op, opa; 8113 unsigned long temp; 8114 unsigned char * new_start; 8115 8116 op = *start++; 8117 opa = op & 0x3f; 8118 if (op & 0xc0) 8119 op &= 0xc0; 8120 8121 /* Warning: if you add any more cases to this switch, be 8122 sure to add them to the corresponding switch below. */ 8123 switch (op) 8124 { 8125 case DW_CFA_advance_loc: 8126 break; 8127 case DW_CFA_offset: 8128 SKIP_ULEB (start, end); 8129 if (frame_need_space (fc, opa) >= 0) 8130 fc->col_type[opa] = DW_CFA_undefined; 8131 break; 8132 case DW_CFA_restore: 8133 if (frame_need_space (fc, opa) >= 0) 8134 fc->col_type[opa] = DW_CFA_undefined; 8135 break; 8136 case DW_CFA_set_loc: 8137 start += encoded_ptr_size; 8138 break; 8139 case DW_CFA_advance_loc1: 8140 start += 1; 8141 break; 8142 case DW_CFA_advance_loc2: 8143 start += 2; 8144 break; 8145 case DW_CFA_advance_loc4: 8146 start += 4; 8147 break; 8148 case DW_CFA_offset_extended: 8149 case DW_CFA_val_offset: 8150 READ_ULEB (reg, start, end); 8151 SKIP_ULEB (start, end); 8152 if (frame_need_space (fc, reg) >= 0) 8153 fc->col_type[reg] = DW_CFA_undefined; 8154 break; 8155 case DW_CFA_restore_extended: 8156 READ_ULEB (reg, start, end); 8157 if (frame_need_space (fc, reg) >= 0) 8158 fc->col_type[reg] = DW_CFA_undefined; 8159 break; 8160 case DW_CFA_undefined: 8161 READ_ULEB (reg, start, end); 8162 if (frame_need_space (fc, reg) >= 0) 8163 fc->col_type[reg] = DW_CFA_undefined; 8164 break; 8165 case DW_CFA_same_value: 8166 READ_ULEB (reg, start, end); 8167 if (frame_need_space (fc, reg) >= 0) 8168 fc->col_type[reg] = DW_CFA_undefined; 8169 break; 8170 case DW_CFA_register: 8171 READ_ULEB (reg, start, end); 8172 SKIP_ULEB (start, end); 8173 if (frame_need_space (fc, reg) >= 0) 8174 fc->col_type[reg] = DW_CFA_undefined; 8175 break; 8176 case DW_CFA_def_cfa: 8177 SKIP_ULEB (start, end); 8178 SKIP_ULEB (start, end); 8179 break; 8180 case DW_CFA_def_cfa_register: 8181 SKIP_ULEB (start, end); 8182 break; 8183 case DW_CFA_def_cfa_offset: 8184 SKIP_ULEB (start, end); 8185 break; 8186 case DW_CFA_def_cfa_expression: 8187 READ_ULEB (temp, start, end); 8188 new_start = start + temp; 8189 if (new_start < start) 8190 { 8191 warn (_("Corrupt CFA_def expression value: %lu\n"), temp); 8192 start = block_end; 8193 } 8194 else 8195 start = new_start; 8196 break; 8197 case DW_CFA_expression: 8198 case DW_CFA_val_expression: 8199 READ_ULEB (reg, start, end); 8200 READ_ULEB (temp, start, end); 8201 new_start = start + temp; 8202 if (new_start < start) 8203 { 8204 /* PR 17512: file:306-192417-0.005. */ 8205 warn (_("Corrupt CFA expression value: %lu\n"), temp); 8206 start = block_end; 8207 } 8208 else 8209 start = new_start; 8210 if (frame_need_space (fc, reg) >= 0) 8211 fc->col_type[reg] = DW_CFA_undefined; 8212 break; 8213 case DW_CFA_offset_extended_sf: 8214 case DW_CFA_val_offset_sf: 8215 READ_ULEB (reg, start, end); 8216 SKIP_SLEB (start, end); 8217 if (frame_need_space (fc, reg) >= 0) 8218 fc->col_type[reg] = DW_CFA_undefined; 8219 break; 8220 case DW_CFA_def_cfa_sf: 8221 SKIP_ULEB (start, end); 8222 SKIP_SLEB (start, end); 8223 break; 8224 case DW_CFA_def_cfa_offset_sf: 8225 SKIP_SLEB (start, end); 8226 break; 8227 case DW_CFA_MIPS_advance_loc8: 8228 start += 8; 8229 break; 8230 case DW_CFA_GNU_args_size: 8231 SKIP_ULEB (start, end); 8232 break; 8233 case DW_CFA_GNU_negative_offset_extended: 8234 READ_ULEB (reg, start, end); 8235 SKIP_ULEB (start, end); 8236 if (frame_need_space (fc, reg) >= 0) 8237 fc->col_type[reg] = DW_CFA_undefined; 8238 break; 8239 default: 8240 break; 8241 } 8242 } 8243 start = tmp; 8244 } 8245 8246 all_nops = TRUE; 8247 8248 /* Now we know what registers are used, make a second pass over 8249 the chunk, this time actually printing out the info. */ 8250 8251 while (start < block_end) 8252 { 8253 unsigned char * tmp; 8254 unsigned op, opa; 8255 unsigned long ul, roffs; 8256 /* Note: It is tempting to use an unsigned long for 'reg' but there 8257 are various functions, notably frame_space_needed() that assume that 8258 reg is an unsigned int. */ 8259 unsigned int reg; 8260 dwarf_signed_vma l; 8261 dwarf_vma ofs; 8262 dwarf_vma vma; 8263 const char *reg_prefix = ""; 8264 8265 op = *start++; 8266 opa = op & 0x3f; 8267 if (op & 0xc0) 8268 op &= 0xc0; 8269 8270 /* Make a note if something other than DW_CFA_nop happens. */ 8271 if (op != DW_CFA_nop) 8272 all_nops = FALSE; 8273 8274 /* Warning: if you add any more cases to this switch, be 8275 sure to add them to the corresponding switch above. */ 8276 switch (op) 8277 { 8278 case DW_CFA_advance_loc: 8279 if (do_debug_frames_interp) 8280 frame_display_row (fc, &need_col_headers, &max_regs); 8281 else 8282 printf (" DW_CFA_advance_loc: %d to %s\n", 8283 opa * fc->code_factor, 8284 dwarf_vmatoa_1 (NULL, 8285 fc->pc_begin + opa * fc->code_factor, 8286 fc->ptr_size)); 8287 fc->pc_begin += opa * fc->code_factor; 8288 break; 8289 8290 case DW_CFA_offset: 8291 READ_ULEB (roffs, start, end); 8292 if (opa >= (unsigned int) fc->ncols) 8293 reg_prefix = bad_reg; 8294 if (! do_debug_frames_interp || *reg_prefix != '\0') 8295 printf (" DW_CFA_offset: %s%s at cfa%+ld\n", 8296 reg_prefix, regname (opa, 0), 8297 roffs * fc->data_factor); 8298 if (*reg_prefix == '\0') 8299 { 8300 fc->col_type[opa] = DW_CFA_offset; 8301 fc->col_offset[opa] = roffs * fc->data_factor; 8302 } 8303 break; 8304 8305 case DW_CFA_restore: 8306 if (opa >= (unsigned int) fc->ncols) 8307 reg_prefix = bad_reg; 8308 if (! do_debug_frames_interp || *reg_prefix != '\0') 8309 printf (" DW_CFA_restore: %s%s\n", 8310 reg_prefix, regname (opa, 0)); 8311 if (*reg_prefix != '\0') 8312 break; 8313 8314 if (opa >= (unsigned int) cie->ncols 8315 || (do_debug_frames_interp 8316 && cie->col_type[opa] == DW_CFA_unreferenced)) 8317 { 8318 fc->col_type[opa] = DW_CFA_undefined; 8319 fc->col_offset[opa] = 0; 8320 } 8321 else 8322 { 8323 fc->col_type[opa] = cie->col_type[opa]; 8324 fc->col_offset[opa] = cie->col_offset[opa]; 8325 } 8326 break; 8327 8328 case DW_CFA_set_loc: 8329 vma = get_encoded_value (&start, fc->fde_encoding, section, block_end); 8330 if (do_debug_frames_interp) 8331 frame_display_row (fc, &need_col_headers, &max_regs); 8332 else 8333 printf (" DW_CFA_set_loc: %s\n", 8334 dwarf_vmatoa_1 (NULL, vma, fc->ptr_size)); 8335 fc->pc_begin = vma; 8336 break; 8337 8338 case DW_CFA_advance_loc1: 8339 SAFE_BYTE_GET_AND_INC (ofs, start, 1, end); 8340 if (do_debug_frames_interp) 8341 frame_display_row (fc, &need_col_headers, &max_regs); 8342 else 8343 printf (" DW_CFA_advance_loc1: %ld to %s\n", 8344 (unsigned long) (ofs * fc->code_factor), 8345 dwarf_vmatoa_1 (NULL, 8346 fc->pc_begin + ofs * fc->code_factor, 8347 fc->ptr_size)); 8348 fc->pc_begin += ofs * fc->code_factor; 8349 break; 8350 8351 case DW_CFA_advance_loc2: 8352 SAFE_BYTE_GET_AND_INC (ofs, start, 2, block_end); 8353 if (do_debug_frames_interp) 8354 frame_display_row (fc, &need_col_headers, &max_regs); 8355 else 8356 printf (" DW_CFA_advance_loc2: %ld to %s\n", 8357 (unsigned long) (ofs * fc->code_factor), 8358 dwarf_vmatoa_1 (NULL, 8359 fc->pc_begin + ofs * fc->code_factor, 8360 fc->ptr_size)); 8361 fc->pc_begin += ofs * fc->code_factor; 8362 break; 8363 8364 case DW_CFA_advance_loc4: 8365 SAFE_BYTE_GET_AND_INC (ofs, start, 4, block_end); 8366 if (do_debug_frames_interp) 8367 frame_display_row (fc, &need_col_headers, &max_regs); 8368 else 8369 printf (" DW_CFA_advance_loc4: %ld to %s\n", 8370 (unsigned long) (ofs * fc->code_factor), 8371 dwarf_vmatoa_1 (NULL, 8372 fc->pc_begin + ofs * fc->code_factor, 8373 fc->ptr_size)); 8374 fc->pc_begin += ofs * fc->code_factor; 8375 break; 8376 8377 case DW_CFA_offset_extended: 8378 READ_ULEB (reg, start, end); 8379 READ_ULEB (roffs, start, end); 8380 if (reg >= (unsigned int) fc->ncols) 8381 reg_prefix = bad_reg; 8382 if (! do_debug_frames_interp || *reg_prefix != '\0') 8383 printf (" DW_CFA_offset_extended: %s%s at cfa%+ld\n", 8384 reg_prefix, regname (reg, 0), 8385 roffs * fc->data_factor); 8386 if (*reg_prefix == '\0') 8387 { 8388 fc->col_type[reg] = DW_CFA_offset; 8389 fc->col_offset[reg] = roffs * fc->data_factor; 8390 } 8391 break; 8392 8393 case DW_CFA_val_offset: 8394 READ_ULEB (reg, start, end); 8395 READ_ULEB (roffs, start, end); 8396 if (reg >= (unsigned int) fc->ncols) 8397 reg_prefix = bad_reg; 8398 if (! do_debug_frames_interp || *reg_prefix != '\0') 8399 printf (" DW_CFA_val_offset: %s%s is cfa%+ld\n", 8400 reg_prefix, regname (reg, 0), 8401 roffs * fc->data_factor); 8402 if (*reg_prefix == '\0') 8403 { 8404 fc->col_type[reg] = DW_CFA_val_offset; 8405 fc->col_offset[reg] = roffs * fc->data_factor; 8406 } 8407 break; 8408 8409 case DW_CFA_restore_extended: 8410 READ_ULEB (reg, start, end); 8411 if (reg >= (unsigned int) fc->ncols) 8412 reg_prefix = bad_reg; 8413 if (! do_debug_frames_interp || *reg_prefix != '\0') 8414 printf (" DW_CFA_restore_extended: %s%s\n", 8415 reg_prefix, regname (reg, 0)); 8416 if (*reg_prefix != '\0') 8417 break; 8418 8419 if (reg >= (unsigned int) cie->ncols) 8420 { 8421 fc->col_type[reg] = DW_CFA_undefined; 8422 fc->col_offset[reg] = 0; 8423 } 8424 else 8425 { 8426 fc->col_type[reg] = cie->col_type[reg]; 8427 fc->col_offset[reg] = cie->col_offset[reg]; 8428 } 8429 break; 8430 8431 case DW_CFA_undefined: 8432 READ_ULEB (reg, start, end); 8433 if (reg >= (unsigned int) fc->ncols) 8434 reg_prefix = bad_reg; 8435 if (! do_debug_frames_interp || *reg_prefix != '\0') 8436 printf (" DW_CFA_undefined: %s%s\n", 8437 reg_prefix, regname (reg, 0)); 8438 if (*reg_prefix == '\0') 8439 { 8440 fc->col_type[reg] = DW_CFA_undefined; 8441 fc->col_offset[reg] = 0; 8442 } 8443 break; 8444 8445 case DW_CFA_same_value: 8446 READ_ULEB (reg, start, end); 8447 if (reg >= (unsigned int) fc->ncols) 8448 reg_prefix = bad_reg; 8449 if (! do_debug_frames_interp || *reg_prefix != '\0') 8450 printf (" DW_CFA_same_value: %s%s\n", 8451 reg_prefix, regname (reg, 0)); 8452 if (*reg_prefix == '\0') 8453 { 8454 fc->col_type[reg] = DW_CFA_same_value; 8455 fc->col_offset[reg] = 0; 8456 } 8457 break; 8458 8459 case DW_CFA_register: 8460 READ_ULEB (reg, start, end); 8461 READ_ULEB (roffs, start, end); 8462 if (reg >= (unsigned int) fc->ncols) 8463 reg_prefix = bad_reg; 8464 if (! do_debug_frames_interp || *reg_prefix != '\0') 8465 { 8466 printf (" DW_CFA_register: %s%s in ", 8467 reg_prefix, regname (reg, 0)); 8468 puts (regname (roffs, 0)); 8469 } 8470 if (*reg_prefix == '\0') 8471 { 8472 fc->col_type[reg] = DW_CFA_register; 8473 fc->col_offset[reg] = roffs; 8474 } 8475 break; 8476 8477 case DW_CFA_remember_state: 8478 if (! do_debug_frames_interp) 8479 printf (" DW_CFA_remember_state\n"); 8480 rs = (Frame_Chunk *) xmalloc (sizeof (Frame_Chunk)); 8481 rs->cfa_offset = fc->cfa_offset; 8482 rs->cfa_reg = fc->cfa_reg; 8483 rs->ra = fc->ra; 8484 rs->cfa_exp = fc->cfa_exp; 8485 rs->ncols = fc->ncols; 8486 rs->col_type = (short int *) xcmalloc (rs->ncols, 8487 sizeof (* rs->col_type)); 8488 rs->col_offset = (int *) xcmalloc (rs->ncols, sizeof (* rs->col_offset)); 8489 memcpy (rs->col_type, fc->col_type, rs->ncols * sizeof (* fc->col_type)); 8490 memcpy (rs->col_offset, fc->col_offset, rs->ncols * sizeof (* fc->col_offset)); 8491 rs->next = remembered_state; 8492 remembered_state = rs; 8493 break; 8494 8495 case DW_CFA_restore_state: 8496 if (! do_debug_frames_interp) 8497 printf (" DW_CFA_restore_state\n"); 8498 rs = remembered_state; 8499 if (rs) 8500 { 8501 remembered_state = rs->next; 8502 fc->cfa_offset = rs->cfa_offset; 8503 fc->cfa_reg = rs->cfa_reg; 8504 fc->ra = rs->ra; 8505 fc->cfa_exp = rs->cfa_exp; 8506 if (frame_need_space (fc, rs->ncols - 1) < 0) 8507 { 8508 warn (_("Invalid column number in saved frame state\n")); 8509 fc->ncols = 0; 8510 break; 8511 } 8512 memcpy (fc->col_type, rs->col_type, rs->ncols * sizeof (* rs->col_type)); 8513 memcpy (fc->col_offset, rs->col_offset, 8514 rs->ncols * sizeof (* rs->col_offset)); 8515 free (rs->col_type); 8516 free (rs->col_offset); 8517 free (rs); 8518 } 8519 else if (do_debug_frames_interp) 8520 printf ("Mismatched DW_CFA_restore_state\n"); 8521 break; 8522 8523 case DW_CFA_def_cfa: 8524 READ_ULEB (fc->cfa_reg, start, end); 8525 READ_ULEB (fc->cfa_offset, start, end); 8526 fc->cfa_exp = 0; 8527 if (! do_debug_frames_interp) 8528 printf (" DW_CFA_def_cfa: %s ofs %d\n", 8529 regname (fc->cfa_reg, 0), (int) fc->cfa_offset); 8530 break; 8531 8532 case DW_CFA_def_cfa_register: 8533 READ_ULEB (fc->cfa_reg, start, end); 8534 fc->cfa_exp = 0; 8535 if (! do_debug_frames_interp) 8536 printf (" DW_CFA_def_cfa_register: %s\n", 8537 regname (fc->cfa_reg, 0)); 8538 break; 8539 8540 case DW_CFA_def_cfa_offset: 8541 READ_ULEB (fc->cfa_offset, start, end); 8542 if (! do_debug_frames_interp) 8543 printf (" DW_CFA_def_cfa_offset: %d\n", (int) fc->cfa_offset); 8544 break; 8545 8546 case DW_CFA_nop: 8547 if (! do_debug_frames_interp) 8548 printf (" DW_CFA_nop\n"); 8549 break; 8550 8551 case DW_CFA_def_cfa_expression: 8552 READ_ULEB (ul, start, end); 8553 if (start >= block_end || ul > (unsigned long) (block_end - start)) 8554 { 8555 printf (_(" DW_CFA_def_cfa_expression: <corrupt len %lu>\n"), ul); 8556 break; 8557 } 8558 if (! do_debug_frames_interp) 8559 { 8560 printf (" DW_CFA_def_cfa_expression ("); 8561 decode_location_expression (start, eh_addr_size, 0, -1, 8562 ul, 0, section); 8563 printf (")\n"); 8564 } 8565 fc->cfa_exp = 1; 8566 start += ul; 8567 break; 8568 8569 case DW_CFA_expression: 8570 READ_ULEB (reg, start, end); 8571 READ_ULEB (ul, start, end); 8572 if (reg >= (unsigned int) fc->ncols) 8573 reg_prefix = bad_reg; 8574 /* PR 17512: file: 069-133014-0.006. */ 8575 /* PR 17512: file: 98c02eb4. */ 8576 tmp = start + ul; 8577 if (start >= block_end || tmp > block_end || tmp < start) 8578 { 8579 printf (_(" DW_CFA_expression: <corrupt len %lu>\n"), ul); 8580 break; 8581 } 8582 if (! do_debug_frames_interp || *reg_prefix != '\0') 8583 { 8584 printf (" DW_CFA_expression: %s%s (", 8585 reg_prefix, regname (reg, 0)); 8586 decode_location_expression (start, eh_addr_size, 0, -1, 8587 ul, 0, section); 8588 printf (")\n"); 8589 } 8590 if (*reg_prefix == '\0') 8591 fc->col_type[reg] = DW_CFA_expression; 8592 start = tmp; 8593 break; 8594 8595 case DW_CFA_val_expression: 8596 READ_ULEB (reg, start, end); 8597 READ_ULEB (ul, start, end); 8598 if (reg >= (unsigned int) fc->ncols) 8599 reg_prefix = bad_reg; 8600 tmp = start + ul; 8601 if (start >= block_end || tmp > block_end || tmp < start) 8602 { 8603 printf (" DW_CFA_val_expression: <corrupt len %lu>\n", ul); 8604 break; 8605 } 8606 if (! do_debug_frames_interp || *reg_prefix != '\0') 8607 { 8608 printf (" DW_CFA_val_expression: %s%s (", 8609 reg_prefix, regname (reg, 0)); 8610 decode_location_expression (start, eh_addr_size, 0, -1, 8611 ul, 0, section); 8612 printf (")\n"); 8613 } 8614 if (*reg_prefix == '\0') 8615 fc->col_type[reg] = DW_CFA_val_expression; 8616 start = tmp; 8617 break; 8618 8619 case DW_CFA_offset_extended_sf: 8620 READ_ULEB (reg, start, end); 8621 READ_SLEB (l, start, end); 8622 if (frame_need_space (fc, reg) < 0) 8623 reg_prefix = bad_reg; 8624 if (! do_debug_frames_interp || *reg_prefix != '\0') 8625 printf (" DW_CFA_offset_extended_sf: %s%s at cfa%+ld\n", 8626 reg_prefix, regname (reg, 0), 8627 (long)(l * fc->data_factor)); 8628 if (*reg_prefix == '\0') 8629 { 8630 fc->col_type[reg] = DW_CFA_offset; 8631 fc->col_offset[reg] = l * fc->data_factor; 8632 } 8633 break; 8634 8635 case DW_CFA_val_offset_sf: 8636 READ_ULEB (reg, start, end); 8637 READ_SLEB (l, start, end); 8638 if (frame_need_space (fc, reg) < 0) 8639 reg_prefix = bad_reg; 8640 if (! do_debug_frames_interp || *reg_prefix != '\0') 8641 printf (" DW_CFA_val_offset_sf: %s%s is cfa%+ld\n", 8642 reg_prefix, regname (reg, 0), 8643 (long)(l * fc->data_factor)); 8644 if (*reg_prefix == '\0') 8645 { 8646 fc->col_type[reg] = DW_CFA_val_offset; 8647 fc->col_offset[reg] = l * fc->data_factor; 8648 } 8649 break; 8650 8651 case DW_CFA_def_cfa_sf: 8652 READ_ULEB (fc->cfa_reg, start, end); 8653 READ_ULEB (fc->cfa_offset, start, end); 8654 fc->cfa_offset = fc->cfa_offset * fc->data_factor; 8655 fc->cfa_exp = 0; 8656 if (! do_debug_frames_interp) 8657 printf (" DW_CFA_def_cfa_sf: %s ofs %d\n", 8658 regname (fc->cfa_reg, 0), (int) fc->cfa_offset); 8659 break; 8660 8661 case DW_CFA_def_cfa_offset_sf: 8662 READ_ULEB (fc->cfa_offset, start, end); 8663 fc->cfa_offset *= fc->data_factor; 8664 if (! do_debug_frames_interp) 8665 printf (" DW_CFA_def_cfa_offset_sf: %d\n", (int) fc->cfa_offset); 8666 break; 8667 8668 case DW_CFA_MIPS_advance_loc8: 8669 SAFE_BYTE_GET_AND_INC (ofs, start, 8, block_end); 8670 if (do_debug_frames_interp) 8671 frame_display_row (fc, &need_col_headers, &max_regs); 8672 else 8673 printf (" DW_CFA_MIPS_advance_loc8: %ld to %s\n", 8674 (unsigned long) (ofs * fc->code_factor), 8675 dwarf_vmatoa_1 (NULL, 8676 fc->pc_begin + ofs * fc->code_factor, 8677 fc->ptr_size)); 8678 fc->pc_begin += ofs * fc->code_factor; 8679 break; 8680 8681 case DW_CFA_GNU_window_save: 8682 if (! do_debug_frames_interp) 8683 printf (" DW_CFA_GNU_window_save\n"); 8684 break; 8685 8686 case DW_CFA_GNU_args_size: 8687 READ_ULEB (ul, start, end); 8688 if (! do_debug_frames_interp) 8689 printf (" DW_CFA_GNU_args_size: %ld\n", ul); 8690 break; 8691 8692 case DW_CFA_GNU_negative_offset_extended: 8693 READ_ULEB (reg, start, end); 8694 READ_SLEB (l, start, end); 8695 l = - l; 8696 if (frame_need_space (fc, reg) < 0) 8697 reg_prefix = bad_reg; 8698 if (! do_debug_frames_interp || *reg_prefix != '\0') 8699 printf (" DW_CFA_GNU_negative_offset_extended: %s%s at cfa%+ld\n", 8700 reg_prefix, regname (reg, 0), 8701 (long)(l * fc->data_factor)); 8702 if (*reg_prefix == '\0') 8703 { 8704 fc->col_type[reg] = DW_CFA_offset; 8705 fc->col_offset[reg] = l * fc->data_factor; 8706 } 8707 break; 8708 8709 default: 8710 if (op >= DW_CFA_lo_user && op <= DW_CFA_hi_user) 8711 printf (_(" DW_CFA_??? (User defined call frame op: %#x)\n"), op); 8712 else 8713 warn (_("Unsupported or unknown Dwarf Call Frame Instruction number: %#x\n"), op); 8714 start = block_end; 8715 } 8716 } 8717 8718 /* Interpret the CFA - as long as it is not completely full of NOPs. */ 8719 if (do_debug_frames_interp && ! all_nops) 8720 frame_display_row (fc, &need_col_headers, &max_regs); 8721 8722 if (fde_fc.col_type != NULL) 8723 { 8724 free (fde_fc.col_type); 8725 fde_fc.col_type = NULL; 8726 } 8727 if (fde_fc.col_offset != NULL) 8728 { 8729 free (fde_fc.col_offset); 8730 fde_fc.col_offset = NULL; 8731 } 8732 8733 start = block_end; 8734 eh_addr_size = saved_eh_addr_size; 8735 } 8736 8737 printf ("\n"); 8738 8739 while (remembered_state != NULL) 8740 { 8741 rs = remembered_state; 8742 remembered_state = rs->next; 8743 free (rs->col_type); 8744 free (rs->col_offset); 8745 rs->next = NULL; /* Paranoia. */ 8746 free (rs); 8747 } 8748 8749 while (chunks != NULL) 8750 { 8751 rs = chunks; 8752 chunks = rs->next; 8753 free (rs->col_type); 8754 free (rs->col_offset); 8755 rs->next = NULL; /* Paranoia. */ 8756 free (rs); 8757 } 8758 8759 while (forward_refs != NULL) 8760 { 8761 rs = forward_refs; 8762 forward_refs = rs->next; 8763 free (rs->col_type); 8764 free (rs->col_offset); 8765 rs->next = NULL; /* Paranoia. */ 8766 free (rs); 8767 } 8768 8769 return 1; 8770 } 8771 8772 #undef GET 8773 8774 static int 8775 display_debug_names (struct dwarf_section *section, void *file) 8776 { 8777 unsigned char *hdrptr = section->start; 8778 dwarf_vma unit_length; 8779 unsigned char *unit_start; 8780 const unsigned char *const section_end = section->start + section->size; 8781 unsigned char *unit_end; 8782 8783 introduce (section, FALSE); 8784 8785 load_debug_section_with_follow (str, file); 8786 8787 for (; hdrptr < section_end; hdrptr = unit_end) 8788 { 8789 unsigned int offset_size; 8790 uint16_t dwarf_version, padding; 8791 uint32_t comp_unit_count, local_type_unit_count, foreign_type_unit_count; 8792 uint32_t bucket_count, name_count, abbrev_table_size; 8793 uint32_t augmentation_string_size; 8794 unsigned int i; 8795 unsigned long sec_off; 8796 bfd_boolean augmentation_printable; 8797 const char *augmentation_string; 8798 8799 unit_start = hdrptr; 8800 8801 /* Get and check the length of the block. */ 8802 SAFE_BYTE_GET_AND_INC (unit_length, hdrptr, 4, section_end); 8803 8804 if (unit_length == 0xffffffff) 8805 { 8806 /* This section is 64-bit DWARF. */ 8807 SAFE_BYTE_GET_AND_INC (unit_length, hdrptr, 8, section_end); 8808 offset_size = 8; 8809 } 8810 else 8811 offset_size = 4; 8812 unit_end = hdrptr + unit_length; 8813 8814 sec_off = hdrptr - section->start; 8815 if (sec_off + unit_length < sec_off 8816 || sec_off + unit_length > section->size) 8817 { 8818 warn (_("Debug info is corrupted, %s header at %#lx has length %s\n"), 8819 section->name, 8820 (unsigned long) (unit_start - section->start), 8821 dwarf_vmatoa ("x", unit_length)); 8822 return 0; 8823 } 8824 8825 /* Get and check the version number. */ 8826 SAFE_BYTE_GET_AND_INC (dwarf_version, hdrptr, 2, unit_end); 8827 printf (_("Version %ld\n"), (long) dwarf_version); 8828 8829 /* Prior versions did not exist, and future versions may not be 8830 backwards compatible. */ 8831 if (dwarf_version != 5) 8832 { 8833 warn (_("Only DWARF version 5 .debug_names " 8834 "is currently supported.\n")); 8835 return 0; 8836 } 8837 8838 SAFE_BYTE_GET_AND_INC (padding, hdrptr, 2, unit_end); 8839 if (padding != 0) 8840 warn (_("Padding field of .debug_names must be 0 (found 0x%x)\n"), 8841 padding); 8842 8843 SAFE_BYTE_GET_AND_INC (comp_unit_count, hdrptr, 4, unit_end); 8844 if (comp_unit_count == 0) 8845 warn (_("Compilation unit count must be >= 1 in .debug_names\n")); 8846 8847 SAFE_BYTE_GET_AND_INC (local_type_unit_count, hdrptr, 4, unit_end); 8848 SAFE_BYTE_GET_AND_INC (foreign_type_unit_count, hdrptr, 4, unit_end); 8849 SAFE_BYTE_GET_AND_INC (bucket_count, hdrptr, 4, unit_end); 8850 SAFE_BYTE_GET_AND_INC (name_count, hdrptr, 4, unit_end); 8851 SAFE_BYTE_GET_AND_INC (abbrev_table_size, hdrptr, 4, unit_end); 8852 8853 SAFE_BYTE_GET_AND_INC (augmentation_string_size, hdrptr, 4, unit_end); 8854 if (augmentation_string_size % 4 != 0) 8855 { 8856 warn (_("Augmentation string length %u must be rounded up " 8857 "to a multiple of 4 in .debug_names.\n"), 8858 augmentation_string_size); 8859 augmentation_string_size += (-augmentation_string_size) & 3; 8860 } 8861 8862 printf (_("Augmentation string:")); 8863 8864 augmentation_printable = TRUE; 8865 augmentation_string = (const char *) hdrptr; 8866 8867 for (i = 0; i < augmentation_string_size; i++) 8868 { 8869 unsigned char uc; 8870 8871 SAFE_BYTE_GET_AND_INC (uc, hdrptr, 1, unit_end); 8872 printf (" %02x", uc); 8873 8874 if (uc != 0 && !ISPRINT (uc)) 8875 augmentation_printable = FALSE; 8876 } 8877 8878 if (augmentation_printable) 8879 { 8880 printf (" (\""); 8881 for (i = 0; 8882 i < augmentation_string_size && augmentation_string[i]; 8883 ++i) 8884 putchar (augmentation_string[i]); 8885 printf ("\")"); 8886 } 8887 putchar ('\n'); 8888 8889 printf (_("CU table:\n")); 8890 for (i = 0; i < comp_unit_count; i++) 8891 { 8892 uint64_t cu_offset; 8893 8894 SAFE_BYTE_GET_AND_INC (cu_offset, hdrptr, offset_size, unit_end); 8895 printf (_("[%3u] 0x%lx\n"), i, (unsigned long) cu_offset); 8896 } 8897 putchar ('\n'); 8898 8899 printf (_("TU table:\n")); 8900 for (i = 0; i < local_type_unit_count; i++) 8901 { 8902 uint64_t tu_offset; 8903 8904 SAFE_BYTE_GET_AND_INC (tu_offset, hdrptr, offset_size, unit_end); 8905 printf (_("[%3u] 0x%lx\n"), i, (unsigned long) tu_offset); 8906 } 8907 putchar ('\n'); 8908 8909 printf (_("Foreign TU table:\n")); 8910 for (i = 0; i < foreign_type_unit_count; i++) 8911 { 8912 uint64_t signature; 8913 8914 SAFE_BYTE_GET_AND_INC (signature, hdrptr, 8, unit_end); 8915 printf (_("[%3u] "), i); 8916 print_dwarf_vma (signature, 8); 8917 putchar ('\n'); 8918 } 8919 putchar ('\n'); 8920 8921 const uint32_t *const hash_table_buckets = (uint32_t *) hdrptr; 8922 hdrptr += bucket_count * sizeof (uint32_t); 8923 const uint32_t *const hash_table_hashes = (uint32_t *) hdrptr; 8924 hdrptr += name_count * sizeof (uint32_t); 8925 unsigned char *const name_table_string_offsets = hdrptr; 8926 hdrptr += name_count * offset_size; 8927 unsigned char *const name_table_entry_offsets = hdrptr; 8928 hdrptr += name_count * offset_size; 8929 unsigned char *const abbrev_table = hdrptr; 8930 hdrptr += abbrev_table_size; 8931 const unsigned char *const abbrev_table_end = hdrptr; 8932 unsigned char *const entry_pool = hdrptr; 8933 if (hdrptr > unit_end) 8934 { 8935 warn (_("Entry pool offset (0x%lx) exceeds unit size 0x%lx " 8936 "for unit 0x%lx in the debug_names\n"), 8937 (long) (hdrptr - section->start), 8938 (long) (unit_end - section->start), 8939 (long) (unit_start - section->start)); 8940 return 0; 8941 } 8942 8943 size_t buckets_filled = 0; 8944 size_t bucketi; 8945 for (bucketi = 0; bucketi < bucket_count; bucketi++) 8946 { 8947 const uint32_t bucket = hash_table_buckets[bucketi]; 8948 8949 if (bucket != 0) 8950 ++buckets_filled; 8951 } 8952 printf (ngettext ("Used %zu of %lu bucket.\n", 8953 "Used %zu of %lu buckets.\n", 8954 bucket_count), 8955 buckets_filled, (unsigned long) bucket_count); 8956 8957 uint32_t hash_prev = 0; 8958 size_t hash_clash_count = 0; 8959 size_t longest_clash = 0; 8960 size_t this_length = 0; 8961 size_t hashi; 8962 for (hashi = 0; hashi < name_count; hashi++) 8963 { 8964 const uint32_t hash_this = hash_table_hashes[hashi]; 8965 8966 if (hashi > 0) 8967 { 8968 if (hash_prev % bucket_count == hash_this % bucket_count) 8969 { 8970 ++hash_clash_count; 8971 ++this_length; 8972 longest_clash = MAX (longest_clash, this_length); 8973 } 8974 else 8975 this_length = 0; 8976 } 8977 hash_prev = hash_this; 8978 } 8979 printf (_("Out of %lu items there are %zu bucket clashes" 8980 " (longest of %zu entries).\n"), 8981 (unsigned long) name_count, hash_clash_count, longest_clash); 8982 assert (name_count == buckets_filled + hash_clash_count); 8983 8984 struct abbrev_lookup_entry 8985 { 8986 dwarf_vma abbrev_tag; 8987 unsigned char *abbrev_lookup_ptr; 8988 }; 8989 struct abbrev_lookup_entry *abbrev_lookup = NULL; 8990 size_t abbrev_lookup_used = 0; 8991 size_t abbrev_lookup_allocated = 0; 8992 8993 unsigned char *abbrevptr = abbrev_table; 8994 for (;;) 8995 { 8996 dwarf_vma abbrev_tag; 8997 8998 READ_ULEB (abbrev_tag, abbrevptr, abbrev_table_end); 8999 if (abbrev_tag == 0) 9000 break; 9001 if (abbrev_lookup_used == abbrev_lookup_allocated) 9002 { 9003 abbrev_lookup_allocated = MAX (0x100, 9004 abbrev_lookup_allocated * 2); 9005 abbrev_lookup = xrealloc (abbrev_lookup, 9006 (abbrev_lookup_allocated 9007 * sizeof (*abbrev_lookup))); 9008 } 9009 assert (abbrev_lookup_used < abbrev_lookup_allocated); 9010 struct abbrev_lookup_entry *entry; 9011 for (entry = abbrev_lookup; 9012 entry < abbrev_lookup + abbrev_lookup_used; 9013 entry++) 9014 if (entry->abbrev_tag == abbrev_tag) 9015 { 9016 warn (_("Duplicate abbreviation tag %lu " 9017 "in unit 0x%lx in the debug_names\n"), 9018 (long) abbrev_tag, (long) (unit_start - section->start)); 9019 break; 9020 } 9021 entry = &abbrev_lookup[abbrev_lookup_used++]; 9022 entry->abbrev_tag = abbrev_tag; 9023 entry->abbrev_lookup_ptr = abbrevptr; 9024 9025 /* Skip DWARF tag. */ 9026 SKIP_ULEB (abbrevptr, abbrev_table_end); 9027 for (;;) 9028 { 9029 dwarf_vma xindex, form; 9030 9031 READ_ULEB (xindex, abbrevptr, abbrev_table_end); 9032 READ_ULEB (form, abbrevptr, abbrev_table_end); 9033 if (xindex == 0 && form == 0) 9034 break; 9035 } 9036 } 9037 9038 printf (_("\nSymbol table:\n")); 9039 uint32_t namei; 9040 for (namei = 0; namei < name_count; ++namei) 9041 { 9042 uint64_t string_offset, entry_offset; 9043 9044 SAFE_BYTE_GET (string_offset, 9045 name_table_string_offsets + namei * offset_size, 9046 offset_size, unit_end); 9047 SAFE_BYTE_GET (entry_offset, 9048 name_table_entry_offsets + namei * offset_size, 9049 offset_size, unit_end); 9050 9051 printf ("[%3u] #%08x %s:", namei, hash_table_hashes[namei], 9052 fetch_indirect_string (string_offset)); 9053 9054 unsigned char *entryptr = entry_pool + entry_offset; 9055 9056 // We need to scan first whether there is a single or multiple 9057 // entries. TAGNO is -2 for the first entry, it is -1 for the 9058 // initial tag read of the second entry, then it becomes 0 for the 9059 // first entry for real printing etc. 9060 int tagno = -2; 9061 /* Initialize it due to a false compiler warning. */ 9062 dwarf_vma second_abbrev_tag = -1; 9063 for (;;) 9064 { 9065 dwarf_vma abbrev_tag; 9066 dwarf_vma dwarf_tag; 9067 const struct abbrev_lookup_entry *entry; 9068 9069 READ_ULEB (abbrev_tag, entryptr, unit_end); 9070 if (tagno == -1) 9071 { 9072 second_abbrev_tag = abbrev_tag; 9073 tagno = 0; 9074 entryptr = entry_pool + entry_offset; 9075 continue; 9076 } 9077 if (abbrev_tag == 0) 9078 break; 9079 if (tagno >= 0) 9080 printf ("%s<%lu>", 9081 (tagno == 0 && second_abbrev_tag == 0 ? " " : "\n\t"), 9082 (unsigned long) abbrev_tag); 9083 9084 for (entry = abbrev_lookup; 9085 entry < abbrev_lookup + abbrev_lookup_used; 9086 entry++) 9087 if (entry->abbrev_tag == abbrev_tag) 9088 break; 9089 if (entry >= abbrev_lookup + abbrev_lookup_used) 9090 { 9091 warn (_("Undefined abbreviation tag %lu " 9092 "in unit 0x%lx in the debug_names\n"), 9093 (long) abbrev_tag, 9094 (long) (unit_start - section->start)); 9095 break; 9096 } 9097 abbrevptr = entry->abbrev_lookup_ptr; 9098 READ_ULEB (dwarf_tag, abbrevptr, abbrev_table_end); 9099 if (tagno >= 0) 9100 printf (" %s", get_TAG_name (dwarf_tag)); 9101 for (;;) 9102 { 9103 dwarf_vma xindex, form; 9104 9105 READ_ULEB (xindex, abbrevptr, abbrev_table_end); 9106 READ_ULEB (form, abbrevptr, abbrev_table_end); 9107 if (xindex == 0 && form == 0) 9108 break; 9109 9110 if (tagno >= 0) 9111 printf (" %s", get_IDX_name (xindex)); 9112 entryptr = read_and_display_attr_value (0, form, 0, 9113 unit_start, entryptr, unit_end, 9114 0, 0, offset_size, 9115 dwarf_version, NULL, 9116 (tagno < 0), NULL, 9117 NULL, '=', -1); 9118 } 9119 ++tagno; 9120 } 9121 if (tagno <= 0) 9122 printf (_(" <no entries>")); 9123 putchar ('\n'); 9124 } 9125 9126 free (abbrev_lookup); 9127 } 9128 9129 return 1; 9130 } 9131 9132 static int 9133 display_debug_links (struct dwarf_section * section, 9134 void * file ATTRIBUTE_UNUSED) 9135 { 9136 const unsigned char * filename; 9137 unsigned int filelen; 9138 9139 introduce (section, FALSE); 9140 9141 /* The .gnu_debuglink section is formatted as: 9142 (c-string) Filename. 9143 (padding) If needed to reach a 4 byte boundary. 9144 (uint32_t) CRC32 value. 9145 9146 The .gun_debugaltlink section is formatted as: 9147 (c-string) Filename. 9148 (binary) Build-ID. */ 9149 9150 filename = section->start; 9151 filelen = strnlen ((const char *) filename, section->size); 9152 if (filelen == section->size) 9153 { 9154 warn (_("The debuglink filename is corrupt/missing\n")); 9155 return 0; 9156 } 9157 9158 printf (_(" Separate debug info file: %s\n"), filename); 9159 9160 if (const_strneq (section->name, ".gnu_debuglink")) 9161 { 9162 unsigned int crc32; 9163 unsigned int crc_offset; 9164 9165 crc_offset = filelen + 1; 9166 crc_offset = (crc_offset + 3) & ~3; 9167 if (crc_offset + 4 > section->size) 9168 { 9169 warn (_("CRC offset missing/truncated\n")); 9170 return 0; 9171 } 9172 9173 crc32 = byte_get (filename + crc_offset, 4); 9174 9175 printf (_(" CRC value: %#x\n"), crc32); 9176 9177 if (crc_offset + 4 < section->size) 9178 { 9179 warn (_("There are %#lx extraneous bytes at the end of the section\n"), 9180 (long)(section->size - (crc_offset + 4))); 9181 return 0; 9182 } 9183 } 9184 else /* const_strneq (section->name, ".gnu_debugaltlink") */ 9185 { 9186 const unsigned char * build_id = section->start + filelen + 1; 9187 bfd_size_type build_id_len = section->size - (filelen + 1); 9188 bfd_size_type printed; 9189 9190 /* FIXME: Should we support smaller build-id notes ? */ 9191 if (build_id_len < 0x14) 9192 { 9193 warn (_("Build-ID is too short (%#lx bytes)\n"), (long) build_id_len); 9194 return 0; 9195 } 9196 9197 printed = printf (_(" Build-ID (%#lx bytes):"), (long) build_id_len); 9198 display_data (printed, build_id, build_id_len); 9199 putchar ('\n'); 9200 } 9201 9202 putchar ('\n'); 9203 return 1; 9204 } 9205 9206 static int 9207 display_gdb_index (struct dwarf_section *section, 9208 void *file ATTRIBUTE_UNUSED) 9209 { 9210 unsigned char *start = section->start; 9211 uint32_t version; 9212 uint32_t cu_list_offset, tu_list_offset; 9213 uint32_t address_table_offset, symbol_table_offset, constant_pool_offset; 9214 unsigned int cu_list_elements, tu_list_elements; 9215 unsigned int address_table_size, symbol_table_slots; 9216 unsigned char *cu_list, *tu_list; 9217 unsigned char *address_table, *symbol_table, *constant_pool; 9218 unsigned int i; 9219 9220 /* The documentation for the format of this file is in gdb/dwarf2read.c. */ 9221 9222 introduce (section, FALSE); 9223 9224 if (section->size < 6 * sizeof (uint32_t)) 9225 { 9226 warn (_("Truncated header in the %s section.\n"), section->name); 9227 return 0; 9228 } 9229 9230 version = byte_get_little_endian (start, 4); 9231 printf (_("Version %ld\n"), (long) version); 9232 9233 /* Prior versions are obsolete, and future versions may not be 9234 backwards compatible. */ 9235 if (version < 3 || version > 8) 9236 { 9237 warn (_("Unsupported version %lu.\n"), (unsigned long) version); 9238 return 0; 9239 } 9240 if (version < 4) 9241 warn (_("The address table data in version 3 may be wrong.\n")); 9242 if (version < 5) 9243 warn (_("Version 4 does not support case insensitive lookups.\n")); 9244 if (version < 6) 9245 warn (_("Version 5 does not include inlined functions.\n")); 9246 if (version < 7) 9247 warn (_("Version 6 does not include symbol attributes.\n")); 9248 /* Version 7 indices generated by Gold have bad type unit references, 9249 PR binutils/15021. But we don't know if the index was generated by 9250 Gold or not, so to avoid worrying users with gdb-generated indices 9251 we say nothing for version 7 here. */ 9252 9253 cu_list_offset = byte_get_little_endian (start + 4, 4); 9254 tu_list_offset = byte_get_little_endian (start + 8, 4); 9255 address_table_offset = byte_get_little_endian (start + 12, 4); 9256 symbol_table_offset = byte_get_little_endian (start + 16, 4); 9257 constant_pool_offset = byte_get_little_endian (start + 20, 4); 9258 9259 if (cu_list_offset > section->size 9260 || tu_list_offset > section->size 9261 || address_table_offset > section->size 9262 || symbol_table_offset > section->size 9263 || constant_pool_offset > section->size) 9264 { 9265 warn (_("Corrupt header in the %s section.\n"), section->name); 9266 return 0; 9267 } 9268 9269 /* PR 17531: file: 418d0a8a. */ 9270 if (tu_list_offset < cu_list_offset) 9271 { 9272 warn (_("TU offset (%x) is less than CU offset (%x)\n"), 9273 tu_list_offset, cu_list_offset); 9274 return 0; 9275 } 9276 9277 cu_list_elements = (tu_list_offset - cu_list_offset) / 8; 9278 9279 if (address_table_offset < tu_list_offset) 9280 { 9281 warn (_("Address table offset (%x) is less than TU offset (%x)\n"), 9282 address_table_offset, tu_list_offset); 9283 return 0; 9284 } 9285 9286 tu_list_elements = (address_table_offset - tu_list_offset) / 8; 9287 9288 /* PR 17531: file: 18a47d3d. */ 9289 if (symbol_table_offset < address_table_offset) 9290 { 9291 warn (_("Symbol table offset (%x) is less then Address table offset (%x)\n"), 9292 symbol_table_offset, address_table_offset); 9293 return 0; 9294 } 9295 9296 address_table_size = symbol_table_offset - address_table_offset; 9297 9298 if (constant_pool_offset < symbol_table_offset) 9299 { 9300 warn (_("Constant pool offset (%x) is less than symbol table offset (%x)\n"), 9301 constant_pool_offset, symbol_table_offset); 9302 return 0; 9303 } 9304 9305 symbol_table_slots = (constant_pool_offset - symbol_table_offset) / 8; 9306 9307 cu_list = start + cu_list_offset; 9308 tu_list = start + tu_list_offset; 9309 address_table = start + address_table_offset; 9310 symbol_table = start + symbol_table_offset; 9311 constant_pool = start + constant_pool_offset; 9312 9313 if (address_table + address_table_size > section->start + section->size) 9314 { 9315 warn (_("Address table extends beyond end of section.\n")); 9316 return 0; 9317 } 9318 9319 printf (_("\nCU table:\n")); 9320 for (i = 0; i < cu_list_elements; i += 2) 9321 { 9322 uint64_t cu_offset = byte_get_little_endian (cu_list + i * 8, 8); 9323 uint64_t cu_length = byte_get_little_endian (cu_list + i * 8 + 8, 8); 9324 9325 printf (_("[%3u] 0x%lx - 0x%lx\n"), i / 2, 9326 (unsigned long) cu_offset, 9327 (unsigned long) (cu_offset + cu_length - 1)); 9328 } 9329 9330 printf (_("\nTU table:\n")); 9331 for (i = 0; i < tu_list_elements; i += 3) 9332 { 9333 uint64_t tu_offset = byte_get_little_endian (tu_list + i * 8, 8); 9334 uint64_t type_offset = byte_get_little_endian (tu_list + i * 8 + 8, 8); 9335 uint64_t signature = byte_get_little_endian (tu_list + i * 8 + 16, 8); 9336 9337 printf (_("[%3u] 0x%lx 0x%lx "), i / 3, 9338 (unsigned long) tu_offset, 9339 (unsigned long) type_offset); 9340 print_dwarf_vma (signature, 8); 9341 printf ("\n"); 9342 } 9343 9344 printf (_("\nAddress table:\n")); 9345 for (i = 0; i < address_table_size && i <= address_table_size - (2 * 8 + 4); 9346 i += 2 * 8 + 4) 9347 { 9348 uint64_t low = byte_get_little_endian (address_table + i, 8); 9349 uint64_t high = byte_get_little_endian (address_table + i + 8, 8); 9350 uint32_t cu_index = byte_get_little_endian (address_table + i + 16, 4); 9351 9352 print_dwarf_vma (low, 8); 9353 print_dwarf_vma (high, 8); 9354 printf (_("%lu\n"), (unsigned long) cu_index); 9355 } 9356 9357 printf (_("\nSymbol table:\n")); 9358 for (i = 0; i < symbol_table_slots; ++i) 9359 { 9360 uint32_t name_offset = byte_get_little_endian (symbol_table + i * 8, 4); 9361 uint32_t cu_vector_offset = byte_get_little_endian (symbol_table + i * 8 + 4, 4); 9362 uint32_t num_cus, cu; 9363 9364 if (name_offset != 0 9365 || cu_vector_offset != 0) 9366 { 9367 unsigned int j; 9368 unsigned char * adr; 9369 9370 adr = constant_pool + name_offset; 9371 /* PR 17531: file: 5b7b07ad. */ 9372 if (adr < constant_pool || adr >= section->start + section->size) 9373 { 9374 printf (_("[%3u] <corrupt offset: %x>"), i, name_offset); 9375 warn (_("Corrupt name offset of 0x%x found for symbol table slot %d\n"), 9376 name_offset, i); 9377 } 9378 else 9379 printf ("[%3u] %.*s:", i, 9380 (int) (section->size - (constant_pool_offset + name_offset)), 9381 constant_pool + name_offset); 9382 9383 adr = constant_pool + cu_vector_offset; 9384 if (adr < constant_pool || adr >= section->start + section->size - 3) 9385 { 9386 printf (_("<invalid CU vector offset: %x>\n"), cu_vector_offset); 9387 warn (_("Corrupt CU vector offset of 0x%x found for symbol table slot %d\n"), 9388 cu_vector_offset, i); 9389 continue; 9390 } 9391 9392 num_cus = byte_get_little_endian (adr, 4); 9393 9394 adr = constant_pool + cu_vector_offset + 4 + num_cus * 4; 9395 if (num_cus * 4 < num_cus 9396 || adr >= section->start + section->size 9397 || adr < constant_pool) 9398 { 9399 printf ("<invalid number of CUs: %d>\n", num_cus); 9400 warn (_("Invalid number of CUs (0x%x) for symbol table slot %d\n"), 9401 num_cus, i); 9402 continue; 9403 } 9404 9405 if (num_cus > 1) 9406 printf ("\n"); 9407 9408 for (j = 0; j < num_cus; ++j) 9409 { 9410 int is_static; 9411 gdb_index_symbol_kind kind; 9412 9413 cu = byte_get_little_endian (constant_pool + cu_vector_offset + 4 + j * 4, 4); 9414 is_static = GDB_INDEX_SYMBOL_STATIC_VALUE (cu); 9415 kind = GDB_INDEX_SYMBOL_KIND_VALUE (cu); 9416 cu = GDB_INDEX_CU_VALUE (cu); 9417 /* Convert to TU number if it's for a type unit. */ 9418 if (cu >= cu_list_elements / 2) 9419 printf ("%cT%lu", num_cus > 1 ? '\t' : ' ', 9420 (unsigned long) (cu - cu_list_elements / 2)); 9421 else 9422 printf ("%c%lu", num_cus > 1 ? '\t' : ' ', (unsigned long) cu); 9423 9424 printf (" [%s, %s]", 9425 is_static ? _("static") : _("global"), 9426 get_gdb_index_symbol_kind_name (kind)); 9427 if (num_cus > 1) 9428 printf ("\n"); 9429 } 9430 if (num_cus <= 1) 9431 printf ("\n"); 9432 } 9433 } 9434 9435 return 1; 9436 } 9437 9438 /* Pre-allocate enough space for the CU/TU sets needed. */ 9439 9440 static void 9441 prealloc_cu_tu_list (unsigned int nshndx) 9442 { 9443 if (shndx_pool == NULL) 9444 { 9445 shndx_pool_size = nshndx; 9446 shndx_pool_used = 0; 9447 shndx_pool = (unsigned int *) xcmalloc (shndx_pool_size, 9448 sizeof (unsigned int)); 9449 } 9450 else 9451 { 9452 shndx_pool_size = shndx_pool_used + nshndx; 9453 shndx_pool = (unsigned int *) xcrealloc (shndx_pool, shndx_pool_size, 9454 sizeof (unsigned int)); 9455 } 9456 } 9457 9458 static void 9459 add_shndx_to_cu_tu_entry (unsigned int shndx) 9460 { 9461 if (shndx_pool_used >= shndx_pool_size) 9462 { 9463 error (_("Internal error: out of space in the shndx pool.\n")); 9464 return; 9465 } 9466 shndx_pool [shndx_pool_used++] = shndx; 9467 } 9468 9469 static void 9470 end_cu_tu_entry (void) 9471 { 9472 if (shndx_pool_used >= shndx_pool_size) 9473 { 9474 error (_("Internal error: out of space in the shndx pool.\n")); 9475 return; 9476 } 9477 shndx_pool [shndx_pool_used++] = 0; 9478 } 9479 9480 /* Return the short name of a DWARF section given by a DW_SECT enumerator. */ 9481 9482 static const char * 9483 get_DW_SECT_short_name (unsigned int dw_sect) 9484 { 9485 static char buf[16]; 9486 9487 switch (dw_sect) 9488 { 9489 case DW_SECT_INFO: 9490 return "info"; 9491 case DW_SECT_TYPES: 9492 return "types"; 9493 case DW_SECT_ABBREV: 9494 return "abbrev"; 9495 case DW_SECT_LINE: 9496 return "line"; 9497 case DW_SECT_LOC: 9498 return "loc"; 9499 case DW_SECT_STR_OFFSETS: 9500 return "str_off"; 9501 case DW_SECT_MACINFO: 9502 return "macinfo"; 9503 case DW_SECT_MACRO: 9504 return "macro"; 9505 default: 9506 break; 9507 } 9508 9509 snprintf (buf, sizeof (buf), "%d", dw_sect); 9510 return buf; 9511 } 9512 9513 /* Process a CU or TU index. If DO_DISPLAY is true, print the contents. 9514 These sections are extensions for Fission. 9515 See http://gcc.gnu.org/wiki/DebugFissionDWP. */ 9516 9517 static int 9518 process_cu_tu_index (struct dwarf_section *section, int do_display) 9519 { 9520 unsigned char *phdr = section->start; 9521 unsigned char *limit = phdr + section->size; 9522 unsigned char *phash; 9523 unsigned char *pindex; 9524 unsigned char *ppool; 9525 unsigned int version; 9526 unsigned int ncols = 0; 9527 unsigned int nused; 9528 unsigned int nslots; 9529 unsigned int i; 9530 unsigned int j; 9531 dwarf_vma signature_high; 9532 dwarf_vma signature_low; 9533 char buf[64]; 9534 9535 /* PR 17512: file: 002-168123-0.004. */ 9536 if (phdr == NULL) 9537 { 9538 warn (_("Section %s is empty\n"), section->name); 9539 return 0; 9540 } 9541 /* PR 17512: file: 002-376-0.004. */ 9542 if (section->size < 24) 9543 { 9544 warn (_("Section %s is too small to contain a CU/TU header\n"), 9545 section->name); 9546 return 0; 9547 } 9548 9549 SAFE_BYTE_GET (version, phdr, 4, limit); 9550 if (version >= 2) 9551 SAFE_BYTE_GET (ncols, phdr + 4, 4, limit); 9552 SAFE_BYTE_GET (nused, phdr + 8, 4, limit); 9553 SAFE_BYTE_GET (nslots, phdr + 12, 4, limit); 9554 9555 phash = phdr + 16; 9556 pindex = phash + (size_t) nslots * 8; 9557 ppool = pindex + (size_t) nslots * 4; 9558 9559 if (do_display) 9560 { 9561 introduce (section, FALSE); 9562 9563 printf (_(" Version: %u\n"), version); 9564 if (version >= 2) 9565 printf (_(" Number of columns: %u\n"), ncols); 9566 printf (_(" Number of used entries: %u\n"), nused); 9567 printf (_(" Number of slots: %u\n\n"), nslots); 9568 } 9569 9570 /* PR 17531: file: 45d69832. */ 9571 if ((size_t) nslots * 8 / 8 != nslots 9572 || phash < phdr || phash > limit 9573 || pindex < phash || pindex > limit 9574 || ppool < pindex || ppool > limit) 9575 { 9576 warn (ngettext ("Section %s is too small for %u slot\n", 9577 "Section %s is too small for %u slots\n", 9578 nslots), 9579 section->name, nslots); 9580 return 0; 9581 } 9582 9583 if (version == 1) 9584 { 9585 if (!do_display) 9586 prealloc_cu_tu_list ((limit - ppool) / 4); 9587 for (i = 0; i < nslots; i++) 9588 { 9589 unsigned char *shndx_list; 9590 unsigned int shndx; 9591 9592 SAFE_BYTE_GET64 (phash, &signature_high, &signature_low, limit); 9593 if (signature_high != 0 || signature_low != 0) 9594 { 9595 SAFE_BYTE_GET (j, pindex, 4, limit); 9596 shndx_list = ppool + j * 4; 9597 /* PR 17531: file: 705e010d. */ 9598 if (shndx_list < ppool) 9599 { 9600 warn (_("Section index pool located before start of section\n")); 9601 return 0; 9602 } 9603 9604 if (do_display) 9605 printf (_(" [%3d] Signature: 0x%s Sections: "), 9606 i, dwarf_vmatoa64 (signature_high, signature_low, 9607 buf, sizeof (buf))); 9608 for (;;) 9609 { 9610 if (shndx_list >= limit) 9611 { 9612 warn (_("Section %s too small for shndx pool\n"), 9613 section->name); 9614 return 0; 9615 } 9616 SAFE_BYTE_GET (shndx, shndx_list, 4, limit); 9617 if (shndx == 0) 9618 break; 9619 if (do_display) 9620 printf (" %d", shndx); 9621 else 9622 add_shndx_to_cu_tu_entry (shndx); 9623 shndx_list += 4; 9624 } 9625 if (do_display) 9626 printf ("\n"); 9627 else 9628 end_cu_tu_entry (); 9629 } 9630 phash += 8; 9631 pindex += 4; 9632 } 9633 } 9634 else if (version == 2) 9635 { 9636 unsigned int val; 9637 unsigned int dw_sect; 9638 unsigned char *ph = phash; 9639 unsigned char *pi = pindex; 9640 unsigned char *poffsets = ppool + (size_t) ncols * 4; 9641 unsigned char *psizes = poffsets + (size_t) nused * ncols * 4; 9642 unsigned char *pend = psizes + (size_t) nused * ncols * 4; 9643 bfd_boolean is_tu_index; 9644 struct cu_tu_set *this_set = NULL; 9645 unsigned int row; 9646 unsigned char *prow; 9647 9648 is_tu_index = strcmp (section->name, ".debug_tu_index") == 0; 9649 9650 /* PR 17531: file: 0dd159bf. 9651 Check for integer overflow (can occur when size_t is 32-bit) 9652 with overlarge ncols or nused values. */ 9653 if (ncols > 0 9654 && ((size_t) ncols * 4 / 4 != ncols 9655 || (size_t) nused * ncols * 4 / ((size_t) ncols * 4) != nused 9656 || poffsets < ppool || poffsets > limit 9657 || psizes < poffsets || psizes > limit 9658 || pend < psizes || pend > limit)) 9659 { 9660 warn (_("Section %s too small for offset and size tables\n"), 9661 section->name); 9662 return 0; 9663 } 9664 9665 if (do_display) 9666 { 9667 printf (_(" Offset table\n")); 9668 printf (" slot %-16s ", 9669 is_tu_index ? _("signature") : _("dwo_id")); 9670 } 9671 else 9672 { 9673 if (is_tu_index) 9674 { 9675 tu_count = nused; 9676 tu_sets = xcalloc2 (nused, sizeof (struct cu_tu_set)); 9677 this_set = tu_sets; 9678 } 9679 else 9680 { 9681 cu_count = nused; 9682 cu_sets = xcalloc2 (nused, sizeof (struct cu_tu_set)); 9683 this_set = cu_sets; 9684 } 9685 } 9686 9687 if (do_display) 9688 { 9689 for (j = 0; j < ncols; j++) 9690 { 9691 SAFE_BYTE_GET (dw_sect, ppool + j * 4, 4, limit); 9692 printf (" %8s", get_DW_SECT_short_name (dw_sect)); 9693 } 9694 printf ("\n"); 9695 } 9696 9697 for (i = 0; i < nslots; i++) 9698 { 9699 SAFE_BYTE_GET64 (ph, &signature_high, &signature_low, limit); 9700 9701 SAFE_BYTE_GET (row, pi, 4, limit); 9702 if (row != 0) 9703 { 9704 /* PR 17531: file: a05f6ab3. */ 9705 if (row > nused) 9706 { 9707 warn (_("Row index (%u) is larger than number of used entries (%u)\n"), 9708 row, nused); 9709 return 0; 9710 } 9711 9712 if (!do_display) 9713 { 9714 size_t num_copy = sizeof (uint64_t); 9715 9716 /* PR 23064: Beware of buffer overflow. */ 9717 if (ph + num_copy < limit) 9718 memcpy (&this_set[row - 1].signature, ph, num_copy); 9719 else 9720 { 9721 warn (_("Signature (%p) extends beyond end of space in section\n"), ph); 9722 return 0; 9723 } 9724 } 9725 9726 prow = poffsets + (row - 1) * ncols * 4; 9727 /* PR 17531: file: b8ce60a8. */ 9728 if (prow < poffsets || prow > limit) 9729 { 9730 warn (_("Row index (%u) * num columns (%u) > space remaining in section\n"), 9731 row, ncols); 9732 return 0; 9733 } 9734 9735 if (do_display) 9736 printf (_(" [%3d] 0x%s"), 9737 i, dwarf_vmatoa64 (signature_high, signature_low, 9738 buf, sizeof (buf))); 9739 for (j = 0; j < ncols; j++) 9740 { 9741 SAFE_BYTE_GET (val, prow + j * 4, 4, limit); 9742 if (do_display) 9743 printf (" %8d", val); 9744 else 9745 { 9746 SAFE_BYTE_GET (dw_sect, ppool + j * 4, 4, limit); 9747 9748 /* PR 17531: file: 10796eb3. */ 9749 if (dw_sect >= DW_SECT_MAX) 9750 warn (_("Overlarge Dwarf section index detected: %u\n"), dw_sect); 9751 else 9752 this_set [row - 1].section_offsets [dw_sect] = val; 9753 } 9754 } 9755 9756 if (do_display) 9757 printf ("\n"); 9758 } 9759 ph += 8; 9760 pi += 4; 9761 } 9762 9763 ph = phash; 9764 pi = pindex; 9765 if (do_display) 9766 { 9767 printf ("\n"); 9768 printf (_(" Size table\n")); 9769 printf (" slot %-16s ", 9770 is_tu_index ? _("signature") : _("dwo_id")); 9771 } 9772 9773 for (j = 0; j < ncols; j++) 9774 { 9775 SAFE_BYTE_GET (val, ppool + j * 4, 4, limit); 9776 if (do_display) 9777 printf (" %8s", get_DW_SECT_short_name (val)); 9778 } 9779 9780 if (do_display) 9781 printf ("\n"); 9782 9783 for (i = 0; i < nslots; i++) 9784 { 9785 SAFE_BYTE_GET64 (ph, &signature_high, &signature_low, limit); 9786 9787 SAFE_BYTE_GET (row, pi, 4, limit); 9788 if (row != 0) 9789 { 9790 prow = psizes + (row - 1) * ncols * 4; 9791 9792 if (do_display) 9793 printf (_(" [%3d] 0x%s"), 9794 i, dwarf_vmatoa64 (signature_high, signature_low, 9795 buf, sizeof (buf))); 9796 9797 for (j = 0; j < ncols; j++) 9798 { 9799 SAFE_BYTE_GET (val, prow + j * 4, 4, limit); 9800 if (do_display) 9801 printf (" %8d", val); 9802 else 9803 { 9804 SAFE_BYTE_GET (dw_sect, ppool + j * 4, 4, limit); 9805 if (dw_sect >= DW_SECT_MAX) 9806 warn (_("Overlarge Dwarf section index detected: %u\n"), dw_sect); 9807 else 9808 this_set [row - 1].section_sizes [dw_sect] = val; 9809 } 9810 } 9811 9812 if (do_display) 9813 printf ("\n"); 9814 } 9815 9816 ph += 8; 9817 pi += 4; 9818 } 9819 } 9820 else if (do_display) 9821 printf (_(" Unsupported version (%d)\n"), version); 9822 9823 if (do_display) 9824 printf ("\n"); 9825 9826 return 1; 9827 } 9828 9829 /* Load the CU and TU indexes if present. This will build a list of 9830 section sets that we can use to associate a .debug_info.dwo section 9831 with its associated .debug_abbrev.dwo section in a .dwp file. */ 9832 9833 static bfd_boolean 9834 load_cu_tu_indexes (void *file) 9835 { 9836 static int cu_tu_indexes_read = -1; /* Tri-state variable. */ 9837 9838 /* If we have already loaded (or tried to load) the CU and TU indexes 9839 then do not bother to repeat the task. */ 9840 if (cu_tu_indexes_read == -1) 9841 { 9842 cu_tu_indexes_read = TRUE; 9843 9844 if (load_debug_section_with_follow (dwp_cu_index, file)) 9845 if (! process_cu_tu_index (&debug_displays [dwp_cu_index].section, 0)) 9846 cu_tu_indexes_read = FALSE; 9847 9848 if (load_debug_section_with_follow (dwp_tu_index, file)) 9849 if (! process_cu_tu_index (&debug_displays [dwp_tu_index].section, 0)) 9850 cu_tu_indexes_read = FALSE; 9851 } 9852 9853 return (bfd_boolean) cu_tu_indexes_read; 9854 } 9855 9856 /* Find the set of sections that includes section SHNDX. */ 9857 9858 unsigned int * 9859 find_cu_tu_set (void *file, unsigned int shndx) 9860 { 9861 unsigned int i; 9862 9863 if (! load_cu_tu_indexes (file)) 9864 return NULL; 9865 9866 /* Find SHNDX in the shndx pool. */ 9867 for (i = 0; i < shndx_pool_used; i++) 9868 if (shndx_pool [i] == shndx) 9869 break; 9870 9871 if (i >= shndx_pool_used) 9872 return NULL; 9873 9874 /* Now backup to find the first entry in the set. */ 9875 while (i > 0 && shndx_pool [i - 1] != 0) 9876 i--; 9877 9878 return shndx_pool + i; 9879 } 9880 9881 /* Display a .debug_cu_index or .debug_tu_index section. */ 9882 9883 static int 9884 display_cu_index (struct dwarf_section *section, void *file ATTRIBUTE_UNUSED) 9885 { 9886 return process_cu_tu_index (section, 1); 9887 } 9888 9889 static int 9890 display_debug_not_supported (struct dwarf_section *section, 9891 void *file ATTRIBUTE_UNUSED) 9892 { 9893 printf (_("Displaying the debug contents of section %s is not yet supported.\n"), 9894 section->name); 9895 9896 return 1; 9897 } 9898 9899 /* Like malloc, but takes two parameters like calloc. 9900 Verifies that the first parameter is not too large. 9901 Note: does *not* initialise the allocated memory to zero. */ 9902 9903 void * 9904 cmalloc (size_t nmemb, size_t size) 9905 { 9906 /* Check for overflow. */ 9907 if (nmemb >= ~(size_t) 0 / size) 9908 return NULL; 9909 9910 return xmalloc (nmemb * size); 9911 } 9912 9913 /* Like xmalloc, but takes two parameters like calloc. 9914 Verifies that the first parameter is not too large. 9915 Note: does *not* initialise the allocated memory to zero. */ 9916 9917 void * 9918 xcmalloc (size_t nmemb, size_t size) 9919 { 9920 /* Check for overflow. */ 9921 if (nmemb >= ~(size_t) 0 / size) 9922 { 9923 fprintf (stderr, 9924 _("Attempt to allocate an array with an excessive number of elements: 0x%lx\n"), 9925 (long) nmemb); 9926 xexit (1); 9927 } 9928 9929 return xmalloc (nmemb * size); 9930 } 9931 9932 /* Like xrealloc, but takes three parameters. 9933 Verifies that the second parameter is not too large. 9934 Note: does *not* initialise any new memory to zero. */ 9935 9936 void * 9937 xcrealloc (void *ptr, size_t nmemb, size_t size) 9938 { 9939 /* Check for overflow. */ 9940 if (nmemb >= ~(size_t) 0 / size) 9941 { 9942 error (_("Attempt to re-allocate an array with an excessive number of elements: 0x%lx\n"), 9943 (long) nmemb); 9944 xexit (1); 9945 } 9946 9947 return xrealloc (ptr, nmemb * size); 9948 } 9949 9950 /* Like xcalloc, but verifies that the first parameter is not too large. */ 9951 9952 void * 9953 xcalloc2 (size_t nmemb, size_t size) 9954 { 9955 /* Check for overflow. */ 9956 if (nmemb >= ~(size_t) 0 / size) 9957 { 9958 error (_("Attempt to allocate a zero'ed array with an excessive number of elements: 0x%lx\n"), 9959 (long) nmemb); 9960 xexit (1); 9961 } 9962 9963 return xcalloc (nmemb, size); 9964 } 9965 9966 static unsigned long 9967 calc_gnu_debuglink_crc32 (unsigned long crc, 9968 const unsigned char * buf, 9969 bfd_size_type len) 9970 { 9971 static const unsigned long crc32_table[256] = 9972 { 9973 0x00000000, 0x77073096, 0xee0e612c, 0x990951ba, 0x076dc419, 9974 0x706af48f, 0xe963a535, 0x9e6495a3, 0x0edb8832, 0x79dcb8a4, 9975 0xe0d5e91e, 0x97d2d988, 0x09b64c2b, 0x7eb17cbd, 0xe7b82d07, 9976 0x90bf1d91, 0x1db71064, 0x6ab020f2, 0xf3b97148, 0x84be41de, 9977 0x1adad47d, 0x6ddde4eb, 0xf4d4b551, 0x83d385c7, 0x136c9856, 9978 0x646ba8c0, 0xfd62f97a, 0x8a65c9ec, 0x14015c4f, 0x63066cd9, 9979 0xfa0f3d63, 0x8d080df5, 0x3b6e20c8, 0x4c69105e, 0xd56041e4, 9980 0xa2677172, 0x3c03e4d1, 0x4b04d447, 0xd20d85fd, 0xa50ab56b, 9981 0x35b5a8fa, 0x42b2986c, 0xdbbbc9d6, 0xacbcf940, 0x32d86ce3, 9982 0x45df5c75, 0xdcd60dcf, 0xabd13d59, 0x26d930ac, 0x51de003a, 9983 0xc8d75180, 0xbfd06116, 0x21b4f4b5, 0x56b3c423, 0xcfba9599, 9984 0xb8bda50f, 0x2802b89e, 0x5f058808, 0xc60cd9b2, 0xb10be924, 9985 0x2f6f7c87, 0x58684c11, 0xc1611dab, 0xb6662d3d, 0x76dc4190, 9986 0x01db7106, 0x98d220bc, 0xefd5102a, 0x71b18589, 0x06b6b51f, 9987 0x9fbfe4a5, 0xe8b8d433, 0x7807c9a2, 0x0f00f934, 0x9609a88e, 9988 0xe10e9818, 0x7f6a0dbb, 0x086d3d2d, 0x91646c97, 0xe6635c01, 9989 0x6b6b51f4, 0x1c6c6162, 0x856530d8, 0xf262004e, 0x6c0695ed, 9990 0x1b01a57b, 0x8208f4c1, 0xf50fc457, 0x65b0d9c6, 0x12b7e950, 9991 0x8bbeb8ea, 0xfcb9887c, 0x62dd1ddf, 0x15da2d49, 0x8cd37cf3, 9992 0xfbd44c65, 0x4db26158, 0x3ab551ce, 0xa3bc0074, 0xd4bb30e2, 9993 0x4adfa541, 0x3dd895d7, 0xa4d1c46d, 0xd3d6f4fb, 0x4369e96a, 9994 0x346ed9fc, 0xad678846, 0xda60b8d0, 0x44042d73, 0x33031de5, 9995 0xaa0a4c5f, 0xdd0d7cc9, 0x5005713c, 0x270241aa, 0xbe0b1010, 9996 0xc90c2086, 0x5768b525, 0x206f85b3, 0xb966d409, 0xce61e49f, 9997 0x5edef90e, 0x29d9c998, 0xb0d09822, 0xc7d7a8b4, 0x59b33d17, 9998 0x2eb40d81, 0xb7bd5c3b, 0xc0ba6cad, 0xedb88320, 0x9abfb3b6, 9999 0x03b6e20c, 0x74b1d29a, 0xead54739, 0x9dd277af, 0x04db2615, 10000 0x73dc1683, 0xe3630b12, 0x94643b84, 0x0d6d6a3e, 0x7a6a5aa8, 10001 0xe40ecf0b, 0x9309ff9d, 0x0a00ae27, 0x7d079eb1, 0xf00f9344, 10002 0x8708a3d2, 0x1e01f268, 0x6906c2fe, 0xf762575d, 0x806567cb, 10003 0x196c3671, 0x6e6b06e7, 0xfed41b76, 0x89d32be0, 0x10da7a5a, 10004 0x67dd4acc, 0xf9b9df6f, 0x8ebeeff9, 0x17b7be43, 0x60b08ed5, 10005 0xd6d6a3e8, 0xa1d1937e, 0x38d8c2c4, 0x4fdff252, 0xd1bb67f1, 10006 0xa6bc5767, 0x3fb506dd, 0x48b2364b, 0xd80d2bda, 0xaf0a1b4c, 10007 0x36034af6, 0x41047a60, 0xdf60efc3, 0xa867df55, 0x316e8eef, 10008 0x4669be79, 0xcb61b38c, 0xbc66831a, 0x256fd2a0, 0x5268e236, 10009 0xcc0c7795, 0xbb0b4703, 0x220216b9, 0x5505262f, 0xc5ba3bbe, 10010 0xb2bd0b28, 0x2bb45a92, 0x5cb36a04, 0xc2d7ffa7, 0xb5d0cf31, 10011 0x2cd99e8b, 0x5bdeae1d, 0x9b64c2b0, 0xec63f226, 0x756aa39c, 10012 0x026d930a, 0x9c0906a9, 0xeb0e363f, 0x72076785, 0x05005713, 10013 0x95bf4a82, 0xe2b87a14, 0x7bb12bae, 0x0cb61b38, 0x92d28e9b, 10014 0xe5d5be0d, 0x7cdcefb7, 0x0bdbdf21, 0x86d3d2d4, 0xf1d4e242, 10015 0x68ddb3f8, 0x1fda836e, 0x81be16cd, 0xf6b9265b, 0x6fb077e1, 10016 0x18b74777, 0x88085ae6, 0xff0f6a70, 0x66063bca, 0x11010b5c, 10017 0x8f659eff, 0xf862ae69, 0x616bffd3, 0x166ccf45, 0xa00ae278, 10018 0xd70dd2ee, 0x4e048354, 0x3903b3c2, 0xa7672661, 0xd06016f7, 10019 0x4969474d, 0x3e6e77db, 0xaed16a4a, 0xd9d65adc, 0x40df0b66, 10020 0x37d83bf0, 0xa9bcae53, 0xdebb9ec5, 0x47b2cf7f, 0x30b5ffe9, 10021 0xbdbdf21c, 0xcabac28a, 0x53b39330, 0x24b4a3a6, 0xbad03605, 10022 0xcdd70693, 0x54de5729, 0x23d967bf, 0xb3667a2e, 0xc4614ab8, 10023 0x5d681b02, 0x2a6f2b94, 0xb40bbe37, 0xc30c8ea1, 0x5a05df1b, 10024 0x2d02ef8d 10025 }; 10026 const unsigned char *end; 10027 10028 crc = ~crc & 0xffffffff; 10029 for (end = buf + len; buf < end; ++ buf) 10030 crc = crc32_table[(crc ^ *buf) & 0xff] ^ (crc >> 8); 10031 return ~crc & 0xffffffff; 10032 } 10033 10034 typedef bfd_boolean (* check_func_type) (const char *, void *); 10035 typedef const char * (* parse_func_type) (struct dwarf_section *, void *); 10036 10037 static bfd_boolean 10038 check_gnu_debuglink (const char * pathname, void * crc_pointer) 10039 { 10040 static unsigned char buffer [8 * 1024]; 10041 FILE * f; 10042 bfd_size_type count; 10043 unsigned long crc = 0; 10044 void * sep_data; 10045 10046 sep_data = open_debug_file (pathname); 10047 if (sep_data == NULL) 10048 return FALSE; 10049 10050 /* Yes - we are opening the file twice... */ 10051 f = fopen (pathname, "rb"); 10052 if (f == NULL) 10053 { 10054 /* Paranoia: This should never happen. */ 10055 close_debug_file (sep_data); 10056 warn (_("Unable to reopen separate debug info file: %s\n"), pathname); 10057 return FALSE; 10058 } 10059 10060 while ((count = fread (buffer, 1, sizeof (buffer), f)) > 0) 10061 crc = calc_gnu_debuglink_crc32 (crc, buffer, count); 10062 10063 fclose (f); 10064 10065 if (crc != * (unsigned long *) crc_pointer) 10066 { 10067 close_debug_file (sep_data); 10068 warn (_("Separate debug info file %s found, but CRC does not match - ignoring\n"), 10069 pathname); 10070 return FALSE; 10071 } 10072 10073 return TRUE; 10074 } 10075 10076 static const char * 10077 parse_gnu_debuglink (struct dwarf_section * section, void * data) 10078 { 10079 const char * name; 10080 unsigned int crc_offset; 10081 unsigned long * crc32 = (unsigned long *) data; 10082 10083 /* The name is first. 10084 The CRC value is stored after the filename, aligned up to 4 bytes. */ 10085 name = (const char *) section->start; 10086 10087 10088 crc_offset = strnlen (name, section->size) + 1; 10089 crc_offset = (crc_offset + 3) & ~3; 10090 if (crc_offset + 4 > section->size) 10091 return NULL; 10092 10093 * crc32 = byte_get (section->start + crc_offset, 4); 10094 return name; 10095 } 10096 10097 static bfd_boolean 10098 check_gnu_debugaltlink (const char * filename, void * data ATTRIBUTE_UNUSED) 10099 { 10100 void * sep_data = open_debug_file (filename); 10101 10102 if (sep_data == NULL) 10103 return FALSE; 10104 10105 /* FIXME: We should now extract the build-id in the separate file 10106 and check it... */ 10107 10108 return TRUE; 10109 } 10110 10111 typedef struct build_id_data 10112 { 10113 bfd_size_type len; 10114 const unsigned char * data; 10115 } Build_id_data; 10116 10117 static const char * 10118 parse_gnu_debugaltlink (struct dwarf_section * section, void * data) 10119 { 10120 const char * name; 10121 bfd_size_type namelen; 10122 bfd_size_type id_len; 10123 Build_id_data * build_id_data; 10124 10125 /* The name is first. 10126 The build-id follows immediately, with no padding, up to the section's end. */ 10127 10128 name = (const char *) section->start; 10129 namelen = strnlen (name, section->size) + 1; 10130 if (namelen >= section->size) 10131 return NULL; 10132 10133 id_len = section->size - namelen; 10134 if (id_len < 0x14) 10135 return NULL; 10136 10137 build_id_data = calloc (1, sizeof * build_id_data); 10138 if (build_id_data == NULL) 10139 return NULL; 10140 10141 build_id_data->len = id_len; 10142 build_id_data->data = section->start + namelen; 10143 10144 * (Build_id_data **) data = build_id_data; 10145 10146 return name; 10147 } 10148 10149 static void 10150 add_separate_debug_file (const char * filename, void * handle) 10151 { 10152 separate_info * i = xmalloc (sizeof * i); 10153 10154 i->filename = filename; 10155 i->handle = handle; 10156 i->next = first_separate_info; 10157 first_separate_info = i; 10158 } 10159 10160 #if HAVE_LIBDEBUGINFOD 10161 /* Query debuginfod servers for the target debuglink or debugaltlink 10162 file. If successful, store the path of the file in filename and 10163 return TRUE, otherwise return FALSE. */ 10164 10165 static bfd_boolean 10166 debuginfod_fetch_separate_debug_info (struct dwarf_section * section, 10167 char ** filename, 10168 void * file) 10169 { 10170 size_t build_id_len; 10171 unsigned char * build_id; 10172 10173 if (strcmp (section->uncompressed_name, ".gnu_debuglink") == 0) 10174 { 10175 /* Get the build-id of file. */ 10176 build_id = get_build_id (file); 10177 build_id_len = 0; 10178 } 10179 else if (strcmp (section->uncompressed_name, ".gnu_debugaltlink") == 0) 10180 { 10181 /* Get the build-id of the debugaltlink file. */ 10182 unsigned int filelen; 10183 10184 filelen = strnlen ((const char *)section->start, section->size); 10185 if (filelen == section->size) 10186 /* Corrupt debugaltlink. */ 10187 return FALSE; 10188 10189 build_id = section->start + filelen + 1; 10190 build_id_len = section->size - (filelen + 1); 10191 10192 if (build_id_len == 0) 10193 return FALSE; 10194 } 10195 else 10196 return FALSE; 10197 10198 if (build_id) 10199 { 10200 int fd; 10201 debuginfod_client * client; 10202 10203 client = debuginfod_begin (); 10204 if (client == NULL) 10205 return FALSE; 10206 10207 /* Query debuginfod servers for the target file. If found its path 10208 will be stored in filename. */ 10209 fd = debuginfod_find_debuginfo (client, build_id, build_id_len, filename); 10210 debuginfod_end (client); 10211 10212 /* Only free build_id if we allocated space for a hex string 10213 in get_build_id (). */ 10214 if (build_id_len == 0) 10215 free (build_id); 10216 10217 if (fd >= 0) 10218 { 10219 /* File successfully retrieved. Close fd since we want to 10220 use open_debug_file () on filename instead. */ 10221 close (fd); 10222 return TRUE; 10223 } 10224 } 10225 10226 return FALSE; 10227 } 10228 #endif 10229 10230 static void * 10231 load_separate_debug_info (const char * main_filename, 10232 struct dwarf_section * xlink, 10233 parse_func_type parse_func, 10234 check_func_type check_func, 10235 void * func_data, 10236 void * file ATTRIBUTE_UNUSED) 10237 { 10238 const char * separate_filename; 10239 char * debug_filename; 10240 char * canon_dir; 10241 size_t canon_dirlen; 10242 size_t dirlen; 10243 10244 if ((separate_filename = parse_func (xlink, func_data)) == NULL) 10245 { 10246 warn (_("Corrupt debuglink section: %s\n"), 10247 xlink->name ? xlink->name : xlink->uncompressed_name); 10248 return FALSE; 10249 } 10250 10251 /* Attempt to locate the separate file. 10252 This should duplicate the logic in bfd/opncls.c:find_separate_debug_file(). */ 10253 10254 canon_dir = lrealpath (main_filename); 10255 10256 for (canon_dirlen = strlen (canon_dir); canon_dirlen > 0; canon_dirlen--) 10257 if (IS_DIR_SEPARATOR (canon_dir[canon_dirlen - 1])) 10258 break; 10259 canon_dir[canon_dirlen] = '\0'; 10260 10261 #ifndef DEBUGDIR 10262 #define DEBUGDIR "/lib/debug" 10263 #endif 10264 #ifndef EXTRA_DEBUG_ROOT1 10265 #define EXTRA_DEBUG_ROOT1 "/usr/lib/debug" 10266 #endif 10267 #ifndef EXTRA_DEBUG_ROOT2 10268 #define EXTRA_DEBUG_ROOT2 "/usr/lib/debug/usr" 10269 #endif 10270 10271 debug_filename = (char *) malloc (strlen (DEBUGDIR) + 1 10272 + canon_dirlen 10273 + strlen (".debug/") 10274 #ifdef EXTRA_DEBUG_ROOT1 10275 + strlen (EXTRA_DEBUG_ROOT1) 10276 #endif 10277 #ifdef EXTRA_DEBUG_ROOT2 10278 + strlen (EXTRA_DEBUG_ROOT2) 10279 #endif 10280 + strlen (separate_filename) 10281 + 1); 10282 if (debug_filename == NULL) 10283 { 10284 warn (_("Out of memory")); 10285 free (canon_dir); 10286 return NULL; 10287 } 10288 10289 /* First try in the current directory. */ 10290 sprintf (debug_filename, "%s", separate_filename); 10291 if (check_func (debug_filename, func_data)) 10292 goto found; 10293 10294 /* Then try in a subdirectory called .debug. */ 10295 sprintf (debug_filename, ".debug/%s", separate_filename); 10296 if (check_func (debug_filename, func_data)) 10297 goto found; 10298 10299 /* Then try in the same directory as the original file. */ 10300 sprintf (debug_filename, "%s%s", canon_dir, separate_filename); 10301 if (check_func (debug_filename, func_data)) 10302 goto found; 10303 10304 /* And the .debug subdirectory of that directory. */ 10305 sprintf (debug_filename, "%s.debug/%s", canon_dir, separate_filename); 10306 if (check_func (debug_filename, func_data)) 10307 goto found; 10308 10309 #ifdef EXTRA_DEBUG_ROOT1 10310 /* Try the first extra debug file root. */ 10311 sprintf (debug_filename, "%s/%s", EXTRA_DEBUG_ROOT1, separate_filename); 10312 if (check_func (debug_filename, func_data)) 10313 goto found; 10314 10315 /* Try the first extra debug file root. */ 10316 sprintf (debug_filename, "%s/%s/%s", EXTRA_DEBUG_ROOT1, canon_dir, separate_filename); 10317 if (check_func (debug_filename, func_data)) 10318 goto found; 10319 #endif 10320 10321 #ifdef EXTRA_DEBUG_ROOT2 10322 /* Try the second extra debug file root. */ 10323 sprintf (debug_filename, "%s/%s", EXTRA_DEBUG_ROOT2, separate_filename); 10324 if (check_func (debug_filename, func_data)) 10325 goto found; 10326 #endif 10327 10328 /* Then try in the global debug_filename directory. */ 10329 strcpy (debug_filename, DEBUGDIR); 10330 dirlen = strlen (DEBUGDIR) - 1; 10331 if (dirlen > 0 && DEBUGDIR[dirlen] != '/') 10332 strcat (debug_filename, "/"); 10333 strcat (debug_filename, (const char *) separate_filename); 10334 10335 if (check_func (debug_filename, func_data)) 10336 goto found; 10337 10338 #if HAVE_LIBDEBUGINFOD 10339 { 10340 char * tmp_filename; 10341 10342 if (debuginfod_fetch_separate_debug_info (xlink, 10343 & tmp_filename, 10344 file)) 10345 { 10346 /* File successfully downloaded from server, replace 10347 debug_filename with the file's path. */ 10348 free (debug_filename); 10349 debug_filename = tmp_filename; 10350 goto found; 10351 } 10352 } 10353 #endif 10354 10355 /* Failed to find the file. */ 10356 warn (_("could not find separate debug file '%s'\n"), separate_filename); 10357 warn (_("tried: %s\n"), debug_filename); 10358 10359 #ifdef EXTRA_DEBUG_ROOT2 10360 sprintf (debug_filename, "%s/%s", EXTRA_DEBUG_ROOT2, separate_filename); 10361 warn (_("tried: %s\n"), debug_filename); 10362 #endif 10363 10364 #ifdef EXTRA_DEBUG_ROOT1 10365 sprintf (debug_filename, "%s/%s/%s", EXTRA_DEBUG_ROOT1, canon_dir, separate_filename); 10366 warn (_("tried: %s\n"), debug_filename); 10367 10368 sprintf (debug_filename, "%s/%s", EXTRA_DEBUG_ROOT1, separate_filename); 10369 warn (_("tried: %s\n"), debug_filename); 10370 #endif 10371 10372 sprintf (debug_filename, "%s.debug/%s", canon_dir, separate_filename); 10373 warn (_("tried: %s\n"), debug_filename); 10374 10375 sprintf (debug_filename, "%s%s", canon_dir, separate_filename); 10376 warn (_("tried: %s\n"), debug_filename); 10377 10378 sprintf (debug_filename, ".debug/%s", separate_filename); 10379 warn (_("tried: %s\n"), debug_filename); 10380 10381 sprintf (debug_filename, "%s", separate_filename); 10382 warn (_("tried: %s\n"), debug_filename); 10383 10384 #if HAVE_LIBDEBUGINFOD 10385 { 10386 char *urls = getenv (DEBUGINFOD_URLS_ENV_VAR); 10387 if (urls == NULL) 10388 urls = ""; 10389 10390 warn (_("tried: DEBUGINFOD_URLS=%s\n"), urls); 10391 } 10392 #endif 10393 10394 free (canon_dir); 10395 free (debug_filename); 10396 return NULL; 10397 10398 found: 10399 free (canon_dir); 10400 10401 void * debug_handle; 10402 10403 /* Now open the file.... */ 10404 if ((debug_handle = open_debug_file (debug_filename)) == NULL) 10405 { 10406 warn (_("failed to open separate debug file: %s\n"), debug_filename); 10407 free (debug_filename); 10408 return FALSE; 10409 } 10410 10411 /* FIXME: We do not check to see if there are any other separate debug info 10412 files that would also match. */ 10413 10414 printf (_("%s: Found separate debug info file: %s\n\n"), main_filename, debug_filename); 10415 add_separate_debug_file (debug_filename, debug_handle); 10416 10417 /* Do not free debug_filename - it might be referenced inside 10418 the structure returned by open_debug_file(). */ 10419 return debug_handle; 10420 } 10421 10422 /* Attempt to load a separate dwarf object file. */ 10423 10424 static void * 10425 load_dwo_file (const char * main_filename, const char * name, const char * dir, const char * id ATTRIBUTE_UNUSED) 10426 { 10427 char * separate_filename; 10428 void * separate_handle; 10429 10430 /* FIXME: Skip adding / if dwo_dir ends in /. */ 10431 separate_filename = concat (dir, "/", name, NULL); 10432 if (separate_filename == NULL) 10433 { 10434 warn (_("Out of memory allocating dwo filename\n")); 10435 return NULL; 10436 } 10437 10438 if ((separate_handle = open_debug_file (separate_filename)) == NULL) 10439 { 10440 warn (_("Unable to load dwo file: %s\n"), separate_filename); 10441 free (separate_filename); 10442 return NULL; 10443 } 10444 10445 /* FIXME: We should check the dwo_id. */ 10446 10447 printf (_("%s: Found separate debug object file: %s\n\n"), main_filename, separate_filename); 10448 add_separate_debug_file (separate_filename, separate_handle); 10449 /* Note - separate_filename will be freed in free_debug_memory(). */ 10450 return separate_handle; 10451 } 10452 10453 /* Load the separate debug info file(s) attached to FILE, if any exist. 10454 Returns TRUE if any were found, FALSE otherwise. 10455 If TRUE is returned then the linked list starting at first_separate_info 10456 will be populated with open file handles. */ 10457 10458 bfd_boolean 10459 load_separate_debug_files (void * file, const char * filename) 10460 { 10461 /* Skip this operation if we are not interested in debug links. */ 10462 if (! do_follow_links && ! do_debug_links) 10463 return FALSE; 10464 10465 /* See if there are any dwo links. */ 10466 if (load_debug_section (str, file) 10467 && load_debug_section (abbrev, file) 10468 && load_debug_section (info, file)) 10469 { 10470 free_dwo_info (); 10471 10472 if (process_debug_info (& debug_displays[info].section, file, abbrev, TRUE, FALSE)) 10473 { 10474 bfd_boolean introduced = FALSE; 10475 dwo_info * dwinfo; 10476 const char * dir = NULL; 10477 const char * id = NULL; 10478 10479 for (dwinfo = first_dwo_info; dwinfo != NULL; dwinfo = dwinfo->next) 10480 { 10481 switch (dwinfo->type) 10482 { 10483 case DWO_NAME: 10484 if (do_debug_links) 10485 { 10486 if (! introduced) 10487 { 10488 printf (_("The %s section contains link(s) to dwo file(s):\n\n"), 10489 debug_displays [info].section.uncompressed_name); 10490 introduced = TRUE; 10491 } 10492 10493 printf (_(" Name: %s\n"), dwinfo->value); 10494 printf (_(" Directory: %s\n"), dir ? dir : _("<not-found>")); 10495 if (id != NULL) 10496 display_data (printf (_(" ID: ")), (unsigned char *) id, 8); 10497 else 10498 printf (_(" ID: <unknown>\n")); 10499 printf ("\n\n"); 10500 } 10501 10502 if (do_follow_links) 10503 load_dwo_file (filename, dwinfo->value, dir, id); 10504 break; 10505 10506 case DWO_DIR: 10507 dir = dwinfo->value; 10508 break; 10509 10510 case DWO_ID: 10511 id = dwinfo->value; 10512 break; 10513 10514 default: 10515 error (_("Unexpected DWO INFO type")); 10516 break; 10517 } 10518 } 10519 } 10520 } 10521 10522 if (! do_follow_links) 10523 /* The other debug links will be displayed by display_debug_links() 10524 so we do not need to do any further processing here. */ 10525 return FALSE; 10526 10527 /* FIXME: We do not check for the presence of both link sections in the same file. */ 10528 /* FIXME: We do not check the separate debug info file to see if it too contains debuglinks. */ 10529 /* FIXME: We do not check for the presence of multiple, same-name debuglink sections. */ 10530 /* FIXME: We do not check for the presence of a dwo link as well as a debuglink. */ 10531 10532 if (load_debug_section (gnu_debugaltlink, file)) 10533 { 10534 Build_id_data * build_id_data; 10535 10536 load_separate_debug_info (filename, 10537 & debug_displays[gnu_debugaltlink].section, 10538 parse_gnu_debugaltlink, 10539 check_gnu_debugaltlink, 10540 & build_id_data, 10541 file); 10542 } 10543 10544 if (load_debug_section (gnu_debuglink, file)) 10545 { 10546 unsigned long crc32; 10547 10548 load_separate_debug_info (filename, 10549 & debug_displays[gnu_debuglink].section, 10550 parse_gnu_debuglink, 10551 check_gnu_debuglink, 10552 & crc32, 10553 file); 10554 } 10555 10556 if (first_separate_info != NULL) 10557 return TRUE; 10558 10559 do_follow_links = 0; 10560 return FALSE; 10561 } 10562 10563 void 10564 free_debug_memory (void) 10565 { 10566 unsigned int i; 10567 10568 free_abbrevs (); 10569 10570 for (i = 0; i < max; i++) 10571 free_debug_section ((enum dwarf_section_display_enum) i); 10572 10573 if (debug_information != NULL) 10574 { 10575 if (num_debug_info_entries != DEBUG_INFO_UNAVAILABLE) 10576 { 10577 for (i = 0; i < num_debug_info_entries; i++) 10578 { 10579 if (!debug_information [i].max_loc_offsets) 10580 { 10581 free (debug_information [i].loc_offsets); 10582 free (debug_information [i].have_frame_base); 10583 } 10584 if (!debug_information [i].max_range_lists) 10585 free (debug_information [i].range_lists); 10586 } 10587 } 10588 free (debug_information); 10589 debug_information = NULL; 10590 alloc_num_debug_info_entries = num_debug_info_entries = 0; 10591 } 10592 10593 separate_info * d; 10594 separate_info * next; 10595 10596 for (d = first_separate_info; d != NULL; d = next) 10597 { 10598 close_debug_file (d->handle); 10599 free ((void *) d->filename); 10600 next = d->next; 10601 free ((void *) d); 10602 } 10603 first_separate_info = NULL; 10604 10605 free_dwo_info (); 10606 } 10607 10608 void 10609 dwarf_select_sections_by_names (const char *names) 10610 { 10611 typedef struct 10612 { 10613 const char * option; 10614 int * variable; 10615 int val; 10616 } 10617 debug_dump_long_opts; 10618 10619 static const debug_dump_long_opts opts_table [] = 10620 { 10621 /* Please keep this table alpha- sorted. */ 10622 { "Ranges", & do_debug_ranges, 1 }, 10623 { "abbrev", & do_debug_abbrevs, 1 }, 10624 { "addr", & do_debug_addr, 1 }, 10625 { "aranges", & do_debug_aranges, 1 }, 10626 { "cu_index", & do_debug_cu_index, 1 }, 10627 { "decodedline", & do_debug_lines, FLAG_DEBUG_LINES_DECODED }, 10628 { "follow-links", & do_follow_links, 1 }, 10629 { "frames", & do_debug_frames, 1 }, 10630 { "frames-interp", & do_debug_frames_interp, 1 }, 10631 /* The special .gdb_index section. */ 10632 { "gdb_index", & do_gdb_index, 1 }, 10633 { "info", & do_debug_info, 1 }, 10634 { "line", & do_debug_lines, FLAG_DEBUG_LINES_RAW }, /* For backwards compatibility. */ 10635 { "links", & do_debug_links, 1 }, 10636 { "loc", & do_debug_loc, 1 }, 10637 { "macro", & do_debug_macinfo, 1 }, 10638 { "pubnames", & do_debug_pubnames, 1 }, 10639 { "pubtypes", & do_debug_pubtypes, 1 }, 10640 /* This entry is for compatibility 10641 with earlier versions of readelf. */ 10642 { "ranges", & do_debug_aranges, 1 }, 10643 { "rawline", & do_debug_lines, FLAG_DEBUG_LINES_RAW }, 10644 { "str", & do_debug_str, 1 }, 10645 /* These trace_* sections are used by Itanium VMS. */ 10646 { "trace_abbrev", & do_trace_abbrevs, 1 }, 10647 { "trace_aranges", & do_trace_aranges, 1 }, 10648 { "trace_info", & do_trace_info, 1 }, 10649 { NULL, NULL, 0 } 10650 }; 10651 10652 const char *p; 10653 10654 p = names; 10655 while (*p) 10656 { 10657 const debug_dump_long_opts * entry; 10658 10659 for (entry = opts_table; entry->option; entry++) 10660 { 10661 size_t len = strlen (entry->option); 10662 10663 if (strncmp (p, entry->option, len) == 0 10664 && (p[len] == ',' || p[len] == '\0')) 10665 { 10666 * entry->variable |= entry->val; 10667 10668 /* The --debug-dump=frames-interp option also 10669 enables the --debug-dump=frames option. */ 10670 if (do_debug_frames_interp) 10671 do_debug_frames = 1; 10672 10673 p += len; 10674 break; 10675 } 10676 } 10677 10678 if (entry->option == NULL) 10679 { 10680 warn (_("Unrecognized debug option '%s'\n"), p); 10681 p = strchr (p, ','); 10682 if (p == NULL) 10683 break; 10684 } 10685 10686 if (*p == ',') 10687 p++; 10688 } 10689 } 10690 10691 void 10692 dwarf_select_sections_by_letters (const char *letters) 10693 { 10694 unsigned int lindex = 0; 10695 10696 while (letters[lindex]) 10697 switch (letters[lindex++]) 10698 { 10699 case 'A': do_debug_addr = 1; break; 10700 case 'a': do_debug_abbrevs = 1; break; 10701 case 'c': do_debug_cu_index = 1; break; 10702 case 'F': do_debug_frames_interp = 1; /* Fall through. */ 10703 case 'f': do_debug_frames = 1; break; 10704 case 'g': do_gdb_index = 1; break; 10705 case 'i': do_debug_info = 1; break; 10706 case 'K': do_follow_links = 1; break; 10707 case 'k': do_debug_links = 1; break; 10708 case 'l': do_debug_lines |= FLAG_DEBUG_LINES_RAW; break; 10709 case 'L': do_debug_lines |= FLAG_DEBUG_LINES_DECODED; break; 10710 case 'm': do_debug_macinfo = 1; break; 10711 case 'o': do_debug_loc = 1; break; 10712 case 'p': do_debug_pubnames = 1; break; 10713 case 'R': do_debug_ranges = 1; break; 10714 case 'r': do_debug_aranges = 1; break; 10715 case 's': do_debug_str = 1; break; 10716 case 'T': do_trace_aranges = 1; break; 10717 case 't': do_debug_pubtypes = 1; break; 10718 case 'U': do_trace_info = 1; break; 10719 case 'u': do_trace_abbrevs = 1; break; 10720 10721 default: 10722 warn (_("Unrecognized debug option '%s'\n"), letters); 10723 break; 10724 } 10725 } 10726 10727 void 10728 dwarf_select_sections_all (void) 10729 { 10730 do_debug_info = 1; 10731 do_debug_abbrevs = 1; 10732 do_debug_lines = FLAG_DEBUG_LINES_RAW; 10733 do_debug_pubnames = 1; 10734 do_debug_pubtypes = 1; 10735 do_debug_aranges = 1; 10736 do_debug_ranges = 1; 10737 do_debug_frames = 1; 10738 do_debug_macinfo = 1; 10739 do_debug_str = 1; 10740 do_debug_loc = 1; 10741 do_gdb_index = 1; 10742 do_trace_info = 1; 10743 do_trace_abbrevs = 1; 10744 do_trace_aranges = 1; 10745 do_debug_addr = 1; 10746 do_debug_cu_index = 1; 10747 do_follow_links = 1; 10748 do_debug_links = 1; 10749 } 10750 10751 #define NO_ABBREVS NULL, NULL, NULL, 0, 0, 0, NULL, 0, NULL 10752 #define ABBREV(N) NULL, NULL, NULL, 0, 0, N, NULL, 0, NULL 10753 10754 /* N.B. The order here must match the order in section_display_enum. */ 10755 10756 struct dwarf_section_display debug_displays[] = 10757 { 10758 { { ".debug_abbrev", ".zdebug_abbrev", NO_ABBREVS }, display_debug_abbrev, &do_debug_abbrevs, FALSE }, 10759 { { ".debug_aranges", ".zdebug_aranges", NO_ABBREVS }, display_debug_aranges, &do_debug_aranges, TRUE }, 10760 { { ".debug_frame", ".zdebug_frame", NO_ABBREVS }, display_debug_frames, &do_debug_frames, TRUE }, 10761 { { ".debug_info", ".zdebug_info", ABBREV (abbrev)}, display_debug_info, &do_debug_info, TRUE }, 10762 { { ".debug_line", ".zdebug_line", NO_ABBREVS }, display_debug_lines, &do_debug_lines, TRUE }, 10763 { { ".debug_pubnames", ".zdebug_pubnames", NO_ABBREVS }, display_debug_pubnames, &do_debug_pubnames, FALSE }, 10764 { { ".debug_gnu_pubnames", ".zdebug_gnu_pubnames", NO_ABBREVS }, display_debug_gnu_pubnames, &do_debug_pubnames, FALSE }, 10765 { { ".eh_frame", "", NO_ABBREVS }, display_debug_frames, &do_debug_frames, TRUE }, 10766 { { ".debug_macinfo", ".zdebug_macinfo", NO_ABBREVS }, display_debug_macinfo, &do_debug_macinfo, FALSE }, 10767 { { ".debug_macro", ".zdebug_macro", NO_ABBREVS }, display_debug_macro, &do_debug_macinfo, TRUE }, 10768 { { ".debug_str", ".zdebug_str", NO_ABBREVS }, display_debug_str, &do_debug_str, FALSE }, 10769 { { ".debug_line_str", ".zdebug_line_str", NO_ABBREVS }, display_debug_str, &do_debug_str, FALSE }, 10770 { { ".debug_loc", ".zdebug_loc", NO_ABBREVS }, display_debug_loc, &do_debug_loc, TRUE }, 10771 { { ".debug_loclists", ".zdebug_loclists", NO_ABBREVS }, display_debug_loc, &do_debug_loc, TRUE }, 10772 { { ".debug_pubtypes", ".zdebug_pubtypes", NO_ABBREVS }, display_debug_pubnames, &do_debug_pubtypes, FALSE }, 10773 { { ".debug_gnu_pubtypes", ".zdebug_gnu_pubtypes", NO_ABBREVS }, display_debug_gnu_pubnames, &do_debug_pubtypes, FALSE }, 10774 { { ".debug_ranges", ".zdebug_ranges", NO_ABBREVS }, display_debug_ranges, &do_debug_ranges, TRUE }, 10775 { { ".debug_rnglists", ".zdebug_rnglists", NO_ABBREVS }, display_debug_ranges, &do_debug_ranges, TRUE }, 10776 { { ".debug_static_func", ".zdebug_static_func", NO_ABBREVS }, display_debug_not_supported, NULL, FALSE }, 10777 { { ".debug_static_vars", ".zdebug_static_vars", NO_ABBREVS }, display_debug_not_supported, NULL, FALSE }, 10778 { { ".debug_types", ".zdebug_types", ABBREV (abbrev) }, display_debug_types, &do_debug_info, TRUE }, 10779 { { ".debug_weaknames", ".zdebug_weaknames", NO_ABBREVS }, display_debug_not_supported, NULL, FALSE }, 10780 { { ".gdb_index", "", NO_ABBREVS }, display_gdb_index, &do_gdb_index, FALSE }, 10781 { { ".debug_names", "", NO_ABBREVS }, display_debug_names, &do_gdb_index, FALSE }, 10782 { { ".trace_info", "", ABBREV (trace_abbrev) }, display_trace_info, &do_trace_info, TRUE }, 10783 { { ".trace_abbrev", "", NO_ABBREVS }, display_debug_abbrev, &do_trace_abbrevs, FALSE }, 10784 { { ".trace_aranges", "", NO_ABBREVS }, display_debug_aranges, &do_trace_aranges, FALSE }, 10785 { { ".debug_info.dwo", ".zdebug_info.dwo", ABBREV (abbrev_dwo) }, display_debug_info, &do_debug_info, TRUE }, 10786 { { ".debug_abbrev.dwo", ".zdebug_abbrev.dwo", NO_ABBREVS }, display_debug_abbrev, &do_debug_abbrevs, FALSE }, 10787 { { ".debug_types.dwo", ".zdebug_types.dwo", ABBREV (abbrev_dwo) }, display_debug_types, &do_debug_info, TRUE }, 10788 { { ".debug_line.dwo", ".zdebug_line.dwo", NO_ABBREVS }, display_debug_lines, &do_debug_lines, TRUE }, 10789 { { ".debug_loc.dwo", ".zdebug_loc.dwo", NO_ABBREVS }, display_debug_loc, &do_debug_loc, TRUE }, 10790 { { ".debug_macro.dwo", ".zdebug_macro.dwo", NO_ABBREVS }, display_debug_macro, &do_debug_macinfo, TRUE }, 10791 { { ".debug_macinfo.dwo", ".zdebug_macinfo.dwo", NO_ABBREVS }, display_debug_macinfo, &do_debug_macinfo, FALSE }, 10792 { { ".debug_str.dwo", ".zdebug_str.dwo", NO_ABBREVS }, display_debug_str, &do_debug_str, TRUE }, 10793 { { ".debug_str_offsets", ".zdebug_str_offsets", NO_ABBREVS }, display_debug_str_offsets, NULL, FALSE }, 10794 { { ".debug_str_offsets.dwo", ".zdebug_str_offsets.dwo", NO_ABBREVS }, display_debug_str_offsets, NULL, FALSE }, 10795 { { ".debug_addr", ".zdebug_addr", NO_ABBREVS }, display_debug_addr, &do_debug_addr, TRUE }, 10796 { { ".debug_cu_index", "", NO_ABBREVS }, display_cu_index, &do_debug_cu_index, FALSE }, 10797 { { ".debug_tu_index", "", NO_ABBREVS }, display_cu_index, &do_debug_cu_index, FALSE }, 10798 { { ".gnu_debuglink", "", NO_ABBREVS }, display_debug_links, &do_debug_links, FALSE }, 10799 { { ".gnu_debugaltlink", "", NO_ABBREVS }, display_debug_links, &do_debug_links, FALSE }, 10800 /* Separate debug info files can containt their own .debug_str section, 10801 and this might be in *addition* to a .debug_str section already present 10802 in the main file. Hence we need to have two entries for .debug_str. */ 10803 { { ".debug_str", ".zdebug_str", NO_ABBREVS }, display_debug_str, &do_debug_str, FALSE }, 10804 }; 10805 10806 /* A static assertion. */ 10807 extern int debug_displays_assert[ARRAY_SIZE (debug_displays) == max ? 1 : -1]; 10808