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