1 //===-- EmulateInstruction.h ------------------------------------*- C++ -*-===// 2 // 3 // The LLVM Compiler Infrastructure 4 // 5 // This file is distributed under the University of Illinois Open Source 6 // License. See LICENSE.TXT for details. 7 // 8 //===----------------------------------------------------------------------===// 9 10 #include "lldb/Core/EmulateInstruction.h" 11 12 #include "lldb/Core/Address.h" 13 #include "lldb/Core/DataBufferHeap.h" 14 #include "lldb/Core/DataExtractor.h" 15 #include "lldb/Core/Error.h" 16 #include "lldb/Core/PluginManager.h" 17 #include "lldb/Core/RegisterValue.h" 18 #include "lldb/Core/StreamFile.h" 19 #include "lldb/Core/StreamString.h" 20 #include "lldb/Host/Endian.h" 21 #include "lldb/Symbol/UnwindPlan.h" 22 #include "lldb/Target/Process.h" 23 #include "lldb/Target/RegisterContext.h" 24 #include "lldb/Target/Target.h" 25 #include "lldb/Target/Thread.h" 26 27 using namespace lldb; 28 using namespace lldb_private; 29 30 EmulateInstruction* 31 EmulateInstruction::FindPlugin (const ArchSpec &arch, InstructionType supported_inst_type, const char *plugin_name) 32 { 33 EmulateInstructionCreateInstance create_callback = NULL; 34 if (plugin_name) 35 { 36 create_callback = PluginManager::GetEmulateInstructionCreateCallbackForPluginName (plugin_name); 37 if (create_callback) 38 { 39 EmulateInstruction *emulate_insn_ptr = create_callback(arch, supported_inst_type); 40 if (emulate_insn_ptr) 41 return emulate_insn_ptr; 42 } 43 } 44 else 45 { 46 for (uint32_t idx = 0; (create_callback = PluginManager::GetEmulateInstructionCreateCallbackAtIndex(idx)) != NULL; ++idx) 47 { 48 EmulateInstruction *emulate_insn_ptr = create_callback(arch, supported_inst_type); 49 if (emulate_insn_ptr) 50 return emulate_insn_ptr; 51 } 52 } 53 return NULL; 54 } 55 56 EmulateInstruction::EmulateInstruction (const ArchSpec &arch) : 57 m_arch (arch), 58 m_baton (NULL), 59 m_read_mem_callback (&ReadMemoryDefault), 60 m_write_mem_callback (&WriteMemoryDefault), 61 m_read_reg_callback (&ReadRegisterDefault), 62 m_write_reg_callback (&WriteRegisterDefault), 63 m_addr (LLDB_INVALID_ADDRESS) 64 { 65 ::memset (&m_opcode, 0, sizeof (m_opcode)); 66 } 67 68 69 bool 70 EmulateInstruction::ReadRegister (const RegisterInfo *reg_info, RegisterValue& reg_value) 71 { 72 if (m_read_reg_callback) 73 return m_read_reg_callback (this, m_baton, reg_info, reg_value); 74 return false; 75 } 76 77 bool 78 EmulateInstruction::ReadRegister (uint32_t reg_kind, uint32_t reg_num, RegisterValue& reg_value) 79 { 80 RegisterInfo reg_info; 81 if (GetRegisterInfo(reg_kind, reg_num, reg_info)) 82 return ReadRegister (®_info, reg_value); 83 return false; 84 } 85 86 uint64_t 87 EmulateInstruction::ReadRegisterUnsigned (uint32_t reg_kind, 88 uint32_t reg_num, 89 uint64_t fail_value, 90 bool *success_ptr) 91 { 92 RegisterValue reg_value; 93 if (ReadRegister (reg_kind, reg_num, reg_value)) 94 return reg_value.GetAsUInt64(fail_value, success_ptr); 95 if (success_ptr) 96 *success_ptr = false; 97 return fail_value; 98 } 99 100 uint64_t 101 EmulateInstruction::ReadRegisterUnsigned (const RegisterInfo *reg_info, 102 uint64_t fail_value, 103 bool *success_ptr) 104 { 105 RegisterValue reg_value; 106 if (ReadRegister (reg_info, reg_value)) 107 return reg_value.GetAsUInt64(fail_value, success_ptr); 108 if (success_ptr) 109 *success_ptr = false; 110 return fail_value; 111 } 112 113 bool 114 EmulateInstruction::WriteRegister (const Context &context, 115 const RegisterInfo *reg_info, 116 const RegisterValue& reg_value) 117 { 118 if (m_write_reg_callback) 119 return m_write_reg_callback (this, m_baton, context, reg_info, reg_value); 120 return false; 121 } 122 123 bool 124 EmulateInstruction::WriteRegister (const Context &context, 125 uint32_t reg_kind, 126 uint32_t reg_num, 127 const RegisterValue& reg_value) 128 { 129 RegisterInfo reg_info; 130 if (GetRegisterInfo(reg_kind, reg_num, reg_info)) 131 return WriteRegister (context, ®_info, reg_value); 132 return false; 133 } 134 135 136 bool 137 EmulateInstruction::WriteRegisterUnsigned (const Context &context, 138 uint32_t reg_kind, 139 uint32_t reg_num, 140 uint64_t uint_value) 141 { 142 143 RegisterInfo reg_info; 144 if (GetRegisterInfo(reg_kind, reg_num, reg_info)) 145 { 146 RegisterValue reg_value; 147 if (reg_value.SetUInt(uint_value, reg_info.byte_size)) 148 return WriteRegister (context, ®_info, reg_value); 149 } 150 return false; 151 } 152 153 bool 154 EmulateInstruction::WriteRegisterUnsigned (const Context &context, 155 const RegisterInfo *reg_info, 156 uint64_t uint_value) 157 { 158 159 if (reg_info) 160 { 161 RegisterValue reg_value; 162 if (reg_value.SetUInt(uint_value, reg_info->byte_size)) 163 return WriteRegister (context, reg_info, reg_value); 164 } 165 return false; 166 } 167 168 size_t 169 EmulateInstruction::ReadMemory (const Context &context, 170 lldb::addr_t addr, 171 void *dst, 172 size_t dst_len) 173 { 174 if (m_read_mem_callback) 175 return m_read_mem_callback (this, m_baton, context, addr, dst, dst_len) == dst_len; 176 return false; 177 } 178 179 uint64_t 180 EmulateInstruction::ReadMemoryUnsigned (const Context &context, lldb::addr_t addr, size_t byte_size, uint64_t fail_value, bool *success_ptr) 181 { 182 uint64_t uval64 = 0; 183 bool success = false; 184 if (byte_size <= 8) 185 { 186 uint8_t buf[sizeof(uint64_t)]; 187 size_t bytes_read = m_read_mem_callback (this, m_baton, context, addr, buf, byte_size); 188 if (bytes_read == byte_size) 189 { 190 uint32_t offset = 0; 191 DataExtractor data (buf, byte_size, GetByteOrder(), GetAddressByteSize()); 192 uval64 = data.GetMaxU64 (&offset, byte_size); 193 success = true; 194 } 195 } 196 197 if (success_ptr) 198 *success_ptr = success; 199 200 if (!success) 201 uval64 = fail_value; 202 return uval64; 203 } 204 205 206 bool 207 EmulateInstruction::WriteMemoryUnsigned (const Context &context, 208 lldb::addr_t addr, 209 uint64_t uval, 210 size_t uval_byte_size) 211 { 212 StreamString strm(Stream::eBinary, GetAddressByteSize(), GetByteOrder()); 213 strm.PutMaxHex64 (uval, uval_byte_size); 214 215 size_t bytes_written = m_write_mem_callback (this, m_baton, context, addr, strm.GetData(), uval_byte_size); 216 if (bytes_written == uval_byte_size) 217 return true; 218 return false; 219 } 220 221 bool 222 EmulateInstruction::WriteMemory (const Context &context, 223 lldb::addr_t addr, 224 const void *src, 225 size_t src_len) 226 { 227 if (m_write_mem_callback) 228 return m_write_mem_callback (this, m_baton, context, addr, src, src_len) == src_len; 229 return false; 230 } 231 232 233 void 234 EmulateInstruction::SetBaton (void *baton) 235 { 236 m_baton = baton; 237 } 238 239 void 240 EmulateInstruction::SetCallbacks (ReadMemoryCallback read_mem_callback, 241 WriteMemoryCallback write_mem_callback, 242 ReadRegisterCallback read_reg_callback, 243 WriteRegisterCallback write_reg_callback) 244 { 245 m_read_mem_callback = read_mem_callback; 246 m_write_mem_callback = write_mem_callback; 247 m_read_reg_callback = read_reg_callback; 248 m_write_reg_callback = write_reg_callback; 249 } 250 251 void 252 EmulateInstruction::SetReadMemCallback (ReadMemoryCallback read_mem_callback) 253 { 254 m_read_mem_callback = read_mem_callback; 255 } 256 257 258 void 259 EmulateInstruction::SetWriteMemCallback (WriteMemoryCallback write_mem_callback) 260 { 261 m_write_mem_callback = write_mem_callback; 262 } 263 264 265 void 266 EmulateInstruction::SetReadRegCallback (ReadRegisterCallback read_reg_callback) 267 { 268 m_read_reg_callback = read_reg_callback; 269 } 270 271 272 void 273 EmulateInstruction::SetWriteRegCallback (WriteRegisterCallback write_reg_callback) 274 { 275 m_write_reg_callback = write_reg_callback; 276 } 277 278 279 280 // 281 // Read & Write Memory and Registers callback functions. 282 // 283 284 size_t 285 EmulateInstruction::ReadMemoryFrame (EmulateInstruction *instruction, 286 void *baton, 287 const Context &context, 288 lldb::addr_t addr, 289 void *dst, 290 size_t length) 291 { 292 if (!baton) 293 return 0; 294 295 296 StackFrame *frame = (StackFrame *) baton; 297 298 DataBufferSP data_sp (new DataBufferHeap (length, '\0')); 299 Error error; 300 301 size_t bytes_read = frame->GetThread().GetProcess().ReadMemory (addr, data_sp->GetBytes(), data_sp->GetByteSize(), 302 error); 303 304 if (bytes_read > 0) 305 ((DataBufferHeap *) data_sp.get())->CopyData (dst, length); 306 307 return bytes_read; 308 } 309 310 size_t 311 EmulateInstruction::WriteMemoryFrame (EmulateInstruction *instruction, 312 void *baton, 313 const Context &context, 314 lldb::addr_t addr, 315 const void *dst, 316 size_t length) 317 { 318 if (!baton) 319 return 0; 320 321 StackFrame *frame = (StackFrame *) baton; 322 323 lldb::DataBufferSP data_sp (new DataBufferHeap (dst, length)); 324 if (data_sp) 325 { 326 length = data_sp->GetByteSize(); 327 if (length > 0) 328 { 329 Error error; 330 size_t bytes_written = frame->GetThread().GetProcess().WriteMemory (addr, data_sp->GetBytes(), length, 331 error); 332 333 return bytes_written; 334 } 335 } 336 337 return 0; 338 } 339 340 bool 341 EmulateInstruction::ReadRegisterFrame (EmulateInstruction *instruction, 342 void *baton, 343 const RegisterInfo *reg_info, 344 RegisterValue ®_value) 345 { 346 if (!baton) 347 return false; 348 349 StackFrame *frame = (StackFrame *) baton; 350 return frame->GetRegisterContext()->ReadRegister (reg_info, reg_value); 351 } 352 353 bool 354 EmulateInstruction::WriteRegisterFrame (EmulateInstruction *instruction, 355 void *baton, 356 const Context &context, 357 const RegisterInfo *reg_info, 358 const RegisterValue ®_value) 359 { 360 if (!baton) 361 return false; 362 363 StackFrame *frame = (StackFrame *) baton; 364 return frame->GetRegisterContext()->WriteRegister (reg_info, reg_value); 365 } 366 367 size_t 368 EmulateInstruction::ReadMemoryDefault (EmulateInstruction *instruction, 369 void *baton, 370 const Context &context, 371 lldb::addr_t addr, 372 void *dst, 373 size_t length) 374 { 375 StreamFile strm (stdout, false); 376 strm.Printf (" Read from Memory (address = 0x%llx, length = %zu, context = ", addr, length); 377 context.Dump (strm, instruction); 378 strm.EOL(); 379 *((uint64_t *) dst) = 0xdeadbeef; 380 return length; 381 } 382 383 size_t 384 EmulateInstruction::WriteMemoryDefault (EmulateInstruction *instruction, 385 void *baton, 386 const Context &context, 387 lldb::addr_t addr, 388 const void *dst, 389 size_t length) 390 { 391 StreamFile strm (stdout, false); 392 strm.Printf (" Write to Memory (address = 0x%llx, length = %zu, context = ", addr, length); 393 context.Dump (strm, instruction); 394 strm.EOL(); 395 return length; 396 } 397 398 bool 399 EmulateInstruction::ReadRegisterDefault (EmulateInstruction *instruction, 400 void *baton, 401 const RegisterInfo *reg_info, 402 RegisterValue ®_value) 403 { 404 StreamFile strm (stdout, false); 405 strm.Printf (" Read Register (%s)\n", reg_info->name); 406 uint32_t reg_kind, reg_num; 407 if (GetBestRegisterKindAndNumber (reg_info, reg_kind, reg_num)) 408 reg_value.SetUInt64((uint64_t)reg_kind << 24 | reg_num); 409 else 410 reg_value.SetUInt64(0); 411 412 return true; 413 } 414 415 bool 416 EmulateInstruction::WriteRegisterDefault (EmulateInstruction *instruction, 417 void *baton, 418 const Context &context, 419 const RegisterInfo *reg_info, 420 const RegisterValue ®_value) 421 { 422 StreamFile strm (stdout, false); 423 strm.Printf (" Write to Register (name = %s, value = " , reg_info->name); 424 reg_value.Dump(&strm, reg_info, false, false, eFormatDefault); 425 strm.PutCString (", context = "); 426 context.Dump (strm, instruction); 427 strm.EOL(); 428 return true; 429 } 430 431 void 432 EmulateInstruction::Context::Dump (Stream &strm, 433 EmulateInstruction *instruction) const 434 { 435 switch (type) 436 { 437 case eContextReadOpcode: 438 strm.PutCString ("reading opcode"); 439 break; 440 441 case eContextImmediate: 442 strm.PutCString ("immediate"); 443 break; 444 445 case eContextPushRegisterOnStack: 446 strm.PutCString ("push register"); 447 break; 448 449 case eContextPopRegisterOffStack: 450 strm.PutCString ("pop register"); 451 break; 452 453 case eContextAdjustStackPointer: 454 strm.PutCString ("adjust sp"); 455 break; 456 457 case eContextSetFramePointer: 458 strm.PutCString ("set frame pointer"); 459 break; 460 461 case eContextAdjustBaseRegister: 462 strm.PutCString ("adjusting (writing value back to) a base register"); 463 break; 464 465 case eContextRegisterPlusOffset: 466 strm.PutCString ("register + offset"); 467 break; 468 469 case eContextRegisterStore: 470 strm.PutCString ("store register"); 471 break; 472 473 case eContextRegisterLoad: 474 strm.PutCString ("load register"); 475 break; 476 477 case eContextRelativeBranchImmediate: 478 strm.PutCString ("relative branch immediate"); 479 break; 480 481 case eContextAbsoluteBranchRegister: 482 strm.PutCString ("absolute branch register"); 483 break; 484 485 case eContextSupervisorCall: 486 strm.PutCString ("supervisor call"); 487 break; 488 489 case eContextTableBranchReadMemory: 490 strm.PutCString ("table branch read memory"); 491 break; 492 493 case eContextWriteRegisterRandomBits: 494 strm.PutCString ("write random bits to a register"); 495 break; 496 497 case eContextWriteMemoryRandomBits: 498 strm.PutCString ("write random bits to a memory address"); 499 break; 500 501 case eContextArithmetic: 502 strm.PutCString ("arithmetic"); 503 break; 504 505 case eContextReturnFromException: 506 strm.PutCString ("return from exception"); 507 break; 508 509 default: 510 strm.PutCString ("unrecognized context."); 511 break; 512 } 513 514 switch (info_type) 515 { 516 case eInfoTypeRegisterPlusOffset: 517 { 518 strm.Printf (" (reg_plus_offset = %s%+lld)", 519 info.RegisterPlusOffset.reg.name, 520 info.RegisterPlusOffset.signed_offset); 521 } 522 break; 523 524 case eInfoTypeRegisterPlusIndirectOffset: 525 { 526 strm.Printf (" (reg_plus_reg = %s + %s)", 527 info.RegisterPlusIndirectOffset.base_reg.name, 528 info.RegisterPlusIndirectOffset.offset_reg.name); 529 } 530 break; 531 532 case eInfoTypeRegisterToRegisterPlusOffset: 533 { 534 strm.Printf (" (base_and_imm_offset = %s%+lld, data_reg = %s)", 535 info.RegisterToRegisterPlusOffset.base_reg.name, 536 info.RegisterToRegisterPlusOffset.offset, 537 info.RegisterToRegisterPlusOffset.data_reg.name); 538 } 539 break; 540 541 case eInfoTypeRegisterToRegisterPlusIndirectOffset: 542 { 543 strm.Printf (" (base_and_reg_offset = %s + %s, data_reg = %s)", 544 info.RegisterToRegisterPlusIndirectOffset.base_reg.name, 545 info.RegisterToRegisterPlusIndirectOffset.offset_reg.name, 546 info.RegisterToRegisterPlusIndirectOffset.data_reg.name); 547 } 548 break; 549 550 case eInfoTypeRegisterRegisterOperands: 551 { 552 strm.Printf (" (register to register binary op: %s and %s)", 553 info.RegisterRegisterOperands.operand1.name, 554 info.RegisterRegisterOperands.operand2.name); 555 } 556 break; 557 558 case eInfoTypeOffset: 559 strm.Printf (" (signed_offset = %+lld)", info.signed_offset); 560 break; 561 562 case eInfoTypeRegister: 563 strm.Printf (" (reg = %s)", info.reg.name); 564 break; 565 566 case eInfoTypeImmediate: 567 strm.Printf (" (unsigned_immediate = %llu (0x%16.16llx))", 568 info.unsigned_immediate, 569 info.unsigned_immediate); 570 break; 571 572 case eInfoTypeImmediateSigned: 573 strm.Printf (" (signed_immediate = %+lld (0x%16.16llx))", 574 info.signed_immediate, 575 info.signed_immediate); 576 break; 577 578 case eInfoTypeAddress: 579 strm.Printf (" (address = 0x%llx)", info.address); 580 break; 581 582 case eInfoTypeISAAndImmediate: 583 strm.Printf (" (isa = %u, unsigned_immediate = %u (0x%8.8x))", 584 info.ISAAndImmediate.isa, 585 info.ISAAndImmediate.unsigned_data32, 586 info.ISAAndImmediate.unsigned_data32); 587 break; 588 589 case eInfoTypeISAAndImmediateSigned: 590 strm.Printf (" (isa = %u, signed_immediate = %i (0x%8.8x))", 591 info.ISAAndImmediateSigned.isa, 592 info.ISAAndImmediateSigned.signed_data32, 593 info.ISAAndImmediateSigned.signed_data32); 594 break; 595 596 case eInfoTypeISA: 597 strm.Printf (" (isa = %u)", info.isa); 598 break; 599 600 case eInfoTypeNoArgs: 601 break; 602 603 default: 604 strm.Printf (" (unknown <info_type>)"); 605 break; 606 } 607 } 608 609 bool 610 EmulateInstruction::SetInstruction (const Opcode &opcode, const Address &inst_addr, Target *target) 611 { 612 m_opcode = opcode; 613 m_addr = LLDB_INVALID_ADDRESS; 614 if (inst_addr.IsValid()) 615 { 616 if (target) 617 m_addr = inst_addr.GetLoadAddress (target); 618 if (m_addr == LLDB_INVALID_ADDRESS) 619 m_addr = inst_addr.GetFileAddress (); 620 } 621 return true; 622 } 623 624 bool 625 EmulateInstruction::GetBestRegisterKindAndNumber (const RegisterInfo *reg_info, 626 uint32_t ®_kind, 627 uint32_t ®_num) 628 { 629 // Generic and DWARF should be the two most popular register kinds when 630 // emulating instructions since they are the most platform agnostic... 631 reg_num = reg_info->kinds[eRegisterKindGeneric]; 632 if (reg_num != LLDB_INVALID_REGNUM) 633 { 634 reg_kind = eRegisterKindGeneric; 635 return true; 636 } 637 638 reg_num = reg_info->kinds[eRegisterKindDWARF]; 639 if (reg_num != LLDB_INVALID_REGNUM) 640 { 641 reg_kind = eRegisterKindDWARF; 642 return true; 643 } 644 645 reg_num = reg_info->kinds[eRegisterKindLLDB]; 646 if (reg_num != LLDB_INVALID_REGNUM) 647 { 648 reg_kind = eRegisterKindLLDB; 649 return true; 650 } 651 652 reg_num = reg_info->kinds[eRegisterKindGCC]; 653 if (reg_num != LLDB_INVALID_REGNUM) 654 { 655 reg_kind = eRegisterKindGCC; 656 return true; 657 } 658 659 reg_num = reg_info->kinds[eRegisterKindGDB]; 660 if (reg_num != LLDB_INVALID_REGNUM) 661 { 662 reg_kind = eRegisterKindGDB; 663 return true; 664 } 665 return false; 666 } 667 668 uint32_t 669 EmulateInstruction::GetInternalRegisterNumber (RegisterContext *reg_ctx, const RegisterInfo ®_info) 670 { 671 uint32_t reg_kind, reg_num; 672 if (reg_ctx && GetBestRegisterKindAndNumber (®_info, reg_kind, reg_num)) 673 return reg_ctx->ConvertRegisterKindToRegisterNumber (reg_kind, reg_num); 674 return LLDB_INVALID_REGNUM; 675 } 676 677 678 bool 679 EmulateInstruction::CreateFunctionEntryUnwind (UnwindPlan &unwind_plan) 680 { 681 unwind_plan.Clear(); 682 return false; 683 } 684 685 686