1 2 /*--------------------------------------------------------------------*/ 3 /*--- Read DWARF1/2/3/4 debug info. readdwarf.c ---*/ 4 /*--------------------------------------------------------------------*/ 5 6 /* 7 This file is part of Valgrind, a dynamic binary instrumentation 8 framework. 9 10 Copyright (C) 2000-2012 Julian Seward 11 jseward (at) acm.org 12 13 This program is free software; you can redistribute it and/or 14 modify it under the terms of the GNU General Public License as 15 published by the Free Software Foundation; either version 2 of the 16 License, or (at your option) any later version. 17 18 This program is distributed in the hope that it will be useful, but 19 WITHOUT ANY WARRANTY; without even the implied warranty of 20 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU 21 General Public License for more details. 22 23 You should have received a copy of the GNU General Public License 24 along with this program; if not, write to the Free Software 25 Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 26 02111-1307, USA. 27 28 The GNU General Public License is contained in the file COPYING. 29 */ 30 31 #if defined(VGO_linux) || defined(VGO_darwin) 32 33 #include "pub_core_basics.h" 34 #include "pub_core_debuginfo.h" 35 #include "pub_core_libcbase.h" 36 #include "pub_core_libcassert.h" 37 #include "pub_core_libcprint.h" 38 #include "pub_core_options.h" 39 #include "pub_core_xarray.h" 40 #include "pub_core_tooliface.h" /* VG_(needs) */ 41 #include "priv_misc.h" /* dinfo_zalloc/free/strdup */ 42 #include "priv_d3basics.h" 43 #include "priv_tytypes.h" 44 #include "priv_storage.h" 45 #include "priv_readdwarf.h" /* self */ 46 47 48 /*------------------------------------------------------------*/ 49 /*--- ---*/ 50 /*--- Read line number and CFI info from DWARF1, DWARF2 ---*/ 51 /*--- and to some extent DWARF3 sections. ---*/ 52 /*--- ---*/ 53 /*------------------------------------------------------------*/ 54 55 /*------------------------------------------------------------*/ 56 /*--- Expanding arrays of words, for holding file name and ---*/ 57 /*--- directory name arrays. ---*/ 58 /*------------------------------------------------------------*/ 59 60 typedef 61 struct { 62 Word* tab; 63 UInt tab_size; 64 UInt tab_used; 65 } 66 WordArray; 67 68 static void init_WordArray ( WordArray* wa ) 69 { 70 wa->tab = NULL; 71 wa->tab_size = 0; 72 wa->tab_used = 0; 73 } 74 75 static void free_WordArray ( WordArray* wa ) 76 { 77 if (wa->tab) { 78 vg_assert(wa->tab_size > 0); 79 ML_(dinfo_free)(wa->tab); 80 } 81 init_WordArray(wa); 82 } 83 84 static void addto_WordArray ( WordArray* wa, Word w ) 85 { 86 UInt new_size, i; 87 Word* new_tab; 88 89 if (0) VG_(printf)("<<ADD %p (new sz = %d) >>\n", 90 (HChar*)w, wa->tab_used+1); 91 92 if (wa->tab_used < wa->tab_size) { 93 /* fine */ 94 } else { 95 /* expand array */ 96 if (0) VG_(printf)("EXPAND ARRAY from %d\n", wa->tab_size); 97 vg_assert(wa->tab_used == wa->tab_size); 98 vg_assert( (wa->tab_size == 0 && wa->tab == NULL) 99 || (wa->tab_size != 0 && wa->tab != NULL) ); 100 new_size = wa->tab_size == 0 ? 8 : 2 * wa->tab_size; 101 new_tab = ML_(dinfo_zalloc)("di.aWA.1", new_size * sizeof(Word)); 102 vg_assert(new_tab != NULL); 103 for (i = 0; i < wa->tab_used; i++) 104 new_tab[i] = wa->tab[i]; 105 wa->tab_size = new_size; 106 if (wa->tab) 107 ML_(dinfo_free)(wa->tab); 108 wa->tab = new_tab; 109 } 110 111 vg_assert(wa->tab_used < wa->tab_size); 112 vg_assert(wa->tab_size > 0); 113 wa->tab[wa->tab_used] = w; 114 wa->tab_used++; 115 } 116 117 static Word index_WordArray ( /*OUT*/Bool* inRange, WordArray* wa, Int i ) 118 { 119 vg_assert(inRange); 120 if (i >= 0 && i < wa->tab_used) { 121 *inRange = True; 122 return wa->tab[i]; 123 } else { 124 *inRange = False; 125 return 0; 126 } 127 } 128 129 130 /*------------------------------------------------------------*/ 131 /*--- Read DWARF2 format line number info. ---*/ 132 /*------------------------------------------------------------*/ 133 134 /* Structure holding info extracted from the a .debug_line 135 section. */ 136 typedef struct 137 { 138 ULong li_length; 139 UShort li_version; 140 ULong li_header_length; 141 UChar li_min_insn_length; 142 UChar li_max_ops_per_insn; 143 UChar li_default_is_stmt; 144 Int li_line_base; 145 UChar li_line_range; 146 UChar li_opcode_base; 147 } 148 DebugLineInfo; 149 150 /* Structure holding additional infos found from a .debug_info 151 * compilation unit block */ 152 typedef struct 153 { 154 /* Feel free to add more members here if you need ! */ 155 Char* compdir; /* Compilation directory - points to .debug_info */ 156 Char* name; /* Main file name - points to .debug_info */ 157 ULong stmt_list; /* Offset in .debug_line */ 158 Bool dw64; /* 64-bit Dwarf? */ 159 } 160 UnitInfo; 161 162 /* Line number opcodes. */ 163 enum dwarf_line_number_ops 164 { 165 DW_LNS_extended_op = 0, 166 DW_LNS_copy = 1, 167 DW_LNS_advance_pc = 2, 168 DW_LNS_advance_line = 3, 169 DW_LNS_set_file = 4, 170 DW_LNS_set_column = 5, 171 DW_LNS_negate_stmt = 6, 172 DW_LNS_set_basic_block = 7, 173 DW_LNS_const_add_pc = 8, 174 DW_LNS_fixed_advance_pc = 9, 175 /* DWARF 3. */ 176 DW_LNS_set_prologue_end = 10, 177 DW_LNS_set_epilogue_begin = 11, 178 DW_LNS_set_isa = 12 179 }; 180 181 /* Line number extended opcodes. */ 182 enum dwarf_line_number_x_ops 183 { 184 DW_LNE_end_sequence = 1, 185 DW_LNE_set_address = 2, 186 DW_LNE_define_file = 3, 187 DW_LNE_set_discriminator = 4 188 }; 189 190 typedef struct 191 { 192 /* Information for the last statement boundary. 193 * Needed to calculate statement lengths. */ 194 Addr last_address; 195 UInt last_file; 196 UInt last_line; 197 198 Addr address; 199 UInt file; 200 UInt line; 201 UInt column; 202 Int is_stmt; 203 Int basic_block; 204 UChar end_sequence; 205 } LineSMR; 206 207 208 /* FIXME: duplicated in readdwarf3.c */ 209 static 210 ULong read_leb128 ( UChar* data, Int* length_return, Int sign ) 211 { 212 ULong result = 0; 213 UInt num_read = 0; 214 Int shift = 0; 215 UChar byte; 216 217 vg_assert(sign == 0 || sign == 1); 218 219 do 220 { 221 byte = * data ++; 222 num_read ++; 223 224 result |= ((ULong)(byte & 0x7f)) << shift; 225 226 shift += 7; 227 228 } 229 while (byte & 0x80); 230 231 if (length_return != NULL) 232 * length_return = num_read; 233 234 if (sign && (shift < 64) && (byte & 0x40)) 235 result |= -(1ULL << shift); 236 237 return result; 238 } 239 240 /* Small helper functions easier to use 241 * value is returned and the given pointer is 242 * moved past end of leb128 data */ 243 /* FIXME: duplicated in readdwarf3.c */ 244 static ULong read_leb128U( UChar **data ) 245 { 246 Int len; 247 ULong val = read_leb128( *data, &len, 0 ); 248 *data += len; 249 return val; 250 } 251 252 /* Same for signed data */ 253 /* FIXME: duplicated in readdwarf3.c */ 254 static Long read_leb128S( UChar **data ) 255 { 256 Int len; 257 ULong val = read_leb128( *data, &len, 1 ); 258 *data += len; 259 return (Long)val; 260 } 261 262 /* Read what the DWARF3 spec calls an "initial length field". This 263 uses up either 4 or 12 bytes of the input and produces a 32-bit or 264 64-bit number respectively. 265 266 Read 32-bit value from p. If it is 0xFFFFFFFF, instead read a 267 64-bit bit value from p+4. This is used in 64-bit dwarf to encode 268 some table lengths. 269 270 XXX this is a hack: the endianness of the initial length field is 271 specified by the DWARF we're reading. This happens to work only 272 because we don't do cross-arch jitting, hence this code runs on a 273 platform of the same endianness as the DWARF it is reading. Same 274 applies for initial lengths for CIE/FDEs and probably in zillions 275 of other places -- to be precise, exactly the places where 276 binutils/dwarf.c calls byte_get(). 277 */ 278 static ULong read_initial_length_field ( UChar* p_img, /*OUT*/Bool* is64 ) 279 { 280 UInt w32 = ML_(read_UInt)(p_img); 281 if (w32 == 0xFFFFFFFF) { 282 *is64 = True; 283 return ML_(read_ULong)(p_img+4); 284 } else { 285 *is64 = False; 286 return (ULong)w32; 287 } 288 } 289 290 291 static LineSMR state_machine_regs; 292 293 static 294 void reset_state_machine ( Int is_stmt ) 295 { 296 if (0) VG_(printf)("smr.a := %p (reset)\n", NULL ); 297 state_machine_regs.last_address = 0; 298 state_machine_regs.last_file = 1; 299 state_machine_regs.last_line = 1; 300 state_machine_regs.address = 0; 301 state_machine_regs.file = 1; 302 state_machine_regs.line = 1; 303 state_machine_regs.column = 0; 304 state_machine_regs.is_stmt = is_stmt; 305 state_machine_regs.basic_block = 0; 306 state_machine_regs.end_sequence = 0; 307 } 308 309 /* Look up a directory name, or return NULL if unknown. */ 310 static 311 Char* lookupDir ( Int filename_index, 312 WordArray* fnidx2dir, 313 WordArray* dirnames ) 314 { 315 Bool inRange; 316 Word diridx, dirname; 317 318 diridx = index_WordArray( &inRange, fnidx2dir, filename_index ); 319 if (!inRange) goto bad; 320 321 dirname = index_WordArray( &inRange, dirnames, (Int)diridx ); 322 if (!inRange) goto bad; 323 324 return (Char*)dirname; 325 bad: 326 return NULL; 327 } 328 329 //////////////////////////////////////////////////////////////////// 330 //////////////////////////////////////////////////////////////////// 331 332 /* Handled an extended line op starting at 'data'. Returns the number 333 of bytes that 'data' should be advanced by. */ 334 static 335 Word process_extended_line_op( struct _DebugInfo* di, 336 WordArray* filenames, 337 WordArray* dirnames, 338 WordArray* fnidx2dir, 339 UChar* data, Int is_stmt) 340 { 341 UChar op_code; 342 Int bytes_read; 343 UInt len; 344 UChar* name; 345 Addr adr; 346 347 len = read_leb128 (data, & bytes_read, 0); 348 data += bytes_read; 349 350 if (len == 0) { 351 VG_(message)(Vg_UserMsg, 352 "Warning: DWARF2 reader: " 353 "Badly formed extended line op encountered\n"); 354 return (Word)bytes_read; 355 } 356 357 len += bytes_read; 358 op_code = * data ++; 359 360 if (0) VG_(printf)("dwarf2: ext OPC: %d\n", op_code); 361 362 switch (op_code) { 363 case DW_LNE_end_sequence: 364 if (0) VG_(printf)("1001: si->o %#lx, smr.a %#lx\n", 365 di->text_debug_bias, state_machine_regs.address ); 366 /* JRS: added for compliance with spec; is pointless due to 367 reset_state_machine below */ 368 state_machine_regs.end_sequence = 1; 369 370 if (state_machine_regs.is_stmt) { 371 if (state_machine_regs.last_address) { 372 Bool inRange = False; 373 Char* filename 374 = (Char*)index_WordArray( &inRange, filenames, 375 state_machine_regs.last_file); 376 if (!inRange || !filename) 377 filename = "???"; 378 ML_(addLineInfo) ( 379 di, 380 filename, 381 lookupDir( state_machine_regs.last_file, 382 fnidx2dir, dirnames ), 383 di->text_debug_bias + state_machine_regs.last_address, 384 di->text_debug_bias + state_machine_regs.address, 385 state_machine_regs.last_line, 0 386 ); 387 } 388 } 389 reset_state_machine (is_stmt); 390 if (di->ddump_line) 391 VG_(printf)(" Extended opcode %d: End of Sequence\n\n", 392 (Int)op_code); 393 break; 394 395 case DW_LNE_set_address: 396 adr = ML_(read_Addr)(data); 397 state_machine_regs.address = adr; 398 if (di->ddump_line) 399 VG_(printf)(" Extended opcode %d: set Address to 0x%lx\n", 400 (Int)op_code, (Addr)adr); 401 break; 402 403 case DW_LNE_define_file: 404 name = data; 405 addto_WordArray( filenames, (Word)ML_(addStr)(di,name,-1) ); 406 data += VG_(strlen) ((char *) data) + 1; 407 read_leb128 (data, & bytes_read, 0); 408 data += bytes_read; 409 read_leb128 (data, & bytes_read, 0); 410 data += bytes_read; 411 read_leb128 (data, & bytes_read, 0); 412 if (di->ddump_line) 413 VG_(printf)(" DWARF2-line: set_address\n"); 414 break; 415 416 case DW_LNE_set_discriminator: 417 read_leb128 (data, & bytes_read, 0); 418 data += bytes_read; 419 break; 420 421 default: 422 if (di->ddump_line) 423 VG_(printf)("process_extended_line_op:default\n"); 424 break; 425 } 426 427 return (Word)len; 428 } 429 430 //////////////////////////////////////////////////////////////////// 431 //////////////////////////////////////////////////////////////////// 432 433 /* read a .debug_line section block for a compilation unit 434 * 435 * Input: - theBlock must point to the start of the block 436 * for the given compilation unit 437 * - ui contains additional info like the compilation dir 438 * for this unit 439 * 440 * Output: - si debug info structures get updated 441 */ 442 static 443 void read_dwarf2_lineblock ( struct _DebugInfo* di, 444 UnitInfo* ui, 445 UChar* theBlock, /* IMAGE */ 446 Int noLargerThan ) 447 { 448 Int i; 449 DebugLineInfo info; 450 UChar* standard_opcodes; 451 UChar* end_of_sequence; 452 Bool is64; 453 WordArray filenames; 454 WordArray dirnames; 455 WordArray fnidx2dir; 456 457 UChar* external = theBlock; 458 UChar* data = theBlock; 459 460 /* filenames is an array of file names harvested from the DWARF2 461 info. Entry [0] is NULL and is never referred to by the state 462 machine. 463 464 Similarly, dirnames is an array of directory names. Entry [0] 465 is also NULL and denotes "we don't know what the path is", since 466 that is different from "the path is the empty string". Unlike 467 the file name table, the state machine does refer to entry [0], 468 which basically means "." ("the current directory of the 469 compilation", whatever that means, according to the DWARF3 470 spec.) 471 472 fnidx2dir is an array of indexes into the dirnames table. 473 (confused yet?) filenames[] and fnidx2dir[] are indexed 474 together. That is, for some index i in the filename table, then 475 476 the filename is filenames[i] 477 the directory is dirnames[ fnidx2dir[i] ] */ 478 479 /* Fails due to gcc padding ... 480 vg_assert(sizeof(DWARF2_External_LineInfo) 481 == sizeof(DWARF2_Internal_LineInfo)); 482 */ 483 484 init_WordArray(&filenames); 485 init_WordArray(&dirnames); 486 init_WordArray(&fnidx2dir); 487 488 /* DWARF2 starts numbering filename entries at 1, so we need to 489 add a dummy zeroth entry to the table. The zeroth dirnames 490 entry denotes 'current directory of compilation' so we might 491 as well make the fnidx2dir zeroth entry denote that. 492 */ 493 addto_WordArray( &filenames, (Word)NULL ); 494 495 if (ui->compdir) 496 addto_WordArray( &dirnames, (Word)ML_(addStr)(di, ui->compdir, -1) ); 497 else 498 addto_WordArray( &dirnames, (Word)ML_(addStr)(di, ".", -1) ); 499 500 addto_WordArray( &fnidx2dir, (Word)0 ); /* compilation dir */ 501 502 info.li_length = read_initial_length_field( external, &is64 ); 503 external += is64 ? 12 : 4; 504 if (di->ddump_line) 505 VG_(printf)(" Length: %llu\n", 506 info.li_length); 507 508 /* Check the length of the block. */ 509 if (info.li_length > noLargerThan) { 510 ML_(symerr)(di, True, 511 "DWARF line info appears to be corrupt " 512 "- the section is too small"); 513 goto out; 514 } 515 516 /* Check its version number. */ 517 info.li_version = ML_(read_UShort)(external); 518 external += 2; 519 if (di->ddump_line) 520 VG_(printf)(" DWARF Version: %d\n", 521 (Int)info.li_version); 522 523 if (info.li_version != 2 && info.li_version != 3 && info.li_version != 4) { 524 ML_(symerr)(di, True, 525 "Only DWARF version 2, 3 and 4 line info " 526 "is currently supported."); 527 goto out; 528 } 529 530 info.li_header_length = ui->dw64 ? ML_(read_ULong)(external) 531 : (ULong)(ML_(read_UInt)(external)); 532 external += ui->dw64 ? 8 : 4; 533 if (di->ddump_line) 534 VG_(printf)(" Prologue Length: %llu\n", 535 info.li_header_length); 536 537 info.li_min_insn_length = * ((UChar *)external); 538 external += 1; 539 if (di->ddump_line) 540 VG_(printf)(" Minimum Instruction Length: %d\n", 541 (Int)info.li_min_insn_length); 542 543 /* We only support machines with one opcode per instruction 544 for now. If we ever want to support VLIW machines there is 545 code to handle multiple opcodes per instruction in the 546 patch attached to BZ#233595. 547 */ 548 if (info.li_version >= 4) { 549 info.li_max_ops_per_insn = * ((UChar *)external); 550 if (info.li_max_ops_per_insn != 1) { 551 ML_(symerr)(di, True, 552 "Invalid Maximum Ops Per Insn in line info."); 553 goto out; 554 } 555 external += 1; 556 if (di->ddump_line) 557 VG_(printf)(" Maximum Ops Per Insn: %d\n", 558 (Int)info.li_max_ops_per_insn); 559 } else { 560 info.li_max_ops_per_insn = 1; 561 } 562 563 info.li_default_is_stmt = * ((UChar *)external); 564 external += 1; 565 if (di->ddump_line) 566 VG_(printf)(" Initial value of 'is_stmt': %d\n", 567 (Int)info.li_default_is_stmt); 568 569 /* Josef Weidendorfer (20021021) writes: 570 571 It seems to me that the Intel Fortran compiler generates bad 572 DWARF2 line info code: It sets "is_stmt" of the state machine in 573 the the line info reader to be always false. Thus, there is 574 never a statement boundary generated and therefore never a 575 instruction range/line number mapping generated for valgrind. 576 577 Please have a look at the DWARF2 specification, Ch. 6.2 578 (x86.ddj.com/ftp/manuals/tools/dwarf.pdf). Perhaps I understand 579 this wrong, but I don't think so. 580 581 I just had a look at the GDB DWARF2 reader... They completely 582 ignore "is_stmt" when recording line info ;-) That's the reason 583 "objdump -S" works on files from the the intel fortran compiler. 584 585 Therefore: */ 586 info.li_default_is_stmt = True; 587 588 /* JRS: changed (UInt*) to (UChar*) */ 589 info.li_line_base = * ((UChar *)external); 590 info.li_line_base = (Int)(signed char)info.li_line_base; 591 external += 1; 592 if (di->ddump_line) 593 VG_(printf)(" Line Base: %d\n", 594 info.li_line_base); 595 596 info.li_line_range = * ((UChar *)external); 597 external += 1; 598 if (di->ddump_line) 599 VG_(printf)(" Line Range: %d\n", 600 (Int)info.li_line_range); 601 602 info.li_opcode_base = * ((UChar *)external); 603 external += 1; 604 if (di->ddump_line) 605 VG_(printf)(" Opcode Base: %d\n\n", 606 info.li_opcode_base); 607 608 if (0) VG_(printf)("dwarf2: line base: %d, range %d, opc base: %d\n", 609 (Int)info.li_line_base, 610 (Int)info.li_line_range, 611 (Int)info.li_opcode_base); 612 613 end_of_sequence = data + info.li_length 614 + (is64 ? 12 : 4); 615 616 reset_state_machine (info.li_default_is_stmt); 617 618 /* Read the contents of the Opcodes table. */ 619 standard_opcodes = external; 620 if (di->ddump_line) { 621 VG_(printf)(" Opcodes:\n"); 622 for (i = 1; i < (Int)info.li_opcode_base; i++) { 623 VG_(printf)(" Opcode %d has %d args\n", 624 i, (Int)standard_opcodes[i-1]); 625 } 626 VG_(printf)("\n"); 627 } 628 629 /* Read the contents of the Directory table. */ 630 data = standard_opcodes + info.li_opcode_base - 1; 631 632 if (di->ddump_line) 633 VG_(printf)(" The Directory Table%s\n", 634 *data == 0 ? " is empty." : ":" ); 635 636 while (* data != 0) { 637 638 # define NBUF 4096 639 static Char buf[NBUF]; 640 641 if (di->ddump_line) 642 VG_(printf)(" %s\n", data); 643 644 /* If data[0] is '/', then 'data' is an absolute path and we 645 don't mess with it. Otherwise, if we can, construct the 646 'path ui->compdir' ++ "/" ++ 'data'. */ 647 648 if (*data != '/' 649 /* not an absolute path */ 650 && ui->compdir != NULL 651 /* actually got something sensible for compdir */ 652 && VG_(strlen)(ui->compdir) + VG_(strlen)(data) + 5/*paranoia*/ < NBUF 653 /* it's short enough to concatenate */) 654 { 655 buf[0] = 0; 656 VG_(strcat)(buf, ui->compdir); 657 VG_(strcat)(buf, "/"); 658 VG_(strcat)(buf, data); 659 vg_assert(VG_(strlen)(buf) < NBUF); 660 addto_WordArray( &dirnames, (Word)ML_(addStr)(di,buf,-1) ); 661 if (0) VG_(printf)("rel path %s\n", buf); 662 } else { 663 /* just use 'data'. */ 664 addto_WordArray( &dirnames, (Word)ML_(addStr)(di,data,-1) ); 665 if (0) VG_(printf)("abs path %s\n", data); 666 } 667 668 data += VG_(strlen)(data) + 1; 669 670 # undef NBUF 671 } 672 673 if (di->ddump_line) 674 VG_(printf)("\n"); 675 676 if (*data != 0) { 677 ML_(symerr)(di, True, 678 "can't find NUL at end of DWARF2 directory table"); 679 goto out; 680 } 681 data ++; 682 683 /* Read the contents of the File Name table. This produces a bunch 684 of file names, and for each, an index to the corresponding 685 directory name entry. */ 686 if (di->ddump_line) { 687 VG_(printf)(" The File Name Table:\n"); 688 VG_(printf)(" Entry Dir Time Size Name\n"); 689 } 690 691 i = 1; 692 while (* data != 0) { 693 UChar* name; 694 Int bytes_read, diridx; 695 Int uu_time, uu_size; /* unused, and a guess */ 696 name = data; 697 data += VG_(strlen) ((Char *) data) + 1; 698 699 diridx = read_leb128 (data, & bytes_read, 0); 700 data += bytes_read; 701 uu_time = read_leb128 (data, & bytes_read, 0); 702 data += bytes_read; 703 uu_size = read_leb128 (data, & bytes_read, 0); 704 data += bytes_read; 705 706 addto_WordArray( &filenames, (Word)ML_(addStr)(di,name,-1) ); 707 addto_WordArray( &fnidx2dir, (Word)diridx ); 708 if (0) VG_(printf)("file %s diridx %d\n", name, diridx ); 709 if (di->ddump_line) 710 VG_(printf)(" %d\t%d\t%d\t%d\t%s\n", 711 i, diridx, uu_time, uu_size, name); 712 i++; 713 } 714 715 if (di->ddump_line) 716 VG_(printf)("\n"); 717 718 if (*data != 0) { 719 ML_(symerr)(di, True, 720 "can't find NUL at end of DWARF2 file name table"); 721 goto out; 722 } 723 data ++; 724 725 if (di->ddump_line) 726 VG_(printf)(" Line Number Statements:\n"); 727 728 /* Now display the statements. */ 729 730 while (data < end_of_sequence) { 731 732 UChar op_code; 733 Int adv; 734 Int bytes_read; 735 736 op_code = * data ++; 737 738 if (0) VG_(printf)("dwarf2: OPC: %d\n", op_code); 739 740 if (op_code >= info.li_opcode_base) { 741 742 Int advAddr; 743 op_code -= info.li_opcode_base; 744 adv = (op_code / info.li_line_range) 745 * info.li_min_insn_length; 746 advAddr = adv; 747 state_machine_regs.address += adv; 748 749 if (0) VG_(printf)("smr.a += %#x\n", adv ); 750 adv = (op_code % info.li_line_range) + info.li_line_base; 751 if (0) VG_(printf)("1002: di->o %#lx, smr.a %#lx\n", 752 di->text_debug_bias, state_machine_regs.address ); 753 state_machine_regs.line += adv; 754 755 if (di->ddump_line) 756 VG_(printf)(" Special opcode %d: advance Address by %d " 757 "to 0x%lx and Line by %d to %d\n", 758 (Int)op_code, advAddr, state_machine_regs.address, 759 (Int)adv, (Int)state_machine_regs.line ); 760 761 if (state_machine_regs.is_stmt) { 762 /* only add a statement if there was a previous boundary */ 763 if (state_machine_regs.last_address) { 764 Bool inRange = False; 765 Char* filename 766 = (Char*)index_WordArray( &inRange, &filenames, 767 state_machine_regs.last_file); 768 if (!inRange || !filename) 769 filename = "???"; 770 ML_(addLineInfo)( 771 di, 772 filename, 773 lookupDir( state_machine_regs.last_file, 774 &fnidx2dir, &dirnames ), 775 di->text_debug_bias + state_machine_regs.last_address, 776 di->text_debug_bias + state_machine_regs.address, 777 state_machine_regs.last_line, 778 0 779 ); 780 } 781 state_machine_regs.last_address = state_machine_regs.address; 782 state_machine_regs.last_file = state_machine_regs.file; 783 state_machine_regs.last_line = state_machine_regs.line; 784 } 785 786 } 787 788 else { /* ! (op_code >= info.li_opcode_base) */ 789 790 switch (op_code) { 791 case DW_LNS_extended_op: 792 data += process_extended_line_op ( 793 di, &filenames, &dirnames, &fnidx2dir, 794 data, info.li_default_is_stmt); 795 break; 796 797 case DW_LNS_copy: 798 if (0) VG_(printf)("1002: di->o %#lx, smr.a %#lx\n", 799 di->text_debug_bias, state_machine_regs.address ); 800 if (state_machine_regs.is_stmt) { 801 /* only add a statement if there was a previous boundary */ 802 if (state_machine_regs.last_address) { 803 Bool inRange = False; 804 Char* filename 805 = (Char*)index_WordArray( &inRange, &filenames, 806 state_machine_regs.last_file ); 807 if (!inRange || !filename) 808 filename = "???"; 809 ML_(addLineInfo)( 810 di, 811 filename, 812 lookupDir( state_machine_regs.last_file, 813 &fnidx2dir, &dirnames ), 814 di->text_debug_bias + state_machine_regs.last_address, 815 di->text_debug_bias + state_machine_regs.address, 816 state_machine_regs.last_line, 817 0 818 ); 819 } 820 state_machine_regs.last_address = state_machine_regs.address; 821 state_machine_regs.last_file = state_machine_regs.file; 822 state_machine_regs.last_line = state_machine_regs.line; 823 } 824 state_machine_regs.basic_block = 0; /* JRS added */ 825 if (di->ddump_line) 826 VG_(printf)(" Copy\n"); 827 break; 828 829 case DW_LNS_advance_pc: 830 adv = info.li_min_insn_length 831 * read_leb128 (data, & bytes_read, 0); 832 data += bytes_read; 833 state_machine_regs.address += adv; 834 if (0) VG_(printf)("smr.a += %#x\n", adv ); 835 if (di->ddump_line) 836 VG_(printf)(" Advance PC by %d to 0x%lx\n", 837 (Int)adv, state_machine_regs.address); 838 break; 839 840 case DW_LNS_advance_line: 841 adv = read_leb128 (data, & bytes_read, 1); 842 data += bytes_read; 843 state_machine_regs.line += adv; 844 if (di->ddump_line) 845 VG_(printf)(" Advance Line by %d to %d\n", 846 (Int)adv, (Int)state_machine_regs.line); 847 break; 848 849 case DW_LNS_set_file: 850 adv = read_leb128 (data, & bytes_read, 0); 851 data += bytes_read; 852 state_machine_regs.file = adv; 853 if (di->ddump_line) 854 VG_(printf)(" Set File Name to entry %d in the File Name Table\n", 855 (Int)adv); 856 break; 857 858 case DW_LNS_set_column: 859 adv = read_leb128 (data, & bytes_read, 0); 860 data += bytes_read; 861 state_machine_regs.column = adv; 862 if (di->ddump_line) 863 VG_(printf)(" Set column to %d\n", (Int)adv); 864 break; 865 866 case DW_LNS_negate_stmt: 867 adv = state_machine_regs.is_stmt; 868 adv = ! adv; 869 state_machine_regs.is_stmt = adv; 870 if (di->ddump_line) 871 VG_(printf)(" DWARF2-line: negate_stmt\n"); 872 break; 873 874 case DW_LNS_set_basic_block: 875 state_machine_regs.basic_block = 1; 876 if (di->ddump_line) 877 VG_(printf)(" DWARF2-line: set_basic_block\n"); 878 break; 879 880 case DW_LNS_const_add_pc: 881 adv = (((255 - info.li_opcode_base) / info.li_line_range) 882 * info.li_min_insn_length); 883 state_machine_regs.address += adv; 884 if (0) VG_(printf)("smr.a += %#x\n", adv ); 885 if (di->ddump_line) 886 VG_(printf)(" Advance PC by constant %d to 0x%lx\n", 887 (Int)adv, (Addr)state_machine_regs.address); 888 break; 889 890 case DW_LNS_fixed_advance_pc: 891 /* XXX: Need something to get 2 bytes */ 892 adv = ML_(read_UShort)(data); 893 data += 2; 894 state_machine_regs.address += adv; 895 if (0) VG_(printf)("smr.a += %#x\n", adv ); 896 if (di->ddump_line) 897 VG_(printf)(" DWARF2-line: fixed_advance_pc\n"); 898 break; 899 900 case DW_LNS_set_prologue_end: 901 if (di->ddump_line) 902 VG_(printf)(" DWARF2-line: set_prologue_end\n"); 903 break; 904 905 case DW_LNS_set_epilogue_begin: 906 if (di->ddump_line) 907 VG_(printf)(" DWARF2-line: set_epilogue_begin\n"); 908 break; 909 910 case DW_LNS_set_isa: 911 /*adv =*/ read_leb128 (data, & bytes_read, 0); 912 data += bytes_read; 913 if (di->ddump_line) 914 VG_(printf)(" DWARF2-line: set_isa\n"); 915 break; 916 917 default: { 918 Int j; 919 for (j = standard_opcodes[op_code - 1]; j > 0 ; --j) { 920 read_leb128 (data, &bytes_read, 0); 921 data += bytes_read; 922 } 923 if (di->ddump_line) 924 VG_(printf)(" Unknown opcode %d\n", (Int)op_code); 925 break; 926 } 927 } /* switch (op_code) */ 928 929 } /* if (op_code >= info.li_opcode_base) */ 930 931 } /* while (data < end_of_sequence) */ 932 933 if (di->ddump_line) 934 VG_(printf)("\n"); 935 936 out: 937 free_WordArray(&filenames); 938 free_WordArray(&dirnames); 939 free_WordArray(&fnidx2dir); 940 } 941 942 //////////////////////////////////////////////////////////////////// 943 //////////////////////////////////////////////////////////////////// 944 945 /* Return abbrev for given code 946 * Returned pointer points to the tag 947 * */ 948 static UChar* lookup_abbrev( UChar* p, UInt acode ) 949 { 950 UInt code; 951 UInt name; 952 for( ; ; ) { 953 code = read_leb128U( &p ); 954 if ( code == acode ) 955 return p; 956 read_leb128U( &p ); /* skip tag */ 957 p++; /* skip has_children flag */ 958 do { 959 name = read_leb128U( &p ); /* name */ 960 read_leb128U( &p ); /* form */ 961 } 962 while( name != 0 ); /* until name == form == 0 */ 963 } 964 return NULL; 965 } 966 967 /* Read general information for a particular compile unit block in 968 * the .debug_info section. 969 * 970 * Input: - unitblock is the start of a compilation 971 * unit block in .debuginfo section 972 * - debugabbrev is start of .debug_abbrev section 973 * - debugstr is start of .debug_str section 974 * 975 * Output: Fill members of ui pertaining to the compilation unit: 976 * - ui->name is the name of the compilation unit 977 * - ui->compdir is the compilation unit directory 978 * - ui->stmt_list is the offset in .debug_line section 979 * for the dbginfos of this compilation unit 980 * 981 * Note : the output strings are not allocated and point 982 * directly to the memory-mapped section. 983 */ 984 static 985 void read_unitinfo_dwarf2( /*OUT*/UnitInfo* ui, 986 UChar* unitblock_img, 987 UChar* debugabbrev_img, 988 UChar* debugstr_img, 989 UChar* debugstr_alt_img ) 990 { 991 UInt acode, abcode; 992 ULong atoffs, blklen; 993 Int level; 994 /* UShort ver; */ 995 996 UChar addr_size; 997 UChar* p = unitblock_img; 998 UChar* end_img; 999 UChar* abbrev_img; 1000 1001 VG_(memset)( ui, 0, sizeof( UnitInfo ) ); 1002 ui->stmt_list = -1LL; 1003 1004 /* Read the compilation unit header in .debug_info section - See p 70 */ 1005 1006 /* This block length */ 1007 blklen = read_initial_length_field( p, &ui->dw64 ); 1008 p += ui->dw64 ? 12 : 4; 1009 1010 /* version should be 2, 3 or 4 */ 1011 /* ver = ML_(read_UShort)(p); */ 1012 p += 2; 1013 1014 /* get offset in abbrev */ 1015 atoffs = ui->dw64 ? ML_(read_ULong)(p) : (ULong)(ML_(read_UInt)(p)); 1016 p += ui->dw64 ? 8 : 4; 1017 1018 /* Address size */ 1019 addr_size = *p; 1020 p += 1; 1021 1022 end_img = unitblock_img 1023 + blklen + (ui->dw64 ? 12 : 4); /* End of this block */ 1024 level = 0; /* Level in the abbrev tree */ 1025 abbrev_img = debugabbrev_img 1026 + atoffs; /* Abbreviation data for this block */ 1027 1028 /* Read the compilation unit entries */ 1029 while ( p < end_img ) { 1030 Bool has_child; 1031 UInt tag; 1032 1033 acode = read_leb128U( &p ); /* abbreviation code */ 1034 if ( acode == 0 ) { 1035 /* NULL entry used for padding - or last child for a sequence 1036 - see para 7.5.3 */ 1037 level--; 1038 continue; 1039 } 1040 1041 /* Read abbreviation header */ 1042 abcode = read_leb128U( &abbrev_img ); /* abbreviation code */ 1043 if ( acode != abcode ) { 1044 /* We are in in children list, and must rewind to a 1045 * previously declared abbrev code. This code works but is 1046 * not triggered since we shortcut the parsing once we have 1047 * read the compile_unit block. This should only occur when 1048 * level > 0 */ 1049 abbrev_img = lookup_abbrev( debugabbrev_img + atoffs, acode ); 1050 } 1051 1052 tag = read_leb128U( &abbrev_img ); 1053 has_child = *(abbrev_img++) == 1; /* DW_CHILDREN_yes */ 1054 1055 if ( has_child ) 1056 level++; 1057 1058 /* And loop on entries */ 1059 for ( ; ; ) { 1060 /* Read entry definition */ 1061 UInt name, form; 1062 ULong cval = -1LL; /* Constant value read */ 1063 Char *sval = NULL; /* String value read */ 1064 name = read_leb128U( &abbrev_img ); 1065 form = read_leb128U( &abbrev_img ); 1066 if ( name == 0 ) 1067 break; 1068 1069 /* Read data */ 1070 /* Attributes encoding explained p 71 */ 1071 if ( form == 0x16 /* FORM_indirect */ ) 1072 form = read_leb128U( &p ); 1073 /* Decode form. For most kinds, Just skip the amount of data since 1074 we don't use it for now */ 1075 /* JRS 9 Feb 06: This now handles 64-bit DWARF too. In 1076 64-bit DWARF, lineptr (and loclistptr,macptr,rangelistptr 1077 classes) use FORM_data8, not FORM_data4. Also, 1078 FORM_ref_addr and FORM_strp are 64-bit values, not 32-bit 1079 values. */ 1080 /* TJH 27 Apr 10: in DWARF 4 lineptr (and loclistptr,macptr, 1081 rangelistptr classes) use FORM_sec_offset which is 64 bits 1082 in 64 bit DWARF and 32 bits in 32 bit DWARF. */ 1083 /* JRS 20 Apr 11: LLVM-2.9 encodes DW_AT_stmt_list using 1084 FORM_addr rather than the FORM_data4 that GCC uses. Hence 1085 handle FORM_addr too. */ 1086 switch( form ) { 1087 /* Those cases extract the data properly */ 1088 case 0x05: /* FORM_data2 */ cval = ML_(read_UShort)(p); p +=2; break; 1089 case 0x06: /* FORM_data4 */ cval = ML_(read_UInt)(p); p +=4; break; 1090 case 0x0e: /* FORM_strp */ /* pointer in .debug_str */ 1091 /* 2006-01-01: only generate a value if 1092 debugstr is non-NULL (which means that a 1093 debug_str section was found) */ 1094 if (debugstr_img && !ui->dw64) 1095 sval = debugstr_img + ML_(read_UInt)(p); 1096 if (debugstr_img && ui->dw64) 1097 sval = debugstr_img + ML_(read_ULong)(p); 1098 p += ui->dw64 ? 8 : 4; 1099 break; 1100 case 0x08: /* FORM_string */ sval = (Char*)p; 1101 p += VG_(strlen)((Char*)p) + 1; break; 1102 case 0x0b: /* FORM_data1 */ cval = *p; p++; break; 1103 case 0x17: /* FORM_sec_offset */if (ui->dw64) { 1104 cval = ML_(read_ULong)(p); p += 8; 1105 } else { 1106 cval = ML_(read_UInt)(p); p += 4; 1107 }; break; 1108 1109 case 0x07: /* FORM_data8 */ if (ui->dw64) cval = ML_(read_ULong)(p); 1110 p += 8; break; 1111 /* perhaps should assign 1112 unconditionally to cval? */ 1113 1114 /* TODO : Following ones just skip data - implement if you need */ 1115 case 0x01: /* FORM_addr */ p += addr_size; break; 1116 case 0x03: /* FORM_block2 */ p += ML_(read_UShort)(p) + 2; break; 1117 case 0x04: /* FORM_block4 */ p += ML_(read_UInt)(p) + 4; break; 1118 case 0x09: /* FORM_block */ /* fallthrough */ 1119 case 0x18: /* FORM_exprloc */ { ULong block_len = read_leb128U( &p ); 1120 p += block_len; break; } 1121 case 0x0a: /* FORM_block1 */ p += *p + 1; break; 1122 case 0x0c: /* FORM_flag */ p++; break; 1123 case 0x0d: /* FORM_sdata */ read_leb128S( &p ); break; 1124 case 0x0f: /* FORM_udata */ read_leb128U( &p ); break; 1125 case 0x10: /* FORM_ref_addr */ p += ui->dw64 ? 8 : 4; break; 1126 case 0x11: /* FORM_ref1 */ p++; break; 1127 case 0x12: /* FORM_ref2 */ p += 2; break; 1128 case 0x13: /* FORM_ref4 */ p += 4; break; 1129 case 0x14: /* FORM_ref8 */ p += 8; break; 1130 case 0x15: /* FORM_ref_udata */ read_leb128U( &p ); break; 1131 case 0x19: /* FORM_flag_present */break; 1132 case 0x20: /* FORM_ref_sig8 */ p += 8; break; 1133 case 0x1f20: /* FORM_GNU_ref_alt */ p += ui->dw64 ? 8 : 4; break; 1134 case 0x1f21: /* FORM_GNU_strp_alt */ 1135 if (debugstr_alt_img && !ui->dw64) 1136 sval = debugstr_alt_img + ML_(read_UInt)(p); 1137 if (debugstr_alt_img && ui->dw64) 1138 sval = debugstr_alt_img + ML_(read_ULong)(p); 1139 p += ui->dw64 ? 8 : 4; 1140 break; 1141 1142 default: 1143 VG_(printf)( "### unhandled dwarf2 abbrev form code 0x%x\n", form ); 1144 break; 1145 } 1146 1147 /* Now store the members we need in the UnitInfo structure */ 1148 if ( tag == 0x0011 /*TAG_compile_unit*/ ) { 1149 if ( name == 0x03 ) ui->name = sval; /* DW_AT_name */ 1150 else if ( name == 0x1b ) ui->compdir = sval; /* DW_AT_compdir */ 1151 else if ( name == 0x10 ) ui->stmt_list = cval; /* DW_AT_stmt_list */ 1152 } 1153 } 1154 /* Shortcut the parsing once we have read the compile_unit block 1155 * That's enough info for us, and we are not gdb ! */ 1156 if ( tag == 0x0011 /*TAG_compile_unit*/ ) 1157 break; 1158 } /* Loop on each sub block */ 1159 1160 /* This test would be valid if we were not shortcutting the parsing 1161 if (level != 0) 1162 VG_(printf)( "#### Exiting debuginfo block at level %d !!!\n", level ); 1163 */ 1164 } 1165 1166 1167 //////////////////////////////////////////////////////////////////// 1168 //////////////////////////////////////////////////////////////////// 1169 1170 /* Collect the debug info from DWARF3 debugging sections 1171 * of a given module. 1172 * 1173 * Inputs: given .debug_xxx sections 1174 * Output: update di to contain all the DWARF3 debug infos 1175 */ 1176 void ML_(read_debuginfo_dwarf3) 1177 ( struct _DebugInfo* di, 1178 UChar* debug_info_img, Word debug_info_sz, /* .debug_info */ 1179 UChar* debug_types_img, Word debug_types_sz, /* .debug_types */ 1180 UChar* debug_abbv_img, Word debug_abbv_sz, /* .debug_abbrev */ 1181 UChar* debug_line_img, Word debug_line_sz, /* .debug_line */ 1182 UChar* debug_str_img, Word debug_str_sz, /* .debug_str */ 1183 UChar* debug_str_alt_img, Word debug_str_alt_sz ) /* .debug_str */ 1184 { 1185 UnitInfo ui; 1186 UShort ver; 1187 UChar* block_img; 1188 UChar* end1_img; 1189 ULong blklen; 1190 Bool blklen_is_64; 1191 Int blklen_len; 1192 1193 end1_img = debug_info_img + debug_info_sz; 1194 blklen_len = 0; 1195 1196 /* Make sure we at least have a header for the first block */ 1197 if (debug_info_sz < 4) { 1198 ML_(symerr)( di, True, 1199 "Last block truncated in .debug_info; ignoring" ); 1200 return; 1201 } 1202 1203 /* Iterate on all the blocks we find in .debug_info */ 1204 for ( block_img = debug_info_img; 1205 block_img < end1_img - 4; 1206 block_img += blklen + blklen_len ) { 1207 1208 /* Read the compilation unit header in .debug_info section - See 1209 p 70 */ 1210 /* This block length */ 1211 blklen = read_initial_length_field( block_img, &blklen_is_64 ); 1212 blklen_len = blklen_is_64 ? 12 : 4; 1213 if ( block_img + blklen + blklen_len > end1_img ) { 1214 ML_(symerr)( di, True, 1215 "Last block truncated in .debug_info; ignoring" ); 1216 return; 1217 } 1218 1219 /* version should be 2 */ 1220 ver = ML_(read_UShort)( block_img + blklen_len ); 1221 if ( ver != 2 && ver != 3 && ver != 4 ) { 1222 ML_(symerr)( di, True, 1223 "Ignoring non-Dwarf2/3/4 block in .debug_info" ); 1224 continue; 1225 } 1226 1227 /* Fill ui with offset in .debug_line and compdir */ 1228 if (0) 1229 VG_(printf)( "Reading UnitInfo at 0x%lx.....\n", 1230 block_img - debug_info_img + 0UL ); 1231 read_unitinfo_dwarf2( &ui, block_img, 1232 debug_abbv_img, debug_str_img, 1233 debug_str_alt_img ); 1234 if (0) 1235 VG_(printf)( " => LINES=0x%llx NAME=%s DIR=%s\n", 1236 ui.stmt_list, ui.name, ui.compdir ); 1237 1238 /* Ignore blocks with no .debug_line associated block */ 1239 if ( ui.stmt_list == -1LL ) 1240 continue; 1241 1242 if (0) 1243 VG_(printf)("debug_line_sz %ld, ui.stmt_list %lld %s\n", 1244 debug_line_sz, ui.stmt_list, ui.name ); 1245 /* Read the .debug_line block for this compile unit */ 1246 read_dwarf2_lineblock( 1247 di, &ui, debug_line_img + ui.stmt_list, 1248 debug_line_sz - ui.stmt_list ); 1249 } 1250 } 1251 1252 1253 //////////////////////////////////////////////////////////////////// 1254 //////////////////////////////////////////////////////////////////// 1255 1256 /*------------------------------------------------------------*/ 1257 /*--- Read DWARF1 format line number info. ---*/ 1258 /*------------------------------------------------------------*/ 1259 1260 /* DWARF1 appears to be redundant, but nevertheless the Lahey Fortran 1261 compiler generates it. 1262 */ 1263 1264 /* The following three enums (dwarf_tag, dwarf_form, dwarf_attribute) 1265 are taken from the file include/elf/dwarf.h in the GNU gdb-6.0 1266 sources, which are Copyright 1992, 1993, 1995, 1999 Free Software 1267 Foundation, Inc and naturally licensed under the GNU General Public 1268 License version 2 or later. 1269 */ 1270 1271 /* Tag names and codes. */ 1272 1273 enum dwarf_tag { 1274 TAG_padding = 0x0000, 1275 TAG_array_type = 0x0001, 1276 TAG_class_type = 0x0002, 1277 TAG_entry_point = 0x0003, 1278 TAG_enumeration_type = 0x0004, 1279 TAG_formal_parameter = 0x0005, 1280 TAG_global_subroutine = 0x0006, 1281 TAG_global_variable = 0x0007, 1282 /* 0x0008 -- reserved */ 1283 /* 0x0009 -- reserved */ 1284 TAG_label = 0x000a, 1285 TAG_lexical_block = 0x000b, 1286 TAG_local_variable = 0x000c, 1287 TAG_member = 0x000d, 1288 /* 0x000e -- reserved */ 1289 TAG_pointer_type = 0x000f, 1290 TAG_reference_type = 0x0010, 1291 TAG_compile_unit = 0x0011, 1292 TAG_string_type = 0x0012, 1293 TAG_structure_type = 0x0013, 1294 TAG_subroutine = 0x0014, 1295 TAG_subroutine_type = 0x0015, 1296 TAG_typedef = 0x0016, 1297 TAG_union_type = 0x0017, 1298 TAG_unspecified_parameters = 0x0018, 1299 TAG_variant = 0x0019, 1300 TAG_common_block = 0x001a, 1301 TAG_common_inclusion = 0x001b, 1302 TAG_inheritance = 0x001c, 1303 TAG_inlined_subroutine = 0x001d, 1304 TAG_module = 0x001e, 1305 TAG_ptr_to_member_type = 0x001f, 1306 TAG_set_type = 0x0020, 1307 TAG_subrange_type = 0x0021, 1308 TAG_with_stmt = 0x0022, 1309 1310 /* GNU extensions */ 1311 1312 TAG_format_label = 0x8000, /* for FORTRAN 77 and Fortran 90 */ 1313 TAG_namelist = 0x8001, /* For Fortran 90 */ 1314 TAG_function_template = 0x8002, /* for C++ */ 1315 TAG_class_template = 0x8003 /* for C++ */ 1316 }; 1317 1318 /* Form names and codes. */ 1319 1320 enum dwarf_form { 1321 FORM_ADDR = 0x1, 1322 FORM_REF = 0x2, 1323 FORM_BLOCK2 = 0x3, 1324 FORM_BLOCK4 = 0x4, 1325 FORM_DATA2 = 0x5, 1326 FORM_DATA4 = 0x6, 1327 FORM_DATA8 = 0x7, 1328 FORM_STRING = 0x8 1329 }; 1330 1331 /* Attribute names and codes. */ 1332 1333 enum dwarf_attribute { 1334 AT_sibling = (0x0010|FORM_REF), 1335 AT_location = (0x0020|FORM_BLOCK2), 1336 AT_name = (0x0030|FORM_STRING), 1337 AT_fund_type = (0x0050|FORM_DATA2), 1338 AT_mod_fund_type = (0x0060|FORM_BLOCK2), 1339 AT_user_def_type = (0x0070|FORM_REF), 1340 AT_mod_u_d_type = (0x0080|FORM_BLOCK2), 1341 AT_ordering = (0x0090|FORM_DATA2), 1342 AT_subscr_data = (0x00a0|FORM_BLOCK2), 1343 AT_byte_size = (0x00b0|FORM_DATA4), 1344 AT_bit_offset = (0x00c0|FORM_DATA2), 1345 AT_bit_size = (0x00d0|FORM_DATA4), 1346 /* (0x00e0|FORM_xxxx) -- reserved */ 1347 AT_element_list = (0x00f0|FORM_BLOCK4), 1348 AT_stmt_list = (0x0100|FORM_DATA4), 1349 AT_low_pc = (0x0110|FORM_ADDR), 1350 AT_high_pc = (0x0120|FORM_ADDR), 1351 AT_language = (0x0130|FORM_DATA4), 1352 AT_member = (0x0140|FORM_REF), 1353 AT_discr = (0x0150|FORM_REF), 1354 AT_discr_value = (0x0160|FORM_BLOCK2), 1355 /* (0x0170|FORM_xxxx) -- reserved */ 1356 /* (0x0180|FORM_xxxx) -- reserved */ 1357 AT_string_length = (0x0190|FORM_BLOCK2), 1358 AT_common_reference = (0x01a0|FORM_REF), 1359 AT_comp_dir = (0x01b0|FORM_STRING), 1360 AT_const_value_string = (0x01c0|FORM_STRING), 1361 AT_const_value_data2 = (0x01c0|FORM_DATA2), 1362 AT_const_value_data4 = (0x01c0|FORM_DATA4), 1363 AT_const_value_data8 = (0x01c0|FORM_DATA8), 1364 AT_const_value_block2 = (0x01c0|FORM_BLOCK2), 1365 AT_const_value_block4 = (0x01c0|FORM_BLOCK4), 1366 AT_containing_type = (0x01d0|FORM_REF), 1367 AT_default_value_addr = (0x01e0|FORM_ADDR), 1368 AT_default_value_data2 = (0x01e0|FORM_DATA2), 1369 AT_default_value_data4 = (0x01e0|FORM_DATA4), 1370 AT_default_value_data8 = (0x01e0|FORM_DATA8), 1371 AT_default_value_string = (0x01e0|FORM_STRING), 1372 AT_friends = (0x01f0|FORM_BLOCK2), 1373 AT_inline = (0x0200|FORM_STRING), 1374 AT_is_optional = (0x0210|FORM_STRING), 1375 AT_lower_bound_ref = (0x0220|FORM_REF), 1376 AT_lower_bound_data2 = (0x0220|FORM_DATA2), 1377 AT_lower_bound_data4 = (0x0220|FORM_DATA4), 1378 AT_lower_bound_data8 = (0x0220|FORM_DATA8), 1379 AT_private = (0x0240|FORM_STRING), 1380 AT_producer = (0x0250|FORM_STRING), 1381 AT_program = (0x0230|FORM_STRING), 1382 AT_protected = (0x0260|FORM_STRING), 1383 AT_prototyped = (0x0270|FORM_STRING), 1384 AT_public = (0x0280|FORM_STRING), 1385 AT_pure_virtual = (0x0290|FORM_STRING), 1386 AT_return_addr = (0x02a0|FORM_BLOCK2), 1387 AT_abstract_origin = (0x02b0|FORM_REF), 1388 AT_start_scope = (0x02c0|FORM_DATA4), 1389 AT_stride_size = (0x02e0|FORM_DATA4), 1390 AT_upper_bound_ref = (0x02f0|FORM_REF), 1391 AT_upper_bound_data2 = (0x02f0|FORM_DATA2), 1392 AT_upper_bound_data4 = (0x02f0|FORM_DATA4), 1393 AT_upper_bound_data8 = (0x02f0|FORM_DATA8), 1394 AT_virtual = (0x0300|FORM_STRING), 1395 1396 /* GNU extensions. */ 1397 1398 AT_sf_names = (0x8000|FORM_DATA4), 1399 AT_src_info = (0x8010|FORM_DATA4), 1400 AT_mac_info = (0x8020|FORM_DATA4), 1401 AT_src_coords = (0x8030|FORM_DATA4), 1402 AT_body_begin = (0x8040|FORM_ADDR), 1403 AT_body_end = (0x8050|FORM_ADDR) 1404 }; 1405 1406 /* end of enums taken from gdb-6.0 sources */ 1407 1408 void ML_(read_debuginfo_dwarf1) ( 1409 struct _DebugInfo* di, 1410 UChar* dwarf1d, Int dwarf1d_sz, 1411 UChar* dwarf1l, Int dwarf1l_sz ) 1412 { 1413 UInt stmt_list; 1414 Bool stmt_list_found; 1415 Int die_offset, die_szb, at_offset; 1416 UShort die_kind, at_kind; 1417 UChar* at_base; 1418 UChar* src_filename; 1419 1420 if (0) 1421 VG_(printf)("read_debuginfo_dwarf1 ( %p, %d, %p, %d )\n", 1422 dwarf1d, dwarf1d_sz, dwarf1l, dwarf1l_sz ); 1423 1424 /* This loop scans the DIEs. */ 1425 die_offset = 0; 1426 while (True) { 1427 if (die_offset >= dwarf1d_sz) break; 1428 1429 die_szb = ML_(read_Int)(dwarf1d + die_offset); 1430 die_kind = ML_(read_UShort)(dwarf1d + die_offset + 4); 1431 1432 /* We're only interested in compile_unit DIEs; ignore others. */ 1433 if (die_kind != TAG_compile_unit) { 1434 die_offset += die_szb; 1435 continue; 1436 } 1437 1438 if (0) 1439 VG_(printf)("compile-unit DIE: offset %d, tag 0x%x, size %d\n", 1440 die_offset, (Int)die_kind, die_szb ); 1441 1442 /* We've got a compile_unit DIE starting at (dwarf1d + 1443 die_offset+6). Try and find the AT_name and AT_stmt_list 1444 attributes. Then, finally, we can read the line number info 1445 for this source file. */ 1446 1447 /* The next 3 are set as we find the relevant attrs. */ 1448 src_filename = NULL; 1449 stmt_list_found = False; 1450 stmt_list = 0; 1451 1452 /* This loop scans the Attrs inside compile_unit DIEs. */ 1453 at_base = dwarf1d + die_offset + 6; 1454 at_offset = 0; 1455 while (True) { 1456 if (at_offset >= die_szb-6) break; 1457 1458 at_kind = ML_(read_UShort)(at_base + at_offset); 1459 if (0) VG_(printf)("atoffset %d, attag 0x%x\n", 1460 at_offset, (Int)at_kind ); 1461 at_offset += 2; /* step over the attribute itself */ 1462 /* We have to examine the attribute to figure out its 1463 length. */ 1464 switch (at_kind) { 1465 case AT_stmt_list: 1466 case AT_language: 1467 case AT_sibling: 1468 if (at_kind == AT_stmt_list) { 1469 stmt_list_found = True; 1470 stmt_list = ML_(read_Int)(at_base+at_offset); 1471 } 1472 at_offset += 4; break; 1473 case AT_high_pc: 1474 case AT_low_pc: 1475 at_offset += sizeof(void*); break; 1476 case AT_name: 1477 case AT_producer: 1478 case AT_comp_dir: 1479 /* Zero terminated string, step over it. */ 1480 if (at_kind == AT_name) 1481 src_filename = at_base + at_offset; 1482 while (at_offset < die_szb-6 && at_base[at_offset] != 0) 1483 at_offset++; 1484 at_offset++; 1485 break; 1486 default: 1487 VG_(printf)("Unhandled DWARF-1 attribute 0x%x\n", 1488 (Int)at_kind ); 1489 VG_(core_panic)("Unhandled DWARF-1 attribute"); 1490 } /* switch (at_kind) */ 1491 } /* looping over attributes */ 1492 1493 /* So, did we find the required stuff for a line number table in 1494 this DIE? If yes, read it. */ 1495 if (stmt_list_found /* there is a line number table */ 1496 && src_filename != NULL /* we know the source filename */ 1497 ) { 1498 /* Table starts: 1499 Length: 1500 4 bytes, includes the entire table 1501 Base address: 1502 unclear (4? 8?), assuming native pointer size here. 1503 Then a sequence of triples 1504 (source line number -- 32 bits 1505 source line column -- 16 bits 1506 address delta -- 32 bits) 1507 */ 1508 Addr base; 1509 Int len; 1510 Char* curr_filenm; 1511 UChar* ptr; 1512 UInt prev_line, prev_delta; 1513 1514 curr_filenm = ML_(addStr) ( di, src_filename, -1 ); 1515 prev_line = prev_delta = 0; 1516 1517 ptr = dwarf1l + stmt_list; 1518 len = ML_(read_Int)(ptr); ptr += sizeof(Int); 1519 base = ML_(read_Addr)(ptr); ptr += sizeof(void*); 1520 len -= (sizeof(Int) + sizeof(void*)); 1521 while (len > 0) { 1522 UInt line; 1523 UShort col; 1524 UInt delta; 1525 line = ML_(read_UInt)(ptr); ptr += sizeof(UInt); 1526 col = ML_(read_UShort)(ptr); ptr += sizeof(UShort); 1527 delta = ML_(read_UInt)(ptr); ptr += sizeof(UInt); 1528 if (0) VG_(printf)("line %d, col %d, delta %d\n", 1529 line, (Int)col, delta ); 1530 len -= (sizeof(UInt) + sizeof(UShort) + sizeof(UInt)); 1531 1532 if (delta > 0 && prev_line > 0) { 1533 if (0) VG_(printf) (" %d %d-%d\n", 1534 prev_line, prev_delta, delta-1); 1535 ML_(addLineInfo) ( di, curr_filenm, NULL, 1536 base + prev_delta, base + delta, 1537 prev_line, 0 ); 1538 } 1539 prev_line = line; 1540 prev_delta = delta; 1541 } 1542 } 1543 1544 /* Move on the the next DIE. */ 1545 die_offset += die_szb; 1546 1547 } /* Looping over DIEs */ 1548 1549 } 1550 1551 1552 /*------------------------------------------------------------*/ 1553 /*--- Read call-frame info from an .eh_frame section ---*/ 1554 /*------------------------------------------------------------*/ 1555 1556 /* Sources of info: 1557 1558 The DWARF3 spec, available from http://www.dwarfstd.org/Download.php 1559 1560 This describes how to read CFA data from .debug_frame sections. 1561 So as to maximise everybody's annoyance and confusion, .eh_frame 1562 sections are almost the same as .debug_frame sections, but differ 1563 in a few subtle and ill documented but important aspects. 1564 1565 Generic ELF Specification, sections 7.5 (DWARF Extensions) and 7.6 1566 (Exception Frames), available from 1567 1568 http://www.linux-foundation.org/spec/book/ELF-generic/ELF-generic.html 1569 1570 This really does describe .eh_frame, at least the aspects that 1571 differ from standard DWARF3. It's better than guessing, and 1572 (marginally) more fun than reading the gdb source code. 1573 */ 1574 1575 /* Useful info .. 1576 1577 In general: 1578 gdb-6.3/gdb/dwarf2-frame.c 1579 1580 gdb-6.3/gdb/i386-tdep.c: 1581 1582 DWARF2/GCC uses the stack address *before* the function call as a 1583 frame's CFA. [jrs: I presume this means %esp before the call as 1584 the CFA]. 1585 1586 JRS: on amd64, the dwarf register numbering is, as per 1587 gdb-6.3/gdb/amd64-tdep.c and also amd64-abi-0.98.pdf: 1588 1589 0 1 2 3 4 5 6 7 1590 RAX RDX RCX RBX RSI RDI RBP RSP 1591 1592 8 ... 15 1593 R8 ... R15 1594 1595 16 is the return address (RIP) 1596 "The table defines Return Address to have a register number, 1597 even though the address is stored in 0(%rsp) and not in a 1598 physical register." 1599 1600 17 ... 24 1601 XMM0 ... XMM7 1602 1603 25 ... 32 1604 XMM8 ... XMM15 1605 1606 33 ... 40 1607 ST0 ... ST7 1608 1609 41 ... 48 1610 MM0 ... MM7 1611 1612 49 RFLAGS 1613 50,51,52,53,54,55 ES,CS,SS,DS,FS,GS 1614 58 FS.BASE (what's that?) 1615 59 GS.BASE (what's that?) 1616 62 TR (task register) 1617 63 LDTR (LDT register) 1618 64 MXCSR 1619 65 FCW (x87 control word) 1620 66 FSW (x86 status word) 1621 1622 On x86 I cannot find any documentation. It _appears_ to be the 1623 actual instruction encoding, viz: 1624 1625 0 1 2 3 4 5 6 7 1626 EAX ECX EDX EBX ESP EBP ESI EDI 1627 1628 8 is the return address (EIP) */ 1629 1630 1631 /* Comments re DW_CFA_set_loc, 16 Nov 06. 1632 1633 JRS: 1634 Someone recently sent me a libcrypto.so.0.9.8 as distributed with 1635 Ubuntu of some flavour, compiled with gcc 4.1.2 on amd64. It 1636 causes V's CF reader to complain a lot: 1637 1638 >> --19976-- DWARF2 CFI reader: unhandled CFI instruction 0:24 1639 >> --19976-- DWARF2 CFI reader: unhandled CFI instruction 0:24 1640 >> --19976-- DWARF2 CFI reader: unhandled CFI instruction 0:24 1641 >> --19976-- DWARF2 CFI reader: unhandled CFI instruction 0:24 1642 >> --19976-- DWARF2 CFI reader: unhandled CFI instruction 0:48 1643 >> --19976-- DWARF2 CFI reader: unhandled CFI instruction 0:24 1644 1645 After chasing this around a bit it seems that the CF bytecode 1646 parser lost sync at a DW_CFA_set_loc, which has a single argument 1647 denoting an address. 1648 1649 As it stands that address is extracted by read_Addr(). On amd64 1650 that just fetches 8 bytes regardless of anything else. 1651 1652 read_encoded_Addr() is more sophisticated. This appears to take 1653 into account some kind of encoding flag. When I replace the uses 1654 of read_Addr by read_encoded_Addr for DW_CFA_set_loc, the 1655 complaints go away, there is no loss of sync, and the parsed CF 1656 instructions are the same as shown by readelf --debug-dump=frames. 1657 1658 So it seems a plausible fix. The problem is I looked in the DWARF3 1659 spec and completely failed to figure out whether or not the arg to 1660 DW_CFA_set_loc is supposed to be encoded in a way suitable for 1661 read_encoded_Addr, nor for that matter any description of what it 1662 is that read_encoded_Addr is really decoding. 1663 1664 TomH: 1665 The problem is that the encoding is not standard - the eh_frame 1666 section uses the same encoding as the dwarf_frame section except 1667 for a few small changes, and this is one of them. So this is not 1668 something the DWARF standard covers. 1669 1670 There is an augmentation string to indicate what is going on though 1671 so that programs can recognise it. 1672 1673 What we are doing seems to match what gdb 6.5 and libdwarf 20060614 1674 do though. I'm not sure about readelf though. 1675 1676 (later): Well dwarfdump barfs on it: 1677 1678 dwarfdump ERROR: dwarf_get_fde_info_for_reg: 1679 DW_DLE_DF_FRAME_DECODING_ERROR(193) (193) 1680 1681 I've looked at binutils as well now, and the code in readelf agrees 1682 with your patch - ie it treats set_loc as having an encoded address 1683 if there is a zR augmentation indicating an encoding. 1684 1685 Quite why gdb and libdwarf don't understand this is an interesting 1686 question... 1687 1688 Final outcome: all uses of read_Addr were replaced by 1689 read_encoded_Addr. A new type AddressDecodingInfo was added to 1690 make it relatively clean to plumb through the extra info needed by 1691 read_encoded_Addr. 1692 */ 1693 1694 /* More badness re address encoding, 12 Jan 07. 1695 1696 Most gcc provided CIEs have a "zR" augmentation, which means they 1697 supply their own address encoding, and that works fine. However, 1698 some icc9 supplied CIEs have no augmentation, which means they use 1699 the default_Addr_encoding(). That says to use a machine-word sized 1700 value, literally unmodified. 1701 1702 Since .so's are, in general, relocated when loaded, having absolute 1703 addresses in the CFI data makes no sense when read_encoded_Addr is 1704 used to find the initial location for a FDE. The resulting saga: 1705 1706 TomH: 1707 > I'm chasing a stack backtrace failure for an amd64 .so which was 1708 > created I believe by icc 9.1. After a while I wound up looking at 1709 > this: (readdwarf.c) 1710 > 1711 > 5083 tom static UChar default_Addr_encoding ( void ) 1712 > 3584 tom { 1713 > 3584 tom switch (sizeof(Addr)) { 1714 > 3584 tom case 4: return DW_EH_PE_udata4; 1715 > 3584 tom case 8: return DW_EH_PE_udata8; 1716 > 3584 tom default: vg_assert(0); 1717 > 3584 tom } 1718 > 3584 tom } 1719 > 1720 > If a CIE does not have an "augmentation string" (typically "zR") then 1721 > addresses are decoded as described by default_Addr_encoding. If there 1722 > is an 'R' in the augmentation string then the encoding to use 1723 > is specified by the CIE itself, which works fine with GCC compiled code 1724 > since that always appears to specify zR. 1725 1726 Correct. 1727 1728 > Problem is this .so has no augmentation string and so uses the 1729 > default encoding, viz DW_EH_PE_udata8. That appears to mean 1730 > "read a 64 bit number" and use that as-is (for the starting value 1731 > of the program counter when running the CFA program). 1732 1733 Strictly speaking the default is DW_EH_PE_absptr, but that amounts 1734 to either udata4 or udata8 depending on the platform's pointer size 1735 which is a shortcut I used. 1736 1737 > For this .so that gives nonsense (very small) PCs which are later 1738 > rejected by the sanity check which ensures PC ranges fall inside 1739 > the mapped text segment. It seems like the .so expects to have the 1740 > start VMA of the text segment added on. This would correspond to 1741 > 1742 > static UChar default_Addr_encoding ( void ) 1743 > { 1744 > switch (sizeof(Addr)) { 1745 > case 4: return DW_EH_PE_textrel + DW_EH_PE_udata4; 1746 > case 8: return DW_EH_PE_textrel + DW_EH_PE_udata8; 1747 > default: vg_assert(0); 1748 > } 1749 > } 1750 1751 The problem you're seeing is that you have absolute pointers inside 1752 a shared library, which obviously makes little sense on the face of 1753 things as how would the linker know where the library will be 1754 loaded? 1755 1756 The answer of course is that it doesn't, so if it points absolute 1757 pointers in the frame unwind data is has to include relocations for 1758 them, and I'm betting that if you look at the relocations in the 1759 library you will there are some for that data. 1760 1761 That is fine of course when ld.so maps the library - it will 1762 relocate the eh_frame data as it maps it (or prelinking will 1763 already have done so) and when the g++ exception code kicks in and 1764 unwinds the stack it will see relocated data. 1765 1766 We of course are mapping the section from the ELF file ourselves 1767 and are not applying the relocations, hence the problem you are 1768 seeing. 1769 1770 Strictly speaking we should apply the relocations but the cheap 1771 solution is essentially to do what you've done - strictly speaking 1772 you should adjust by the difference between the address the library 1773 was linked for and the address it has been loaded at, but a shared 1774 library will normally be linked for address zero I believe. It's 1775 possible that prelinking might change that though? 1776 1777 JRS: 1778 That all syncs with what I am seeing. 1779 1780 So what I am inclined to do is: 1781 1782 - Leave default_Addr_encoding as it is 1783 1784 - Change read_encoded_Addr's handling of "case DW_EH_PE_absptr" so 1785 it sets base to, as you say, the difference between the address 1786 the library was linked for and the address it has been loaded at 1787 (== the SegInfo's text_bias) 1788 1789 Does that sound sane? I think it should even handle the prelinked 1790 case. 1791 1792 (JRS, later) 1793 1794 Hmm. Plausible as it sounds, it doesn't work. It now produces 1795 bogus backtraces for locations inside the (statically linked) 1796 memcheck executable. 1797 1798 Besides, there are a couple of other places where read_encoded_Addr 1799 is used -- one of which is used to establish the length of the 1800 address range covered by the current FDE: 1801 1802 fde_arange = read_encoded_Addr(&nbytes, &adi, data); 1803 1804 and it doesn't seem to make any sense for read_encoded_Addr to add 1805 on the text segment bias in that context. The DWARF3 spec says 1806 that both the initial_location and address_range (length) fields 1807 are encoded the same way ("target address"), so it is unclear at 1808 what stage in the process it would be appropriate to relocate the 1809 former but not the latter. 1810 1811 One unprincipled kludge that does work is the following: just 1812 before handing one of the address range fragments off to 1813 ML_(addDiCfSI) for permanent storage, check its start address. If 1814 that is very low (less than 2 M), and is far below the mapped text 1815 segment, and adding the text bias would move the fragment entirely 1816 inside the mapped text segment, then do so. A kind of kludged 1817 last-minute relocation, if you like. 1818 1819 12 Jan 07: committing said kludge (see kludge_then_addDiCfSI). If 1820 the situation clarifies, it can easily enough be backed out and 1821 replaced by a better fix. 1822 */ 1823 1824 /* --------------- Decls --------------- */ 1825 1826 #if defined(VGP_x86_linux) 1827 # define FP_REG 5 1828 # define SP_REG 4 1829 # define RA_REG_DEFAULT 8 1830 #elif defined(VGP_amd64_linux) 1831 # define FP_REG 6 1832 # define SP_REG 7 1833 # define RA_REG_DEFAULT 16 1834 #elif defined(VGP_ppc32_linux) 1835 # define FP_REG 1 1836 # define SP_REG 1 1837 # define RA_REG_DEFAULT 65 1838 #elif defined(VGP_ppc64_linux) 1839 # define FP_REG 1 1840 # define SP_REG 1 1841 # define RA_REG_DEFAULT 65 1842 #elif defined(VGP_arm_linux) 1843 # define FP_REG 12 1844 # define SP_REG 13 1845 # define RA_REG_DEFAULT 14 //??? 1846 #elif defined(VGP_x86_darwin) 1847 # define FP_REG 5 1848 # define SP_REG 4 1849 # define RA_REG_DEFAULT 8 1850 #elif defined(VGP_amd64_darwin) 1851 # define FP_REG 6 1852 # define SP_REG 7 1853 # define RA_REG_DEFAULT 16 1854 #elif defined(VGP_s390x_linux) 1855 # define FP_REG 11 // sometimes s390 has a frame pointer in r11 1856 # define SP_REG 15 // stack is always r15 1857 # define RA_REG_DEFAULT 14 // the return address is in r14 1858 #elif defined(VGP_mips32_linux) 1859 # define FP_REG 30 1860 # define SP_REG 29 1861 # define RA_REG_DEFAULT 31 1862 #else 1863 # error "Unknown platform" 1864 #endif 1865 1866 /* The number of regs we are prepared to unwind. The number for 1867 arm-linux (320) seems ludicrously high, but the ARM IHI 0040A page 1868 7 (DWARF for the ARM Architecture) specifies that values up to 320 1869 might exist, for Neon/VFP-v3. */ 1870 #if defined(VGP_ppc32_linux) || defined(VGP_ppc64_linux) \ 1871 || defined(VGP_mips32_linux) 1872 # define N_CFI_REGS 72 1873 #elif defined(VGP_arm_linux) 1874 # define N_CFI_REGS 320 1875 #else 1876 # define N_CFI_REGS 20 1877 #endif 1878 1879 /* Instructions for the automaton */ 1880 enum dwarf_cfa_primary_ops 1881 { 1882 DW_CFA_use_secondary = 0, 1883 DW_CFA_advance_loc = 1, 1884 DW_CFA_offset = 2, 1885 DW_CFA_restore = 3 1886 }; 1887 1888 enum dwarf_cfa_secondary_ops 1889 { 1890 DW_CFA_nop = 0x00, 1891 DW_CFA_set_loc = 0x01, 1892 DW_CFA_advance_loc1 = 0x02, 1893 DW_CFA_advance_loc2 = 0x03, 1894 DW_CFA_advance_loc4 = 0x04, 1895 DW_CFA_offset_extended = 0x05, 1896 DW_CFA_restore_extended = 0x06, 1897 DW_CFA_undefined = 0x07, 1898 DW_CFA_same_value = 0x08, 1899 DW_CFA_register = 0x09, 1900 DW_CFA_remember_state = 0x0a, 1901 DW_CFA_restore_state = 0x0b, 1902 DW_CFA_def_cfa = 0x0c, 1903 DW_CFA_def_cfa_register = 0x0d, 1904 DW_CFA_def_cfa_offset = 0x0e, 1905 DW_CFA_def_cfa_expression = 0x0f, /* DWARF3 only */ 1906 DW_CFA_expression = 0x10, /* DWARF3 only */ 1907 DW_CFA_offset_extended_sf = 0x11, /* DWARF3 only */ 1908 DW_CFA_def_cfa_sf = 0x12, /* DWARF3 only */ 1909 DW_CFA_def_cfa_offset_sf = 0x13, /* DWARF3 only */ 1910 DW_CFA_val_offset = 0x14, /* DWARF3 only */ 1911 DW_CFA_val_offset_sf = 0x15, /* DWARF3 only */ 1912 DW_CFA_val_expression = 0x16, /* DWARF3 only */ 1913 DW_CFA_lo_user = 0x1c, 1914 DW_CFA_GNU_window_save = 0x2d, /* GNU extension */ 1915 DW_CFA_GNU_args_size = 0x2e, /* GNU extension */ 1916 DW_CFA_GNU_negative_offset_extended = 0x2f, /* GNU extension */ 1917 DW_CFA_hi_user = 0x3f 1918 }; 1919 1920 #define DW_EH_PE_absptr 0x00 1921 #define DW_EH_PE_omit 0xff 1922 1923 #define DW_EH_PE_uleb128 0x01 1924 #define DW_EH_PE_udata2 0x02 1925 #define DW_EH_PE_udata4 0x03 1926 #define DW_EH_PE_udata8 0x04 1927 #define DW_EH_PE_sleb128 0x09 1928 #define DW_EH_PE_sdata2 0x0A 1929 #define DW_EH_PE_sdata4 0x0B 1930 #define DW_EH_PE_sdata8 0x0C 1931 #define DW_EH_PE_signed 0x08 1932 1933 #define DW_EH_PE_pcrel 0x10 1934 #define DW_EH_PE_textrel 0x20 1935 #define DW_EH_PE_datarel 0x30 1936 #define DW_EH_PE_funcrel 0x40 1937 #define DW_EH_PE_aligned 0x50 1938 1939 #define DW_EH_PE_indirect 0x80 1940 1941 1942 /* RegRule and UnwindContext are used temporarily to do the unwinding. 1943 The result is then summarised into a sequence of CfiSIs, if 1944 possible. UnwindContext effectively holds the state of the 1945 abstract machine whilst it is running. 1946 1947 The CFA can either be a signed offset from a register, 1948 or an expression: 1949 1950 CFA = cfa_reg + cfa_off when UnwindContext.cfa_is_regoff==True 1951 | [[ cfa_expr_id ]] 1952 1953 When .cfa_is_regoff == True, cfa_expr_id must be zero 1954 When .cfa_is_regoff == False, cfa_reg must be zero 1955 and cfa_off must be zero 1956 1957 RegRule describes, for each register, how to get its 1958 value in the previous frame, where 'cfa' denotes the cfa 1959 for the frame as a whole: 1960 1961 RegRule = RR_Undef -- undefined 1962 | RR_Same -- same as in previous frame 1963 | RR_CFAOff arg -- is at * ( cfa + arg ) 1964 | RR_CFAValOff arg -- is ( cfa + arg ) 1965 | RR_Reg arg -- is in register 'arg' 1966 | RR_Expr arg -- is at * [[ arg ]] 1967 | RR_ValExpr arg -- is [[ arg ]] 1968 | RR_Arch -- dunno 1969 1970 Note that RR_Expr is redundant since the same can be represented 1971 using RR_ValExpr with an explicit dereference (CfiExpr_Deref) at 1972 the outermost level. 1973 1974 All expressions are stored in exprs in the containing 1975 UnwindContext. Since the UnwindContext gets reinitialised for each 1976 new FDE, summarise_context needs to copy out any expressions it 1977 wants to keep into the cfsi_exprs field of the containing SegInfo. 1978 */ 1979 typedef 1980 struct { 1981 enum { RR_Undef, RR_Same, RR_CFAOff, RR_CFAValOff, 1982 RR_Reg, /*RR_Expr,*/ RR_ValExpr, RR_Arch } tag; 1983 /* meaning: int offset for CFAoff/CFAValOff 1984 reg # for Reg 1985 expr index for Expr/ValExpr */ 1986 Int arg; 1987 } 1988 RegRule; 1989 1990 static void ppRegRule ( XArray* exprs, RegRule* rrule ) 1991 { 1992 vg_assert(exprs); 1993 switch (rrule->tag) { 1994 case RR_Undef: VG_(printf)("u "); break; 1995 case RR_Same: VG_(printf)("s "); break; 1996 case RR_CFAOff: VG_(printf)("c%d ", rrule->arg); break; 1997 case RR_CFAValOff: VG_(printf)("v%d ", rrule->arg); break; 1998 case RR_Reg: VG_(printf)("r%d ", rrule->arg); break; 1999 case RR_ValExpr: VG_(printf)("ve{"); 2000 ML_(ppCfiExpr)( exprs, rrule->arg ); 2001 VG_(printf)("} "); 2002 break; 2003 case RR_Arch: VG_(printf)("a "); break; 2004 default: VG_(core_panic)("ppRegRule"); 2005 } 2006 } 2007 2008 2009 /* Size of the stack of register unwind rules. This is only 2010 exceedingly rarely used, so a stack of size 1 should actually work 2011 with almost all compiler-generated CFA. */ 2012 #define N_RR_STACK 4 2013 2014 typedef 2015 struct { 2016 /* Read-only fields (set by the CIE) */ 2017 Int code_a_f; 2018 Int data_a_f; 2019 Addr initloc; 2020 Int ra_reg; 2021 /* The rest of these fields can be modifed by 2022 run_CF_instruction. */ 2023 /* The LOC entry */ 2024 Addr loc; 2025 /* We need a stack of these in order to handle 2026 DW_CFA_{remember,restore}_state. */ 2027 struct UnwindContextState { 2028 /* The CFA entry. This can be either reg+/-offset or an expr. */ 2029 Bool cfa_is_regoff; /* True=>is reg+offset; False=>is expr */ 2030 Int cfa_reg; 2031 Int cfa_off; /* in bytes */ 2032 Int cfa_expr_ix; /* index into cfa_exprs */ 2033 /* Register unwind rules. */ 2034 RegRule reg[N_CFI_REGS]; 2035 } 2036 state[N_RR_STACK]; 2037 Int state_sp; /* 0 <= state_sp < N_RR_STACK; points at the 2038 currently-in-use rule set. */ 2039 /* array of CfiExpr, shared by reg[] and cfa_expr_ix */ 2040 XArray* exprs; 2041 } 2042 UnwindContext; 2043 2044 static void ppUnwindContext ( UnwindContext* ctx ) 2045 { 2046 Int j, i; 2047 VG_(printf)("0x%llx: ", (ULong)ctx->loc); 2048 for (j = 0; j <= ctx->state_sp; j++) { 2049 struct UnwindContextState* ctxs = &ctx->state[j]; 2050 VG_(printf)("%s[%d]={ ", j > 0 ? " " : "", j); 2051 if (ctxs->cfa_is_regoff) { 2052 VG_(printf)("%d(r%d) ", ctxs->cfa_off, ctxs->cfa_reg); 2053 } else { 2054 vg_assert(ctx->exprs); 2055 VG_(printf)("{"); 2056 ML_(ppCfiExpr)( ctx->exprs, ctxs->cfa_expr_ix ); 2057 VG_(printf)("} "); 2058 } 2059 VG_(printf)("{ "); 2060 for (i = 0; i < N_CFI_REGS; i++) 2061 ppRegRule(ctx->exprs, &ctxs->reg[i]); 2062 VG_(printf)("}"); 2063 } 2064 VG_(printf)("\n"); 2065 } 2066 2067 static void initUnwindContext ( /*OUT*/UnwindContext* ctx ) 2068 { 2069 Int j, i; 2070 VG_(memset)(ctx, 0, sizeof(*ctx)); 2071 /* ctx->code_a_f = 0; 2072 ctx->data_a_f = 0; 2073 ctx->initloc = 0; */ 2074 ctx->ra_reg = RA_REG_DEFAULT; 2075 /* ctx->loc = 0; 2076 ctx->exprs = NULL; 2077 ctx->state_sp = 0; */ 2078 for (j = 0; j < N_RR_STACK; j++) { 2079 ctx->state[j].cfa_is_regoff = True; 2080 /* ctx->state[j].cfa_reg = 0; 2081 ctx->state[j].cfa_off = 0; 2082 ctx->state[j].cfa_expr_ix = 0; */ 2083 for (i = 0; i < N_CFI_REGS; i++) { 2084 if (RR_Undef != 0) 2085 ctx->state[j].reg[i].tag = RR_Undef; 2086 /* ctx->state[j].reg[i].arg = 0; */ 2087 } 2088 # if defined(VGA_arm) 2089 /* All callee-saved registers (or at least the ones we are 2090 summarising for) should start out as RR_Same, on ARM. */ 2091 ctx->state[j].reg[11].tag = RR_Same; 2092 /* ctx->state[j].reg[13].tag = RR_Same; */ 2093 ctx->state[j].reg[14].tag = RR_Same; 2094 ctx->state[j].reg[12].tag = RR_Same; 2095 ctx->state[j].reg[7].tag = RR_Same; 2096 /* this can't be right though: R12 (IP) isn't callee saved. */ 2097 # endif 2098 } 2099 } 2100 2101 2102 /* A structure which holds information needed by read_encoded_Addr(). 2103 */ 2104 typedef 2105 struct { 2106 UChar encoding; 2107 UChar* ehframe_image; 2108 Addr ehframe_avma; 2109 Addr text_bias; 2110 } 2111 AddressDecodingInfo; 2112 2113 2114 /* ------------ Deal with summary-info records ------------ */ 2115 2116 static void initCfiSI ( DiCfSI* si ) 2117 { 2118 VG_(memset)(si, 0, sizeof(*si)); 2119 } 2120 2121 2122 /* --------------- Summarisation --------------- */ 2123 2124 /* Forward */ 2125 static 2126 Int copy_convert_CfiExpr_tree ( XArray* dst, 2127 UnwindContext* srcuc, 2128 Int nd ); 2129 2130 /* Summarise ctx into si, if possible. Returns True if successful. 2131 This is taken to be just after ctx's loc advances; hence the 2132 summary is up to but not including the current loc. This works 2133 on both x86 and amd64. 2134 */ 2135 static Bool summarise_context( /*OUT*/DiCfSI* si, 2136 Addr loc_start, 2137 UnwindContext* ctx, 2138 struct _DebugInfo* debuginfo ) 2139 { 2140 Int why = 0; 2141 struct UnwindContextState* ctxs; 2142 initCfiSI(si); 2143 2144 /* Guard against obviously stupid settings of the reg-rule stack 2145 pointer. */ 2146 if (ctx->state_sp < 0) { why = 8; goto failed; } 2147 if (ctx->state_sp >= N_RR_STACK) { why = 9; goto failed; } 2148 ctxs = &ctx->state[ctx->state_sp]; 2149 2150 /* First, summarise the method for generating the CFA */ 2151 if (!ctxs->cfa_is_regoff) { 2152 /* it was set by DW_CFA_def_cfa_expression; try to convert */ 2153 XArray *src, *dst; 2154 Int conv; 2155 src = ctx->exprs; 2156 dst = debuginfo->cfsi_exprs; 2157 if (src && (VG_(sizeXA)(src) > 0) && (!dst)) { 2158 dst = VG_(newXA)( ML_(dinfo_zalloc), "di.ccCt.1", ML_(dinfo_free), 2159 sizeof(CfiExpr) ); 2160 vg_assert(dst); 2161 debuginfo->cfsi_exprs = dst; 2162 } 2163 conv = copy_convert_CfiExpr_tree 2164 ( dst, ctx, ctxs->cfa_expr_ix ); 2165 vg_assert(conv >= -1); 2166 if (conv == -1) { why = 6; goto failed; } 2167 si->cfa_how = CFIC_EXPR; 2168 si->cfa_off = conv; 2169 if (0 && debuginfo->ddump_frames) 2170 ML_(ppCfiExpr)(dst, conv); 2171 } 2172 else 2173 if (ctxs->cfa_is_regoff && ctxs->cfa_reg == SP_REG) { 2174 si->cfa_off = ctxs->cfa_off; 2175 # if defined(VGA_x86) || defined(VGA_amd64) || defined(VGA_s390x) \ 2176 || defined(VGA_mips32) 2177 si->cfa_how = CFIC_IA_SPREL; 2178 # elif defined(VGA_arm) 2179 si->cfa_how = CFIC_ARM_R13REL; 2180 # else 2181 si->cfa_how = 0; /* invalid */ 2182 # endif 2183 } 2184 else 2185 if (ctxs->cfa_is_regoff && ctxs->cfa_reg == FP_REG) { 2186 si->cfa_off = ctxs->cfa_off; 2187 # if defined(VGA_x86) || defined(VGA_amd64) || defined(VGA_s390x) \ 2188 || defined(VGA_mips32) 2189 si->cfa_how = CFIC_IA_BPREL; 2190 # elif defined(VGA_arm) 2191 si->cfa_how = CFIC_ARM_R12REL; 2192 # else 2193 si->cfa_how = 0; /* invalid */ 2194 # endif 2195 } 2196 # if defined(VGA_arm) 2197 else 2198 if (ctxs->cfa_is_regoff && ctxs->cfa_reg == 11/*??_REG*/) { 2199 si->cfa_how = CFIC_ARM_R11REL; 2200 si->cfa_off = ctxs->cfa_off; 2201 } 2202 else 2203 if (ctxs->cfa_is_regoff && ctxs->cfa_reg == 7/*??_REG*/) { 2204 si->cfa_how = CFIC_ARM_R7REL; 2205 si->cfa_off = ctxs->cfa_off; 2206 } 2207 # endif 2208 else { 2209 why = 1; 2210 goto failed; 2211 } 2212 2213 # define SUMMARISE_HOW(_how, _off, _ctxreg) \ 2214 switch (_ctxreg.tag) { \ 2215 case RR_Undef: \ 2216 _how = CFIR_UNKNOWN; _off = 0; break; \ 2217 case RR_Same: \ 2218 _how = CFIR_SAME; _off = 0; break; \ 2219 case RR_CFAOff: \ 2220 _how = CFIR_MEMCFAREL; _off = _ctxreg.arg; break; \ 2221 case RR_CFAValOff: \ 2222 _how = CFIR_CFAREL; _off = _ctxreg.arg; break; \ 2223 case RR_ValExpr: { \ 2224 XArray *src, *dst; \ 2225 Int conv; \ 2226 src = ctx->exprs; \ 2227 dst = debuginfo->cfsi_exprs; \ 2228 if (src && (VG_(sizeXA)(src) > 0) && (!dst)) { \ 2229 dst = VG_(newXA)( ML_(dinfo_zalloc), \ 2230 "di.ccCt.2", \ 2231 ML_(dinfo_free), \ 2232 sizeof(CfiExpr) ); \ 2233 vg_assert(dst); \ 2234 debuginfo->cfsi_exprs = dst; \ 2235 } \ 2236 conv = copy_convert_CfiExpr_tree \ 2237 ( dst, ctx, _ctxreg.arg ); \ 2238 vg_assert(conv >= -1); \ 2239 if (conv == -1) { why = 7; goto failed; } \ 2240 _how = CFIR_EXPR; \ 2241 _off = conv; \ 2242 if (0 && debuginfo->ddump_frames) \ 2243 ML_(ppCfiExpr)(dst, conv); \ 2244 break; \ 2245 } \ 2246 default: \ 2247 why = 2; goto failed; /* otherwise give up */ \ 2248 } 2249 2250 # if defined(VGA_x86) || defined(VGA_amd64) 2251 2252 /* --- entire tail of this fn specialised for x86/amd64 --- */ 2253 2254 SUMMARISE_HOW(si->ra_how, si->ra_off, 2255 ctxs->reg[ctx->ra_reg] ); 2256 SUMMARISE_HOW(si->bp_how, si->bp_off, 2257 ctxs->reg[FP_REG] ); 2258 2259 /* on x86/amd64, it seems the old %{e,r}sp value before the call is 2260 always the same as the CFA. Therefore ... */ 2261 si->sp_how = CFIR_CFAREL; 2262 si->sp_off = 0; 2263 2264 /* also, gcc says "Undef" for %{e,r}bp when it is unchanged. So 2265 .. */ 2266 if (ctxs->reg[FP_REG].tag == RR_Undef) 2267 si->bp_how = CFIR_SAME; 2268 2269 /* knock out some obviously stupid cases */ 2270 if (si->ra_how == CFIR_SAME) 2271 { why = 3; goto failed; } 2272 2273 /* bogus looking range? Note, we require that the difference is 2274 representable in 32 bits. */ 2275 if (loc_start >= ctx->loc) 2276 { why = 4; goto failed; } 2277 if (ctx->loc - loc_start > 10000000 /* let's say */) 2278 { why = 5; goto failed; } 2279 2280 si->base = loc_start + ctx->initloc; 2281 si->len = (UInt)(ctx->loc - loc_start); 2282 2283 return True; 2284 2285 # elif defined(VGA_arm) 2286 2287 /* ---- entire tail of this fn specialised for arm ---- */ 2288 2289 SUMMARISE_HOW(si->r14_how, si->r14_off, 2290 ctxs->reg[14] ); 2291 2292 //SUMMARISE_HOW(si->r13_how, si->r13_off, 2293 // ctxs->reg[13] ); 2294 2295 SUMMARISE_HOW(si->r12_how, si->r12_off, 2296 ctxs->reg[FP_REG] ); 2297 2298 SUMMARISE_HOW(si->r11_how, si->r11_off, 2299 ctxs->reg[11/*FP_REG*/] ); 2300 2301 SUMMARISE_HOW(si->r7_how, si->r7_off, 2302 ctxs->reg[7] ); 2303 2304 if (ctxs->reg[14/*LR*/].tag == RR_Same 2305 && ctx->ra_reg == 14/*as we expect it always to be*/) { 2306 /* Generate a trivial CfiExpr, which merely says "r14". First 2307 ensure this DebugInfo has a cfsi_expr array in which to park 2308 it. */ 2309 if (!debuginfo->cfsi_exprs) 2310 debuginfo->cfsi_exprs = VG_(newXA)( ML_(dinfo_zalloc), 2311 "di.ccCt.2a", 2312 ML_(dinfo_free), 2313 sizeof(CfiExpr) ); 2314 si->ra_off = ML_(CfiExpr_CfiReg)( debuginfo->cfsi_exprs, 2315 Creg_ARM_R14); 2316 si->ra_how = CFIR_EXPR; 2317 } else { 2318 /* Just summarise it in the normal way */ 2319 SUMMARISE_HOW(si->ra_how, si->ra_off, 2320 ctxs->reg[ctx->ra_reg] ); 2321 } 2322 2323 /* on arm, it seems the old r13 (SP) value before the call is 2324 always the same as the CFA. Therefore ... */ 2325 si->r13_how = CFIR_CFAREL; 2326 si->r13_off = 0; 2327 2328 /* bogus looking range? Note, we require that the difference is 2329 representable in 32 bits. */ 2330 if (loc_start >= ctx->loc) 2331 { why = 4; goto failed; } 2332 if (ctx->loc - loc_start > 10000000 /* let's say */) 2333 { why = 5; goto failed; } 2334 2335 si->base = loc_start + ctx->initloc; 2336 si->len = (UInt)(ctx->loc - loc_start); 2337 2338 return True; 2339 2340 2341 # elif defined(VGA_s390x) 2342 2343 SUMMARISE_HOW(si->ra_how, si->ra_off, 2344 ctxs->reg[ctx->ra_reg] ); 2345 SUMMARISE_HOW(si->fp_how, si->fp_off, 2346 ctxs->reg[FP_REG] ); 2347 SUMMARISE_HOW(si->sp_how, si->sp_off, 2348 ctxs->reg[SP_REG] ); 2349 2350 /* change some defaults to consumable values */ 2351 if (si->sp_how == CFIR_UNKNOWN) 2352 si->sp_how = CFIR_SAME; 2353 2354 if (si->fp_how == CFIR_UNKNOWN) 2355 si->fp_how = CFIR_SAME; 2356 2357 if (si->cfa_how == CFIR_UNKNOWN) { 2358 si->cfa_how = CFIC_IA_SPREL; 2359 si->cfa_off = 160; 2360 } 2361 if (si->ra_how == CFIR_UNKNOWN) { 2362 if (!debuginfo->cfsi_exprs) 2363 debuginfo->cfsi_exprs = VG_(newXA)( ML_(dinfo_zalloc), 2364 "di.ccCt.2a", 2365 ML_(dinfo_free), 2366 sizeof(CfiExpr) ); 2367 si->ra_how = CFIR_EXPR; 2368 si->ra_off = ML_(CfiExpr_CfiReg)( debuginfo->cfsi_exprs, 2369 Creg_S390_R14); 2370 } 2371 2372 /* knock out some obviously stupid cases */ 2373 if (si->ra_how == CFIR_SAME) 2374 { why = 3; goto failed; } 2375 2376 /* bogus looking range? Note, we require that the difference is 2377 representable in 32 bits. */ 2378 if (loc_start >= ctx->loc) 2379 { why = 4; goto failed; } 2380 if (ctx->loc - loc_start > 10000000 /* let's say */) 2381 { why = 5; goto failed; } 2382 2383 si->base = loc_start + ctx->initloc; 2384 si->len = (UInt)(ctx->loc - loc_start); 2385 2386 return True; 2387 2388 2389 # elif defined(VGA_mips32) 2390 2391 /* --- entire tail of this fn specialised for mips --- */ 2392 2393 SUMMARISE_HOW(si->ra_how, si->ra_off, 2394 ctxs->reg[ctx->ra_reg] ); 2395 SUMMARISE_HOW(si->fp_how, si->fp_off, 2396 ctxs->reg[FP_REG] ); 2397 SUMMARISE_HOW(si->sp_how, si->sp_off, 2398 ctxs->reg[SP_REG] ); 2399 si->sp_how = CFIR_CFAREL; 2400 si->sp_off = 0; 2401 2402 if (si->fp_how == CFIR_UNKNOWN) 2403 si->fp_how = CFIR_SAME; 2404 if (si->cfa_how == CFIR_UNKNOWN) { 2405 si->cfa_how = CFIC_IA_SPREL; 2406 si->cfa_off = 160; 2407 } 2408 if (si->ra_how == CFIR_UNKNOWN) { 2409 if (!debuginfo->cfsi_exprs) 2410 debuginfo->cfsi_exprs = VG_(newXA)( ML_(dinfo_zalloc), 2411 "di.ccCt.2a", 2412 ML_(dinfo_free), 2413 sizeof(CfiExpr) ); 2414 si->ra_how = CFIR_EXPR; 2415 si->ra_off = ML_(CfiExpr_CfiReg)( debuginfo->cfsi_exprs, 2416 Creg_MIPS_RA); 2417 } 2418 2419 if (si->ra_how == CFIR_SAME) 2420 { why = 3; goto failed; } 2421 2422 if (loc_start >= ctx->loc) 2423 { why = 4; goto failed; } 2424 if (ctx->loc - loc_start > 10000000 /* let's say */) 2425 { why = 5; goto failed; } 2426 2427 si->base = loc_start + ctx->initloc; 2428 si->len = (UInt)(ctx->loc - loc_start); 2429 2430 return True; 2431 2432 2433 2434 # elif defined(VGA_ppc32) || defined(VGA_ppc64) 2435 # else 2436 # error "Unknown arch" 2437 # endif 2438 2439 # undef SUMMARISE_HOW 2440 2441 failed: 2442 if (VG_(clo_verbosity) > 2 || debuginfo->trace_cfi) { 2443 VG_(message)(Vg_DebugMsg, 2444 "summarise_context(loc_start = %#lx)" 2445 ": cannot summarise(why=%d): \n", loc_start, why); 2446 ppUnwindContext(ctx); 2447 } 2448 return False; 2449 } 2450 2451 /* Copy the tree rooted at srcuc->exprs node srcix to dstxa, on the 2452 way converting any DwReg regs (regs numbered using the Dwarf scheme 2453 defined by each architecture's ABI) into CfiRegs, which are 2454 platform independent. If the conversion isn't possible because 2455 there is no equivalent register, return -1. This has the 2456 undesirable side effect of de-dagifying the input; oh well. */ 2457 static Int copy_convert_CfiExpr_tree ( XArray* dstxa, 2458 UnwindContext* srcuc, 2459 Int srcix ) 2460 { 2461 CfiExpr* src; 2462 Int cpL, cpR, cpA; 2463 XArray* srcxa = srcuc->exprs; 2464 vg_assert(srcxa); 2465 vg_assert(dstxa); 2466 vg_assert(srcix >= 0 && srcix < VG_(sizeXA)(srcxa)); 2467 2468 src = VG_(indexXA)( srcxa, srcix ); 2469 switch (src->tag) { 2470 case Cex_Undef: 2471 return ML_(CfiExpr_Undef)( dstxa ); 2472 case Cex_Deref: 2473 cpA = copy_convert_CfiExpr_tree( dstxa, srcuc, src->Cex.Deref.ixAddr ); 2474 if (cpA == -1) 2475 return -1; /* propagate failure */ 2476 return ML_(CfiExpr_Deref)( dstxa, cpA ); 2477 case Cex_Const: 2478 return ML_(CfiExpr_Const)( dstxa, src->Cex.Const.con ); 2479 case Cex_Binop: 2480 cpL = copy_convert_CfiExpr_tree( dstxa, srcuc, src->Cex.Binop.ixL ); 2481 cpR = copy_convert_CfiExpr_tree( dstxa, srcuc, src->Cex.Binop.ixR ); 2482 vg_assert(cpL >= -1 && cpR >= -1); 2483 if (cpL == -1 || cpR == -1) 2484 return -1; /* propagate failure */ 2485 return ML_(CfiExpr_Binop)( dstxa, src->Cex.Binop.op, cpL, cpR ); 2486 case Cex_CfiReg: 2487 /* should not see these in input (are created only by this 2488 conversion step!) */ 2489 VG_(core_panic)("copy_convert_CfiExpr_tree: CfiReg in input"); 2490 case Cex_DwReg: { 2491 /* This is the only place where the conversion can fail. */ 2492 Int dwreg __attribute__((unused)); 2493 dwreg = src->Cex.DwReg.reg; 2494 # if defined(VGA_x86) || defined(VGA_amd64) 2495 if (dwreg == SP_REG) 2496 return ML_(CfiExpr_CfiReg)( dstxa, Creg_IA_SP ); 2497 if (dwreg == FP_REG) 2498 return ML_(CfiExpr_CfiReg)( dstxa, Creg_IA_BP ); 2499 if (dwreg == srcuc->ra_reg) 2500 return ML_(CfiExpr_CfiReg)( dstxa, Creg_IA_IP ); /* correct? */ 2501 # elif defined(VGA_arm) 2502 if (dwreg == SP_REG) 2503 return ML_(CfiExpr_CfiReg)( dstxa, Creg_ARM_R13 ); 2504 if (dwreg == FP_REG) 2505 return ML_(CfiExpr_CfiReg)( dstxa, Creg_ARM_R12 ); 2506 if (dwreg == srcuc->ra_reg) 2507 return ML_(CfiExpr_CfiReg)( dstxa, Creg_ARM_R15 ); /* correct? */ 2508 # elif defined(VGA_s390x) 2509 if (dwreg == SP_REG) 2510 return ML_(CfiExpr_CfiReg)( dstxa, Creg_IA_SP ); 2511 if (dwreg == FP_REG) 2512 return ML_(CfiExpr_CfiReg)( dstxa, Creg_IA_BP ); 2513 if (dwreg == srcuc->ra_reg) 2514 return ML_(CfiExpr_CfiReg)( dstxa, Creg_IA_IP ); /* correct? */ 2515 # elif defined(VGA_mips32) 2516 if (dwreg == SP_REG) 2517 return ML_(CfiExpr_CfiReg)( dstxa, Creg_IA_SP ); 2518 if (dwreg == FP_REG) 2519 return ML_(CfiExpr_CfiReg)( dstxa, Creg_IA_BP ); 2520 if (dwreg == srcuc->ra_reg) 2521 return ML_(CfiExpr_CfiReg)( dstxa, Creg_IA_IP ); 2522 # elif defined(VGA_ppc32) || defined(VGA_ppc64) 2523 # else 2524 # error "Unknown arch" 2525 # endif 2526 /* else we must fail - can't represent the reg */ 2527 return -1; 2528 } 2529 default: 2530 VG_(core_panic)("copy_convert_CfiExpr_tree: default"); 2531 } 2532 } 2533 2534 2535 static void ppUnwindContext_summary ( UnwindContext* ctx ) 2536 { 2537 struct UnwindContextState* ctxs = &ctx->state[ctx->state_sp]; 2538 2539 VG_(printf)("0x%llx-1: ", (ULong)ctx->loc); 2540 2541 if (ctxs->cfa_reg == SP_REG) { 2542 VG_(printf)("SP/CFA=%d+SP ", ctxs->cfa_off); 2543 } else 2544 if (ctxs->cfa_reg == FP_REG) { 2545 VG_(printf)("SP/CFA=%d+FP ", ctxs->cfa_off); 2546 } else { 2547 VG_(printf)("SP/CFA=unknown "); 2548 } 2549 2550 VG_(printf)("RA="); 2551 ppRegRule( ctx->exprs, &ctxs->reg[ctx->ra_reg] ); 2552 2553 VG_(printf)("FP="); 2554 ppRegRule( ctx->exprs, &ctxs->reg[FP_REG] ); 2555 VG_(printf)("\n"); 2556 } 2557 2558 2559 /* ------------ Pick apart DWARF2 byte streams ------------ */ 2560 2561 static ULong read_le_u_encoded_literal ( UChar* data, UInt size ) 2562 { 2563 switch (size) { 2564 case 8: return (ULong)ML_(read_ULong)( data ); 2565 case 4: return (ULong)ML_(read_UInt)( data ); 2566 case 2: return (ULong)ML_(read_UShort)( data ); 2567 case 1: return (ULong)ML_(read_UChar)( data ); 2568 default: vg_assert(0); /*NOTREACHED*/ return 0; 2569 } 2570 } 2571 2572 static Long read_le_s_encoded_literal ( UChar* data, UInt size ) 2573 { 2574 Long s64 = read_le_u_encoded_literal( data, size ); 2575 switch (size) { 2576 case 8: break; 2577 case 4: s64 <<= 32; s64 >>= 32; break; 2578 case 2: s64 <<= 48; s64 >>= 48; break; 2579 case 1: s64 <<= 56; s64 >>= 56; break; 2580 default: vg_assert(0); /*NOTREACHED*/ return 0; 2581 } 2582 return s64; 2583 } 2584 2585 static UChar default_Addr_encoding ( void ) 2586 { 2587 switch (sizeof(Addr)) { 2588 case 4: return DW_EH_PE_udata4; 2589 case 8: return DW_EH_PE_udata8; 2590 default: vg_assert(0); 2591 } 2592 } 2593 2594 static UInt size_of_encoded_Addr ( UChar encoding ) 2595 { 2596 if (encoding == DW_EH_PE_omit) 2597 return 0; 2598 2599 switch (encoding & 0x07) { 2600 case DW_EH_PE_absptr: return sizeof(Addr); 2601 case DW_EH_PE_udata2: return sizeof(UShort); 2602 case DW_EH_PE_udata4: return sizeof(UInt); 2603 case DW_EH_PE_udata8: return sizeof(ULong); 2604 default: vg_assert(0); 2605 } 2606 } 2607 2608 static Addr read_encoded_Addr ( /*OUT*/Int* nbytes, 2609 AddressDecodingInfo* adi, 2610 UChar* data ) 2611 { 2612 /* Regarding the handling of DW_EH_PE_absptr. DWARF3 says this 2613 denotes an absolute address, hence you would think 'base' is 2614 zero. However, that is nonsensical (unless relocations are to 2615 be applied to the unwind data before reading it, which sounds 2616 unlikely). My interpretation is that DW_EH_PE_absptr indicates 2617 an address relative to where the object was loaded (technically, 2618 relative to its stated load VMA, hence the use of text_bias 2619 rather than text_avma). Hmm, should we use text_bias or 2620 text_avma here? Not sure. 2621 2622 This view appears to be supported by DWARF3 spec sec 7.3 2623 "Executable Objects and Shared Objects": 2624 2625 This requirement makes the debugging information for shared 2626 objects position independent. Virtual addresses in a shared 2627 object may be calculated by adding the offset to the base 2628 address at which the object was attached. This offset is 2629 available in the run-time linker's data structures. 2630 */ 2631 Addr base; 2632 Word offset; 2633 UChar encoding = adi->encoding; 2634 UChar* ehframe_image = adi->ehframe_image; 2635 Addr ehframe_avma = adi->ehframe_avma; 2636 2637 vg_assert((encoding & DW_EH_PE_indirect) == 0); 2638 2639 *nbytes = 0; 2640 2641 switch (encoding & 0x70) { 2642 case DW_EH_PE_absptr: 2643 base = adi->text_bias; 2644 break; 2645 case DW_EH_PE_pcrel: 2646 base = ehframe_avma + ( data - ehframe_image ); 2647 break; 2648 case DW_EH_PE_datarel: 2649 vg_assert(0); 2650 base = /* data base address */ 0; 2651 break; 2652 case DW_EH_PE_textrel: 2653 vg_assert(0); 2654 base = /* text base address */ 0; 2655 break; 2656 case DW_EH_PE_funcrel: 2657 base = 0; 2658 break; 2659 case DW_EH_PE_aligned: 2660 base = 0; 2661 offset = data - ehframe_image; 2662 if ((offset % sizeof(Addr)) != 0) { 2663 *nbytes = sizeof(Addr) - (offset % sizeof(Addr)); 2664 data += *nbytes; 2665 } 2666 break; 2667 default: 2668 vg_assert(0); 2669 } 2670 2671 if ((encoding & 0x07) == 0x00) 2672 encoding |= default_Addr_encoding(); 2673 2674 switch (encoding & 0x0f) { 2675 case DW_EH_PE_udata2: 2676 *nbytes += sizeof(UShort); 2677 return base + ML_(read_UShort)(data); 2678 case DW_EH_PE_udata4: 2679 *nbytes += sizeof(UInt); 2680 return base + ML_(read_UInt)(data); 2681 case DW_EH_PE_udata8: 2682 *nbytes += sizeof(ULong); 2683 return base + ML_(read_ULong)(data); 2684 case DW_EH_PE_sdata2: 2685 *nbytes += sizeof(Short); 2686 return base + ML_(read_Short)(data); 2687 case DW_EH_PE_sdata4: 2688 *nbytes += sizeof(Int); 2689 return base + ML_(read_Int)(data); 2690 case DW_EH_PE_sdata8: 2691 *nbytes += sizeof(Long); 2692 return base + ML_(read_Long)(data); 2693 default: 2694 vg_assert2(0, "read encoded address %d\n", encoding & 0x0f); 2695 } 2696 } 2697 2698 2699 /* ------------ Run/show DWARF3 expressions ---------- */ 2700 2701 /* Convert the DWARF3 expression in expr[0 .. exprlen-1] into a dag 2702 (of CfiExprs) stored in ctx->exprs, and return the index in 2703 ctx->exprs of the root node. Or fail in which case return -1. */ 2704 /* IMPORTANT: when adding expression forms here, also remember to 2705 add suitable evaluation code in evalCfiExpr in debuginfo.c. */ 2706 static Int dwarfexpr_to_dag ( UnwindContext* ctx, 2707 UChar* expr, Int exprlen, 2708 Bool push_cfa_at_start, 2709 Bool ddump_frames ) 2710 { 2711 # define N_EXPR_STACK 20 2712 2713 # define PUSH(_arg) \ 2714 do { \ 2715 vg_assert(sp >= -1 && sp < N_EXPR_STACK); \ 2716 if (sp == N_EXPR_STACK-1) \ 2717 return -1; \ 2718 sp++; \ 2719 stack[sp] = (_arg); \ 2720 } while (0) 2721 2722 # define POP(_lval) \ 2723 do { \ 2724 vg_assert(sp >= -1 && sp < N_EXPR_STACK); \ 2725 if (sp == -1) \ 2726 return -1; \ 2727 _lval = stack[sp]; \ 2728 sp--; \ 2729 } while (0) 2730 2731 Int ix, ix2, reg; 2732 UChar opcode; 2733 Word sw; 2734 UWord uw; 2735 CfiOp op; 2736 HChar* opname; 2737 2738 Int sp; /* # of top element: valid is -1 .. N_EXPR_STACK-1 */ 2739 Int stack[N_EXPR_STACK]; /* indices into ctx->exprs */ 2740 struct UnwindContextState* ctxs = &ctx->state[ctx->state_sp]; 2741 2742 XArray* dst = ctx->exprs; 2743 UChar* limit = expr + exprlen; 2744 2745 vg_assert(dst); 2746 vg_assert(exprlen >= 0); 2747 2748 sp = -1; /* empty */ 2749 2750 /* Synthesise the CFA as a CfiExpr */ 2751 if (push_cfa_at_start) { 2752 if (ctxs->cfa_is_regoff) { 2753 /* cfa is reg +/- offset */ 2754 ix = ML_(CfiExpr_Binop)( dst, 2755 Cop_Add, 2756 ML_(CfiExpr_DwReg)( dst, ctxs->cfa_reg ), 2757 ML_(CfiExpr_Const)( dst, (UWord)(Word)ctxs->cfa_off ) 2758 ); 2759 PUSH(ix); 2760 } else { 2761 /* CFA is already an expr; use its root node */ 2762 PUSH(ctxs->cfa_expr_ix); 2763 } 2764 } 2765 2766 while (True) { 2767 2768 vg_assert(sp >= -1 && sp < N_EXPR_STACK); 2769 2770 if (expr > limit) 2771 return -1; /* overrun - something's wrong */ 2772 2773 if (expr == limit) { 2774 /* end of expr - return expr on the top of stack. */ 2775 if (sp == -1) 2776 return -1; /* stack empty. Bad. */ 2777 else 2778 break; 2779 } 2780 2781 op = 0; opname = NULL; /* excessively conservative */ 2782 2783 opcode = *expr++; 2784 switch (opcode) { 2785 2786 case DW_OP_lit0 ... DW_OP_lit31: 2787 /* push: literal 0 .. 31 */ 2788 sw = (Word)opcode - (Word)DW_OP_lit0; 2789 vg_assert(sw >= 0 && sw <= 31); 2790 PUSH( ML_(CfiExpr_Const)( dst, (UWord)sw ) ); 2791 if (ddump_frames) 2792 VG_(printf)("DW_OP_lit%ld", sw); 2793 break; 2794 2795 case DW_OP_breg0 ... DW_OP_breg31: 2796 /* push: reg + sleb128 */ 2797 reg = (Int)opcode - (Int)DW_OP_breg0; 2798 vg_assert(reg >= 0 && reg <= 31); 2799 sw = read_leb128S( &expr ); 2800 ix = ML_(CfiExpr_Binop)( dst, 2801 Cop_Add, 2802 ML_(CfiExpr_DwReg)( dst, reg ), 2803 ML_(CfiExpr_Const)( dst, (UWord)sw ) 2804 ); 2805 PUSH(ix); 2806 if (ddump_frames) 2807 VG_(printf)("DW_OP_breg%d: %ld", reg, sw); 2808 break; 2809 2810 case DW_OP_reg0 ... DW_OP_reg31: 2811 /* push: reg */ 2812 reg = (Int)opcode - (Int)DW_OP_reg0; 2813 vg_assert(reg >= 0 && reg <= 31); 2814 ix = ML_(CfiExpr_DwReg)( dst, reg ); 2815 PUSH(ix); 2816 if (ddump_frames) 2817 VG_(printf)("DW_OP_reg%d", reg); 2818 break; 2819 2820 case DW_OP_plus_uconst: 2821 uw = read_leb128U( &expr ); 2822 PUSH( ML_(CfiExpr_Const)( dst, uw ) ); 2823 POP( ix ); 2824 POP( ix2 ); 2825 PUSH( ML_(CfiExpr_Binop)( dst, op, ix2, ix ) ); 2826 if (ddump_frames) 2827 VG_(printf)("DW_OP_plus_uconst: %lu", uw); 2828 break; 2829 2830 case DW_OP_const4s: 2831 /* push: 32-bit signed immediate */ 2832 sw = read_le_s_encoded_literal( expr, 4 ); 2833 expr += 4; 2834 PUSH( ML_(CfiExpr_Const)( dst, (UWord)sw ) ); 2835 if (ddump_frames) 2836 VG_(printf)("DW_OP_const4s: %ld", sw); 2837 break; 2838 2839 case DW_OP_const1s: 2840 /* push: 8-bit signed immediate */ 2841 sw = read_le_s_encoded_literal( expr, 1 ); 2842 expr += 1; 2843 PUSH( ML_(CfiExpr_Const)( dst, (UWord)sw ) ); 2844 if (ddump_frames) 2845 VG_(printf)("DW_OP_const1s: %ld", sw); 2846 break; 2847 2848 case DW_OP_minus: 2849 op = Cop_Sub; opname = "minus"; goto binop; 2850 case DW_OP_plus: 2851 op = Cop_Add; opname = "plus"; goto binop; 2852 case DW_OP_and: 2853 op = Cop_And; opname = "and"; goto binop; 2854 case DW_OP_mul: 2855 op = Cop_Mul; opname = "mul"; goto binop; 2856 case DW_OP_shl: 2857 op = Cop_Shl; opname = "shl"; goto binop; 2858 case DW_OP_shr: 2859 op = Cop_Shr; opname = "shr"; goto binop; 2860 case DW_OP_eq: 2861 op = Cop_Eq; opname = "eq"; goto binop; 2862 case DW_OP_ge: 2863 op = Cop_Ge; opname = "ge"; goto binop; 2864 case DW_OP_gt: 2865 op = Cop_Gt; opname = "gt"; goto binop; 2866 case DW_OP_le: 2867 op = Cop_Le; opname = "le"; goto binop; 2868 case DW_OP_lt: 2869 op = Cop_Lt; opname = "lt"; goto binop; 2870 case DW_OP_ne: 2871 op = Cop_Ne; opname = "ne"; goto binop; 2872 binop: 2873 POP( ix ); 2874 POP( ix2 ); 2875 PUSH( ML_(CfiExpr_Binop)( dst, op, ix2, ix ) ); 2876 if (ddump_frames) 2877 VG_(printf)("DW_OP_%s", opname); 2878 break; 2879 2880 case DW_OP_deref: 2881 POP( ix ); 2882 PUSH( ML_(CfiExpr_Deref)( dst, ix ) ); 2883 if (ddump_frames) 2884 VG_(printf)("DW_OP_deref"); 2885 break; 2886 2887 default: 2888 if (!VG_(clo_xml)) 2889 VG_(message)(Vg_DebugMsg, 2890 "Warning: DWARF2 CFI reader: unhandled DW_OP_ " 2891 "opcode 0x%x\n", (Int)opcode); 2892 return -1; 2893 } 2894 2895 if (expr < limit && ddump_frames) 2896 VG_(printf)("; "); 2897 2898 } 2899 2900 vg_assert(sp >= -1 && sp < N_EXPR_STACK); 2901 if (sp == -1) 2902 return -1; 2903 2904 if (0 && ddump_frames) 2905 ML_(ppCfiExpr)( dst, stack[sp] ); 2906 return stack[sp]; 2907 2908 # undef POP 2909 # undef PUSH 2910 # undef N_EXPR_STACK 2911 } 2912 2913 2914 /* ------------ Run/show CFI instructions ------------ */ 2915 2916 /* Run a CFI instruction, and also return its length. 2917 Returns 0 if the instruction could not be executed. 2918 */ 2919 static Int run_CF_instruction ( /*MOD*/UnwindContext* ctx, 2920 UChar* instr, 2921 UnwindContext* restore_ctx, 2922 AddressDecodingInfo* adi, 2923 struct _DebugInfo* di ) 2924 { 2925 Int off, reg, reg2, nleb, len; 2926 UInt delta; 2927 UChar* expr; 2928 Int j; 2929 Int i = 0; 2930 UChar hi2 = (instr[i] >> 6) & 3; 2931 UChar lo6 = instr[i] & 0x3F; 2932 Addr printing_bias = ((Addr)ctx->initloc) - ((Addr)di->text_bias); 2933 struct UnwindContextState* ctxs; 2934 i++; 2935 2936 if (ctx->state_sp < 0 || ctx->state_sp >= N_RR_STACK) 2937 return 0; /* bogus reg-rule stack pointer */ 2938 2939 ctxs = &ctx->state[ctx->state_sp]; 2940 if (hi2 == DW_CFA_advance_loc) { 2941 delta = (UInt)lo6; 2942 delta *= ctx->code_a_f; 2943 ctx->loc += delta; 2944 if (di->ddump_frames) 2945 VG_(printf)(" DW_CFA_advance_loc: %d to %08lx\n", 2946 (Int)delta, (Addr)ctx->loc + printing_bias); 2947 return i; 2948 } 2949 2950 if (hi2 == DW_CFA_offset) { 2951 /* Set rule for reg 'lo6' to CFAOff(off * data_af) */ 2952 off = read_leb128( &instr[i], &nleb, 0 ); 2953 i += nleb; 2954 reg = (Int)lo6; 2955 if (reg < 0 || reg >= N_CFI_REGS) 2956 return 0; /* fail */ 2957 ctxs->reg[reg].tag = RR_CFAOff; 2958 ctxs->reg[reg].arg = off * ctx->data_a_f; 2959 if (di->ddump_frames) 2960 VG_(printf)(" DW_CFA_offset: r%d at cfa%s%d\n", 2961 (Int)reg, 2962 ctxs->reg[reg].arg < 0 ? "" : "+", 2963 (Int)ctxs->reg[reg].arg ); 2964 return i; 2965 } 2966 2967 if (hi2 == DW_CFA_restore) { 2968 reg = (Int)lo6; 2969 if (reg < 0 || reg >= N_CFI_REGS) 2970 return 0; /* fail */ 2971 if (restore_ctx == NULL) 2972 return 0; /* fail */ 2973 ctxs->reg[reg] = restore_ctx->state[restore_ctx->state_sp].reg[reg]; 2974 if (di->ddump_frames) 2975 VG_(printf)(" DW_CFA_restore: r%d\n", (Int)reg); 2976 return i; 2977 } 2978 2979 vg_assert(hi2 == DW_CFA_use_secondary); 2980 2981 switch (lo6) { 2982 case DW_CFA_nop: 2983 if (di->ddump_frames) 2984 VG_(printf)(" DW_CFA_nop\n"); 2985 break; 2986 case DW_CFA_set_loc: 2987 /* WAS: 2988 ctx->loc = read_Addr(&instr[i]) - ctx->initloc; i+= sizeof(Addr); 2989 Was this ever right? */ 2990 /* 2007 Feb 23: No. binutils/dwarf.c treats it as an encoded 2991 address and that appears to be in accordance with the 2992 DWARF3 spec. */ 2993 ctx->loc = read_encoded_Addr(&len, adi, &instr[i]); 2994 i += len; 2995 if (di->ddump_frames) 2996 VG_(printf)(" rci:DW_CFA_set_loc\n"); 2997 break; 2998 case DW_CFA_advance_loc1: 2999 delta = (UInt)ML_(read_UChar)(&instr[i]); i+= sizeof(UChar); 3000 delta *= ctx->code_a_f; 3001 ctx->loc += delta; 3002 if (di->ddump_frames) 3003 VG_(printf)(" DW_CFA_advance_loc1: %d to %08lx\n", 3004 (Int)delta, (Addr)ctx->loc + printing_bias); 3005 break; 3006 case DW_CFA_advance_loc2: 3007 delta = (UInt)ML_(read_UShort)(&instr[i]); i+= sizeof(UShort); 3008 delta *= ctx->code_a_f; 3009 ctx->loc += delta; 3010 if (di->ddump_frames) 3011 VG_(printf)(" DW_CFA_advance_loc2: %d to %08lx\n", 3012 (Int)delta, (Addr)ctx->loc + printing_bias); 3013 break; 3014 case DW_CFA_advance_loc4: 3015 delta = (UInt)ML_(read_UInt)(&instr[i]); i+= sizeof(UInt); 3016 delta *= ctx->code_a_f; 3017 ctx->loc += delta; 3018 if (di->ddump_frames) 3019 VG_(printf)(" DW_CFA_advance_loc4: %d to %08lx\n", 3020 (Int)delta, (Addr)ctx->loc + printing_bias); 3021 break; 3022 3023 case DW_CFA_def_cfa: 3024 reg = read_leb128( &instr[i], &nleb, 0 ); 3025 i += nleb; 3026 off = read_leb128( &instr[i], &nleb, 0 ); 3027 i += nleb; 3028 if (reg < 0 || reg >= N_CFI_REGS) 3029 return 0; /* fail */ 3030 ctxs->cfa_is_regoff = True; 3031 ctxs->cfa_expr_ix = 0; 3032 ctxs->cfa_reg = reg; 3033 ctxs->cfa_off = off; 3034 if (di->ddump_frames) 3035 VG_(printf)(" DW_CFA_def_cfa: r%d ofs %d\n", (Int)reg, (Int)off); 3036 break; 3037 3038 case DW_CFA_def_cfa_sf: 3039 reg = read_leb128( &instr[i], &nleb, 0 ); 3040 i += nleb; 3041 off = read_leb128( &instr[i], &nleb, 1 ); 3042 i += nleb; 3043 if (reg < 0 || reg >= N_CFI_REGS) 3044 return 0; /* fail */ 3045 ctxs->cfa_is_regoff = True; 3046 ctxs->cfa_expr_ix = 0; 3047 ctxs->cfa_reg = reg; 3048 ctxs->cfa_off = off * ctx->data_a_f; 3049 if (di->ddump_frames) 3050 VG_(printf)(" rci:DW_CFA_def_cfa_sf\n"); 3051 break; 3052 3053 case DW_CFA_register: 3054 reg = read_leb128( &instr[i], &nleb, 0); 3055 i += nleb; 3056 reg2 = read_leb128( &instr[i], &nleb, 0); 3057 i += nleb; 3058 if (reg < 0 || reg >= N_CFI_REGS) 3059 return 0; /* fail */ 3060 if (reg2 < 0 || reg2 >= N_CFI_REGS) 3061 return 0; /* fail */ 3062 ctxs->reg[reg].tag = RR_Reg; 3063 ctxs->reg[reg].arg = reg2; 3064 if (di->ddump_frames) 3065 VG_(printf)(" DW_CFA_register: r%d in r%d\n", 3066 (Int)reg, (Int)reg2); 3067 break; 3068 3069 case DW_CFA_offset_extended: 3070 reg = read_leb128( &instr[i], &nleb, 0 ); 3071 i += nleb; 3072 off = read_leb128( &instr[i], &nleb, 0 ); 3073 i += nleb; 3074 if (reg < 0 || reg >= N_CFI_REGS) 3075 return 0; /* fail */ 3076 ctxs->reg[reg].tag = RR_CFAOff; 3077 ctxs->reg[reg].arg = off * ctx->data_a_f; 3078 if (di->ddump_frames) 3079 VG_(printf)(" rci:DW_CFA_offset_extended\n"); 3080 break; 3081 3082 case DW_CFA_offset_extended_sf: 3083 reg = read_leb128( &instr[i], &nleb, 0 ); 3084 i += nleb; 3085 off = read_leb128( &instr[i], &nleb, 1 ); 3086 i += nleb; 3087 if (reg < 0 || reg >= N_CFI_REGS) 3088 return 0; /* fail */ 3089 ctxs->reg[reg].tag = RR_CFAOff; 3090 ctxs->reg[reg].arg = off * ctx->data_a_f; 3091 if (di->ddump_frames) 3092 VG_(printf)(" DW_CFA_offset_extended_sf: r%d at cfa%s%d\n", 3093 reg, 3094 ctxs->reg[reg].arg < 0 ? "" : "+", 3095 (Int)ctxs->reg[reg].arg); 3096 break; 3097 3098 case DW_CFA_GNU_negative_offset_extended: 3099 reg = read_leb128( &instr[i], &nleb, 0 ); 3100 i += nleb; 3101 off = read_leb128( &instr[i], &nleb, 0 ); 3102 i += nleb; 3103 if (reg < 0 || reg >= N_CFI_REGS) 3104 return 0; /* fail */ 3105 ctxs->reg[reg].tag = RR_CFAOff; 3106 ctxs->reg[reg].arg = (-off) * ctx->data_a_f; 3107 if (di->ddump_frames) 3108 VG_(printf)(" rci:DW_CFA_GNU_negative_offset_extended\n"); 3109 break; 3110 3111 case DW_CFA_restore_extended: 3112 reg = read_leb128( &instr[i], &nleb, 0 ); 3113 i += nleb; 3114 if (reg < 0 || reg >= N_CFI_REGS) 3115 return 0; /* fail */ 3116 if (restore_ctx == NULL) 3117 return 0; /* fail */ 3118 ctxs->reg[reg] = restore_ctx->state[restore_ctx->state_sp].reg[reg]; 3119 if (di->ddump_frames) 3120 VG_(printf)(" rci:DW_CFA_restore_extended\n"); 3121 break; 3122 3123 case DW_CFA_val_offset: 3124 reg = read_leb128( &instr[i], &nleb, 0 ); 3125 i += nleb; 3126 off = read_leb128( &instr[i], &nleb, 0 ); 3127 i += nleb; 3128 if (reg < 0 || reg >= N_CFI_REGS) 3129 return 0; /* fail */ 3130 ctxs->reg[reg].tag = RR_CFAValOff; 3131 ctxs->reg[reg].arg = off * ctx->data_a_f; 3132 if (di->ddump_frames) 3133 VG_(printf)(" rci:DW_CFA_val_offset\n"); 3134 break; 3135 3136 case DW_CFA_val_offset_sf: 3137 reg = read_leb128( &instr[i], &nleb, 0 ); 3138 i += nleb; 3139 off = read_leb128( &instr[i], &nleb, 1 ); 3140 i += nleb; 3141 if (reg < 0 || reg >= N_CFI_REGS) 3142 return 0; /* fail */ 3143 ctxs->reg[reg].tag = RR_CFAValOff; 3144 ctxs->reg[reg].arg = off * ctx->data_a_f; 3145 if (di->ddump_frames) 3146 VG_(printf)(" rci:DW_CFA_val_offset_sf\n"); 3147 break; 3148 3149 case DW_CFA_def_cfa_register: 3150 reg = read_leb128( &instr[i], &nleb, 0); 3151 i += nleb; 3152 if (reg < 0 || reg >= N_CFI_REGS) 3153 return 0; /* fail */ 3154 ctxs->cfa_is_regoff = True; 3155 ctxs->cfa_expr_ix = 0; 3156 ctxs->cfa_reg = reg; 3157 /* ->cfa_off unchanged */ 3158 if (di->ddump_frames) 3159 VG_(printf)(" DW_CFA_def_cfa_register: r%d\n", (Int)reg ); 3160 break; 3161 3162 case DW_CFA_def_cfa_offset: 3163 off = read_leb128( &instr[i], &nleb, 0); 3164 i += nleb; 3165 ctxs->cfa_is_regoff = True; 3166 ctxs->cfa_expr_ix = 0; 3167 /* ->reg is unchanged */ 3168 ctxs->cfa_off = off; 3169 if (di->ddump_frames) 3170 VG_(printf)(" DW_CFA_def_cfa_offset: %d\n", (Int)off); 3171 break; 3172 3173 case DW_CFA_def_cfa_offset_sf: 3174 off = read_leb128( &instr[i], &nleb, 1); 3175 i += nleb; 3176 ctxs->cfa_is_regoff = True; 3177 ctxs->cfa_expr_ix = 0; 3178 /* ->reg is unchanged */ 3179 ctxs->cfa_off = off * ctx->data_a_f; 3180 if (di->ddump_frames) 3181 VG_(printf)(" DW_CFA_def_cfa_offset_sf: %d\n", ctxs->cfa_off); 3182 break; 3183 3184 case DW_CFA_undefined: 3185 reg = read_leb128( &instr[i], &nleb, 0); 3186 i += nleb; 3187 if (reg < 0 || reg >= N_CFI_REGS) 3188 return 0; /* fail */ 3189 ctxs->reg[reg].tag = RR_Undef; 3190 ctxs->reg[reg].arg = 0; 3191 if (di->ddump_frames) 3192 VG_(printf)(" rci:DW_CFA_undefined\n"); 3193 break; 3194 3195 case DW_CFA_same_value: 3196 reg = read_leb128( &instr[i], &nleb, 0); 3197 i += nleb; 3198 if (reg < 0 || reg >= N_CFI_REGS) 3199 return 0; /* fail */ 3200 ctxs->reg[reg].tag = RR_Same; 3201 ctxs->reg[reg].arg = 0; 3202 if (di->ddump_frames) 3203 VG_(printf)(" rci:DW_CFA_same_value\n"); 3204 break; 3205 3206 case DW_CFA_GNU_args_size: 3207 /* No idea what is supposed to happen. gdb-6.3 simply 3208 ignores these. */ 3209 /*off = */ read_leb128( &instr[i], &nleb, 0 ); 3210 i += nleb; 3211 if (di->ddump_frames) 3212 VG_(printf)(" rci:DW_CFA_GNU_args_size (ignored)\n"); 3213 break; 3214 3215 case DW_CFA_expression: 3216 /* Identical to DW_CFA_val_expression except that the value 3217 computed is an address and so needs one final 3218 dereference. */ 3219 reg = read_leb128( &instr[i], &nleb, 0 ); 3220 i += nleb; 3221 len = read_leb128( &instr[i], &nleb, 0 ); 3222 i += nleb; 3223 expr = &instr[i]; 3224 i += len; 3225 if (reg < 0 || reg >= N_CFI_REGS) 3226 return 0; /* fail */ 3227 if (di->ddump_frames) 3228 VG_(printf)(" DW_CFA_expression: r%d (", 3229 (Int)reg); 3230 /* Convert the expression into a dag rooted at ctx->exprs index j, 3231 or fail. */ 3232 j = dwarfexpr_to_dag ( ctx, expr, len, True/*push CFA at start*/, 3233 di->ddump_frames); 3234 if (di->ddump_frames) 3235 VG_(printf)(")\n"); 3236 vg_assert(j >= -1); 3237 if (j >= 0) { 3238 vg_assert(ctx->exprs); 3239 vg_assert( j < VG_(sizeXA)(ctx->exprs) ); 3240 } 3241 if (j == -1) 3242 return 0; /* fail */ 3243 /* Add an extra dereference */ 3244 j = ML_(CfiExpr_Deref)( ctx->exprs, j ); 3245 ctxs->reg[reg].tag = RR_ValExpr; 3246 ctxs->reg[reg].arg = j; 3247 break; 3248 3249 case DW_CFA_val_expression: 3250 reg = read_leb128( &instr[i], &nleb, 0 ); 3251 i += nleb; 3252 len = read_leb128( &instr[i], &nleb, 0 ); 3253 i += nleb; 3254 expr = &instr[i]; 3255 i += len; 3256 if (reg < 0 || reg >= N_CFI_REGS) 3257 return 0; /* fail */ 3258 if (di->ddump_frames) 3259 VG_(printf)(" DW_CFA_val_expression: r%d (", 3260 (Int)reg); 3261 /* Convert the expression into a dag rooted at ctx->exprs index j, 3262 or fail. */ 3263 j = dwarfexpr_to_dag ( ctx, expr, len, True/*push CFA at start*/, 3264 di->ddump_frames); 3265 if (di->ddump_frames) 3266 VG_(printf)(")\n"); 3267 vg_assert(j >= -1); 3268 if (j >= 0) { 3269 vg_assert(ctx->exprs); 3270 vg_assert( j < VG_(sizeXA)(ctx->exprs) ); 3271 } 3272 if (j == -1) 3273 return 0; /* fail */ 3274 ctxs->reg[reg].tag = RR_ValExpr; 3275 ctxs->reg[reg].arg = j; 3276 break; 3277 3278 case DW_CFA_def_cfa_expression: 3279 len = read_leb128( &instr[i], &nleb, 0 ); 3280 i += nleb; 3281 expr = &instr[i]; 3282 i += len; 3283 if (di->ddump_frames) 3284 VG_(printf)(" DW_CFA_def_cfa_expression ("); 3285 /* Convert the expression into a dag rooted at ctx->exprs index j, 3286 or fail. */ 3287 j = dwarfexpr_to_dag ( ctx, expr, len, True/*push CFA at start*/, 3288 di->ddump_frames); 3289 if (di->ddump_frames) 3290 VG_(printf)(")\n"); 3291 ctxs->cfa_is_regoff = False; 3292 ctxs->cfa_reg = 0; 3293 ctxs->cfa_off = 0; 3294 ctxs->cfa_expr_ix = j; 3295 break; 3296 3297 case DW_CFA_GNU_window_save: 3298 /* Ignored. This appears to be sparc-specific; quite why it 3299 turns up in SuSE-supplied x86 .so's beats me. */ 3300 if (di->ddump_frames) 3301 VG_(printf)(" DW_CFA_GNU_window_save\n"); 3302 break; 3303 3304 case DW_CFA_remember_state: 3305 if (di->ddump_frames) 3306 VG_(printf)(" DW_CFA_remember_state\n"); 3307 /* we just checked this at entry, so: */ 3308 vg_assert(ctx->state_sp >= 0 && ctx->state_sp < N_RR_STACK); 3309 ctx->state_sp++; 3310 if (ctx->state_sp == N_RR_STACK) { 3311 /* stack overflow. We're hosed. */ 3312 VG_(message)(Vg_DebugMsg, "DWARF2 CFI reader: N_RR_STACK is " 3313 "too low; increase and recompile."); 3314 i = 0; /* indicate failure */ 3315 } else { 3316 VG_(memcpy)(/*dst*/&ctx->state[ctx->state_sp], 3317 /*src*/&ctx->state[ctx->state_sp - 1], 3318 sizeof(ctx->state[ctx->state_sp]) ); 3319 } 3320 break; 3321 3322 case DW_CFA_restore_state: 3323 if (di->ddump_frames) 3324 VG_(printf)(" DW_CFA_restore_state\n"); 3325 /* we just checked this at entry, so: */ 3326 vg_assert(ctx->state_sp >= 0 && ctx->state_sp < N_RR_STACK); 3327 if (ctx->state_sp == 0) { 3328 /* stack overflow. Give up. */ 3329 i = 0; /* indicate failure */ 3330 } else { 3331 /* simply fall back to previous entry */ 3332 ctx->state_sp--; 3333 } 3334 break; 3335 3336 default: 3337 VG_(message)(Vg_DebugMsg, "DWARF2 CFI reader: unhandled CFI " 3338 "instruction 0:%d\n", (Int)lo6); 3339 if (di->ddump_frames) 3340 VG_(printf)(" rci:run_CF_instruction:default\n"); 3341 i = 0; 3342 break; 3343 } 3344 3345 return i; 3346 } 3347 3348 3349 /* Show a CFI instruction, and also return its length. Show it as 3350 close as possible (preferably identical) to how GNU binutils 3351 readelf --debug-dump=frames would. */ 3352 3353 static Int show_CF_instruction ( UChar* instr, 3354 AddressDecodingInfo* adi, 3355 Int code_a_f, Int data_a_f ) 3356 { 3357 UInt delta; 3358 Int off, coff, reg, reg2, nleb, len; 3359 Addr loc; 3360 Int i = 0; 3361 UChar hi2 = (instr[i] >> 6) & 3; 3362 UChar lo6 = instr[i] & 0x3F; 3363 i++; 3364 3365 if (0) VG_(printf)("raw:%x/%x:%x:%x:%x:%x:%x:%x:%x:%x\n", 3366 hi2, lo6, 3367 instr[i+0], instr[i+1], instr[i+2], instr[i+3], 3368 instr[i+4], instr[i+5], instr[i+6], instr[i+7] ); 3369 3370 if (hi2 == DW_CFA_advance_loc) { 3371 VG_(printf)(" sci:DW_CFA_advance_loc(%d)\n", (Int)lo6); 3372 return i; 3373 } 3374 3375 if (hi2 == DW_CFA_offset) { 3376 off = read_leb128( &instr[i], &nleb, 0 ); 3377 i += nleb; 3378 coff = off * data_a_f; 3379 VG_(printf)(" DW_CFA_offset: r%d at cfa%s%d\n", 3380 (Int)lo6, coff < 0 ? "" : "+", (Int)coff ); 3381 return i; 3382 } 3383 3384 if (hi2 == DW_CFA_restore) { 3385 VG_(printf)(" sci:DW_CFA_restore(r%d)\n", (Int)lo6); 3386 return i; 3387 } 3388 3389 vg_assert(hi2 == DW_CFA_use_secondary); 3390 3391 switch (lo6) { 3392 3393 case DW_CFA_nop: 3394 VG_(printf)(" DW_CFA_nop\n"); 3395 break; 3396 3397 case DW_CFA_set_loc: 3398 /* WAS: loc = read_Addr(&instr[i]); i+= sizeof(Addr); 3399 (now known to be incorrect -- the address is encoded) */ 3400 loc = read_encoded_Addr(&len, adi, &instr[i]); 3401 i += len; 3402 VG_(printf)(" sci:DW_CFA_set_loc(%#lx)\n", loc); 3403 break; 3404 3405 case DW_CFA_advance_loc1: 3406 delta = (UInt)ML_(read_UChar)(&instr[i]); i+= sizeof(UChar); 3407 VG_(printf)(" sci:DW_CFA_advance_loc1(%d)\n", delta); 3408 break; 3409 3410 case DW_CFA_advance_loc2: 3411 delta = (UInt)ML_(read_UShort)(&instr[i]); i+= sizeof(UShort); 3412 VG_(printf)(" sci:DW_CFA_advance_loc2(%d)\n", delta); 3413 break; 3414 3415 case DW_CFA_advance_loc4: 3416 delta = (UInt)ML_(read_UInt)(&instr[i]); i+= sizeof(UInt); 3417 VG_(printf)(" DW_CFA_advance_loc4(%d)\n", delta); 3418 break; 3419 3420 case DW_CFA_def_cfa: 3421 reg = read_leb128( &instr[i], &nleb, 0 ); 3422 i += nleb; 3423 off = read_leb128( &instr[i], &nleb, 0 ); 3424 i += nleb; 3425 VG_(printf)(" DW_CFA_def_cfa: r%d ofs %d\n", (Int)reg, (Int)off); 3426 break; 3427 3428 case DW_CFA_def_cfa_sf: 3429 reg = read_leb128( &instr[i], &nleb, 0 ); 3430 i += nleb; 3431 off = read_leb128( &instr[i], &nleb, 1 ); 3432 i += nleb; 3433 VG_(printf)(" DW_CFA_def_cfa_sf: r%d ofs %d\n", 3434 (Int)reg, (Int)(off * data_a_f)); 3435 break; 3436 3437 case DW_CFA_register: 3438 reg = read_leb128( &instr[i], &nleb, 0); 3439 i += nleb; 3440 reg2 = read_leb128( &instr[i], &nleb, 0); 3441 i += nleb; 3442 VG_(printf)(" sci:DW_CFA_register(r%d, r%d)\n", reg, reg2); 3443 break; 3444 3445 case DW_CFA_def_cfa_register: 3446 reg = read_leb128( &instr[i], &nleb, 0); 3447 i += nleb; 3448 VG_(printf)(" sci:DW_CFA_def_cfa_register(r%d)\n", reg); 3449 break; 3450 3451 case DW_CFA_def_cfa_offset: 3452 off = read_leb128( &instr[i], &nleb, 0); 3453 i += nleb; 3454 VG_(printf)(" sci:DW_CFA_def_cfa_offset(%d)\n", off); 3455 break; 3456 3457 case DW_CFA_def_cfa_offset_sf: 3458 off = read_leb128( &instr[i], &nleb, 1); 3459 i += nleb; 3460 VG_(printf)(" sci:DW_CFA_def_cfa_offset_sf(%d)\n", off); 3461 break; 3462 3463 case DW_CFA_restore_extended: 3464 reg = read_leb128( &instr[i], &nleb, 0); 3465 i += nleb; 3466 VG_(printf)(" sci:DW_CFA_restore_extended(r%d)\n", reg); 3467 break; 3468 3469 case DW_CFA_undefined: 3470 reg = read_leb128( &instr[i], &nleb, 0); 3471 i += nleb; 3472 VG_(printf)(" sci:DW_CFA_undefined(r%d)\n", reg); 3473 break; 3474 3475 case DW_CFA_same_value: 3476 reg = read_leb128( &instr[i], &nleb, 0); 3477 i += nleb; 3478 VG_(printf)(" sci:DW_CFA_same_value(r%d)\n", reg); 3479 break; 3480 3481 case DW_CFA_remember_state: 3482 VG_(printf)(" sci:DW_CFA_remember_state\n"); 3483 break; 3484 3485 case DW_CFA_restore_state: 3486 VG_(printf)(" sci:DW_CFA_restore_state\n"); 3487 break; 3488 3489 case DW_CFA_GNU_args_size: 3490 off = read_leb128( &instr[i], &nleb, 0 ); 3491 i += nleb; 3492 VG_(printf)(" sci:DW_CFA_GNU_args_size(%d)\n", off ); 3493 break; 3494 3495 case DW_CFA_def_cfa_expression: 3496 len = read_leb128( &instr[i], &nleb, 0 ); 3497 i += nleb; 3498 i += len; 3499 VG_(printf)(" sci:DW_CFA_def_cfa_expression(length %d)\n", len); 3500 break; 3501 3502 case DW_CFA_expression: 3503 reg = read_leb128( &instr[i], &nleb, 0 ); 3504 i += nleb; 3505 len = read_leb128( &instr[i], &nleb, 0 ); 3506 i += nleb; 3507 i += len; 3508 VG_(printf)(" sci:DW_CFA_expression(r%d, length %d)\n", reg, len); 3509 break; 3510 3511 case DW_CFA_val_expression: 3512 reg = read_leb128( &instr[i], &nleb, 0 ); 3513 i += nleb; 3514 len = read_leb128( &instr[i], &nleb, 0 ); 3515 i += nleb; 3516 i += len; 3517 VG_(printf)(" sci:DW_CFA_val_expression(r%d, length %d)\n", reg, len); 3518 break; 3519 3520 case DW_CFA_offset_extended: 3521 reg = read_leb128( &instr[i], &nleb, 0 ); 3522 i += nleb; 3523 off = read_leb128( &instr[i], &nleb, 0 ); 3524 i += nleb; 3525 VG_(printf)(" sci:DW_CFA_offset_extended(r%d, " 3526 "off %d x data_af)\n", reg, off); 3527 break; 3528 3529 case DW_CFA_offset_extended_sf: 3530 reg = read_leb128( &instr[i], &nleb, 0 ); 3531 i += nleb; 3532 off = read_leb128( &instr[i], &nleb, 1 ); 3533 i += nleb; 3534 coff = (Int)(off * data_a_f); 3535 VG_(printf)(" DW_CFA_offset_extended_sf: r%d at cfa%s%d\n", 3536 reg, coff < 0 ? "" : "+", coff); 3537 break; 3538 3539 case DW_CFA_GNU_negative_offset_extended: 3540 reg = read_leb128( &instr[i], &nleb, 0 ); 3541 i += nleb; 3542 off = read_leb128( &instr[i], &nleb, 0 ); 3543 i += nleb; 3544 VG_(printf)(" sci:DW_CFA_GNU_negative_offset_extended" 3545 "(r%d, off %d x data_af)\n", reg, -off); 3546 break; 3547 3548 case DW_CFA_val_offset: 3549 reg = read_leb128( &instr[i], &nleb, 0 ); 3550 i += nleb; 3551 off = read_leb128( &instr[i], &nleb, 0 ); 3552 i += nleb; 3553 VG_(printf)(" sci:DW_CFA_val_offset(r%d, off %d x data_af)\n", 3554 reg, off); 3555 break; 3556 3557 case DW_CFA_val_offset_sf: 3558 reg = read_leb128( &instr[i], &nleb, 0 ); 3559 i += nleb; 3560 off = read_leb128( &instr[i], &nleb, 1 ); 3561 i += nleb; 3562 VG_(printf)(" sci:DW_CFA_val_offset_sf(r%d, off %d x data_af)\n", 3563 reg, off); 3564 break; 3565 3566 case DW_CFA_GNU_window_save: 3567 VG_(printf)(" sci:DW_CFA_GNU_window_save\n"); 3568 break; 3569 3570 default: 3571 VG_(printf)(" sci:0:%d\n", (Int)lo6); 3572 break; 3573 } 3574 3575 return i; 3576 } 3577 3578 3579 /* Show the instructions in instrs[0 .. ilen-1]. */ 3580 static void show_CF_instructions ( UChar* instrs, Int ilen, 3581 AddressDecodingInfo* adi, 3582 Int code_a_f, Int data_a_f ) 3583 { 3584 Int i = 0; 3585 while (True) { 3586 if (i >= ilen) break; 3587 i += show_CF_instruction( &instrs[i], adi, code_a_f, data_a_f ); 3588 } 3589 } 3590 3591 3592 /* Run the CF instructions in instrs[0 .. ilen-1], until the end is 3593 reached, or until there is a failure. Return True iff success. 3594 */ 3595 static 3596 Bool run_CF_instructions ( struct _DebugInfo* di, 3597 Bool record, 3598 UnwindContext* ctx, UChar* instrs, Int ilen, 3599 UWord fde_arange, 3600 UnwindContext* restore_ctx, 3601 AddressDecodingInfo* adi ) 3602 { 3603 DiCfSI cfsi; 3604 Bool summ_ok; 3605 Int j, i = 0; 3606 Addr loc_prev; 3607 if (0) ppUnwindContext(ctx); 3608 if (0) ppUnwindContext_summary(ctx); 3609 while (True) { 3610 loc_prev = ctx->loc; 3611 if (i >= ilen) break; 3612 if (0) (void)show_CF_instruction( &instrs[i], adi, 3613 ctx->code_a_f, ctx->data_a_f ); 3614 j = run_CF_instruction( ctx, &instrs[i], restore_ctx, adi, di ); 3615 if (j == 0) 3616 return False; /* execution failed */ 3617 i += j; 3618 if (0) ppUnwindContext(ctx); 3619 if (record && loc_prev != ctx->loc) { 3620 summ_ok = summarise_context ( &cfsi, loc_prev, ctx, di ); 3621 if (summ_ok) { 3622 ML_(addDiCfSI)(di, &cfsi); 3623 if (di->trace_cfi) 3624 ML_(ppDiCfSI)(di->cfsi_exprs, &cfsi); 3625 } 3626 } 3627 } 3628 if (ctx->loc < fde_arange) { 3629 loc_prev = ctx->loc; 3630 ctx->loc = fde_arange; 3631 if (record) { 3632 summ_ok = summarise_context ( &cfsi, loc_prev, ctx, di ); 3633 if (summ_ok) { 3634 ML_(addDiCfSI)(di, &cfsi); 3635 if (di->trace_cfi) 3636 ML_(ppDiCfSI)(di->cfsi_exprs, &cfsi); 3637 } 3638 } 3639 } 3640 return True; 3641 } 3642 3643 3644 /* ------------ Main entry point for CFI reading ------------ */ 3645 3646 typedef 3647 struct { 3648 /* This gives the CIE an identity to which FDEs will refer. */ 3649 ULong offset; 3650 /* Code, data factors. */ 3651 Int code_a_f; 3652 Int data_a_f; 3653 /* Return-address pseudo-register. */ 3654 Int ra_reg; 3655 UChar address_encoding; 3656 /* Where are the instrs? Note, this are simply pointers back to 3657 the transiently-mapped-in section. */ 3658 UChar* instrs; 3659 Int ilen; 3660 /* God knows .. don't ask */ 3661 Bool saw_z_augmentation; 3662 } 3663 CIE; 3664 3665 static void init_CIE ( CIE* cie ) 3666 { 3667 cie->offset = 0; 3668 cie->code_a_f = 0; 3669 cie->data_a_f = 0; 3670 cie->ra_reg = 0; 3671 cie->address_encoding = 0; 3672 cie->instrs = NULL; 3673 cie->ilen = 0; 3674 cie->saw_z_augmentation = False; 3675 } 3676 3677 #define N_CIEs 4000 3678 static CIE the_CIEs[N_CIEs]; 3679 3680 3681 /* Read, summarise and store CFA unwind info from .eh_frame and 3682 .debug_frame sections. is_ehframe tells us which kind we are 3683 dealing with -- they are slightly different. */ 3684 void ML_(read_callframe_info_dwarf3) 3685 ( /*OUT*/struct _DebugInfo* di, 3686 UChar* frame_image, SizeT frame_size, Addr frame_avma, 3687 Bool is_ehframe ) 3688 { 3689 Int nbytes; 3690 HChar* how = NULL; 3691 Int n_CIEs = 0; 3692 UChar* data = frame_image; 3693 UWord cfsi_used_orig; 3694 3695 /* If we're dealing with a .debug_frame, assume zero frame_avma. */ 3696 if (!is_ehframe) 3697 vg_assert(frame_avma == 0); 3698 3699 # if defined(VGP_ppc32_linux) || defined(VGP_ppc64_linux) 3700 /* These targets don't use CFI-based stack unwinding. */ 3701 return; 3702 # endif 3703 3704 /* If we read more than one .debug_frame or .eh_frame for this 3705 DebugInfo*, the second and subsequent reads should only add FDEs 3706 for address ranges not already covered by the FDEs already 3707 present. To be able to quickly check which address ranges are 3708 already present, any existing records (DiCFSIs) must be sorted, 3709 so we can binary-search them in the code below. We also record 3710 di->cfsi_used so that we know where the boundary is between 3711 existing and new records. */ 3712 if (di->cfsi_used > 0) { 3713 ML_(canonicaliseCFI) ( di ); 3714 } 3715 cfsi_used_orig = di->cfsi_used; 3716 3717 if (di->trace_cfi) { 3718 VG_(printf)("\n-----------------------------------------------\n"); 3719 VG_(printf)("CFI info: szB %ld, _avma %#lx, _image %p\n", 3720 frame_size, frame_avma, frame_image ); 3721 VG_(printf)("CFI info: name %s\n", 3722 di->fsm.filename ); 3723 } 3724 3725 /* Loop over CIEs/FDEs */ 3726 3727 /* Conceptually, the frame info is a sequence of FDEs, one for each 3728 function. Inside an FDE is a miniature program for a special 3729 state machine, which, when run, produces the stack-unwinding 3730 info for that function. 3731 3732 Because the FDEs typically have much in common, and because the 3733 DWARF designers appear to have been fanatical about space 3734 saving, the common parts are factored out into so-called CIEs. 3735 That means that what we traverse is a sequence of structs, each 3736 of which is either a FDE (usually) or a CIE (occasionally). 3737 Each FDE has a field indicating which CIE is the one pertaining 3738 to it. 3739 3740 The following loop traverses the sequence. FDEs are dealt with 3741 immediately; once we harvest the useful info in an FDE, it is 3742 then forgotten about. By contrast, CIEs are validated and 3743 dumped into an array, because later FDEs may refer to any 3744 previously-seen CIE. 3745 */ 3746 while (True) { 3747 UChar* ciefde_start; 3748 ULong ciefde_len; 3749 ULong cie_pointer; 3750 Bool dw64; 3751 3752 /* Are we done? */ 3753 if (data == frame_image + frame_size) 3754 return; 3755 3756 /* Overshot the end? Means something is wrong */ 3757 if (data > frame_image + frame_size) { 3758 how = "overran the end of .eh_frame"; 3759 goto bad; 3760 } 3761 3762 /* Ok, we must be looking at the start of a new CIE or FDE. 3763 Figure out which it is. */ 3764 3765 ciefde_start = data; 3766 if (di->trace_cfi) 3767 VG_(printf)("\ncie/fde.start = %p (frame_image + 0x%lx)\n", 3768 ciefde_start, 3769 ciefde_start - frame_image + 0UL); 3770 3771 ciefde_len = (ULong)ML_(read_UInt)(data); data += sizeof(UInt); 3772 if (di->trace_cfi) 3773 VG_(printf)("cie/fde.length = %lld\n", ciefde_len); 3774 3775 /* Apparently, if the .length field is zero, we are at the end 3776 of the sequence. This is stated in the Generic Elf 3777 Specification (see comments far above here) and is one of the 3778 places where .eh_frame and .debug_frame data differ. */ 3779 if (ciefde_len == 0) { 3780 if (di->ddump_frames) 3781 VG_(printf)("%08lx ZERO terminator\n\n", 3782 ((Addr)ciefde_start) - ((Addr)frame_image)); 3783 return; 3784 } 3785 3786 /* If the .length field is 0xFFFFFFFF then we're dealing with 3787 64-bit DWARF, and the real length is stored as a 64-bit 3788 number immediately following it. */ 3789 dw64 = False; 3790 if (ciefde_len == 0xFFFFFFFFUL) { 3791 dw64 = True; 3792 ciefde_len = ML_(read_ULong)(data); data += sizeof(ULong); 3793 } 3794 3795 /* Now get the CIE ID, whose size depends on the DWARF 32 vs 3796 64-ness. */ 3797 if (dw64) { 3798 cie_pointer = ML_(read_ULong)(data); 3799 data += sizeof(ULong); /* XXX see XXX below */ 3800 } else { 3801 cie_pointer = (ULong)ML_(read_UInt)(data); 3802 data += sizeof(UInt); /* XXX see XXX below */ 3803 } 3804 3805 if (di->trace_cfi) 3806 VG_(printf)("cie.pointer = %lld\n", cie_pointer); 3807 3808 /* If cie_pointer is zero for .eh_frame or all ones for .debug_frame, 3809 we've got a CIE; else it's an FDE. */ 3810 if (cie_pointer == (is_ehframe ? 0ULL 3811 : dw64 ? 0xFFFFFFFFFFFFFFFFULL : 0xFFFFFFFFULL)) { 3812 3813 Int this_CIE; 3814 UChar cie_version; 3815 UChar* cie_augmentation; 3816 3817 /* --------- CIE --------- */ 3818 if (di->trace_cfi) 3819 VG_(printf)("------ new CIE (#%d of 0 .. %d) ------\n", 3820 n_CIEs, N_CIEs - 1); 3821 3822 /* Allocate a new CIE record. */ 3823 vg_assert(n_CIEs >= 0 && n_CIEs <= N_CIEs); 3824 if (n_CIEs == N_CIEs) { 3825 how = "N_CIEs is too low. Increase and recompile."; 3826 goto bad; 3827 } 3828 3829 this_CIE = n_CIEs; 3830 n_CIEs++; 3831 init_CIE( &the_CIEs[this_CIE] ); 3832 3833 /* Record its offset. This is how we will find it again 3834 later when looking at an FDE. */ 3835 the_CIEs[this_CIE].offset = (ULong)(ciefde_start - frame_image); 3836 3837 if (di->ddump_frames) 3838 VG_(printf)("%08lx %08lx %08lx CIE\n", 3839 ((Addr)ciefde_start) - ((Addr)frame_image), 3840 (Addr)ciefde_len, 3841 (Addr)(UWord)cie_pointer ); 3842 3843 cie_version = ML_(read_UChar)(data); data += sizeof(UChar); 3844 if (di->trace_cfi) 3845 VG_(printf)("cie.version = %d\n", (Int)cie_version); 3846 if (di->ddump_frames) 3847 VG_(printf)(" Version: %d\n", (Int)cie_version); 3848 if (cie_version != 1 && cie_version != 3 && cie_version != 4) { 3849 how = "unexpected CIE version (not 1 nor 3 nor 4)"; 3850 goto bad; 3851 } 3852 3853 cie_augmentation = data; 3854 data += 1 + VG_(strlen)(cie_augmentation); 3855 if (di->trace_cfi) 3856 VG_(printf)("cie.augment = \"%s\"\n", cie_augmentation); 3857 if (di->ddump_frames) 3858 VG_(printf)(" Augmentation: \"%s\"\n", cie_augmentation); 3859 3860 if (cie_augmentation[0] == 'e' && cie_augmentation[1] == 'h') { 3861 data += sizeof(Addr); 3862 cie_augmentation += 2; 3863 } 3864 3865 if (cie_version >= 4) { 3866 if (ML_(read_UChar)(data) != sizeof(Addr)) { 3867 how = "unexpected address size"; 3868 goto bad; 3869 } 3870 data += sizeof(UChar); 3871 if (ML_(read_UChar)(data) != 0) { 3872 how = "unexpected non-zero segment size"; 3873 goto bad; 3874 } 3875 data += sizeof(UChar); 3876 } 3877 3878 the_CIEs[this_CIE].code_a_f = read_leb128( data, &nbytes, 0); 3879 data += nbytes; 3880 if (di->trace_cfi) 3881 VG_(printf)("cie.code_af = %d\n", 3882 the_CIEs[this_CIE].code_a_f); 3883 if (di->ddump_frames) 3884 VG_(printf)(" Code alignment factor: %d\n", 3885 (Int)the_CIEs[this_CIE].code_a_f); 3886 3887 the_CIEs[this_CIE].data_a_f = read_leb128( data, &nbytes, 1); 3888 data += nbytes; 3889 if (di->trace_cfi) 3890 VG_(printf)("cie.data_af = %d\n", 3891 the_CIEs[this_CIE].data_a_f); 3892 if (di->ddump_frames) 3893 VG_(printf)(" Data alignment factor: %d\n", 3894 (Int)the_CIEs[this_CIE].data_a_f); 3895 3896 if (cie_version == 1) { 3897 the_CIEs[this_CIE].ra_reg = (Int)ML_(read_UChar)(data); 3898 data += sizeof(UChar); 3899 } else { 3900 the_CIEs[this_CIE].ra_reg = read_leb128( data, &nbytes, 0); 3901 data += nbytes; 3902 } 3903 if (di->trace_cfi) 3904 VG_(printf)("cie.ra_reg = %d\n", 3905 the_CIEs[this_CIE].ra_reg); 3906 if (di->ddump_frames) 3907 VG_(printf)(" Return address column: %d\n", 3908 (Int)the_CIEs[this_CIE].ra_reg); 3909 3910 if (the_CIEs[this_CIE].ra_reg < 0 3911 || the_CIEs[this_CIE].ra_reg >= N_CFI_REGS) { 3912 how = "cie.ra_reg has implausible value"; 3913 goto bad; 3914 } 3915 3916 the_CIEs[this_CIE].saw_z_augmentation 3917 = *cie_augmentation == 'z'; 3918 if (the_CIEs[this_CIE].saw_z_augmentation) { 3919 UInt length = read_leb128( data, &nbytes, 0); 3920 data += nbytes; 3921 the_CIEs[this_CIE].instrs = data + length; 3922 cie_augmentation++; 3923 if (di->ddump_frames) { 3924 UInt i; 3925 VG_(printf)(" Augmentation data: "); 3926 for (i = 0; i < length; i++) 3927 VG_(printf)(" %02x", (UInt)data[i]); 3928 VG_(printf)("\n"); 3929 } 3930 } else { 3931 the_CIEs[this_CIE].instrs = NULL; 3932 } 3933 3934 the_CIEs[this_CIE].address_encoding = default_Addr_encoding(); 3935 3936 while (*cie_augmentation) { 3937 switch (*cie_augmentation) { 3938 case 'L': 3939 data++; 3940 cie_augmentation++; 3941 break; 3942 case 'R': 3943 the_CIEs[this_CIE].address_encoding 3944 = ML_(read_UChar)(data); data += sizeof(UChar); 3945 cie_augmentation++; 3946 break; 3947 case 'P': 3948 data += size_of_encoded_Addr( ML_(read_UChar)(data) ); 3949 data++; 3950 cie_augmentation++; 3951 break; 3952 case 'S': 3953 cie_augmentation++; 3954 break; 3955 default: 3956 if (the_CIEs[this_CIE].instrs == NULL) { 3957 how = "unhandled cie.augmentation"; 3958 goto bad; 3959 } 3960 data = the_CIEs[this_CIE].instrs; 3961 goto done_augmentation; 3962 } 3963 } 3964 3965 done_augmentation: 3966 3967 if (di->trace_cfi) 3968 VG_(printf)("cie.encoding = 0x%x\n", 3969 the_CIEs[this_CIE].address_encoding); 3970 3971 the_CIEs[this_CIE].instrs = data; 3972 the_CIEs[this_CIE].ilen 3973 = ciefde_start + ciefde_len + sizeof(UInt) - data; 3974 if (di->trace_cfi) { 3975 VG_(printf)("cie.instrs = %p\n", the_CIEs[this_CIE].instrs); 3976 VG_(printf)("cie.ilen = %d\n", the_CIEs[this_CIE].ilen); 3977 } 3978 3979 if (the_CIEs[this_CIE].ilen < 0 3980 || the_CIEs[this_CIE].ilen > frame_size) { 3981 how = "implausible # cie initial insns"; 3982 goto bad; 3983 } 3984 3985 data += the_CIEs[this_CIE].ilen; 3986 3987 /* Show the CIE's instructions (the preamble for each FDE 3988 that uses this CIE). */ 3989 if (di->ddump_frames) 3990 VG_(printf)("\n"); 3991 3992 if (di->trace_cfi || di->ddump_frames) { 3993 AddressDecodingInfo adi; 3994 adi.encoding = the_CIEs[this_CIE].address_encoding; 3995 adi.ehframe_image = frame_image; 3996 adi.ehframe_avma = frame_avma; 3997 adi.text_bias = di->text_debug_bias; 3998 show_CF_instructions( the_CIEs[this_CIE].instrs, 3999 the_CIEs[this_CIE].ilen, &adi, 4000 the_CIEs[this_CIE].code_a_f, 4001 the_CIEs[this_CIE].data_a_f ); 4002 } 4003 4004 if (di->ddump_frames) 4005 VG_(printf)("\n"); 4006 4007 } else { 4008 4009 AddressDecodingInfo adi; 4010 UnwindContext ctx, restore_ctx; 4011 Int cie; 4012 ULong look_for; 4013 Bool ok; 4014 Addr fde_initloc; 4015 UWord fde_arange; 4016 UChar* fde_instrs; 4017 Int fde_ilen; 4018 4019 /* --------- FDE --------- */ 4020 4021 /* Find the relevant CIE. The CIE we want is located 4022 cie_pointer bytes back from here. */ 4023 4024 /* re sizeof(UInt) / sizeof(ULong), matches XXX above. */ 4025 if (is_ehframe) 4026 look_for = (data - (dw64 ? sizeof(ULong) : sizeof(UInt)) 4027 - frame_image) 4028 - cie_pointer; 4029 else 4030 look_for = cie_pointer; 4031 4032 for (cie = 0; cie < n_CIEs; cie++) { 4033 if (0) VG_(printf)("look for %lld %lld\n", 4034 look_for, the_CIEs[cie].offset ); 4035 if (the_CIEs[cie].offset == look_for) 4036 break; 4037 } 4038 vg_assert(cie >= 0 && cie <= n_CIEs); 4039 if (cie == n_CIEs) { 4040 how = "FDE refers to not-findable CIE"; 4041 goto bad; 4042 } 4043 4044 adi.encoding = the_CIEs[cie].address_encoding; 4045 adi.ehframe_image = frame_image; 4046 adi.ehframe_avma = frame_avma; 4047 adi.text_bias = di->text_debug_bias; 4048 fde_initloc = read_encoded_Addr(&nbytes, &adi, data); 4049 data += nbytes; 4050 if (di->trace_cfi) 4051 VG_(printf)("fde.initloc = %#lx\n", fde_initloc); 4052 4053 adi.encoding = the_CIEs[cie].address_encoding & 0xf; 4054 adi.ehframe_image = frame_image; 4055 adi.ehframe_avma = frame_avma; 4056 adi.text_bias = di->text_debug_bias; 4057 4058 /* WAS (incorrectly): 4059 fde_arange = read_encoded_Addr(&nbytes, &adi, data); 4060 data += nbytes; 4061 The following corresponds to what binutils/dwarf.c does: 4062 */ 4063 { UInt ptr_size = size_of_encoded_Addr( adi.encoding ); 4064 switch (ptr_size) { 4065 case 8: case 4: case 2: case 1: 4066 fde_arange 4067 = (UWord)read_le_u_encoded_literal(data, ptr_size); 4068 data += ptr_size; 4069 break; 4070 default: 4071 how = "unknown arange field encoding in FDE"; 4072 goto bad; 4073 } 4074 } 4075 4076 if (di->trace_cfi) 4077 VG_(printf)("fde.arangec = %#lx\n", fde_arange); 4078 4079 if (di->ddump_frames) 4080 VG_(printf)("%08lx %08lx %08lx FDE cie=%08lx pc=%08lx..%08lx\n", 4081 ((Addr)ciefde_start) - ((Addr)frame_image), 4082 (Addr)ciefde_len, 4083 (Addr)(UWord)cie_pointer, 4084 (Addr)look_for, 4085 ((Addr)fde_initloc) - di->text_debug_bias, 4086 ((Addr)fde_initloc) - di->text_debug_bias + fde_arange); 4087 4088 if (the_CIEs[cie].saw_z_augmentation) { 4089 UInt length = read_leb128( data, &nbytes, 0); 4090 data += nbytes; 4091 if (di->ddump_frames && (length > 0)) { 4092 UInt i; 4093 VG_(printf)(" Augmentation data: "); 4094 for (i = 0; i < length; i++) 4095 VG_(printf)(" %02x", (UInt)data[i]); 4096 VG_(printf)("\n\n"); 4097 } 4098 data += length; 4099 } 4100 4101 fde_instrs = data; 4102 fde_ilen = ciefde_start + ciefde_len + sizeof(UInt) - data; 4103 if (di->trace_cfi) { 4104 VG_(printf)("fde.instrs = %p\n", fde_instrs); 4105 VG_(printf)("fde.ilen = %d\n", (Int)fde_ilen); 4106 } 4107 4108 if (fde_ilen < 0 || fde_ilen > frame_size) { 4109 how = "implausible # fde insns"; 4110 goto bad; 4111 } 4112 4113 data += fde_ilen; 4114 4115 /* If this object's DebugInfo* had some DiCFSIs from a 4116 previous .eh_frame or .debug_frame read, we must check 4117 that we're not adding a duplicate. */ 4118 if (cfsi_used_orig > 0) { 4119 Addr a_mid_lo, a_mid_hi; 4120 Word mid, size, 4121 lo = 0, 4122 hi = cfsi_used_orig-1; 4123 while (True) { 4124 /* current unsearched space is from lo to hi, inclusive. */ 4125 if (lo > hi) break; /* not found */ 4126 mid = (lo + hi) / 2; 4127 a_mid_lo = di->cfsi[mid].base; 4128 size = di->cfsi[mid].len; 4129 a_mid_hi = a_mid_lo + size - 1; 4130 vg_assert(a_mid_hi >= a_mid_lo); 4131 if (fde_initloc + fde_arange <= a_mid_lo) { 4132 hi = mid-1; continue; 4133 } 4134 if (fde_initloc > a_mid_hi) { lo = mid+1; continue; } 4135 break; 4136 } 4137 4138 /* The range this .debug_frame FDE covers has been already 4139 covered in .eh_frame section. Don't add it from .debug_frame 4140 section again. */ 4141 if (lo <= hi) 4142 continue; 4143 } 4144 4145 adi.encoding = the_CIEs[cie].address_encoding; 4146 adi.ehframe_image = frame_image; 4147 adi.ehframe_avma = frame_avma; 4148 adi.text_bias = di->text_debug_bias; 4149 4150 if (di->trace_cfi) 4151 show_CF_instructions( fde_instrs, fde_ilen, &adi, 4152 the_CIEs[cie].code_a_f, 4153 the_CIEs[cie].data_a_f ); 4154 4155 initUnwindContext(&ctx); 4156 ctx.code_a_f = the_CIEs[cie].code_a_f; 4157 ctx.data_a_f = the_CIEs[cie].data_a_f; 4158 ctx.initloc = fde_initloc; 4159 ctx.ra_reg = the_CIEs[cie].ra_reg; 4160 ctx.exprs = VG_(newXA)( ML_(dinfo_zalloc), "di.rcid.1", 4161 ML_(dinfo_free), 4162 sizeof(CfiExpr) ); 4163 vg_assert(ctx.exprs); 4164 4165 /* Run the CIE's instructions. Ugly hack: if 4166 --debug-dump=frames is in effect, suppress output for 4167 these instructions since they will already have been shown 4168 at the time the CIE was first encountered. Note, not 4169 thread safe - if this reader is ever made threaded, should 4170 fix properly. */ 4171 { Bool hack = di->ddump_frames; 4172 di->ddump_frames = False; 4173 initUnwindContext(&restore_ctx); 4174 ok = run_CF_instructions( 4175 di, False, &ctx, the_CIEs[cie].instrs, 4176 the_CIEs[cie].ilen, 0, NULL, &adi 4177 ); 4178 di->ddump_frames = hack; 4179 } 4180 /* And now run the instructions for the FDE, starting from 4181 the state created by running the CIE preamble 4182 instructions. */ 4183 if (ok) { 4184 restore_ctx = ctx; 4185 ok = run_CF_instructions( 4186 di, True, &ctx, fde_instrs, fde_ilen, fde_arange, 4187 &restore_ctx, &adi 4188 ); 4189 if (di->ddump_frames) 4190 VG_(printf)("\n"); 4191 } 4192 4193 VG_(deleteXA)( ctx.exprs ); 4194 } 4195 } 4196 4197 return; 4198 4199 bad: 4200 if (!VG_(clo_xml) && VG_(clo_verbosity) > 1) 4201 VG_(message)(Vg_UserMsg, 4202 "Warning: %s in DWARF2 CFI reading\n", how); 4203 return; 4204 } 4205 4206 #endif // defined(VGO_linux) || defined(VGO_darwin) 4207 4208 /*--------------------------------------------------------------------*/ 4209 /*--- end ---*/ 4210 /*--------------------------------------------------------------------*/ 4211
