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 eContextAdjustBaseRegister: 458 strm.PutCString ("adjusting (writing value back to) a base register"); 459 break; 460 461 case eContextRegisterPlusOffset: 462 strm.PutCString ("register + offset"); 463 break; 464 465 case eContextRegisterStore: 466 strm.PutCString ("store register"); 467 break; 468 469 case eContextRegisterLoad: 470 strm.PutCString ("load register"); 471 break; 472 473 case eContextRelativeBranchImmediate: 474 strm.PutCString ("relative branch immediate"); 475 break; 476 477 case eContextAbsoluteBranchRegister: 478 strm.PutCString ("absolute branch register"); 479 break; 480 481 case eContextSupervisorCall: 482 strm.PutCString ("supervisor call"); 483 break; 484 485 case eContextTableBranchReadMemory: 486 strm.PutCString ("table branch read memory"); 487 break; 488 489 case eContextWriteRegisterRandomBits: 490 strm.PutCString ("write random bits to a register"); 491 break; 492 493 case eContextWriteMemoryRandomBits: 494 strm.PutCString ("write random bits to a memory address"); 495 break; 496 497 case eContextArithmetic: 498 strm.PutCString ("arithmetic"); 499 break; 500 501 case eContextReturnFromException: 502 strm.PutCString ("return from exception"); 503 break; 504 505 default: 506 strm.PutCString ("unrecognized context."); 507 break; 508 } 509 510 switch (info_type) 511 { 512 case eInfoTypeRegisterPlusOffset: 513 { 514 strm.Printf (" (reg_plus_offset = %s%+lld)", 515 info.RegisterPlusOffset.reg.name, 516 info.RegisterPlusOffset.signed_offset); 517 } 518 break; 519 520 case eInfoTypeRegisterPlusIndirectOffset: 521 { 522 strm.Printf (" (reg_plus_reg = %s + %s)", 523 info.RegisterPlusIndirectOffset.base_reg.name, 524 info.RegisterPlusIndirectOffset.offset_reg.name); 525 } 526 break; 527 528 case eInfoTypeRegisterToRegisterPlusOffset: 529 { 530 strm.Printf (" (base_and_imm_offset = %s%+lld, data_reg = %s)", 531 info.RegisterToRegisterPlusOffset.base_reg.name, 532 info.RegisterToRegisterPlusOffset.offset, 533 info.RegisterToRegisterPlusOffset.data_reg.name); 534 } 535 break; 536 537 case eInfoTypeRegisterToRegisterPlusIndirectOffset: 538 { 539 strm.Printf (" (base_and_reg_offset = %s + %s, data_reg = %s)", 540 info.RegisterToRegisterPlusIndirectOffset.base_reg.name, 541 info.RegisterToRegisterPlusIndirectOffset.offset_reg.name, 542 info.RegisterToRegisterPlusIndirectOffset.data_reg.name); 543 } 544 break; 545 546 case eInfoTypeRegisterRegisterOperands: 547 { 548 strm.Printf (" (register to register binary op: %s and %s)", 549 info.RegisterRegisterOperands.operand1.name, 550 info.RegisterRegisterOperands.operand2.name); 551 } 552 break; 553 554 case eInfoTypeOffset: 555 strm.Printf (" (signed_offset = %+lld)", info.signed_offset); 556 break; 557 558 case eInfoTypeRegister: 559 strm.Printf (" (reg = %s)", info.reg.name); 560 break; 561 562 case eInfoTypeImmediate: 563 strm.Printf (" (unsigned_immediate = %llu (0x%16.16llx))", 564 info.unsigned_immediate, 565 info.unsigned_immediate); 566 break; 567 568 case eInfoTypeImmediateSigned: 569 strm.Printf (" (signed_immediate = %+lld (0x%16.16llx))", 570 info.signed_immediate, 571 info.signed_immediate); 572 break; 573 574 case eInfoTypeAddress: 575 strm.Printf (" (address = 0x%llx)", info.address); 576 break; 577 578 case eInfoTypeISAAndImmediate: 579 strm.Printf (" (isa = %u, unsigned_immediate = %u (0x%8.8x))", 580 info.ISAAndImmediate.isa, 581 info.ISAAndImmediate.unsigned_data32, 582 info.ISAAndImmediate.unsigned_data32); 583 break; 584 585 case eInfoTypeISAAndImmediateSigned: 586 strm.Printf (" (isa = %u, signed_immediate = %i (0x%8.8x))", 587 info.ISAAndImmediateSigned.isa, 588 info.ISAAndImmediateSigned.signed_data32, 589 info.ISAAndImmediateSigned.signed_data32); 590 break; 591 592 case eInfoTypeISA: 593 strm.Printf (" (isa = %u)", info.isa); 594 break; 595 596 case eInfoTypeNoArgs: 597 break; 598 599 default: 600 strm.Printf (" (unknown <info_type>)"); 601 break; 602 } 603 } 604 605 bool 606 EmulateInstruction::SetInstruction (const Opcode &opcode, const Address &inst_addr, Target *target) 607 { 608 m_opcode = opcode; 609 m_addr = LLDB_INVALID_ADDRESS; 610 if (inst_addr.IsValid()) 611 { 612 if (target) 613 m_addr = inst_addr.GetLoadAddress (target); 614 if (m_addr == LLDB_INVALID_ADDRESS) 615 m_addr = inst_addr.GetFileAddress (); 616 } 617 return true; 618 } 619 620 bool 621 EmulateInstruction::GetBestRegisterKindAndNumber (const RegisterInfo *reg_info, 622 uint32_t ®_kind, 623 uint32_t ®_num) 624 { 625 // Generic and DWARF should be the two most popular register kinds when 626 // emulating instructions since they are the most platform agnostic... 627 reg_num = reg_info->kinds[eRegisterKindGeneric]; 628 if (reg_num != LLDB_INVALID_REGNUM) 629 { 630 reg_kind = eRegisterKindGeneric; 631 return true; 632 } 633 634 reg_num = reg_info->kinds[eRegisterKindDWARF]; 635 if (reg_num != LLDB_INVALID_REGNUM) 636 { 637 reg_kind = eRegisterKindDWARF; 638 return true; 639 } 640 641 reg_num = reg_info->kinds[eRegisterKindLLDB]; 642 if (reg_num != LLDB_INVALID_REGNUM) 643 { 644 reg_kind = eRegisterKindLLDB; 645 return true; 646 } 647 648 reg_num = reg_info->kinds[eRegisterKindGCC]; 649 if (reg_num != LLDB_INVALID_REGNUM) 650 { 651 reg_kind = eRegisterKindGCC; 652 return true; 653 } 654 655 reg_num = reg_info->kinds[eRegisterKindGDB]; 656 if (reg_num != LLDB_INVALID_REGNUM) 657 { 658 reg_kind = eRegisterKindGDB; 659 return true; 660 } 661 return false; 662 } 663 664 uint32_t 665 EmulateInstruction::GetInternalRegisterNumber (RegisterContext *reg_ctx, const RegisterInfo ®_info) 666 { 667 uint32_t reg_kind, reg_num; 668 if (reg_ctx && GetBestRegisterKindAndNumber (®_info, reg_kind, reg_num)) 669 return reg_ctx->ConvertRegisterKindToRegisterNumber (reg_kind, reg_num); 670 return LLDB_INVALID_REGNUM; 671 } 672 673 674 bool 675 EmulateInstruction::CreateFunctionEntryUnwind (UnwindPlan &unwind_plan) 676 { 677 unwind_plan.Clear(); 678 return false; 679 } 680 681 682