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