1/* dwarf.c -- display DWARF contents of a BFD binary file 2 Copyright 2005, 2006, 2007 3 Free Software Foundation, Inc. 4 5 This file is part of GNU Binutils. 6 7 This program is free software; you can redistribute it and/or modify 8 it under the terms of the GNU General Public License as published by 9 the Free Software Foundation; either version 2 of the License, or 10 (at your option) any later version. 11 12 This program is distributed in the hope that it will be useful, 13 but WITHOUT ANY WARRANTY; without even the implied warranty of 14 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the 15 GNU General Public License for more details. 16 17 You should have received a copy of the GNU General Public License 18 along with this program; if not, write to the Free Software 19 Foundation, Inc., 51 Franklin Street - Fifth Floor, Boston, MA 20 02110-1301, USA. */ 21 22#include "sysdep.h" 23#include "libiberty.h" 24#include "bfd.h" 25#include "bucomm.h" 26#include "elf/dwarf2.h" 27#include "dwarf.h" 28 29static int have_frame_base; 30static int need_base_address; 31 32static unsigned int last_pointer_size = 0; 33static int warned_about_missing_comp_units = FALSE; 34 35static unsigned int num_debug_info_entries = 0; 36static debug_info *debug_information = NULL; 37 38dwarf_vma eh_addr_size; 39int is_relocatable; 40 41int do_debug_info; 42int do_debug_abbrevs; 43int do_debug_lines; 44int do_debug_pubnames; 45int do_debug_aranges; 46int do_debug_ranges; 47int do_debug_frames; 48int do_debug_frames_interp; 49int do_debug_macinfo; 50int do_debug_str; 51int do_debug_loc; 52 53dwarf_vma (*byte_get) (unsigned char *, int); 54 55dwarf_vma 56byte_get_little_endian (unsigned char *field, int size) 57{ 58 switch (size) 59 { 60 case 1: 61 return *field; 62 63 case 2: 64 return ((unsigned int) (field[0])) 65 | (((unsigned int) (field[1])) << 8); 66 67 case 4: 68 return ((unsigned long) (field[0])) 69 | (((unsigned long) (field[1])) << 8) 70 | (((unsigned long) (field[2])) << 16) 71 | (((unsigned long) (field[3])) << 24); 72 73 case 8: 74 if (sizeof (dwarf_vma) == 8) 75 return ((dwarf_vma) (field[0])) 76 | (((dwarf_vma) (field[1])) << 8) 77 | (((dwarf_vma) (field[2])) << 16) 78 | (((dwarf_vma) (field[3])) << 24) 79 | (((dwarf_vma) (field[4])) << 32) 80 | (((dwarf_vma) (field[5])) << 40) 81 | (((dwarf_vma) (field[6])) << 48) 82 | (((dwarf_vma) (field[7])) << 56); 83 else if (sizeof (dwarf_vma) == 4) 84 /* We want to extract data from an 8 byte wide field and 85 place it into a 4 byte wide field. Since this is a little 86 endian source we can just use the 4 byte extraction code. */ 87 return ((unsigned long) (field[0])) 88 | (((unsigned long) (field[1])) << 8) 89 | (((unsigned long) (field[2])) << 16) 90 | (((unsigned long) (field[3])) << 24); 91 92 default: 93 error (_("Unhandled data length: %d\n"), size); 94 abort (); 95 } 96} 97 98dwarf_vma 99byte_get_big_endian (unsigned char *field, int size) 100{ 101 switch (size) 102 { 103 case 1: 104 return *field; 105 106 case 2: 107 return ((unsigned int) (field[1])) | (((int) (field[0])) << 8); 108 109 case 4: 110 return ((unsigned long) (field[3])) 111 | (((unsigned long) (field[2])) << 8) 112 | (((unsigned long) (field[1])) << 16) 113 | (((unsigned long) (field[0])) << 24); 114 115 case 8: 116 if (sizeof (dwarf_vma) == 8) 117 return ((dwarf_vma) (field[7])) 118 | (((dwarf_vma) (field[6])) << 8) 119 | (((dwarf_vma) (field[5])) << 16) 120 | (((dwarf_vma) (field[4])) << 24) 121 | (((dwarf_vma) (field[3])) << 32) 122 | (((dwarf_vma) (field[2])) << 40) 123 | (((dwarf_vma) (field[1])) << 48) 124 | (((dwarf_vma) (field[0])) << 56); 125 else if (sizeof (dwarf_vma) == 4) 126 { 127 /* Although we are extracing data from an 8 byte wide field, 128 we are returning only 4 bytes of data. */ 129 field += 4; 130 return ((unsigned long) (field[3])) 131 | (((unsigned long) (field[2])) << 8) 132 | (((unsigned long) (field[1])) << 16) 133 | (((unsigned long) (field[0])) << 24); 134 } 135 136 default: 137 error (_("Unhandled data length: %d\n"), size); 138 abort (); 139 } 140} 141 142static dwarf_vma 143byte_get_signed (unsigned char *field, int size) 144{ 145 dwarf_vma x = byte_get (field, size); 146 147 switch (size) 148 { 149 case 1: 150 return (x ^ 0x80) - 0x80; 151 case 2: 152 return (x ^ 0x8000) - 0x8000; 153 case 4: 154 return (x ^ 0x80000000) - 0x80000000; 155 case 8: 156 return x; 157 default: 158 abort (); 159 } 160} 161 162static unsigned long int 163read_leb128 (unsigned char *data, unsigned int *length_return, int sign) 164{ 165 unsigned long int result = 0; 166 unsigned int num_read = 0; 167 unsigned int shift = 0; 168 unsigned char byte; 169 170 do 171 { 172 byte = *data++; 173 num_read++; 174 175 result |= ((unsigned long int) (byte & 0x7f)) << shift; 176 177 shift += 7; 178 179 } 180 while (byte & 0x80); 181 182 if (length_return != NULL) 183 *length_return = num_read; 184 185 if (sign && (shift < 8 * sizeof (result)) && (byte & 0x40)) 186 result |= -1L << shift; 187 188 return result; 189} 190 191typedef struct State_Machine_Registers 192{ 193 unsigned long address; 194 unsigned int file; 195 unsigned int line; 196 unsigned int column; 197 int is_stmt; 198 int basic_block; 199 int end_sequence; 200/* This variable hold the number of the last entry seen 201 in the File Table. */ 202 unsigned int last_file_entry; 203} SMR; 204 205static SMR state_machine_regs; 206 207static void 208reset_state_machine (int is_stmt) 209{ 210 state_machine_regs.address = 0; 211 state_machine_regs.file = 1; 212 state_machine_regs.line = 1; 213 state_machine_regs.column = 0; 214 state_machine_regs.is_stmt = is_stmt; 215 state_machine_regs.basic_block = 0; 216 state_machine_regs.end_sequence = 0; 217 state_machine_regs.last_file_entry = 0; 218} 219 220/* Handled an extend line op. 221 Returns the number of bytes read. */ 222 223static int 224process_extended_line_op (unsigned char *data, int is_stmt) 225{ 226 unsigned char op_code; 227 unsigned int bytes_read; 228 unsigned int len; 229 unsigned char *name; 230 unsigned long adr; 231 232 len = read_leb128 (data, & bytes_read, 0); 233 data += bytes_read; 234 235 if (len == 0) 236 { 237 warn (_("badly formed extended line op encountered!\n")); 238 return bytes_read; 239 } 240 241 len += bytes_read; 242 op_code = *data++; 243 244 printf (_(" Extended opcode %d: "), op_code); 245 246 switch (op_code) 247 { 248 case DW_LNE_end_sequence: 249 printf (_("End of Sequence\n\n")); 250 reset_state_machine (is_stmt); 251 break; 252 253 case DW_LNE_set_address: 254 adr = byte_get (data, len - bytes_read - 1); 255 printf (_("set Address to 0x%lx\n"), adr); 256 state_machine_regs.address = adr; 257 break; 258 259 case DW_LNE_define_file: 260 printf (_(" define new File Table entry\n")); 261 printf (_(" Entry\tDir\tTime\tSize\tName\n")); 262 263 printf (_(" %d\t"), ++state_machine_regs.last_file_entry); 264 name = data; 265 data += strlen ((char *) data) + 1; 266 printf (_("%lu\t"), read_leb128 (data, & bytes_read, 0)); 267 data += bytes_read; 268 printf (_("%lu\t"), read_leb128 (data, & bytes_read, 0)); 269 data += bytes_read; 270 printf (_("%lu\t"), read_leb128 (data, & bytes_read, 0)); 271 printf (_("%s\n\n"), name); 272 break; 273 274 default: 275 printf (_("UNKNOWN: length %d\n"), len - bytes_read); 276 break; 277 } 278 279 return len; 280} 281 282static const char * 283fetch_indirect_string (unsigned long offset) 284{ 285 struct dwarf_section *section = &debug_displays [str].section; 286 287 if (section->start == NULL) 288 return _("<no .debug_str section>"); 289 290 /* DWARF sections under Mach-O have non-zero addresses. */ 291 offset -= section->address; 292 if (offset > section->size) 293 { 294 warn (_("DW_FORM_strp offset too big: %lx\n"), offset); 295 return _("<offset is too big>"); 296 } 297 298 return (const char *) section->start + offset; 299} 300 301/* FIXME: There are better and more efficient ways to handle 302 these structures. For now though, I just want something that 303 is simple to implement. */ 304typedef struct abbrev_attr 305{ 306 unsigned long attribute; 307 unsigned long form; 308 struct abbrev_attr *next; 309} 310abbrev_attr; 311 312typedef struct abbrev_entry 313{ 314 unsigned long entry; 315 unsigned long tag; 316 int children; 317 struct abbrev_attr *first_attr; 318 struct abbrev_attr *last_attr; 319 struct abbrev_entry *next; 320} 321abbrev_entry; 322 323static abbrev_entry *first_abbrev = NULL; 324static abbrev_entry *last_abbrev = NULL; 325 326static void 327free_abbrevs (void) 328{ 329 abbrev_entry *abbrev; 330 331 for (abbrev = first_abbrev; abbrev;) 332 { 333 abbrev_entry *next = abbrev->next; 334 abbrev_attr *attr; 335 336 for (attr = abbrev->first_attr; attr;) 337 { 338 abbrev_attr *next = attr->next; 339 340 free (attr); 341 attr = next; 342 } 343 344 free (abbrev); 345 abbrev = next; 346 } 347 348 last_abbrev = first_abbrev = NULL; 349} 350 351static void 352add_abbrev (unsigned long number, unsigned long tag, int children) 353{ 354 abbrev_entry *entry; 355 356 entry = malloc (sizeof (*entry)); 357 358 if (entry == NULL) 359 /* ugg */ 360 return; 361 362 entry->entry = number; 363 entry->tag = tag; 364 entry->children = children; 365 entry->first_attr = NULL; 366 entry->last_attr = NULL; 367 entry->next = NULL; 368 369 if (first_abbrev == NULL) 370 first_abbrev = entry; 371 else 372 last_abbrev->next = entry; 373 374 last_abbrev = entry; 375} 376 377static void 378add_abbrev_attr (unsigned long attribute, unsigned long form) 379{ 380 abbrev_attr *attr; 381 382 attr = malloc (sizeof (*attr)); 383 384 if (attr == NULL) 385 /* ugg */ 386 return; 387 388 attr->attribute = attribute; 389 attr->form = form; 390 attr->next = NULL; 391 392 if (last_abbrev->first_attr == NULL) 393 last_abbrev->first_attr = attr; 394 else 395 last_abbrev->last_attr->next = attr; 396 397 last_abbrev->last_attr = attr; 398} 399 400/* Processes the (partial) contents of a .debug_abbrev section. 401 Returns NULL if the end of the section was encountered. 402 Returns the address after the last byte read if the end of 403 an abbreviation set was found. */ 404 405static unsigned char * 406process_abbrev_section (unsigned char *start, unsigned char *end) 407{ 408 if (first_abbrev != NULL) 409 return NULL; 410 411 while (start < end) 412 { 413 unsigned int bytes_read; 414 unsigned long entry; 415 unsigned long tag; 416 unsigned long attribute; 417 int children; 418 419 entry = read_leb128 (start, & bytes_read, 0); 420 start += bytes_read; 421 422 /* A single zero is supposed to end the section according 423 to the standard. If there's more, then signal that to 424 the caller. */ 425 if (entry == 0) 426 return start == end ? NULL : start; 427 428 tag = read_leb128 (start, & bytes_read, 0); 429 start += bytes_read; 430 431 children = *start++; 432 433 add_abbrev (entry, tag, children); 434 435 do 436 { 437 unsigned long form; 438 439 attribute = read_leb128 (start, & bytes_read, 0); 440 start += bytes_read; 441 442 form = read_leb128 (start, & bytes_read, 0); 443 start += bytes_read; 444 445 if (attribute != 0) 446 add_abbrev_attr (attribute, form); 447 } 448 while (attribute != 0); 449 } 450 451 return NULL; 452} 453 454static char * 455get_TAG_name (unsigned long tag) 456{ 457 switch (tag) 458 { 459 case DW_TAG_padding: return "DW_TAG_padding"; 460 case DW_TAG_array_type: return "DW_TAG_array_type"; 461 case DW_TAG_class_type: return "DW_TAG_class_type"; 462 case DW_TAG_entry_point: return "DW_TAG_entry_point"; 463 case DW_TAG_enumeration_type: return "DW_TAG_enumeration_type"; 464 case DW_TAG_formal_parameter: return "DW_TAG_formal_parameter"; 465 case DW_TAG_imported_declaration: return "DW_TAG_imported_declaration"; 466 case DW_TAG_label: return "DW_TAG_label"; 467 case DW_TAG_lexical_block: return "DW_TAG_lexical_block"; 468 case DW_TAG_member: return "DW_TAG_member"; 469 case DW_TAG_pointer_type: return "DW_TAG_pointer_type"; 470 case DW_TAG_reference_type: return "DW_TAG_reference_type"; 471 case DW_TAG_compile_unit: return "DW_TAG_compile_unit"; 472 case DW_TAG_string_type: return "DW_TAG_string_type"; 473 case DW_TAG_structure_type: return "DW_TAG_structure_type"; 474 case DW_TAG_subroutine_type: return "DW_TAG_subroutine_type"; 475 case DW_TAG_typedef: return "DW_TAG_typedef"; 476 case DW_TAG_union_type: return "DW_TAG_union_type"; 477 case DW_TAG_unspecified_parameters: return "DW_TAG_unspecified_parameters"; 478 case DW_TAG_variant: return "DW_TAG_variant"; 479 case DW_TAG_common_block: return "DW_TAG_common_block"; 480 case DW_TAG_common_inclusion: return "DW_TAG_common_inclusion"; 481 case DW_TAG_inheritance: return "DW_TAG_inheritance"; 482 case DW_TAG_inlined_subroutine: return "DW_TAG_inlined_subroutine"; 483 case DW_TAG_module: return "DW_TAG_module"; 484 case DW_TAG_ptr_to_member_type: return "DW_TAG_ptr_to_member_type"; 485 case DW_TAG_set_type: return "DW_TAG_set_type"; 486 case DW_TAG_subrange_type: return "DW_TAG_subrange_type"; 487 case DW_TAG_with_stmt: return "DW_TAG_with_stmt"; 488 case DW_TAG_access_declaration: return "DW_TAG_access_declaration"; 489 case DW_TAG_base_type: return "DW_TAG_base_type"; 490 case DW_TAG_catch_block: return "DW_TAG_catch_block"; 491 case DW_TAG_const_type: return "DW_TAG_const_type"; 492 case DW_TAG_constant: return "DW_TAG_constant"; 493 case DW_TAG_enumerator: return "DW_TAG_enumerator"; 494 case DW_TAG_file_type: return "DW_TAG_file_type"; 495 case DW_TAG_friend: return "DW_TAG_friend"; 496 case DW_TAG_namelist: return "DW_TAG_namelist"; 497 case DW_TAG_namelist_item: return "DW_TAG_namelist_item"; 498 case DW_TAG_packed_type: return "DW_TAG_packed_type"; 499 case DW_TAG_subprogram: return "DW_TAG_subprogram"; 500 case DW_TAG_template_type_param: return "DW_TAG_template_type_param"; 501 case DW_TAG_template_value_param: return "DW_TAG_template_value_param"; 502 case DW_TAG_thrown_type: return "DW_TAG_thrown_type"; 503 case DW_TAG_try_block: return "DW_TAG_try_block"; 504 case DW_TAG_variant_part: return "DW_TAG_variant_part"; 505 case DW_TAG_variable: return "DW_TAG_variable"; 506 case DW_TAG_volatile_type: return "DW_TAG_volatile_type"; 507 case DW_TAG_MIPS_loop: return "DW_TAG_MIPS_loop"; 508 case DW_TAG_format_label: return "DW_TAG_format_label"; 509 case DW_TAG_function_template: return "DW_TAG_function_template"; 510 case DW_TAG_class_template: return "DW_TAG_class_template"; 511 /* DWARF 2.1 values. */ 512 case DW_TAG_dwarf_procedure: return "DW_TAG_dwarf_procedure"; 513 case DW_TAG_restrict_type: return "DW_TAG_restrict_type"; 514 case DW_TAG_interface_type: return "DW_TAG_interface_type"; 515 case DW_TAG_namespace: return "DW_TAG_namespace"; 516 case DW_TAG_imported_module: return "DW_TAG_imported_module"; 517 case DW_TAG_unspecified_type: return "DW_TAG_unspecified_type"; 518 case DW_TAG_partial_unit: return "DW_TAG_partial_unit"; 519 case DW_TAG_imported_unit: return "DW_TAG_imported_unit"; 520 /* UPC values. */ 521 case DW_TAG_upc_shared_type: return "DW_TAG_upc_shared_type"; 522 case DW_TAG_upc_strict_type: return "DW_TAG_upc_strict_type"; 523 case DW_TAG_upc_relaxed_type: return "DW_TAG_upc_relaxed_type"; 524 default: 525 { 526 static char buffer[100]; 527 528 snprintf (buffer, sizeof (buffer), _("Unknown TAG value: %lx"), tag); 529 return buffer; 530 } 531 } 532} 533 534static char * 535get_FORM_name (unsigned long form) 536{ 537 switch (form) 538 { 539 case DW_FORM_addr: return "DW_FORM_addr"; 540 case DW_FORM_block2: return "DW_FORM_block2"; 541 case DW_FORM_block4: return "DW_FORM_block4"; 542 case DW_FORM_data2: return "DW_FORM_data2"; 543 case DW_FORM_data4: return "DW_FORM_data4"; 544 case DW_FORM_data8: return "DW_FORM_data8"; 545 case DW_FORM_string: return "DW_FORM_string"; 546 case DW_FORM_block: return "DW_FORM_block"; 547 case DW_FORM_block1: return "DW_FORM_block1"; 548 case DW_FORM_data1: return "DW_FORM_data1"; 549 case DW_FORM_flag: return "DW_FORM_flag"; 550 case DW_FORM_sdata: return "DW_FORM_sdata"; 551 case DW_FORM_strp: return "DW_FORM_strp"; 552 case DW_FORM_udata: return "DW_FORM_udata"; 553 case DW_FORM_ref_addr: return "DW_FORM_ref_addr"; 554 case DW_FORM_ref1: return "DW_FORM_ref1"; 555 case DW_FORM_ref2: return "DW_FORM_ref2"; 556 case DW_FORM_ref4: return "DW_FORM_ref4"; 557 case DW_FORM_ref8: return "DW_FORM_ref8"; 558 case DW_FORM_ref_udata: return "DW_FORM_ref_udata"; 559 case DW_FORM_indirect: return "DW_FORM_indirect"; 560 case DW_FORM_flag_present: return "DW_FORM_flag_present"; 561 default: 562 { 563 static char buffer[100]; 564 565 snprintf (buffer, sizeof (buffer), _("Unknown FORM value: %lx"), form); 566 return buffer; 567 } 568 } 569} 570 571static unsigned char * 572display_block (unsigned char *data, unsigned long length) 573{ 574 printf (_(" %lu byte block: "), length); 575 576 while (length --) 577 printf ("%lx ", (unsigned long) byte_get (data++, 1)); 578 579 return data; 580} 581 582static int 583decode_location_expression (unsigned char * data, 584 unsigned int pointer_size, 585 unsigned long length, 586 unsigned long cu_offset) 587{ 588 unsigned op; 589 unsigned int bytes_read; 590 unsigned long uvalue; 591 unsigned char *end = data + length; 592 int need_frame_base = 0; 593 594 while (data < end) 595 { 596 op = *data++; 597 598 switch (op) 599 { 600 case DW_OP_addr: 601 printf ("DW_OP_addr: %lx", 602 (unsigned long) byte_get (data, pointer_size)); 603 data += pointer_size; 604 break; 605 case DW_OP_deref: 606 printf ("DW_OP_deref"); 607 break; 608 case DW_OP_const1u: 609 printf ("DW_OP_const1u: %lu", (unsigned long) byte_get (data++, 1)); 610 break; 611 case DW_OP_const1s: 612 printf ("DW_OP_const1s: %ld", (long) byte_get_signed (data++, 1)); 613 break; 614 case DW_OP_const2u: 615 printf ("DW_OP_const2u: %lu", (unsigned long) byte_get (data, 2)); 616 data += 2; 617 break; 618 case DW_OP_const2s: 619 printf ("DW_OP_const2s: %ld", (long) byte_get_signed (data, 2)); 620 data += 2; 621 break; 622 case DW_OP_const4u: 623 printf ("DW_OP_const4u: %lu", (unsigned long) byte_get (data, 4)); 624 data += 4; 625 break; 626 case DW_OP_const4s: 627 printf ("DW_OP_const4s: %ld", (long) byte_get_signed (data, 4)); 628 data += 4; 629 break; 630 case DW_OP_const8u: 631 printf ("DW_OP_const8u: %lu %lu", (unsigned long) byte_get (data, 4), 632 (unsigned long) byte_get (data + 4, 4)); 633 data += 8; 634 break; 635 case DW_OP_const8s: 636 printf ("DW_OP_const8s: %ld %ld", (long) byte_get (data, 4), 637 (long) byte_get (data + 4, 4)); 638 data += 8; 639 break; 640 case DW_OP_constu: 641 printf ("DW_OP_constu: %lu", read_leb128 (data, &bytes_read, 0)); 642 data += bytes_read; 643 break; 644 case DW_OP_consts: 645 printf ("DW_OP_consts: %ld", read_leb128 (data, &bytes_read, 1)); 646 data += bytes_read; 647 break; 648 case DW_OP_dup: 649 printf ("DW_OP_dup"); 650 break; 651 case DW_OP_drop: 652 printf ("DW_OP_drop"); 653 break; 654 case DW_OP_over: 655 printf ("DW_OP_over"); 656 break; 657 case DW_OP_pick: 658 printf ("DW_OP_pick: %ld", (unsigned long) byte_get (data++, 1)); 659 break; 660 case DW_OP_swap: 661 printf ("DW_OP_swap"); 662 break; 663 case DW_OP_rot: 664 printf ("DW_OP_rot"); 665 break; 666 case DW_OP_xderef: 667 printf ("DW_OP_xderef"); 668 break; 669 case DW_OP_abs: 670 printf ("DW_OP_abs"); 671 break; 672 case DW_OP_and: 673 printf ("DW_OP_and"); 674 break; 675 case DW_OP_div: 676 printf ("DW_OP_div"); 677 break; 678 case DW_OP_minus: 679 printf ("DW_OP_minus"); 680 break; 681 case DW_OP_mod: 682 printf ("DW_OP_mod"); 683 break; 684 case DW_OP_mul: 685 printf ("DW_OP_mul"); 686 break; 687 case DW_OP_neg: 688 printf ("DW_OP_neg"); 689 break; 690 case DW_OP_not: 691 printf ("DW_OP_not"); 692 break; 693 case DW_OP_or: 694 printf ("DW_OP_or"); 695 break; 696 case DW_OP_plus: 697 printf ("DW_OP_plus"); 698 break; 699 case DW_OP_plus_uconst: 700 printf ("DW_OP_plus_uconst: %lu", 701 read_leb128 (data, &bytes_read, 0)); 702 data += bytes_read; 703 break; 704 case DW_OP_shl: 705 printf ("DW_OP_shl"); 706 break; 707 case DW_OP_shr: 708 printf ("DW_OP_shr"); 709 break; 710 case DW_OP_shra: 711 printf ("DW_OP_shra"); 712 break; 713 case DW_OP_xor: 714 printf ("DW_OP_xor"); 715 break; 716 case DW_OP_bra: 717 printf ("DW_OP_bra: %ld", (long) byte_get_signed (data, 2)); 718 data += 2; 719 break; 720 case DW_OP_eq: 721 printf ("DW_OP_eq"); 722 break; 723 case DW_OP_ge: 724 printf ("DW_OP_ge"); 725 break; 726 case DW_OP_gt: 727 printf ("DW_OP_gt"); 728 break; 729 case DW_OP_le: 730 printf ("DW_OP_le"); 731 break; 732 case DW_OP_lt: 733 printf ("DW_OP_lt"); 734 break; 735 case DW_OP_ne: 736 printf ("DW_OP_ne"); 737 break; 738 case DW_OP_skip: 739 printf ("DW_OP_skip: %ld", (long) byte_get_signed (data, 2)); 740 data += 2; 741 break; 742 743 case DW_OP_lit0: 744 case DW_OP_lit1: 745 case DW_OP_lit2: 746 case DW_OP_lit3: 747 case DW_OP_lit4: 748 case DW_OP_lit5: 749 case DW_OP_lit6: 750 case DW_OP_lit7: 751 case DW_OP_lit8: 752 case DW_OP_lit9: 753 case DW_OP_lit10: 754 case DW_OP_lit11: 755 case DW_OP_lit12: 756 case DW_OP_lit13: 757 case DW_OP_lit14: 758 case DW_OP_lit15: 759 case DW_OP_lit16: 760 case DW_OP_lit17: 761 case DW_OP_lit18: 762 case DW_OP_lit19: 763 case DW_OP_lit20: 764 case DW_OP_lit21: 765 case DW_OP_lit22: 766 case DW_OP_lit23: 767 case DW_OP_lit24: 768 case DW_OP_lit25: 769 case DW_OP_lit26: 770 case DW_OP_lit27: 771 case DW_OP_lit28: 772 case DW_OP_lit29: 773 case DW_OP_lit30: 774 case DW_OP_lit31: 775 printf ("DW_OP_lit%d", op - DW_OP_lit0); 776 break; 777 778 case DW_OP_reg0: 779 case DW_OP_reg1: 780 case DW_OP_reg2: 781 case DW_OP_reg3: 782 case DW_OP_reg4: 783 case DW_OP_reg5: 784 case DW_OP_reg6: 785 case DW_OP_reg7: 786 case DW_OP_reg8: 787 case DW_OP_reg9: 788 case DW_OP_reg10: 789 case DW_OP_reg11: 790 case DW_OP_reg12: 791 case DW_OP_reg13: 792 case DW_OP_reg14: 793 case DW_OP_reg15: 794 case DW_OP_reg16: 795 case DW_OP_reg17: 796 case DW_OP_reg18: 797 case DW_OP_reg19: 798 case DW_OP_reg20: 799 case DW_OP_reg21: 800 case DW_OP_reg22: 801 case DW_OP_reg23: 802 case DW_OP_reg24: 803 case DW_OP_reg25: 804 case DW_OP_reg26: 805 case DW_OP_reg27: 806 case DW_OP_reg28: 807 case DW_OP_reg29: 808 case DW_OP_reg30: 809 case DW_OP_reg31: 810 printf ("DW_OP_reg%d", op - DW_OP_reg0); 811 break; 812 813 case DW_OP_breg0: 814 case DW_OP_breg1: 815 case DW_OP_breg2: 816 case DW_OP_breg3: 817 case DW_OP_breg4: 818 case DW_OP_breg5: 819 case DW_OP_breg6: 820 case DW_OP_breg7: 821 case DW_OP_breg8: 822 case DW_OP_breg9: 823 case DW_OP_breg10: 824 case DW_OP_breg11: 825 case DW_OP_breg12: 826 case DW_OP_breg13: 827 case DW_OP_breg14: 828 case DW_OP_breg15: 829 case DW_OP_breg16: 830 case DW_OP_breg17: 831 case DW_OP_breg18: 832 case DW_OP_breg19: 833 case DW_OP_breg20: 834 case DW_OP_breg21: 835 case DW_OP_breg22: 836 case DW_OP_breg23: 837 case DW_OP_breg24: 838 case DW_OP_breg25: 839 case DW_OP_breg26: 840 case DW_OP_breg27: 841 case DW_OP_breg28: 842 case DW_OP_breg29: 843 case DW_OP_breg30: 844 case DW_OP_breg31: 845 printf ("DW_OP_breg%d: %ld", op - DW_OP_breg0, 846 read_leb128 (data, &bytes_read, 1)); 847 data += bytes_read; 848 break; 849 850 case DW_OP_regx: 851 printf ("DW_OP_regx: %lu", read_leb128 (data, &bytes_read, 0)); 852 data += bytes_read; 853 break; 854 case DW_OP_fbreg: 855 need_frame_base = 1; 856 printf ("DW_OP_fbreg: %ld", read_leb128 (data, &bytes_read, 1)); 857 data += bytes_read; 858 break; 859 case DW_OP_bregx: 860 uvalue = read_leb128 (data, &bytes_read, 0); 861 data += bytes_read; 862 printf ("DW_OP_bregx: %lu %ld", uvalue, 863 read_leb128 (data, &bytes_read, 1)); 864 data += bytes_read; 865 break; 866 case DW_OP_piece: 867 printf ("DW_OP_piece: %lu", read_leb128 (data, &bytes_read, 0)); 868 data += bytes_read; 869 break; 870 case DW_OP_deref_size: 871 printf ("DW_OP_deref_size: %ld", (long) byte_get (data++, 1)); 872 break; 873 case DW_OP_xderef_size: 874 printf ("DW_OP_xderef_size: %ld", (long) byte_get (data++, 1)); 875 break; 876 case DW_OP_nop: 877 printf ("DW_OP_nop"); 878 break; 879 880 /* DWARF 3 extensions. */ 881 case DW_OP_push_object_address: 882 printf ("DW_OP_push_object_address"); 883 break; 884 case DW_OP_call2: 885 /* XXX: Strictly speaking for 64-bit DWARF3 files 886 this ought to be an 8-byte wide computation. */ 887 printf ("DW_OP_call2: <%lx>", (long) byte_get (data, 2) + cu_offset); 888 data += 2; 889 break; 890 case DW_OP_call4: 891 /* XXX: Strictly speaking for 64-bit DWARF3 files 892 this ought to be an 8-byte wide computation. */ 893 printf ("DW_OP_call4: <%lx>", (long) byte_get (data, 4) + cu_offset); 894 data += 4; 895 break; 896 case DW_OP_call_ref: 897 printf ("DW_OP_call_ref"); 898 break; 899 case DW_OP_form_tls_address: 900 printf ("DW_OP_form_tls_address"); 901 break; 902 903 /* GNU extensions. */ 904 case DW_OP_GNU_push_tls_address: 905 printf ("DW_OP_GNU_push_tls_address"); 906 break; 907 908 default: 909 if (op >= DW_OP_lo_user 910 && op <= DW_OP_hi_user) 911 printf (_("(User defined location op)")); 912 else 913 printf (_("(Unknown location op)")); 914 /* No way to tell where the next op is, so just bail. */ 915 return need_frame_base; 916 } 917 918 /* Separate the ops. */ 919 if (data < end) 920 printf ("; "); 921 } 922 923 return need_frame_base; 924} 925 926static unsigned char * 927read_and_display_attr_value (unsigned long attribute, 928 unsigned long form, 929 unsigned char *data, 930 unsigned long cu_offset, 931 unsigned long pointer_size, 932 unsigned long offset_size, 933 int dwarf_version, 934 debug_info *debug_info_p, 935 int do_loc) 936{ 937 unsigned long uvalue = 0; 938 unsigned char *block_start = NULL; 939 unsigned int bytes_read; 940 941 switch (form) 942 { 943 default: 944 break; 945 946 case DW_FORM_ref_addr: 947 if (dwarf_version == 2) 948 { 949 uvalue = byte_get (data, pointer_size); 950 data += pointer_size; 951 } 952 else if (dwarf_version == 3) 953 { 954 uvalue = byte_get (data, offset_size); 955 data += offset_size; 956 } 957 else 958 { 959 error (_("Internal error: DWARF version is not 2 or 3.\n")); 960 } 961 break; 962 963 case DW_FORM_addr: 964 uvalue = byte_get (data, pointer_size); 965 data += pointer_size; 966 break; 967 968 case DW_FORM_strp: 969 uvalue = byte_get (data, offset_size); 970 data += offset_size; 971 break; 972 973 case DW_FORM_flag_present: 974 uvalue = 1; 975 break; 976 977 case DW_FORM_ref1: 978 case DW_FORM_flag: 979 case DW_FORM_data1: 980 uvalue = byte_get (data++, 1); 981 break; 982 983 case DW_FORM_ref2: 984 case DW_FORM_data2: 985 uvalue = byte_get (data, 2); 986 data += 2; 987 break; 988 989 case DW_FORM_ref4: 990 case DW_FORM_data4: 991 uvalue = byte_get (data, 4); 992 data += 4; 993 break; 994 995 case DW_FORM_sdata: 996 uvalue = read_leb128 (data, & bytes_read, 1); 997 data += bytes_read; 998 break; 999 1000 case DW_FORM_ref_udata: 1001 case DW_FORM_udata: 1002 uvalue = read_leb128 (data, & bytes_read, 0); 1003 data += bytes_read; 1004 break; 1005 1006 case DW_FORM_indirect: 1007 form = read_leb128 (data, & bytes_read, 0); 1008 data += bytes_read; 1009 if (!do_loc) 1010 printf (" %s", get_FORM_name (form)); 1011 return read_and_display_attr_value (attribute, form, data, 1012 cu_offset, pointer_size, 1013 offset_size, dwarf_version, 1014 debug_info_p, do_loc); 1015 } 1016 1017 switch (form) 1018 { 1019 case DW_FORM_ref_addr: 1020 if (!do_loc) 1021 printf (" <#%lx>", uvalue); 1022 break; 1023 1024 case DW_FORM_ref1: 1025 case DW_FORM_ref2: 1026 case DW_FORM_ref4: 1027 case DW_FORM_ref_udata: 1028 if (!do_loc) 1029 printf (" <%lx>", uvalue + cu_offset); 1030 break; 1031 1032 case DW_FORM_data4: 1033 case DW_FORM_addr: 1034 if (!do_loc) 1035 printf (" %#lx", uvalue); 1036 break; 1037 1038 case DW_FORM_flag_present: 1039 case DW_FORM_flag: 1040 case DW_FORM_data1: 1041 case DW_FORM_data2: 1042 case DW_FORM_sdata: 1043 case DW_FORM_udata: 1044 if (!do_loc) 1045 printf (" %ld", uvalue); 1046 break; 1047 1048 case DW_FORM_ref8: 1049 case DW_FORM_data8: 1050 if (!do_loc) 1051 { 1052 uvalue = byte_get (data, 4); 1053 printf (" %lx", uvalue); 1054 printf (" %lx", (unsigned long) byte_get (data + 4, 4)); 1055 } 1056 if ((do_loc || do_debug_loc || do_debug_ranges) 1057 && num_debug_info_entries == 0) 1058 { 1059 if (sizeof (uvalue) == 8) 1060 uvalue = byte_get (data, 8); 1061 else 1062 error (_("DW_FORM_data8 is unsupported when sizeof (unsigned long) != 8\n")); 1063 } 1064 data += 8; 1065 break; 1066 1067 case DW_FORM_string: 1068 if (!do_loc) 1069 printf (" %s", data); 1070 data += strlen ((char *) data) + 1; 1071 break; 1072 1073 case DW_FORM_block: 1074 uvalue = read_leb128 (data, & bytes_read, 0); 1075 block_start = data + bytes_read; 1076 if (do_loc) 1077 data = block_start + uvalue; 1078 else 1079 data = display_block (block_start, uvalue); 1080 break; 1081 1082 case DW_FORM_block1: 1083 uvalue = byte_get (data, 1); 1084 block_start = data + 1; 1085 if (do_loc) 1086 data = block_start + uvalue; 1087 else 1088 data = display_block (block_start, uvalue); 1089 break; 1090 1091 case DW_FORM_block2: 1092 uvalue = byte_get (data, 2); 1093 block_start = data + 2; 1094 if (do_loc) 1095 data = block_start + uvalue; 1096 else 1097 data = display_block (block_start, uvalue); 1098 break; 1099 1100 case DW_FORM_block4: 1101 uvalue = byte_get (data, 4); 1102 block_start = data + 4; 1103 if (do_loc) 1104 data = block_start + uvalue; 1105 else 1106 data = display_block (block_start, uvalue); 1107 break; 1108 1109 case DW_FORM_strp: 1110 if (!do_loc) 1111 printf (_(" (indirect string, offset: 0x%lx): %s"), 1112 uvalue, fetch_indirect_string (uvalue)); 1113 break; 1114 1115 case DW_FORM_indirect: 1116 /* Handled above. */ 1117 break; 1118 1119 default: 1120 warn (_("Unrecognized form: %lu\n"), form); 1121 break; 1122 } 1123 1124 /* For some attributes we can display further information. */ 1125 if ((do_loc || do_debug_loc || do_debug_ranges) 1126 && num_debug_info_entries == 0) 1127 { 1128 switch (attribute) 1129 { 1130 case DW_AT_frame_base: 1131 have_frame_base = 1; 1132 case DW_AT_location: 1133 case DW_AT_data_member_location: 1134 case DW_AT_vtable_elem_location: 1135 case DW_AT_allocated: 1136 case DW_AT_associated: 1137 case DW_AT_data_location: 1138 case DW_AT_stride: 1139 case DW_AT_upper_bound: 1140 case DW_AT_lower_bound: 1141 if (form == DW_FORM_data4 || form == DW_FORM_data8) 1142 { 1143 /* Process location list. */ 1144 unsigned int max = debug_info_p->max_loc_offsets; 1145 unsigned int num = debug_info_p->num_loc_offsets; 1146 1147 if (max == 0 || num >= max) 1148 { 1149 max += 1024; 1150 debug_info_p->loc_offsets 1151 = xcrealloc (debug_info_p->loc_offsets, 1152 max, sizeof (*debug_info_p->loc_offsets)); 1153 debug_info_p->have_frame_base 1154 = xcrealloc (debug_info_p->have_frame_base, 1155 max, sizeof (*debug_info_p->have_frame_base)); 1156 debug_info_p->max_loc_offsets = max; 1157 } 1158 debug_info_p->loc_offsets [num] = uvalue; 1159 debug_info_p->have_frame_base [num] = have_frame_base; 1160 debug_info_p->num_loc_offsets++; 1161 } 1162 break; 1163 1164 case DW_AT_low_pc: 1165 if (need_base_address) 1166 debug_info_p->base_address = uvalue; 1167 break; 1168 1169 case DW_AT_ranges: 1170 if (form == DW_FORM_data4 || form == DW_FORM_data8) 1171 { 1172 /* Process range list. */ 1173 unsigned int max = debug_info_p->max_range_lists; 1174 unsigned int num = debug_info_p->num_range_lists; 1175 1176 if (max == 0 || num >= max) 1177 { 1178 max += 1024; 1179 debug_info_p->range_lists 1180 = xcrealloc (debug_info_p->range_lists, 1181 max, sizeof (*debug_info_p->range_lists)); 1182 debug_info_p->max_range_lists = max; 1183 } 1184 debug_info_p->range_lists [num] = uvalue; 1185 debug_info_p->num_range_lists++; 1186 } 1187 break; 1188 1189 default: 1190 break; 1191 } 1192 } 1193 1194 if (do_loc) 1195 return data; 1196 1197 printf ("\t"); 1198 1199 switch (attribute) 1200 { 1201 case DW_AT_inline: 1202 switch (uvalue) 1203 { 1204 case DW_INL_not_inlined: 1205 printf (_("(not inlined)")); 1206 break; 1207 case DW_INL_inlined: 1208 printf (_("(inlined)")); 1209 break; 1210 case DW_INL_declared_not_inlined: 1211 printf (_("(declared as inline but ignored)")); 1212 break; 1213 case DW_INL_declared_inlined: 1214 printf (_("(declared as inline and inlined)")); 1215 break; 1216 default: 1217 printf (_(" (Unknown inline attribute value: %lx)"), uvalue); 1218 break; 1219 } 1220 break; 1221 1222 case DW_AT_language: 1223 switch (uvalue) 1224 { 1225 /* Ordered by the numeric value of these constants. */ 1226 case DW_LANG_C89: printf ("(ANSI C)"); break; 1227 case DW_LANG_C: printf ("(non-ANSI C)"); break; 1228 case DW_LANG_Ada83: printf ("(Ada)"); break; 1229 case DW_LANG_C_plus_plus: printf ("(C++)"); break; 1230 case DW_LANG_Cobol74: printf ("(Cobol 74)"); break; 1231 case DW_LANG_Cobol85: printf ("(Cobol 85)"); break; 1232 case DW_LANG_Fortran77: printf ("(FORTRAN 77)"); break; 1233 case DW_LANG_Fortran90: printf ("(Fortran 90)"); break; 1234 case DW_LANG_Pascal83: printf ("(ANSI Pascal)"); break; 1235 case DW_LANG_Modula2: printf ("(Modula 2)"); break; 1236 /* DWARF 2.1 values. */ 1237 case DW_LANG_Java: printf ("(Java)"); break; 1238 case DW_LANG_C99: printf ("(ANSI C99)"); break; 1239 case DW_LANG_Ada95: printf ("(ADA 95)"); break; 1240 case DW_LANG_Fortran95: printf ("(Fortran 95)"); break; 1241 /* DWARF 3 values. */ 1242 case DW_LANG_PLI: printf ("(PLI)"); break; 1243 case DW_LANG_ObjC: printf ("(Objective C)"); break; 1244 case DW_LANG_ObjC_plus_plus: printf ("(Objective C++)"); break; 1245 case DW_LANG_UPC: printf ("(Unified Parallel C)"); break; 1246 case DW_LANG_D: printf ("(D)"); break; 1247 /* MIPS extension. */ 1248 case DW_LANG_Mips_Assembler: printf ("(MIPS assembler)"); break; 1249 /* UPC extension. */ 1250 case DW_LANG_Upc: printf ("(Unified Parallel C)"); break; 1251 default: 1252 if (uvalue >= DW_LANG_lo_user && uvalue <= DW_LANG_hi_user) 1253 printf ("(implementation defined: %lx)", uvalue); 1254 else 1255 printf ("(Unknown: %lx)", uvalue); 1256 break; 1257 } 1258 break; 1259 1260 case DW_AT_encoding: 1261 switch (uvalue) 1262 { 1263 case DW_ATE_void: printf ("(void)"); break; 1264 case DW_ATE_address: printf ("(machine address)"); break; 1265 case DW_ATE_boolean: printf ("(boolean)"); break; 1266 case DW_ATE_complex_float: printf ("(complex float)"); break; 1267 case DW_ATE_float: printf ("(float)"); break; 1268 case DW_ATE_signed: printf ("(signed)"); break; 1269 case DW_ATE_signed_char: printf ("(signed char)"); break; 1270 case DW_ATE_unsigned: printf ("(unsigned)"); break; 1271 case DW_ATE_unsigned_char: printf ("(unsigned char)"); break; 1272 /* DWARF 2.1 value. */ 1273 case DW_ATE_imaginary_float: printf ("(imaginary float)"); break; 1274 case DW_ATE_decimal_float: printf ("(decimal float)"); break; 1275 default: 1276 if (uvalue >= DW_ATE_lo_user 1277 && uvalue <= DW_ATE_hi_user) 1278 printf ("(user defined type)"); 1279 else 1280 printf ("(unknown type)"); 1281 break; 1282 } 1283 break; 1284 1285 case DW_AT_accessibility: 1286 switch (uvalue) 1287 { 1288 case DW_ACCESS_public: printf ("(public)"); break; 1289 case DW_ACCESS_protected: printf ("(protected)"); break; 1290 case DW_ACCESS_private: printf ("(private)"); break; 1291 default: 1292 printf ("(unknown accessibility)"); 1293 break; 1294 } 1295 break; 1296 1297 case DW_AT_visibility: 1298 switch (uvalue) 1299 { 1300 case DW_VIS_local: printf ("(local)"); break; 1301 case DW_VIS_exported: printf ("(exported)"); break; 1302 case DW_VIS_qualified: printf ("(qualified)"); break; 1303 default: printf ("(unknown visibility)"); break; 1304 } 1305 break; 1306 1307 case DW_AT_virtuality: 1308 switch (uvalue) 1309 { 1310 case DW_VIRTUALITY_none: printf ("(none)"); break; 1311 case DW_VIRTUALITY_virtual: printf ("(virtual)"); break; 1312 case DW_VIRTUALITY_pure_virtual:printf ("(pure_virtual)"); break; 1313 default: printf ("(unknown virtuality)"); break; 1314 } 1315 break; 1316 1317 case DW_AT_identifier_case: 1318 switch (uvalue) 1319 { 1320 case DW_ID_case_sensitive: printf ("(case_sensitive)"); break; 1321 case DW_ID_up_case: printf ("(up_case)"); break; 1322 case DW_ID_down_case: printf ("(down_case)"); break; 1323 case DW_ID_case_insensitive: printf ("(case_insensitive)"); break; 1324 default: printf ("(unknown case)"); break; 1325 } 1326 break; 1327 1328 case DW_AT_calling_convention: 1329 switch (uvalue) 1330 { 1331 case DW_CC_normal: printf ("(normal)"); break; 1332 case DW_CC_program: printf ("(program)"); break; 1333 case DW_CC_nocall: printf ("(nocall)"); break; 1334 default: 1335 if (uvalue >= DW_CC_lo_user 1336 && uvalue <= DW_CC_hi_user) 1337 printf ("(user defined)"); 1338 else 1339 printf ("(unknown convention)"); 1340 } 1341 break; 1342 1343 case DW_AT_ordering: 1344 switch (uvalue) 1345 { 1346 case -1: printf ("(undefined)"); break; 1347 case 0: printf ("(row major)"); break; 1348 case 1: printf ("(column major)"); break; 1349 } 1350 break; 1351 1352 case DW_AT_frame_base: 1353 have_frame_base = 1; 1354 case DW_AT_location: 1355 case DW_AT_data_member_location: 1356 case DW_AT_vtable_elem_location: 1357 case DW_AT_allocated: 1358 case DW_AT_associated: 1359 case DW_AT_data_location: 1360 case DW_AT_stride: 1361 case DW_AT_upper_bound: 1362 case DW_AT_lower_bound: 1363 if (block_start) 1364 { 1365 int need_frame_base; 1366 1367 printf ("("); 1368 need_frame_base = decode_location_expression (block_start, 1369 pointer_size, 1370 uvalue, 1371 cu_offset); 1372 printf (")"); 1373 if (need_frame_base && !have_frame_base) 1374 printf (_(" [without DW_AT_frame_base]")); 1375 } 1376 else if (form == DW_FORM_data4 || form == DW_FORM_data8) 1377 printf (_("(location list)")); 1378 1379 break; 1380 1381 default: 1382 break; 1383 } 1384 1385 return data; 1386} 1387 1388static char * 1389get_AT_name (unsigned long attribute) 1390{ 1391 switch (attribute) 1392 { 1393 case DW_AT_sibling: return "DW_AT_sibling"; 1394 case DW_AT_location: return "DW_AT_location"; 1395 case DW_AT_name: return "DW_AT_name"; 1396 case DW_AT_ordering: return "DW_AT_ordering"; 1397 case DW_AT_subscr_data: return "DW_AT_subscr_data"; 1398 case DW_AT_byte_size: return "DW_AT_byte_size"; 1399 case DW_AT_bit_offset: return "DW_AT_bit_offset"; 1400 case DW_AT_bit_size: return "DW_AT_bit_size"; 1401 case DW_AT_element_list: return "DW_AT_element_list"; 1402 case DW_AT_stmt_list: return "DW_AT_stmt_list"; 1403 case DW_AT_low_pc: return "DW_AT_low_pc"; 1404 case DW_AT_high_pc: return "DW_AT_high_pc"; 1405 case DW_AT_language: return "DW_AT_language"; 1406 case DW_AT_member: return "DW_AT_member"; 1407 case DW_AT_discr: return "DW_AT_discr"; 1408 case DW_AT_discr_value: return "DW_AT_discr_value"; 1409 case DW_AT_visibility: return "DW_AT_visibility"; 1410 case DW_AT_import: return "DW_AT_import"; 1411 case DW_AT_string_length: return "DW_AT_string_length"; 1412 case DW_AT_common_reference: return "DW_AT_common_reference"; 1413 case DW_AT_comp_dir: return "DW_AT_comp_dir"; 1414 case DW_AT_const_value: return "DW_AT_const_value"; 1415 case DW_AT_containing_type: return "DW_AT_containing_type"; 1416 case DW_AT_default_value: return "DW_AT_default_value"; 1417 case DW_AT_inline: return "DW_AT_inline"; 1418 case DW_AT_is_optional: return "DW_AT_is_optional"; 1419 case DW_AT_lower_bound: return "DW_AT_lower_bound"; 1420 case DW_AT_producer: return "DW_AT_producer"; 1421 case DW_AT_prototyped: return "DW_AT_prototyped"; 1422 case DW_AT_return_addr: return "DW_AT_return_addr"; 1423 case DW_AT_start_scope: return "DW_AT_start_scope"; 1424 case DW_AT_stride_size: return "DW_AT_stride_size"; 1425 case DW_AT_upper_bound: return "DW_AT_upper_bound"; 1426 case DW_AT_abstract_origin: return "DW_AT_abstract_origin"; 1427 case DW_AT_accessibility: return "DW_AT_accessibility"; 1428 case DW_AT_address_class: return "DW_AT_address_class"; 1429 case DW_AT_artificial: return "DW_AT_artificial"; 1430 case DW_AT_base_types: return "DW_AT_base_types"; 1431 case DW_AT_calling_convention: return "DW_AT_calling_convention"; 1432 case DW_AT_count: return "DW_AT_count"; 1433 case DW_AT_data_member_location: return "DW_AT_data_member_location"; 1434 case DW_AT_decl_column: return "DW_AT_decl_column"; 1435 case DW_AT_decl_file: return "DW_AT_decl_file"; 1436 case DW_AT_decl_line: return "DW_AT_decl_line"; 1437 case DW_AT_declaration: return "DW_AT_declaration"; 1438 case DW_AT_discr_list: return "DW_AT_discr_list"; 1439 case DW_AT_encoding: return "DW_AT_encoding"; 1440 case DW_AT_external: return "DW_AT_external"; 1441 case DW_AT_frame_base: return "DW_AT_frame_base"; 1442 case DW_AT_friend: return "DW_AT_friend"; 1443 case DW_AT_identifier_case: return "DW_AT_identifier_case"; 1444 case DW_AT_macro_info: return "DW_AT_macro_info"; 1445 case DW_AT_namelist_items: return "DW_AT_namelist_items"; 1446 case DW_AT_priority: return "DW_AT_priority"; 1447 case DW_AT_segment: return "DW_AT_segment"; 1448 case DW_AT_specification: return "DW_AT_specification"; 1449 case DW_AT_static_link: return "DW_AT_static_link"; 1450 case DW_AT_type: return "DW_AT_type"; 1451 case DW_AT_use_location: return "DW_AT_use_location"; 1452 case DW_AT_variable_parameter: return "DW_AT_variable_parameter"; 1453 case DW_AT_virtuality: return "DW_AT_virtuality"; 1454 case DW_AT_vtable_elem_location: return "DW_AT_vtable_elem_location"; 1455 /* DWARF 2.1 values. */ 1456 case DW_AT_allocated: return "DW_AT_allocated"; 1457 case DW_AT_associated: return "DW_AT_associated"; 1458 case DW_AT_data_location: return "DW_AT_data_location"; 1459 case DW_AT_stride: return "DW_AT_stride"; 1460 case DW_AT_entry_pc: return "DW_AT_entry_pc"; 1461 case DW_AT_use_UTF8: return "DW_AT_use_UTF8"; 1462 case DW_AT_extension: return "DW_AT_extension"; 1463 case DW_AT_ranges: return "DW_AT_ranges"; 1464 case DW_AT_trampoline: return "DW_AT_trampoline"; 1465 case DW_AT_call_column: return "DW_AT_call_column"; 1466 case DW_AT_call_file: return "DW_AT_call_file"; 1467 case DW_AT_call_line: return "DW_AT_call_line"; 1468 /* SGI/MIPS extensions. */ 1469 case DW_AT_MIPS_fde: return "DW_AT_MIPS_fde"; 1470 case DW_AT_MIPS_loop_begin: return "DW_AT_MIPS_loop_begin"; 1471 case DW_AT_MIPS_tail_loop_begin: return "DW_AT_MIPS_tail_loop_begin"; 1472 case DW_AT_MIPS_epilog_begin: return "DW_AT_MIPS_epilog_begin"; 1473 case DW_AT_MIPS_loop_unroll_factor: return "DW_AT_MIPS_loop_unroll_factor"; 1474 case DW_AT_MIPS_software_pipeline_depth: 1475 return "DW_AT_MIPS_software_pipeline_depth"; 1476 case DW_AT_MIPS_linkage_name: return "DW_AT_MIPS_linkage_name"; 1477 case DW_AT_MIPS_stride: return "DW_AT_MIPS_stride"; 1478 case DW_AT_MIPS_abstract_name: return "DW_AT_MIPS_abstract_name"; 1479 case DW_AT_MIPS_clone_origin: return "DW_AT_MIPS_clone_origin"; 1480 case DW_AT_MIPS_has_inlines: return "DW_AT_MIPS_has_inlines"; 1481 /* GNU extensions. */ 1482 case DW_AT_sf_names: return "DW_AT_sf_names"; 1483 case DW_AT_src_info: return "DW_AT_src_info"; 1484 case DW_AT_mac_info: return "DW_AT_mac_info"; 1485 case DW_AT_src_coords: return "DW_AT_src_coords"; 1486 case DW_AT_body_begin: return "DW_AT_body_begin"; 1487 case DW_AT_body_end: return "DW_AT_body_end"; 1488 case DW_AT_GNU_vector: return "DW_AT_GNU_vector"; 1489 /* UPC extension. */ 1490 case DW_AT_upc_threads_scaled: return "DW_AT_upc_threads_scaled"; 1491 default: 1492 { 1493 static char buffer[100]; 1494 1495 snprintf (buffer, sizeof (buffer), _("Unknown AT value: %lx"), 1496 attribute); 1497 return buffer; 1498 } 1499 } 1500} 1501 1502static unsigned char * 1503read_and_display_attr (unsigned long attribute, 1504 unsigned long form, 1505 unsigned char *data, 1506 unsigned long cu_offset, 1507 unsigned long pointer_size, 1508 unsigned long offset_size, 1509 int dwarf_version, 1510 debug_info *debug_info_p, 1511 int do_loc) 1512{ 1513 if (!do_loc) 1514 printf (" %-18s:", get_AT_name (attribute)); 1515 data = read_and_display_attr_value (attribute, form, data, cu_offset, 1516 pointer_size, offset_size, 1517 dwarf_version, debug_info_p, 1518 do_loc); 1519 if (!do_loc) 1520 printf ("\n"); 1521 return data; 1522} 1523 1524 1525/* Process the contents of a .debug_info section. If do_loc is non-zero 1526 then we are scanning for location lists and we do not want to display 1527 anything to the user. */ 1528 1529static int 1530process_debug_info (struct dwarf_section *section, void *file, 1531 int do_loc) 1532{ 1533 unsigned char *start = section->start; 1534 unsigned char *end = start + section->size; 1535 unsigned char *section_begin; 1536 unsigned int unit; 1537 unsigned int num_units = 0; 1538 1539 if ((do_loc || do_debug_loc || do_debug_ranges) 1540 && num_debug_info_entries == 0) 1541 { 1542 unsigned long length; 1543 1544 /* First scan the section to get the number of comp units. */ 1545 for (section_begin = start, num_units = 0; section_begin < end; 1546 num_units ++) 1547 { 1548 /* Read the first 4 bytes. For a 32-bit DWARF section, this 1549 will be the length. For a 64-bit DWARF section, it'll be 1550 the escape code 0xffffffff followed by an 8 byte length. */ 1551 length = byte_get (section_begin, 4); 1552 1553 if (length == 0xffffffff) 1554 { 1555 length = byte_get (section_begin + 4, 8); 1556 section_begin += length + 12; 1557 } 1558 else 1559 section_begin += length + 4; 1560 } 1561 1562 if (num_units == 0) 1563 { 1564 error (_("No comp units in %s section ?"), section->name); 1565 return 0; 1566 } 1567 1568 /* Then allocate an array to hold the information. */ 1569 debug_information = cmalloc (num_units, 1570 sizeof (* debug_information)); 1571 if (debug_information == NULL) 1572 { 1573 error (_("Not enough memory for a debug info array of %u entries"), 1574 num_units); 1575 return 0; 1576 } 1577 } 1578 1579 if (!do_loc) 1580 { 1581 printf (_("The section %s contains:\n\n"), section->name); 1582 1583 load_debug_section (str, file); 1584 } 1585 1586 load_debug_section (abbrev, file); 1587 if (debug_displays [abbrev].section.start == NULL) 1588 { 1589 warn (_("Unable to locate %s section!\n"), 1590 debug_displays [abbrev].section.name); 1591 return 0; 1592 } 1593 1594 for (section_begin = start, unit = 0; start < end; unit++) 1595 { 1596 DWARF2_Internal_CompUnit compunit; 1597 unsigned char *hdrptr; 1598 unsigned char *cu_abbrev_offset_ptr; 1599 unsigned char *tags; 1600 int level; 1601 unsigned long cu_offset; 1602 int offset_size; 1603 int initial_length_size; 1604 1605 hdrptr = start; 1606 1607 compunit.cu_length = byte_get (hdrptr, 4); 1608 hdrptr += 4; 1609 1610 if (compunit.cu_length == 0xffffffff) 1611 { 1612 compunit.cu_length = byte_get (hdrptr, 8); 1613 hdrptr += 8; 1614 offset_size = 8; 1615 initial_length_size = 12; 1616 } 1617 else 1618 { 1619 offset_size = 4; 1620 initial_length_size = 4; 1621 } 1622 1623 compunit.cu_version = byte_get (hdrptr, 2); 1624 hdrptr += 2; 1625 1626 cu_offset = start - section_begin; 1627 1628 cu_abbrev_offset_ptr = hdrptr; 1629 compunit.cu_abbrev_offset = byte_get (hdrptr, offset_size); 1630 hdrptr += offset_size; 1631 1632 compunit.cu_pointer_size = byte_get (hdrptr, 1); 1633 hdrptr += 1; 1634 if ((do_loc || do_debug_loc || do_debug_ranges) 1635 && num_debug_info_entries == 0) 1636 { 1637 debug_information [unit].cu_offset = cu_offset; 1638 debug_information [unit].pointer_size 1639 = compunit.cu_pointer_size; 1640 debug_information [unit].base_address = 0; 1641 debug_information [unit].loc_offsets = NULL; 1642 debug_information [unit].have_frame_base = NULL; 1643 debug_information [unit].max_loc_offsets = 0; 1644 debug_information [unit].num_loc_offsets = 0; 1645 debug_information [unit].range_lists = NULL; 1646 debug_information [unit].max_range_lists= 0; 1647 debug_information [unit].num_range_lists = 0; 1648 } 1649 1650 if (!do_loc) 1651 { 1652 printf (_(" Compilation Unit @ offset 0x%lx:\n"), cu_offset); 1653 printf (_(" Length: %ld\n"), compunit.cu_length); 1654 printf (_(" Version: %d\n"), compunit.cu_version); 1655 printf (_(" Abbrev Offset: %ld\n"), compunit.cu_abbrev_offset); 1656 printf (_(" Pointer Size: %d\n"), compunit.cu_pointer_size); 1657 } 1658 1659 if (cu_offset + compunit.cu_length + initial_length_size 1660 > section->size) 1661 { 1662 warn (_("Debug info is corrupted, length is invalid (section is %lu bytes)\n"), 1663 (unsigned long)section->size); 1664 break; 1665 } 1666 tags = hdrptr; 1667 start += compunit.cu_length + initial_length_size; 1668 1669 if (compunit.cu_version != 2 && compunit.cu_version != 3) 1670 { 1671 warn (_("Only version 2 and 3 DWARF debug information is currently supported.\n")); 1672 continue; 1673 } 1674 1675 free_abbrevs (); 1676 1677 /* Process the abbrevs used by this compilation unit. DWARF 1678 sections under Mach-O have non-zero addresses. */ 1679 if (compunit.cu_abbrev_offset >= debug_displays [abbrev].section.size) 1680 warn (_("Debug info is corrupted, abbrev offset is invalid (section is %lu bytes)\n"), 1681 (unsigned long)debug_displays [abbrev].section.size); 1682 else 1683 process_abbrev_section 1684 ((unsigned char *) debug_displays [abbrev].section.start 1685 + compunit.cu_abbrev_offset - debug_displays [abbrev].section.address, 1686 (unsigned char *) debug_displays [abbrev].section.start 1687 + debug_displays [abbrev].section.size); 1688 1689 level = 0; 1690 while (tags < start) 1691 { 1692 unsigned int bytes_read; 1693 unsigned long abbrev_number; 1694 abbrev_entry *entry; 1695 abbrev_attr *attr; 1696 1697 abbrev_number = read_leb128 (tags, & bytes_read, 0); 1698 tags += bytes_read; 1699 1700 /* A null DIE marks the end of a list of children. */ 1701 if (abbrev_number == 0) 1702 { 1703 --level; 1704 continue; 1705 } 1706 1707 if (!do_loc) 1708 printf (_(" <%d><%lx>: Abbrev Number: %lu"), 1709 level, 1710 (unsigned long) (tags - section_begin 1711 - bytes_read), 1712 abbrev_number); 1713 1714 /* Scan through the abbreviation list until we reach the 1715 correct entry. */ 1716 for (entry = first_abbrev; 1717 entry && entry->entry != abbrev_number; 1718 entry = entry->next) 1719 continue; 1720 1721 if (entry == NULL) 1722 { 1723 if (!do_loc) 1724 { 1725 printf ("\n"); 1726 fflush (stdout); 1727 } 1728 warn (_("Unable to locate entry %lu in the abbreviation table\n"), 1729 abbrev_number); 1730 return 0; 1731 } 1732 1733 if (!do_loc) 1734 printf (_(" (%s)\n"), get_TAG_name (entry->tag)); 1735 1736 switch (entry->tag) 1737 { 1738 default: 1739 need_base_address = 0; 1740 break; 1741 case DW_TAG_compile_unit: 1742 need_base_address = 1; 1743 break; 1744 case DW_TAG_entry_point: 1745 case DW_TAG_subprogram: 1746 need_base_address = 0; 1747 /* Assuming that there is no DW_AT_frame_base. */ 1748 have_frame_base = 0; 1749 break; 1750 } 1751 1752 for (attr = entry->first_attr; attr; attr = attr->next) 1753 { 1754 if (! do_loc) 1755 /* Show the offset from where the tag was extracted. */ 1756 printf (" <%2lx>", (unsigned long)(tags - section_begin)); 1757 1758 tags = read_and_display_attr (attr->attribute, 1759 attr->form, 1760 tags, cu_offset, 1761 compunit.cu_pointer_size, 1762 offset_size, 1763 compunit.cu_version, 1764 &debug_information [unit], 1765 do_loc); 1766 } 1767 1768 if (entry->children) 1769 ++level; 1770 } 1771 } 1772 1773 /* Set num_debug_info_entries here so that it can be used to check if 1774 we need to process .debug_loc and .debug_ranges sections. */ 1775 if ((do_loc || do_debug_loc || do_debug_ranges) 1776 && num_debug_info_entries == 0) 1777 num_debug_info_entries = num_units; 1778 1779 if (!do_loc) 1780 { 1781 printf ("\n"); 1782 } 1783 1784 return 1; 1785} 1786 1787/* Locate and scan the .debug_info section in the file and record the pointer 1788 sizes and offsets for the compilation units in it. Usually an executable 1789 will have just one pointer size, but this is not guaranteed, and so we try 1790 not to make any assumptions. Returns zero upon failure, or the number of 1791 compilation units upon success. */ 1792 1793static unsigned int 1794load_debug_info (void * file) 1795{ 1796 /* Reset the last pointer size so that we can issue correct error 1797 messages if we are displaying the contents of more than one section. */ 1798 last_pointer_size = 0; 1799 warned_about_missing_comp_units = FALSE; 1800 1801 /* If we already have the information there is nothing else to do. */ 1802 if (num_debug_info_entries > 0) 1803 return num_debug_info_entries; 1804 1805 if (load_debug_section (info, file) 1806 && process_debug_info (&debug_displays [info].section, file, 1)) 1807 return num_debug_info_entries; 1808 else 1809 return 0; 1810} 1811 1812static int 1813display_debug_lines (struct dwarf_section *section, void *file) 1814{ 1815 unsigned char *start = section->start; 1816 unsigned char *data = start; 1817 unsigned char *end = start + section->size; 1818 1819 printf (_("\nDump of debug contents of section %s:\n\n"), 1820 section->name); 1821 1822 load_debug_info (file); 1823 1824 while (data < end) 1825 { 1826 DWARF2_Internal_LineInfo info; 1827 unsigned char *standard_opcodes; 1828 unsigned char *end_of_sequence; 1829 unsigned char *hdrptr; 1830 int initial_length_size; 1831 int offset_size; 1832 int i; 1833 1834 hdrptr = data; 1835 1836 /* Check the length of the block. */ 1837 info.li_length = byte_get (hdrptr, 4); 1838 hdrptr += 4; 1839 1840 if (info.li_length == 0xffffffff) 1841 { 1842 /* This section is 64-bit DWARF 3. */ 1843 info.li_length = byte_get (hdrptr, 8); 1844 hdrptr += 8; 1845 offset_size = 8; 1846 initial_length_size = 12; 1847 } 1848 else 1849 { 1850 offset_size = 4; 1851 initial_length_size = 4; 1852 } 1853 1854 if (info.li_length + initial_length_size > section->size) 1855 { 1856 warn 1857 (_("The line info appears to be corrupt - the section is too small\n")); 1858 return 0; 1859 } 1860 1861 /* Check its version number. */ 1862 info.li_version = byte_get (hdrptr, 2); 1863 hdrptr += 2; 1864 if (info.li_version != 2 && info.li_version != 3) 1865 { 1866 warn (_("Only DWARF version 2 and 3 line info is currently supported.\n")); 1867 return 0; 1868 } 1869 1870 info.li_prologue_length = byte_get (hdrptr, offset_size); 1871 hdrptr += offset_size; 1872 info.li_min_insn_length = byte_get (hdrptr, 1); 1873 hdrptr++; 1874 info.li_default_is_stmt = byte_get (hdrptr, 1); 1875 hdrptr++; 1876 info.li_line_base = byte_get (hdrptr, 1); 1877 hdrptr++; 1878 info.li_line_range = byte_get (hdrptr, 1); 1879 hdrptr++; 1880 info.li_opcode_base = byte_get (hdrptr, 1); 1881 hdrptr++; 1882 1883 /* Sign extend the line base field. */ 1884 info.li_line_base <<= 24; 1885 info.li_line_base >>= 24; 1886 1887 printf (_(" Length: %ld\n"), info.li_length); 1888 printf (_(" DWARF Version: %d\n"), info.li_version); 1889 printf (_(" Prologue Length: %d\n"), info.li_prologue_length); 1890 printf (_(" Minimum Instruction Length: %d\n"), info.li_min_insn_length); 1891 printf (_(" Initial value of 'is_stmt': %d\n"), info.li_default_is_stmt); 1892 printf (_(" Line Base: %d\n"), info.li_line_base); 1893 printf (_(" Line Range: %d\n"), info.li_line_range); 1894 printf (_(" Opcode Base: %d\n"), info.li_opcode_base); 1895 1896 end_of_sequence = data + info.li_length + initial_length_size; 1897 1898 reset_state_machine (info.li_default_is_stmt); 1899 1900 /* Display the contents of the Opcodes table. */ 1901 standard_opcodes = hdrptr; 1902 1903 printf (_("\n Opcodes:\n")); 1904 1905 for (i = 1; i < info.li_opcode_base; i++) 1906 printf (_(" Opcode %d has %d args\n"), i, standard_opcodes[i - 1]); 1907 1908 /* Display the contents of the Directory table. */ 1909 data = standard_opcodes + info.li_opcode_base - 1; 1910 1911 if (*data == 0) 1912 printf (_("\n The Directory Table is empty.\n")); 1913 else 1914 { 1915 printf (_("\n The Directory Table:\n")); 1916 1917 while (*data != 0) 1918 { 1919 printf (_(" %s\n"), data); 1920 1921 data += strlen ((char *) data) + 1; 1922 } 1923 } 1924 1925 /* Skip the NUL at the end of the table. */ 1926 data++; 1927 1928 /* Display the contents of the File Name table. */ 1929 if (*data == 0) 1930 printf (_("\n The File Name Table is empty.\n")); 1931 else 1932 { 1933 printf (_("\n The File Name Table:\n")); 1934 printf (_(" Entry\tDir\tTime\tSize\tName\n")); 1935 1936 while (*data != 0) 1937 { 1938 unsigned char *name; 1939 unsigned int bytes_read; 1940 1941 printf (_(" %d\t"), ++state_machine_regs.last_file_entry); 1942 name = data; 1943 1944 data += strlen ((char *) data) + 1; 1945 1946 printf (_("%lu\t"), read_leb128 (data, & bytes_read, 0)); 1947 data += bytes_read; 1948 printf (_("%lu\t"), read_leb128 (data, & bytes_read, 0)); 1949 data += bytes_read; 1950 printf (_("%lu\t"), read_leb128 (data, & bytes_read, 0)); 1951 data += bytes_read; 1952 printf (_("%s\n"), name); 1953 } 1954 } 1955 1956 /* Skip the NUL at the end of the table. */ 1957 data++; 1958 1959 /* Now display the statements. */ 1960 printf (_("\n Line Number Statements:\n")); 1961 1962 while (data < end_of_sequence) 1963 { 1964 unsigned char op_code; 1965 int adv; 1966 unsigned long int uladv; 1967 unsigned int bytes_read; 1968 1969 op_code = *data++; 1970 1971 if (op_code >= info.li_opcode_base) 1972 { 1973 op_code -= info.li_opcode_base; 1974 uladv = (op_code / info.li_line_range) * info.li_min_insn_length; 1975 state_machine_regs.address += uladv; 1976 printf (_(" Special opcode %d: advance Address by %lu to 0x%lx"), 1977 op_code, uladv, state_machine_regs.address); 1978 adv = (op_code % info.li_line_range) + info.li_line_base; 1979 state_machine_regs.line += adv; 1980 printf (_(" and Line by %d to %d\n"), 1981 adv, state_machine_regs.line); 1982 } 1983 else switch (op_code) 1984 { 1985 case DW_LNS_extended_op: 1986 data += process_extended_line_op (data, info.li_default_is_stmt); 1987 break; 1988 1989 case DW_LNS_copy: 1990 printf (_(" Copy\n")); 1991 break; 1992 1993 case DW_LNS_advance_pc: 1994 uladv = read_leb128 (data, & bytes_read, 0); 1995 uladv *= info.li_min_insn_length; 1996 data += bytes_read; 1997 state_machine_regs.address += uladv; 1998 printf (_(" Advance PC by %lu to 0x%lx\n"), uladv, 1999 state_machine_regs.address); 2000 break; 2001 2002 case DW_LNS_advance_line: 2003 adv = read_leb128 (data, & bytes_read, 1); 2004 data += bytes_read; 2005 state_machine_regs.line += adv; 2006 printf (_(" Advance Line by %d to %d\n"), adv, 2007 state_machine_regs.line); 2008 break; 2009 2010 case DW_LNS_set_file: 2011 adv = read_leb128 (data, & bytes_read, 0); 2012 data += bytes_read; 2013 printf (_(" Set File Name to entry %d in the File Name Table\n"), 2014 adv); 2015 state_machine_regs.file = adv; 2016 break; 2017 2018 case DW_LNS_set_column: 2019 uladv = read_leb128 (data, & bytes_read, 0); 2020 data += bytes_read; 2021 printf (_(" Set column to %lu\n"), uladv); 2022 state_machine_regs.column = uladv; 2023 break; 2024 2025 case DW_LNS_negate_stmt: 2026 adv = state_machine_regs.is_stmt; 2027 adv = ! adv; 2028 printf (_(" Set is_stmt to %d\n"), adv); 2029 state_machine_regs.is_stmt = adv; 2030 break; 2031 2032 case DW_LNS_set_basic_block: 2033 printf (_(" Set basic block\n")); 2034 state_machine_regs.basic_block = 1; 2035 break; 2036 2037 case DW_LNS_const_add_pc: 2038 uladv = (((255 - info.li_opcode_base) / info.li_line_range) 2039 * info.li_min_insn_length); 2040 state_machine_regs.address += uladv; 2041 printf (_(" Advance PC by constant %lu to 0x%lx\n"), uladv, 2042 state_machine_regs.address); 2043 break; 2044 2045 case DW_LNS_fixed_advance_pc: 2046 uladv = byte_get (data, 2); 2047 data += 2; 2048 state_machine_regs.address += uladv; 2049 printf (_(" Advance PC by fixed size amount %lu to 0x%lx\n"), 2050 uladv, state_machine_regs.address); 2051 break; 2052 2053 case DW_LNS_set_prologue_end: 2054 printf (_(" Set prologue_end to true\n")); 2055 break; 2056 2057 case DW_LNS_set_epilogue_begin: 2058 printf (_(" Set epilogue_begin to true\n")); 2059 break; 2060 2061 case DW_LNS_set_isa: 2062 uladv = read_leb128 (data, & bytes_read, 0); 2063 data += bytes_read; 2064 printf (_(" Set ISA to %lu\n"), uladv); 2065 break; 2066 2067 default: 2068 printf (_(" Unknown opcode %d with operands: "), op_code); 2069 2070 for (i = standard_opcodes[op_code - 1]; i > 0 ; --i) 2071 { 2072 printf ("0x%lx%s", read_leb128 (data, &bytes_read, 0), 2073 i == 1 ? "" : ", "); 2074 data += bytes_read; 2075 } 2076 putchar ('\n'); 2077 break; 2078 } 2079 } 2080 putchar ('\n'); 2081 } 2082 2083 return 1; 2084} 2085 2086static int 2087display_debug_pubnames (struct dwarf_section *section, 2088 void *file ATTRIBUTE_UNUSED) 2089{ 2090 DWARF2_Internal_PubNames pubnames; 2091 unsigned char *start = section->start; 2092 unsigned char *end = start + section->size; 2093 2094 printf (_("Contents of the %s section:\n\n"), section->name); 2095 2096 while (start < end) 2097 { 2098 unsigned char *data; 2099 unsigned long offset; 2100 int offset_size, initial_length_size; 2101 2102 data = start; 2103 2104 pubnames.pn_length = byte_get (data, 4); 2105 data += 4; 2106 if (pubnames.pn_length == 0xffffffff) 2107 { 2108 pubnames.pn_length = byte_get (data, 8); 2109 data += 8; 2110 offset_size = 8; 2111 initial_length_size = 12; 2112 } 2113 else 2114 { 2115 offset_size = 4; 2116 initial_length_size = 4; 2117 } 2118 2119 pubnames.pn_version = byte_get (data, 2); 2120 data += 2; 2121 pubnames.pn_offset = byte_get (data, offset_size); 2122 data += offset_size; 2123 pubnames.pn_size = byte_get (data, offset_size); 2124 data += offset_size; 2125 2126 start += pubnames.pn_length + initial_length_size; 2127 2128 if (pubnames.pn_version != 2 && pubnames.pn_version != 3) 2129 { 2130 static int warned = 0; 2131 2132 if (! warned) 2133 { 2134 warn (_("Only DWARF 2 and 3 pubnames are currently supported\n")); 2135 warned = 1; 2136 } 2137 2138 continue; 2139 } 2140 2141 printf (_(" Length: %ld\n"), 2142 pubnames.pn_length); 2143 printf (_(" Version: %d\n"), 2144 pubnames.pn_version); 2145 printf (_(" Offset into .debug_info section: %ld\n"), 2146 pubnames.pn_offset); 2147 printf (_(" Size of area in .debug_info section: %ld\n"), 2148 pubnames.pn_size); 2149 2150 printf (_("\n Offset\tName\n")); 2151 2152 do 2153 { 2154 offset = byte_get (data, offset_size); 2155 2156 if (offset != 0) 2157 { 2158 data += offset_size; 2159 printf (" %-6ld\t\t%s\n", offset, data); 2160 data += strlen ((char *) data) + 1; 2161 } 2162 } 2163 while (offset != 0); 2164 } 2165 2166 printf ("\n"); 2167 return 1; 2168} 2169 2170static int 2171display_debug_macinfo (struct dwarf_section *section, 2172 void *file ATTRIBUTE_UNUSED) 2173{ 2174 unsigned char *start = section->start; 2175 unsigned char *end = start + section->size; 2176 unsigned char *curr = start; 2177 unsigned int bytes_read; 2178 enum dwarf_macinfo_record_type op; 2179 2180 printf (_("Contents of the %s section:\n\n"), section->name); 2181 2182 while (curr < end) 2183 { 2184 unsigned int lineno; 2185 const char *string; 2186 2187 op = *curr; 2188 curr++; 2189 2190 switch (op) 2191 { 2192 case DW_MACINFO_start_file: 2193 { 2194 unsigned int filenum; 2195 2196 lineno = read_leb128 (curr, & bytes_read, 0); 2197 curr += bytes_read; 2198 filenum = read_leb128 (curr, & bytes_read, 0); 2199 curr += bytes_read; 2200 2201 printf (_(" DW_MACINFO_start_file - lineno: %d filenum: %d\n"), 2202 lineno, filenum); 2203 } 2204 break; 2205 2206 case DW_MACINFO_end_file: 2207 printf (_(" DW_MACINFO_end_file\n")); 2208 break; 2209 2210 case DW_MACINFO_define: 2211 lineno = read_leb128 (curr, & bytes_read, 0); 2212 curr += bytes_read; 2213 string = (char *) curr; 2214 curr += strlen (string) + 1; 2215 printf (_(" DW_MACINFO_define - lineno : %d macro : %s\n"), 2216 lineno, string); 2217 break; 2218 2219 case DW_MACINFO_undef: 2220 lineno = read_leb128 (curr, & bytes_read, 0); 2221 curr += bytes_read; 2222 string = (char *) curr; 2223 curr += strlen (string) + 1; 2224 printf (_(" DW_MACINFO_undef - lineno : %d macro : %s\n"), 2225 lineno, string); 2226 break; 2227 2228 case DW_MACINFO_vendor_ext: 2229 { 2230 unsigned int constant; 2231 2232 constant = read_leb128 (curr, & bytes_read, 0); 2233 curr += bytes_read; 2234 string = (char *) curr; 2235 curr += strlen (string) + 1; 2236 printf (_(" DW_MACINFO_vendor_ext - constant : %d string : %s\n"), 2237 constant, string); 2238 } 2239 break; 2240 } 2241 } 2242 2243 return 1; 2244} 2245 2246static int 2247display_debug_abbrev (struct dwarf_section *section, 2248 void *file ATTRIBUTE_UNUSED) 2249{ 2250 abbrev_entry *entry; 2251 unsigned char *start = section->start; 2252 unsigned char *end = start + section->size; 2253 2254 printf (_("Contents of the %s section:\n\n"), section->name); 2255 2256 do 2257 { 2258 free_abbrevs (); 2259 2260 start = process_abbrev_section (start, end); 2261 2262 if (first_abbrev == NULL) 2263 continue; 2264 2265 printf (_(" Number TAG\n")); 2266 2267 for (entry = first_abbrev; entry; entry = entry->next) 2268 { 2269 abbrev_attr *attr; 2270 2271 printf (_(" %ld %s [%s]\n"), 2272 entry->entry, 2273 get_TAG_name (entry->tag), 2274 entry->children ? _("has children") : _("no children")); 2275 2276 for (attr = entry->first_attr; attr; attr = attr->next) 2277 printf (_(" %-18s %s\n"), 2278 get_AT_name (attr->attribute), 2279 get_FORM_name (attr->form)); 2280 } 2281 } 2282 while (start); 2283 2284 printf ("\n"); 2285 2286 return 1; 2287} 2288 2289static int 2290display_debug_loc (struct dwarf_section *section, void *file) 2291{ 2292 unsigned char *start = section->start; 2293 unsigned char *section_end; 2294 unsigned long bytes; 2295 unsigned char *section_begin = start; 2296 unsigned int num_loc_list = 0; 2297 unsigned long last_offset = 0; 2298 unsigned int first = 0; 2299 unsigned int i; 2300 unsigned int j; 2301 int seen_first_offset = 0; 2302 int use_debug_info = 1; 2303 unsigned char *next; 2304 2305 bytes = section->size; 2306 section_end = start + bytes; 2307 2308 if (bytes == 0) 2309 { 2310 printf (_("\nThe %s section is empty.\n"), section->name); 2311 return 0; 2312 } 2313 2314 load_debug_info (file); 2315 2316 /* Check the order of location list in .debug_info section. If 2317 offsets of location lists are in the ascending order, we can 2318 use `debug_information' directly. */ 2319 for (i = 0; i < num_debug_info_entries; i++) 2320 { 2321 unsigned int num; 2322 2323 num = debug_information [i].num_loc_offsets; 2324 num_loc_list += num; 2325 2326 /* Check if we can use `debug_information' directly. */ 2327 if (use_debug_info && num != 0) 2328 { 2329 if (!seen_first_offset) 2330 { 2331 /* This is the first location list. */ 2332 last_offset = debug_information [i].loc_offsets [0]; 2333 first = i; 2334 seen_first_offset = 1; 2335 j = 1; 2336 } 2337 else 2338 j = 0; 2339 2340 for (; j < num; j++) 2341 { 2342 if (last_offset > 2343 debug_information [i].loc_offsets [j]) 2344 { 2345 use_debug_info = 0; 2346 break; 2347 } 2348 last_offset = debug_information [i].loc_offsets [j]; 2349 } 2350 } 2351 } 2352 2353 if (!use_debug_info) 2354 /* FIXME: Should we handle this case? */ 2355 error (_("Location lists in .debug_info section aren't in ascending order!\n")); 2356 2357 if (!seen_first_offset) 2358 error (_("No location lists in .debug_info section!\n")); 2359 2360 /* DWARF sections under Mach-O have non-zero addresses. */ 2361 if (debug_information [first].num_loc_offsets > 0 2362 && debug_information [first].loc_offsets [0] != section->address) 2363 warn (_("Location lists in %s section start at 0x%lx\n"), 2364 section->name, debug_information [first].loc_offsets [0]); 2365 2366 printf (_("Contents of the %s section:\n\n"), section->name); 2367 printf (_(" Offset Begin End Expression\n")); 2368 2369 seen_first_offset = 0; 2370 for (i = first; i < num_debug_info_entries; i++) 2371 { 2372 unsigned long begin; 2373 unsigned long end; 2374 unsigned short length; 2375 unsigned long offset; 2376 unsigned int pointer_size; 2377 unsigned long cu_offset; 2378 unsigned long base_address; 2379 int need_frame_base; 2380 int has_frame_base; 2381 2382 pointer_size = debug_information [i].pointer_size; 2383 cu_offset = debug_information [i].cu_offset; 2384 2385 for (j = 0; j < debug_information [i].num_loc_offsets; j++) 2386 { 2387 has_frame_base = debug_information [i].have_frame_base [j]; 2388 /* DWARF sections under Mach-O have non-zero addresses. */ 2389 offset = debug_information [i].loc_offsets [j] - section->address; 2390 next = section_begin + offset; 2391 base_address = debug_information [i].base_address; 2392 2393 if (!seen_first_offset) 2394 seen_first_offset = 1; 2395 else 2396 { 2397 if (start < next) 2398 warn (_("There is a hole [0x%lx - 0x%lx] in .debug_loc section.\n"), 2399 (long)(start - section_begin), (long)(next - section_begin)); 2400 else if (start > next) 2401 warn (_("There is an overlap [0x%lx - 0x%lx] in .debug_loc section.\n"), 2402 (long)(start - section_begin), (long)(next - section_begin)); 2403 } 2404 start = next; 2405 2406 if (offset >= bytes) 2407 { 2408 warn (_("Offset 0x%lx is bigger than .debug_loc section size.\n"), 2409 offset); 2410 continue; 2411 } 2412 2413 while (1) 2414 { 2415 if (start + 2 * pointer_size > section_end) 2416 { 2417 warn (_("Location list starting at offset 0x%lx is not terminated.\n"), 2418 offset); 2419 break; 2420 } 2421 2422 begin = byte_get (start, pointer_size); 2423 start += pointer_size; 2424 end = byte_get (start, pointer_size); 2425 start += pointer_size; 2426 2427 if (begin == 0 && end == 0) 2428 { 2429 printf (_(" %8.8lx <End of list>\n"), offset); 2430 break; 2431 } 2432 2433 /* Check base address specifiers. */ 2434 if (begin == -1UL && end != -1UL) 2435 { 2436 base_address = end; 2437 printf (_(" %8.8lx %8.8lx %8.8lx (base address)\n"), 2438 offset, begin, end); 2439 continue; 2440 } 2441 2442 if (start + 2 > section_end) 2443 { 2444 warn (_("Location list starting at offset 0x%lx is not terminated.\n"), 2445 offset); 2446 break; 2447 } 2448 2449 length = byte_get (start, 2); 2450 start += 2; 2451 2452 if (start + length > section_end) 2453 { 2454 warn (_("Location list starting at offset 0x%lx is not terminated.\n"), 2455 offset); 2456 break; 2457 } 2458 2459 printf (" %8.8lx %8.8lx %8.8lx (", 2460 offset, begin + base_address, end + base_address); 2461 need_frame_base = decode_location_expression (start, 2462 pointer_size, 2463 length, 2464 cu_offset); 2465 putchar (')'); 2466 2467 if (need_frame_base && !has_frame_base) 2468 printf (_(" [without DW_AT_frame_base]")); 2469 2470 if (begin == end) 2471 fputs (_(" (start == end)"), stdout); 2472 else if (begin > end) 2473 fputs (_(" (start > end)"), stdout); 2474 2475 putchar ('\n'); 2476 2477 start += length; 2478 } 2479 } 2480 } 2481 return 1; 2482} 2483 2484static int 2485display_debug_str (struct dwarf_section *section, 2486 void *file ATTRIBUTE_UNUSED) 2487{ 2488 unsigned char *start = section->start; 2489 unsigned long bytes = section->size; 2490 dwarf_vma addr = section->address; 2491 2492 if (bytes == 0) 2493 { 2494 printf (_("\nThe %s section is empty.\n"), section->name); 2495 return 0; 2496 } 2497 2498 printf (_("Contents of the %s section:\n\n"), section->name); 2499 2500 while (bytes) 2501 { 2502 int j; 2503 int k; 2504 int lbytes; 2505 2506 lbytes = (bytes > 16 ? 16 : bytes); 2507 2508 printf (" 0x%8.8lx ", (unsigned long) addr); 2509 2510 for (j = 0; j < 16; j++) 2511 { 2512 if (j < lbytes) 2513 printf ("%2.2x", start[j]); 2514 else 2515 printf (" "); 2516 2517 if ((j & 3) == 3) 2518 printf (" "); 2519 } 2520 2521 for (j = 0; j < lbytes; j++) 2522 { 2523 k = start[j]; 2524 if (k >= ' ' && k < 0x80) 2525 printf ("%c", k); 2526 else 2527 printf ("."); 2528 } 2529 2530 putchar ('\n'); 2531 2532 start += lbytes; 2533 addr += lbytes; 2534 bytes -= lbytes; 2535 } 2536 2537 putchar ('\n'); 2538 2539 return 1; 2540} 2541 2542static int 2543display_debug_info (struct dwarf_section *section, void *file) 2544{ 2545 return process_debug_info (section, file, 0); 2546} 2547 2548 2549static int 2550display_debug_aranges (struct dwarf_section *section, 2551 void *file ATTRIBUTE_UNUSED) 2552{ 2553 unsigned char *start = section->start; 2554 unsigned char *end = start + section->size; 2555 2556 printf (_("The section %s contains:\n\n"), section->name); 2557 2558 while (start < end) 2559 { 2560 unsigned char *hdrptr; 2561 DWARF2_Internal_ARange arange; 2562 unsigned char *ranges; 2563 unsigned long length; 2564 unsigned long address; 2565 unsigned char address_size; 2566 int excess; 2567 int offset_size; 2568 int initial_length_size; 2569 2570 hdrptr = start; 2571 2572 arange.ar_length = byte_get (hdrptr, 4); 2573 hdrptr += 4; 2574 2575 if (arange.ar_length == 0xffffffff) 2576 { 2577 arange.ar_length = byte_get (hdrptr, 8); 2578 hdrptr += 8; 2579 offset_size = 8; 2580 initial_length_size = 12; 2581 } 2582 else 2583 { 2584 offset_size = 4; 2585 initial_length_size = 4; 2586 } 2587 2588 arange.ar_version = byte_get (hdrptr, 2); 2589 hdrptr += 2; 2590 2591 arange.ar_info_offset = byte_get (hdrptr, offset_size); 2592 hdrptr += offset_size; 2593 2594 arange.ar_pointer_size = byte_get (hdrptr, 1); 2595 hdrptr += 1; 2596 2597 arange.ar_segment_size = byte_get (hdrptr, 1); 2598 hdrptr += 1; 2599 2600 if (arange.ar_version != 2 && arange.ar_version != 3) 2601 { 2602 warn (_("Only DWARF 2 and 3 aranges are currently supported.\n")); 2603 break; 2604 } 2605 2606 printf (_(" Length: %ld\n"), arange.ar_length); 2607 printf (_(" Version: %d\n"), arange.ar_version); 2608 printf (_(" Offset into .debug_info: %lx\n"), arange.ar_info_offset); 2609 printf (_(" Pointer Size: %d\n"), arange.ar_pointer_size); 2610 printf (_(" Segment Size: %d\n"), arange.ar_segment_size); 2611 2612 address_size = arange.ar_pointer_size + arange.ar_segment_size; 2613 2614 /* The DWARF spec does not require that the address size be a power 2615 of two, but we do. This will have to change if we ever encounter 2616 an uneven architecture. */ 2617 if ((address_size & (address_size - 1)) != 0) 2618 { 2619 warn (_("Pointer size + Segment size is not a power of two.\n")); 2620 break; 2621 } 2622 2623 if (address_size > 4) 2624 printf (_("\n Address Length\n")); 2625 else 2626 printf (_("\n Address Length\n")); 2627 2628 ranges = hdrptr; 2629 2630 /* Must pad to an alignment boundary that is twice the address size. */ 2631 excess = (hdrptr - start) % (2 * address_size); 2632 if (excess) 2633 ranges += (2 * address_size) - excess; 2634 2635 start += arange.ar_length + initial_length_size; 2636 2637 while (ranges + 2 * address_size <= start) 2638 { 2639 address = byte_get (ranges, address_size); 2640 2641 ranges += address_size; 2642 2643 length = byte_get (ranges, address_size); 2644 2645 ranges += address_size; 2646 2647 if (address_size > 4) 2648 printf (" 0x%16.16lx 0x%lx\n", address, length); 2649 else 2650 printf (" 0x%8.8lx 0x%lx\n", address, length); 2651 } 2652 } 2653 2654 printf ("\n"); 2655 2656 return 1; 2657} 2658 2659static int 2660display_debug_ranges (struct dwarf_section *section, 2661 void *file ATTRIBUTE_UNUSED) 2662{ 2663 unsigned char *start = section->start; 2664 unsigned char *section_end; 2665 unsigned long bytes; 2666 unsigned char *section_begin = start; 2667 unsigned int num_range_list = 0; 2668 unsigned long last_offset = 0; 2669 unsigned int first = 0; 2670 unsigned int i; 2671 unsigned int j; 2672 int seen_first_offset = 0; 2673 int use_debug_info = 1; 2674 unsigned char *next; 2675 2676 bytes = section->size; 2677 section_end = start + bytes; 2678 2679 if (bytes == 0) 2680 { 2681 printf (_("\nThe %s section is empty.\n"), section->name); 2682 return 0; 2683 } 2684 2685 load_debug_info (file); 2686 2687 /* Check the order of range list in .debug_info section. If 2688 offsets of range lists are in the ascending order, we can 2689 use `debug_information' directly. */ 2690 for (i = 0; i < num_debug_info_entries; i++) 2691 { 2692 unsigned int num; 2693 2694 num = debug_information [i].num_range_lists; 2695 num_range_list += num; 2696 2697 /* Check if we can use `debug_information' directly. */ 2698 if (use_debug_info && num != 0) 2699 { 2700 if (!seen_first_offset) 2701 { 2702 /* This is the first range list. */ 2703 last_offset = debug_information [i].range_lists [0]; 2704 first = i; 2705 seen_first_offset = 1; 2706 j = 1; 2707 } 2708 else 2709 j = 0; 2710 2711 for (; j < num; j++) 2712 { 2713 if (last_offset > 2714 debug_information [i].range_lists [j]) 2715 { 2716 use_debug_info = 0; 2717 break; 2718 } 2719 last_offset = debug_information [i].range_lists [j]; 2720 } 2721 } 2722 } 2723 2724 if (!use_debug_info) 2725 /* FIXME: Should we handle this case? */ 2726 error (_("Range lists in .debug_info section aren't in ascending order!\n")); 2727 2728 if (!seen_first_offset) 2729 error (_("No range lists in .debug_info section!\n")); 2730 2731 /* DWARF sections under Mach-O have non-zero addresses. */ 2732 if (debug_information [first].num_range_lists > 0 2733 && debug_information [first].range_lists [0] != section->address) 2734 warn (_("Range lists in %s section start at 0x%lx\n"), 2735 section->name, debug_information [first].range_lists [0]); 2736 2737 printf (_("Contents of the %s section:\n\n"), section->name); 2738 printf (_(" Offset Begin End\n")); 2739 2740 seen_first_offset = 0; 2741 for (i = first; i < num_debug_info_entries; i++) 2742 { 2743 unsigned long begin; 2744 unsigned long end; 2745 unsigned long offset; 2746 unsigned int pointer_size; 2747 unsigned long base_address; 2748 2749 pointer_size = debug_information [i].pointer_size; 2750 2751 for (j = 0; j < debug_information [i].num_range_lists; j++) 2752 { 2753 /* DWARF sections under Mach-O have non-zero addresses. */ 2754 offset = debug_information [i].range_lists [j] - section->address; 2755 next = section_begin + offset; 2756 base_address = debug_information [i].base_address; 2757 2758 if (!seen_first_offset) 2759 seen_first_offset = 1; 2760 else 2761 { 2762 if (start < next) 2763 warn (_("There is a hole [0x%lx - 0x%lx] in %s section.\n"), 2764 (long)(start - section_begin), 2765 (long)(next - section_begin), section->name); 2766 else if (start > next) 2767 warn (_("There is an overlap [0x%lx - 0x%lx] in %s section.\n"), 2768 (long)(start - section_begin), 2769 (long)(next - section_begin), section->name); 2770 } 2771 start = next; 2772 2773 while (1) 2774 { 2775 begin = byte_get (start, pointer_size); 2776 start += pointer_size; 2777 end = byte_get (start, pointer_size); 2778 start += pointer_size; 2779 2780 if (begin == 0 && end == 0) 2781 { 2782 printf (_(" %8.8lx <End of list>\n"), offset); 2783 break; 2784 } 2785 2786 /* Check base address specifiers. */ 2787 if (begin == -1UL && end != -1UL) 2788 { 2789 base_address = end; 2790 printf (" %8.8lx %8.8lx %8.8lx (base address)\n", 2791 offset, begin, end); 2792 continue; 2793 } 2794 2795 printf (" %8.8lx %8.8lx %8.8lx", 2796 offset, begin + base_address, end + base_address); 2797 2798 if (begin == end) 2799 fputs (_(" (start == end)"), stdout); 2800 else if (begin > end) 2801 fputs (_(" (start > end)"), stdout); 2802 2803 putchar ('\n'); 2804 } 2805 } 2806 } 2807 putchar ('\n'); 2808 return 1; 2809} 2810 2811typedef struct Frame_Chunk 2812{ 2813 struct Frame_Chunk *next; 2814 unsigned char *chunk_start; 2815 int ncols; 2816 /* DW_CFA_{undefined,same_value,offset,register,unreferenced} */ 2817 short int *col_type; 2818 int *col_offset; 2819 char *augmentation; 2820 unsigned int code_factor; 2821 int data_factor; 2822 unsigned long pc_begin; 2823 unsigned long pc_range; 2824 int cfa_reg; 2825 int cfa_offset; 2826 int ra; 2827 unsigned char fde_encoding; 2828 unsigned char cfa_exp; 2829} 2830Frame_Chunk; 2831 2832/* A marker for a col_type that means this column was never referenced 2833 in the frame info. */ 2834#define DW_CFA_unreferenced (-1) 2835 2836static void 2837frame_need_space (Frame_Chunk *fc, int reg) 2838{ 2839 int prev = fc->ncols; 2840 2841 if (reg < fc->ncols) 2842 return; 2843 2844 fc->ncols = reg + 1; 2845 fc->col_type = xcrealloc (fc->col_type, fc->ncols, sizeof (short int)); 2846 fc->col_offset = xcrealloc (fc->col_offset, fc->ncols, sizeof (int)); 2847 2848 while (prev < fc->ncols) 2849 { 2850 fc->col_type[prev] = DW_CFA_unreferenced; 2851 fc->col_offset[prev] = 0; 2852 prev++; 2853 } 2854} 2855 2856static void 2857frame_display_row (Frame_Chunk *fc, int *need_col_headers, int *max_regs) 2858{ 2859 int r; 2860 char tmp[100]; 2861 2862 if (*max_regs < fc->ncols) 2863 *max_regs = fc->ncols; 2864 2865 if (*need_col_headers) 2866 { 2867 *need_col_headers = 0; 2868 2869 printf (" LOC CFA "); 2870 2871 for (r = 0; r < *max_regs; r++) 2872 if (fc->col_type[r] != DW_CFA_unreferenced) 2873 { 2874 if (r == fc->ra) 2875 printf ("ra "); 2876 else 2877 printf ("r%-4d", r); 2878 } 2879 2880 printf ("\n"); 2881 } 2882 2883 printf ("%08lx ", fc->pc_begin); 2884 if (fc->cfa_exp) 2885 strcpy (tmp, "exp"); 2886 else 2887 sprintf (tmp, "r%d%+d", fc->cfa_reg, fc->cfa_offset); 2888 printf ("%-8s ", tmp); 2889 2890 for (r = 0; r < fc->ncols; r++) 2891 { 2892 if (fc->col_type[r] != DW_CFA_unreferenced) 2893 { 2894 switch (fc->col_type[r]) 2895 { 2896 case DW_CFA_undefined: 2897 strcpy (tmp, "u"); 2898 break; 2899 case DW_CFA_same_value: 2900 strcpy (tmp, "s"); 2901 break; 2902 case DW_CFA_offset: 2903 sprintf (tmp, "c%+d", fc->col_offset[r]); 2904 break; 2905 case DW_CFA_val_offset: 2906 sprintf (tmp, "v%+d", fc->col_offset[r]); 2907 break; 2908 case DW_CFA_register: 2909 sprintf (tmp, "r%d", fc->col_offset[r]); 2910 break; 2911 case DW_CFA_expression: 2912 strcpy (tmp, "exp"); 2913 break; 2914 case DW_CFA_val_expression: 2915 strcpy (tmp, "vexp"); 2916 break; 2917 default: 2918 strcpy (tmp, "n/a"); 2919 break; 2920 } 2921 printf ("%-5s", tmp); 2922 } 2923 } 2924 printf ("\n"); 2925} 2926 2927static int 2928size_of_encoded_value (int encoding) 2929{ 2930 switch (encoding & 0x7) 2931 { 2932 default: /* ??? */ 2933 case 0: return eh_addr_size; 2934 case 2: return 2; 2935 case 3: return 4; 2936 case 4: return 8; 2937 } 2938} 2939 2940static dwarf_vma 2941get_encoded_value (unsigned char *data, int encoding) 2942{ 2943 int size = size_of_encoded_value (encoding); 2944 2945 if (encoding & DW_EH_PE_signed) 2946 return byte_get_signed (data, size); 2947 else 2948 return byte_get (data, size); 2949} 2950 2951#define GET(N) byte_get (start, N); start += N 2952#define LEB() read_leb128 (start, & length_return, 0); start += length_return 2953#define SLEB() read_leb128 (start, & length_return, 1); start += length_return 2954 2955static int 2956display_debug_frames (struct dwarf_section *section, 2957 void *file ATTRIBUTE_UNUSED) 2958{ 2959 unsigned char *start = section->start; 2960 unsigned char *end = start + section->size; 2961 unsigned char *section_start = start; 2962 Frame_Chunk *chunks = 0; 2963 Frame_Chunk *remembered_state = 0; 2964 Frame_Chunk *rs; 2965 int is_eh = strcmp (section->name, ".eh_frame") == 0; 2966 unsigned int length_return; 2967 int max_regs = 0; 2968 2969 printf (_("The section %s contains:\n"), section->name); 2970 2971 while (start < end) 2972 { 2973 unsigned char *saved_start; 2974 unsigned char *block_end; 2975 unsigned long length; 2976 unsigned long cie_id; 2977 Frame_Chunk *fc; 2978 Frame_Chunk *cie; 2979 int need_col_headers = 1; 2980 unsigned char *augmentation_data = NULL; 2981 unsigned long augmentation_data_len = 0; 2982 int encoded_ptr_size = eh_addr_size; 2983 int offset_size; 2984 int initial_length_size; 2985 2986 saved_start = start; 2987 length = byte_get (start, 4); start += 4; 2988 2989 if (length == 0) 2990 { 2991 printf ("\n%08lx ZERO terminator\n\n", 2992 (unsigned long)(saved_start - section_start)); 2993 continue; 2994 } 2995 2996 if (length == 0xffffffff) 2997 { 2998 length = byte_get (start, 8); 2999 start += 8; 3000 offset_size = 8; 3001 initial_length_size = 12; 3002 } 3003 else 3004 { 3005 offset_size = 4; 3006 initial_length_size = 4; 3007 } 3008 3009 block_end = saved_start + length + initial_length_size; 3010 if (block_end > end) 3011 { 3012 warn ("Invalid length %#08lx in FDE at %#08lx\n", 3013 length, (unsigned long)(saved_start - section_start)); 3014 block_end = end; 3015 } 3016 cie_id = byte_get (start, offset_size); start += offset_size; 3017 3018 if (is_eh ? (cie_id == 0) : (cie_id == DW_CIE_ID)) 3019 { 3020 int version; 3021 3022 fc = xmalloc (sizeof (Frame_Chunk)); 3023 memset (fc, 0, sizeof (Frame_Chunk)); 3024 3025 fc->next = chunks; 3026 chunks = fc; 3027 fc->chunk_start = saved_start; 3028 fc->ncols = 0; 3029 fc->col_type = xmalloc (sizeof (short int)); 3030 fc->col_offset = xmalloc (sizeof (int)); 3031 frame_need_space (fc, max_regs-1); 3032 3033 version = *start++; 3034 3035 fc->augmentation = (char *) start; 3036 start = (unsigned char *) strchr ((char *) start, '\0') + 1; 3037 3038 if (fc->augmentation[0] == 'z') 3039 { 3040 fc->code_factor = LEB (); 3041 fc->data_factor = SLEB (); 3042 if (version == 1) 3043 { 3044 fc->ra = GET (1); 3045 } 3046 else 3047 { 3048 fc->ra = LEB (); 3049 } 3050 augmentation_data_len = LEB (); 3051 augmentation_data = start; 3052 start += augmentation_data_len; 3053 } 3054 else if (strcmp (fc->augmentation, "eh") == 0) 3055 { 3056 start += eh_addr_size; 3057 fc->code_factor = LEB (); 3058 fc->data_factor = SLEB (); 3059 if (version == 1) 3060 { 3061 fc->ra = GET (1); 3062 } 3063 else 3064 { 3065 fc->ra = LEB (); 3066 } 3067 } 3068 else 3069 { 3070 fc->code_factor = LEB (); 3071 fc->data_factor = SLEB (); 3072 if (version == 1) 3073 { 3074 fc->ra = GET (1); 3075 } 3076 else 3077 { 3078 fc->ra = LEB (); 3079 } 3080 } 3081 cie = fc; 3082 3083 if (do_debug_frames_interp) 3084 printf ("\n%08lx %08lx %08lx CIE \"%s\" cf=%d df=%d ra=%d\n", 3085 (unsigned long)(saved_start - section_start), length, cie_id, 3086 fc->augmentation, fc->code_factor, fc->data_factor, 3087 fc->ra); 3088 else 3089 { 3090 printf ("\n%08lx %08lx %08lx CIE\n", 3091 (unsigned long)(saved_start - section_start), length, cie_id); 3092 printf (" Version: %d\n", version); 3093 printf (" Augmentation: \"%s\"\n", fc->augmentation); 3094 printf (" Code alignment factor: %u\n", fc->code_factor); 3095 printf (" Data alignment factor: %d\n", fc->data_factor); 3096 printf (" Return address column: %d\n", fc->ra); 3097 3098 if (augmentation_data_len) 3099 { 3100 unsigned long i; 3101 printf (" Augmentation data: "); 3102 for (i = 0; i < augmentation_data_len; ++i) 3103 printf (" %02x", augmentation_data[i]); 3104 putchar ('\n'); 3105 } 3106 putchar ('\n'); 3107 } 3108 3109 if (augmentation_data_len) 3110 { 3111 unsigned char *p, *q; 3112 p = (unsigned char *) fc->augmentation + 1; 3113 q = augmentation_data; 3114 3115 while (1) 3116 { 3117 if (*p == 'L') 3118 q++; 3119 else if (*p == 'P') 3120 q += 1 + size_of_encoded_value (*q); 3121 else if (*p == 'R') 3122 fc->fde_encoding = *q++; 3123 else 3124 break; 3125 p++; 3126 } 3127 3128 if (fc->fde_encoding) 3129 encoded_ptr_size = size_of_encoded_value (fc->fde_encoding); 3130 } 3131 3132 frame_need_space (fc, fc->ra); 3133 } 3134 else 3135 { 3136 unsigned char *look_for; 3137 static Frame_Chunk fde_fc; 3138 3139 fc = & fde_fc; 3140 memset (fc, 0, sizeof (Frame_Chunk)); 3141 3142 look_for = is_eh ? start - 4 - cie_id : section_start + cie_id; 3143 3144 for (cie = chunks; cie ; cie = cie->next) 3145 if (cie->chunk_start == look_for) 3146 break; 3147 3148 if (!cie) 3149 { 3150 warn ("Invalid CIE pointer %#08lx in FDE at %#08lx\n", 3151 cie_id, (unsigned long)(saved_start - section_start)); 3152 fc->ncols = 0; 3153 fc->col_type = xmalloc (sizeof (short int)); 3154 fc->col_offset = xmalloc (sizeof (int)); 3155 frame_need_space (fc, max_regs - 1); 3156 cie = fc; 3157 fc->augmentation = ""; 3158 fc->fde_encoding = 0; 3159 } 3160 else 3161 { 3162 fc->ncols = cie->ncols; 3163 fc->col_type = xcmalloc (fc->ncols, sizeof (short int)); 3164 fc->col_offset = xcmalloc (fc->ncols, sizeof (int)); 3165 memcpy (fc->col_type, cie->col_type, fc->ncols * sizeof (short int)); 3166 memcpy (fc->col_offset, cie->col_offset, fc->ncols * sizeof (int)); 3167 fc->augmentation = cie->augmentation; 3168 fc->code_factor = cie->code_factor; 3169 fc->data_factor = cie->data_factor; 3170 fc->cfa_reg = cie->cfa_reg; 3171 fc->cfa_offset = cie->cfa_offset; 3172 fc->ra = cie->ra; 3173 frame_need_space (fc, max_regs-1); 3174 fc->fde_encoding = cie->fde_encoding; 3175 } 3176 3177 if (fc->fde_encoding) 3178 encoded_ptr_size = size_of_encoded_value (fc->fde_encoding); 3179 3180 fc->pc_begin = get_encoded_value (start, fc->fde_encoding); 3181 if ((fc->fde_encoding & 0x70) == DW_EH_PE_pcrel 3182 /* Don't adjust for relocatable file since there's 3183 invariably a pcrel reloc here, which we haven't 3184 applied. */ 3185 && !is_relocatable) 3186 fc->pc_begin += section->address + (start - section_start); 3187 start += encoded_ptr_size; 3188 fc->pc_range = byte_get (start, encoded_ptr_size); 3189 start += encoded_ptr_size; 3190 3191 if (cie->augmentation[0] == 'z') 3192 { 3193 augmentation_data_len = LEB (); 3194 augmentation_data = start; 3195 start += augmentation_data_len; 3196 } 3197 3198 printf ("\n%08lx %08lx %08lx FDE cie=%08lx pc=%08lx..%08lx\n", 3199 (unsigned long)(saved_start - section_start), length, cie_id, 3200 (unsigned long)(cie->chunk_start - section_start), 3201 fc->pc_begin, fc->pc_begin + fc->pc_range); 3202 if (! do_debug_frames_interp && augmentation_data_len) 3203 { 3204 unsigned long i; 3205 3206 printf (" Augmentation data: "); 3207 for (i = 0; i < augmentation_data_len; ++i) 3208 printf (" %02x", augmentation_data[i]); 3209 putchar ('\n'); 3210 putchar ('\n'); 3211 } 3212 } 3213 3214 /* At this point, fc is the current chunk, cie (if any) is set, and 3215 we're about to interpret instructions for the chunk. */ 3216 /* ??? At present we need to do this always, since this sizes the 3217 fc->col_type and fc->col_offset arrays, which we write into always. 3218 We should probably split the interpreted and non-interpreted bits 3219 into two different routines, since there's so much that doesn't 3220 really overlap between them. */ 3221 if (1 || do_debug_frames_interp) 3222 { 3223 /* Start by making a pass over the chunk, allocating storage 3224 and taking note of what registers are used. */ 3225 unsigned char *tmp = start; 3226 3227 while (start < block_end) 3228 { 3229 unsigned op, opa; 3230 unsigned long reg, tmp; 3231 3232 op = *start++; 3233 opa = op & 0x3f; 3234 if (op & 0xc0) 3235 op &= 0xc0; 3236 3237 /* Warning: if you add any more cases to this switch, be 3238 sure to add them to the corresponding switch below. */ 3239 switch (op) 3240 { 3241 case DW_CFA_advance_loc: 3242 break; 3243 case DW_CFA_offset: 3244 LEB (); 3245 frame_need_space (fc, opa); 3246 fc->col_type[opa] = DW_CFA_undefined; 3247 break; 3248 case DW_CFA_restore: 3249 frame_need_space (fc, opa); 3250 fc->col_type[opa] = DW_CFA_undefined; 3251 break; 3252 case DW_CFA_set_loc: 3253 start += encoded_ptr_size; 3254 break; 3255 case DW_CFA_advance_loc1: 3256 start += 1; 3257 break; 3258 case DW_CFA_advance_loc2: 3259 start += 2; 3260 break; 3261 case DW_CFA_advance_loc4: 3262 start += 4; 3263 break; 3264 case DW_CFA_offset_extended: 3265 case DW_CFA_val_offset: 3266 reg = LEB (); LEB (); 3267 frame_need_space (fc, reg); 3268 fc->col_type[reg] = DW_CFA_undefined; 3269 break; 3270 case DW_CFA_restore_extended: 3271 reg = LEB (); 3272 frame_need_space (fc, reg); 3273 fc->col_type[reg] = DW_CFA_undefined; 3274 break; 3275 case DW_CFA_undefined: 3276 reg = LEB (); 3277 frame_need_space (fc, reg); 3278 fc->col_type[reg] = DW_CFA_undefined; 3279 break; 3280 case DW_CFA_same_value: 3281 reg = LEB (); 3282 frame_need_space (fc, reg); 3283 fc->col_type[reg] = DW_CFA_undefined; 3284 break; 3285 case DW_CFA_register: 3286 reg = LEB (); LEB (); 3287 frame_need_space (fc, reg); 3288 fc->col_type[reg] = DW_CFA_undefined; 3289 break; 3290 case DW_CFA_def_cfa: 3291 LEB (); LEB (); 3292 break; 3293 case DW_CFA_def_cfa_register: 3294 LEB (); 3295 break; 3296 case DW_CFA_def_cfa_offset: 3297 LEB (); 3298 break; 3299 case DW_CFA_def_cfa_expression: 3300 tmp = LEB (); 3301 start += tmp; 3302 break; 3303 case DW_CFA_expression: 3304 case DW_CFA_val_expression: 3305 reg = LEB (); 3306 tmp = LEB (); 3307 start += tmp; 3308 frame_need_space (fc, reg); 3309 fc->col_type[reg] = DW_CFA_undefined; 3310 break; 3311 case DW_CFA_offset_extended_sf: 3312 case DW_CFA_val_offset_sf: 3313 reg = LEB (); SLEB (); 3314 frame_need_space (fc, reg); 3315 fc->col_type[reg] = DW_CFA_undefined; 3316 break; 3317 case DW_CFA_def_cfa_sf: 3318 LEB (); SLEB (); 3319 break; 3320 case DW_CFA_def_cfa_offset_sf: 3321 SLEB (); 3322 break; 3323 case DW_CFA_MIPS_advance_loc8: 3324 start += 8; 3325 break; 3326 case DW_CFA_GNU_args_size: 3327 LEB (); 3328 break; 3329 case DW_CFA_GNU_negative_offset_extended: 3330 reg = LEB (); LEB (); 3331 frame_need_space (fc, reg); 3332 fc->col_type[reg] = DW_CFA_undefined; 3333 3334 default: 3335 break; 3336 } 3337 } 3338 start = tmp; 3339 } 3340 3341 /* Now we know what registers are used, make a second pass over 3342 the chunk, this time actually printing out the info. */ 3343 3344 while (start < block_end) 3345 { 3346 unsigned op, opa; 3347 unsigned long ul, reg, roffs; 3348 long l, ofs; 3349 dwarf_vma vma; 3350 3351 op = *start++; 3352 opa = op & 0x3f; 3353 if (op & 0xc0) 3354 op &= 0xc0; 3355 3356 /* Warning: if you add any more cases to this switch, be 3357 sure to add them to the corresponding switch above. */ 3358 switch (op) 3359 { 3360 case DW_CFA_advance_loc: 3361 if (do_debug_frames_interp) 3362 frame_display_row (fc, &need_col_headers, &max_regs); 3363 else 3364 printf (" DW_CFA_advance_loc: %d to %08lx\n", 3365 opa * fc->code_factor, 3366 fc->pc_begin + opa * fc->code_factor); 3367 fc->pc_begin += opa * fc->code_factor; 3368 break; 3369 3370 case DW_CFA_offset: 3371 roffs = LEB (); 3372 if (! do_debug_frames_interp) 3373 printf (" DW_CFA_offset: r%d at cfa%+ld\n", 3374 opa, roffs * fc->data_factor); 3375 fc->col_type[opa] = DW_CFA_offset; 3376 fc->col_offset[opa] = roffs * fc->data_factor; 3377 break; 3378 3379 case DW_CFA_restore: 3380 if (! do_debug_frames_interp) 3381 printf (" DW_CFA_restore: r%d\n", opa); 3382 fc->col_type[opa] = cie->col_type[opa]; 3383 fc->col_offset[opa] = cie->col_offset[opa]; 3384 break; 3385 3386 case DW_CFA_set_loc: 3387 vma = get_encoded_value (start, fc->fde_encoding); 3388 if ((fc->fde_encoding & 0x70) == DW_EH_PE_pcrel 3389 && !is_relocatable) 3390 vma += section->address + (start - section_start); 3391 start += encoded_ptr_size; 3392 if (do_debug_frames_interp) 3393 frame_display_row (fc, &need_col_headers, &max_regs); 3394 else 3395 printf (" DW_CFA_set_loc: %08lx\n", (unsigned long)vma); 3396 fc->pc_begin = vma; 3397 break; 3398 3399 case DW_CFA_advance_loc1: 3400 ofs = byte_get (start, 1); start += 1; 3401 if (do_debug_frames_interp) 3402 frame_display_row (fc, &need_col_headers, &max_regs); 3403 else 3404 printf (" DW_CFA_advance_loc1: %ld to %08lx\n", 3405 ofs * fc->code_factor, 3406 fc->pc_begin + ofs * fc->code_factor); 3407 fc->pc_begin += ofs * fc->code_factor; 3408 break; 3409 3410 case DW_CFA_advance_loc2: 3411 ofs = byte_get (start, 2); start += 2; 3412 if (do_debug_frames_interp) 3413 frame_display_row (fc, &need_col_headers, &max_regs); 3414 else 3415 printf (" DW_CFA_advance_loc2: %ld to %08lx\n", 3416 ofs * fc->code_factor, 3417 fc->pc_begin + ofs * fc->code_factor); 3418 fc->pc_begin += ofs * fc->code_factor; 3419 break; 3420 3421 case DW_CFA_advance_loc4: 3422 ofs = byte_get (start, 4); start += 4; 3423 if (do_debug_frames_interp) 3424 frame_display_row (fc, &need_col_headers, &max_regs); 3425 else 3426 printf (" DW_CFA_advance_loc4: %ld to %08lx\n", 3427 ofs * fc->code_factor, 3428 fc->pc_begin + ofs * fc->code_factor); 3429 fc->pc_begin += ofs * fc->code_factor; 3430 break; 3431 3432 case DW_CFA_offset_extended: 3433 reg = LEB (); 3434 roffs = LEB (); 3435 if (! do_debug_frames_interp) 3436 printf (" DW_CFA_offset_extended: r%ld at cfa%+ld\n", 3437 reg, roffs * fc->data_factor); 3438 fc->col_type[reg] = DW_CFA_offset; 3439 fc->col_offset[reg] = roffs * fc->data_factor; 3440 break; 3441 3442 case DW_CFA_val_offset: 3443 reg = LEB (); 3444 roffs = LEB (); 3445 if (! do_debug_frames_interp) 3446 printf (" DW_CFA_val_offset: r%ld at cfa%+ld\n", 3447 reg, roffs * fc->data_factor); 3448 fc->col_type[reg] = DW_CFA_val_offset; 3449 fc->col_offset[reg] = roffs * fc->data_factor; 3450 break; 3451 3452 case DW_CFA_restore_extended: 3453 reg = LEB (); 3454 if (! do_debug_frames_interp) 3455 printf (" DW_CFA_restore_extended: r%ld\n", reg); 3456 fc->col_type[reg] = cie->col_type[reg]; 3457 fc->col_offset[reg] = cie->col_offset[reg]; 3458 break; 3459 3460 case DW_CFA_undefined: 3461 reg = LEB (); 3462 if (! do_debug_frames_interp) 3463 printf (" DW_CFA_undefined: r%ld\n", reg); 3464 fc->col_type[reg] = DW_CFA_undefined; 3465 fc->col_offset[reg] = 0; 3466 break; 3467 3468 case DW_CFA_same_value: 3469 reg = LEB (); 3470 if (! do_debug_frames_interp) 3471 printf (" DW_CFA_same_value: r%ld\n", reg); 3472 fc->col_type[reg] = DW_CFA_same_value; 3473 fc->col_offset[reg] = 0; 3474 break; 3475 3476 case DW_CFA_register: 3477 reg = LEB (); 3478 roffs = LEB (); 3479 if (! do_debug_frames_interp) 3480 printf (" DW_CFA_register: r%ld in r%ld\n", reg, roffs); 3481 fc->col_type[reg] = DW_CFA_register; 3482 fc->col_offset[reg] = roffs; 3483 break; 3484 3485 case DW_CFA_remember_state: 3486 if (! do_debug_frames_interp) 3487 printf (" DW_CFA_remember_state\n"); 3488 rs = xmalloc (sizeof (Frame_Chunk)); 3489 rs->ncols = fc->ncols; 3490 rs->col_type = xcmalloc (rs->ncols, sizeof (short int)); 3491 rs->col_offset = xcmalloc (rs->ncols, sizeof (int)); 3492 memcpy (rs->col_type, fc->col_type, rs->ncols); 3493 memcpy (rs->col_offset, fc->col_offset, rs->ncols * sizeof (int)); 3494 rs->next = remembered_state; 3495 remembered_state = rs; 3496 break; 3497 3498 case DW_CFA_restore_state: 3499 if (! do_debug_frames_interp) 3500 printf (" DW_CFA_restore_state\n"); 3501 rs = remembered_state; 3502 if (rs) 3503 { 3504 remembered_state = rs->next; 3505 frame_need_space (fc, rs->ncols-1); 3506 memcpy (fc->col_type, rs->col_type, rs->ncols); 3507 memcpy (fc->col_offset, rs->col_offset, 3508 rs->ncols * sizeof (int)); 3509 free (rs->col_type); 3510 free (rs->col_offset); 3511 free (rs); 3512 } 3513 else if (do_debug_frames_interp) 3514 printf ("Mismatched DW_CFA_restore_state\n"); 3515 break; 3516 3517 case DW_CFA_def_cfa: 3518 fc->cfa_reg = LEB (); 3519 fc->cfa_offset = LEB (); 3520 fc->cfa_exp = 0; 3521 if (! do_debug_frames_interp) 3522 printf (" DW_CFA_def_cfa: r%d ofs %d\n", 3523 fc->cfa_reg, fc->cfa_offset); 3524 break; 3525 3526 case DW_CFA_def_cfa_register: 3527 fc->cfa_reg = LEB (); 3528 fc->cfa_exp = 0; 3529 if (! do_debug_frames_interp) 3530 printf (" DW_CFA_def_cfa_reg: r%d\n", fc->cfa_reg); 3531 break; 3532 3533 case DW_CFA_def_cfa_offset: 3534 fc->cfa_offset = LEB (); 3535 if (! do_debug_frames_interp) 3536 printf (" DW_CFA_def_cfa_offset: %d\n", fc->cfa_offset); 3537 break; 3538 3539 case DW_CFA_nop: 3540 if (! do_debug_frames_interp) 3541 printf (" DW_CFA_nop\n"); 3542 break; 3543 3544 case DW_CFA_def_cfa_expression: 3545 ul = LEB (); 3546 if (! do_debug_frames_interp) 3547 { 3548 printf (" DW_CFA_def_cfa_expression ("); 3549 decode_location_expression (start, eh_addr_size, ul, 0); 3550 printf (")\n"); 3551 } 3552 fc->cfa_exp = 1; 3553 start += ul; 3554 break; 3555 3556 case DW_CFA_expression: 3557 reg = LEB (); 3558 ul = LEB (); 3559 if (! do_debug_frames_interp) 3560 { 3561 printf (" DW_CFA_expression: r%ld (", reg); 3562 decode_location_expression (start, eh_addr_size, ul, 0); 3563 printf (")\n"); 3564 } 3565 fc->col_type[reg] = DW_CFA_expression; 3566 start += ul; 3567 break; 3568 3569 case DW_CFA_val_expression: 3570 reg = LEB (); 3571 ul = LEB (); 3572 if (! do_debug_frames_interp) 3573 { 3574 printf (" DW_CFA_val_expression: r%ld (", reg); 3575 decode_location_expression (start, eh_addr_size, ul, 0); 3576 printf (")\n"); 3577 } 3578 fc->col_type[reg] = DW_CFA_val_expression; 3579 start += ul; 3580 break; 3581 3582 case DW_CFA_offset_extended_sf: 3583 reg = LEB (); 3584 l = SLEB (); 3585 frame_need_space (fc, reg); 3586 if (! do_debug_frames_interp) 3587 printf (" DW_CFA_offset_extended_sf: r%ld at cfa%+ld\n", 3588 reg, l * fc->data_factor); 3589 fc->col_type[reg] = DW_CFA_offset; 3590 fc->col_offset[reg] = l * fc->data_factor; 3591 break; 3592 3593 case DW_CFA_val_offset_sf: 3594 reg = LEB (); 3595 l = SLEB (); 3596 frame_need_space (fc, reg); 3597 if (! do_debug_frames_interp) 3598 printf (" DW_CFA_val_offset_sf: r%ld at cfa%+ld\n", 3599 reg, l * fc->data_factor); 3600 fc->col_type[reg] = DW_CFA_val_offset; 3601 fc->col_offset[reg] = l * fc->data_factor; 3602 break; 3603 3604 case DW_CFA_def_cfa_sf: 3605 fc->cfa_reg = LEB (); 3606 fc->cfa_offset = SLEB (); 3607 fc->cfa_offset = fc->cfa_offset * fc->data_factor; 3608 fc->cfa_exp = 0; 3609 if (! do_debug_frames_interp) 3610 printf (" DW_CFA_def_cfa_sf: r%d ofs %d\n", 3611 fc->cfa_reg, fc->cfa_offset); 3612 break; 3613 3614 case DW_CFA_def_cfa_offset_sf: 3615 fc->cfa_offset = SLEB (); 3616 fc->cfa_offset = fc->cfa_offset * fc->data_factor; 3617 if (! do_debug_frames_interp) 3618 printf (" DW_CFA_def_cfa_offset_sf: %d\n", fc->cfa_offset); 3619 break; 3620 3621 case DW_CFA_MIPS_advance_loc8: 3622 ofs = byte_get (start, 8); start += 8; 3623 if (do_debug_frames_interp) 3624 frame_display_row (fc, &need_col_headers, &max_regs); 3625 else 3626 printf (" DW_CFA_MIPS_advance_loc8: %ld to %08lx\n", 3627 ofs * fc->code_factor, 3628 fc->pc_begin + ofs * fc->code_factor); 3629 fc->pc_begin += ofs * fc->code_factor; 3630 break; 3631 3632 case DW_CFA_GNU_window_save: 3633 if (! do_debug_frames_interp) 3634 printf (" DW_CFA_GNU_window_save\n"); 3635 break; 3636 3637 case DW_CFA_GNU_args_size: 3638 ul = LEB (); 3639 if (! do_debug_frames_interp) 3640 printf (" DW_CFA_GNU_args_size: %ld\n", ul); 3641 break; 3642 3643 case DW_CFA_GNU_negative_offset_extended: 3644 reg = LEB (); 3645 l = - LEB (); 3646 frame_need_space (fc, reg); 3647 if (! do_debug_frames_interp) 3648 printf (" DW_CFA_GNU_negative_offset_extended: r%ld at cfa%+ld\n", 3649 reg, l * fc->data_factor); 3650 fc->col_type[reg] = DW_CFA_offset; 3651 fc->col_offset[reg] = l * fc->data_factor; 3652 break; 3653 3654 default: 3655 if (op >= DW_CFA_lo_user && op <= DW_CFA_hi_user) 3656 printf (_(" DW_CFA_??? (User defined call frame op: %#x)\n"), op); 3657 else 3658 warn (_("unsupported or unknown Dwarf Call Frame Instruction number: %#x\n"), op); 3659 start = block_end; 3660 } 3661 } 3662 3663 if (do_debug_frames_interp) 3664 frame_display_row (fc, &need_col_headers, &max_regs); 3665 3666 start = block_end; 3667 } 3668 3669 printf ("\n"); 3670 3671 return 1; 3672} 3673 3674#undef GET 3675#undef LEB 3676#undef SLEB 3677 3678static int 3679display_debug_not_supported (struct dwarf_section *section, 3680 void *file ATTRIBUTE_UNUSED) 3681{ 3682 printf (_("Displaying the debug contents of section %s is not yet supported.\n"), 3683 section->name); 3684 3685 return 1; 3686} 3687 3688void * 3689cmalloc (size_t nmemb, size_t size) 3690{ 3691 /* Check for overflow. */ 3692 if (nmemb >= ~(size_t) 0 / size) 3693 return NULL; 3694 else 3695 return malloc (nmemb * size); 3696} 3697 3698void * 3699xcmalloc (size_t nmemb, size_t size) 3700{ 3701 /* Check for overflow. */ 3702 if (nmemb >= ~(size_t) 0 / size) 3703 return NULL; 3704 else 3705 return xmalloc (nmemb * size); 3706} 3707 3708void * 3709xcrealloc (void *ptr, size_t nmemb, size_t size) 3710{ 3711 /* Check for overflow. */ 3712 if (nmemb >= ~(size_t) 0 / size) 3713 return NULL; 3714 else 3715 return xrealloc (ptr, nmemb * size); 3716} 3717 3718void 3719error (const char *message, ...) 3720{ 3721 va_list args; 3722 3723 va_start (args, message); 3724 fprintf (stderr, _("%s: Error: "), program_name); 3725 vfprintf (stderr, message, args); 3726 va_end (args); 3727} 3728 3729void 3730warn (const char *message, ...) 3731{ 3732 va_list args; 3733 3734 va_start (args, message); 3735 fprintf (stderr, _("%s: Warning: "), program_name); 3736 vfprintf (stderr, message, args); 3737 va_end (args); 3738} 3739 3740void 3741free_debug_memory (void) 3742{ 3743 enum dwarf_section_display_enum i; 3744 3745 free_abbrevs (); 3746 3747 for (i = 0; i < max; i++) 3748 free_debug_section (i); 3749 3750 if (debug_information) 3751 { 3752 for (i = 0; i < num_debug_info_entries; i++) 3753 { 3754 if (!debug_information [i].max_loc_offsets) 3755 { 3756 free (debug_information [i].loc_offsets); 3757 free (debug_information [i].have_frame_base); 3758 } 3759 if (!debug_information [i].max_range_lists) 3760 free (debug_information [i].range_lists); 3761 } 3762 free (debug_information); 3763 debug_information = NULL; 3764 num_debug_info_entries = 0; 3765 } 3766 3767} 3768 3769struct dwarf_section_display debug_displays[] = 3770{ 3771 { { ".debug_abbrev", NULL, 0, 0 }, 3772 display_debug_abbrev, 0, 0 }, 3773 { { ".debug_aranges", NULL, 0, 0 }, 3774 display_debug_aranges, 0, 0 }, 3775 { { ".debug_frame", NULL, 0, 0 }, 3776 display_debug_frames, 1, 0 }, 3777 { { ".debug_info", NULL, 0, 0 }, 3778 display_debug_info, 1, 0 }, 3779 { { ".debug_line", NULL, 0, 0 }, 3780 display_debug_lines, 0, 0 }, 3781 { { ".debug_pubnames", NULL, 0, 0 }, 3782 display_debug_pubnames, 0, 0 }, 3783 { { ".eh_frame", NULL, 0, 0 }, 3784 display_debug_frames, 1, 1 }, 3785 { { ".debug_macinfo", NULL, 0, 0 }, 3786 display_debug_macinfo, 0, 0 }, 3787 { { ".debug_str", NULL, 0, 0 }, 3788 display_debug_str, 0, 0 }, 3789 { { ".debug_loc", NULL, 0, 0 }, 3790 display_debug_loc, 0, 0 }, 3791 { { ".debug_pubtypes", NULL, 0, 0 }, 3792 display_debug_pubnames, 0, 0 }, 3793 { { ".debug_ranges", NULL, 0, 0 }, 3794 display_debug_ranges, 0, 0 }, 3795 { { ".debug_static_func", NULL, 0, 0 }, 3796 display_debug_not_supported, 0, 0 }, 3797 { { ".debug_static_vars", NULL, 0, 0 }, 3798 display_debug_not_supported, 0, 0 }, 3799 { { ".debug_types", NULL, 0, 0 }, 3800 display_debug_not_supported, 0, 0 }, 3801 { { ".debug_weaknames", NULL, 0, 0 }, 3802 display_debug_not_supported, 0, 0 } 3803}; 3804