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