source/Core/EmulateInstruction.cpp

   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/DataExtractor.h"
  14 #include "lldb/Core/Error.h"
  15 #include "lldb/Core/PluginManager.h"
  16 #include "lldb/Core/RegisterValue.h"
  17 #include "lldb/Core/StreamFile.h"
  18 #include "lldb/Core/StreamString.h"
  19 #include "lldb/Host/Endian.h"
  20 #include "lldb/Symbol/UnwindPlan.h"
  21 #include "lldb/Target/Process.h"
  22 #include "lldb/Target/RegisterContext.h"
  23 #include "lldb/Target/Target.h"
  24 #include "lldb/Target/Thread.h"
  25
  26 using namespace lldb;
  27 using namespace lldb_private;
  28
  29 EmulateInstruction*
  30 EmulateInstruction::FindPlugin (const ArchSpec &arch, InstructionType supported_inst_type, const char *plugin_name)
  31 {
  32     EmulateInstructionCreateInstance create_callback = NULL;
  33     if (plugin_name)
  34     {
  35         ConstString const_plugin_name (plugin_name);
  36         create_callback  = PluginManager::GetEmulateInstructionCreateCallbackForPluginName (const_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 (lldb::RegisterKind 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 (&reg_info, reg_value);
  83     return false;
  84 }
  85
  86 uint64_t
  87 EmulateInstruction::ReadRegisterUnsigned (lldb::RegisterKind 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                                    lldb::RegisterKind 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, &reg_info, reg_value);
 132     return false;
 133 }
 134
 135
 136 bool
 137 EmulateInstruction::WriteRegisterUnsigned (const Context &context,
 138                                            lldb::RegisterKind 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, &reg_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             lldb::offset_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 dst_len)
 291 {
 292     if (!baton || dst == NULL || dst_len == 0)
 293         return 0;
 294
 295     StackFrame *frame = (StackFrame *) baton;
 296
 297     ProcessSP process_sp (frame->CalculateProcess());
 298     if (process_sp)
 299     {
 300         Error error;
 301         return process_sp->ReadMemory (addr, dst, dst_len, error);
 302     }
 303     return 0;
 304 }
 305
 306 size_t
 307 EmulateInstruction::WriteMemoryFrame (EmulateInstruction *instruction,
 308                                       void *baton,
 309                                       const Context &context,
 310                                       lldb::addr_t addr,
 311                                       const void *src,
 312                                       size_t src_len)
 313 {
 314     if (!baton || src == NULL || src_len == 0)
 315         return 0;
 316
 317     StackFrame *frame = (StackFrame *) baton;
 318
 319     ProcessSP process_sp (frame->CalculateProcess());
 320     if (process_sp)
 321     {
 322         Error error;
 323         return process_sp->WriteMemory (addr, src, src_len, error);
 324     }
 325
 326     return 0;
 327 }
 328
 329 bool
 330 EmulateInstruction::ReadRegisterFrame  (EmulateInstruction *instruction,
 331                                         void *baton,
 332                                         const RegisterInfo *reg_info,
 333                                         RegisterValue &reg_value)
 334 {
 335     if (!baton)
 336         return false;
 337
 338     StackFrame *frame = (StackFrame *) baton;
 339     return frame->GetRegisterContext()->ReadRegister (reg_info, reg_value);
 340 }
 341
 342 bool
 343 EmulateInstruction::WriteRegisterFrame (EmulateInstruction *instruction,
 344                                         void *baton,
 345                                         const Context &context,
 346                                         const RegisterInfo *reg_info,
 347                                         const RegisterValue &reg_value)
 348 {
 349     if (!baton)
 350         return false;
 351
 352     StackFrame *frame = (StackFrame *) baton;
 353     return frame->GetRegisterContext()->WriteRegister (reg_info, reg_value);
 354 }
 355
 356 size_t
 357 EmulateInstruction::ReadMemoryDefault (EmulateInstruction *instruction,
 358                                        void *baton,
 359                                        const Context &context,
 360                                        lldb::addr_t addr,
 361                                        void *dst,
 362                                        size_t length)
 363 {
 364     StreamFile strm (stdout, false);
 365     strm.Printf ("    Read from Memory (address = 0x%" PRIx64 ", length = %" PRIu64 ", context = ", addr, (uint64_t)length);
 366     context.Dump (strm, instruction);
 367     strm.EOL();
 368     *((uint64_t *) dst) = 0xdeadbeef;
 369     return length;
 370 }
 371
 372 size_t
 373 EmulateInstruction::WriteMemoryDefault (EmulateInstruction *instruction,
 374                                         void *baton,
 375                                         const Context &context,
 376                                         lldb::addr_t addr,
 377                                         const void *dst,
 378                                         size_t length)
 379 {
 380     StreamFile strm (stdout, false);
 381     strm.Printf ("    Write to Memory (address = 0x%" PRIx64 ", length = %" PRIu64 ", context = ", addr, (uint64_t)length);
 382     context.Dump (strm, instruction);
 383     strm.EOL();
 384     return length;
 385 }
 386
 387 bool
 388 EmulateInstruction::ReadRegisterDefault  (EmulateInstruction *instruction,
 389                                           void *baton,
 390                                           const RegisterInfo *reg_info,
 391                                           RegisterValue &reg_value)
 392 {
 393     StreamFile strm (stdout, false);
 394     strm.Printf ("  Read Register (%s)\n", reg_info->name);
 395     lldb::RegisterKind reg_kind;
 396     uint32_t reg_num;
 397     if (GetBestRegisterKindAndNumber (reg_info, reg_kind, reg_num))
 398         reg_value.SetUInt64((uint64_t)reg_kind << 24 | reg_num);
 399     else
 400         reg_value.SetUInt64(0);
 401
 402     return true;
 403 }
 404
 405 bool
 406 EmulateInstruction::WriteRegisterDefault (EmulateInstruction *instruction,
 407                                           void *baton,
 408                                           const Context &context,
 409                                           const RegisterInfo *reg_info,
 410                                           const RegisterValue &reg_value)
 411 {
 412     StreamFile strm (stdout, false);
 413     strm.Printf ("    Write to Register (name = %s, value = " , reg_info->name);
 414     reg_value.Dump(&strm, reg_info, false, false, eFormatDefault);
 415     strm.PutCString (", context = ");
 416     context.Dump (strm, instruction);
 417     strm.EOL();
 418     return true;
 419 }
 420
 421 void
 422 EmulateInstruction::Context::Dump (Stream &strm,
 423                                    EmulateInstruction *instruction) const
 424 {
 425     switch (type)
 426     {
 427         case eContextReadOpcode:
 428             strm.PutCString ("reading opcode");
 429             break;
 430
 431         case eContextImmediate:
 432             strm.PutCString ("immediate");
 433             break;
 434
 435         case eContextPushRegisterOnStack:
 436             strm.PutCString ("push register");
 437             break;
 438
 439         case eContextPopRegisterOffStack:
 440             strm.PutCString ("pop register");
 441             break;
 442
 443         case eContextAdjustStackPointer:
 444             strm.PutCString ("adjust sp");
 445             break;
 446
 447         case eContextSetFramePointer:
 448             strm.PutCString ("set frame pointer");
 449             break;
 450
 451         case eContextAdjustBaseRegister:
 452             strm.PutCString ("adjusting (writing value back to) a base register");
 453             break;
 454
 455         case eContextRegisterPlusOffset:
 456             strm.PutCString ("register + offset");
 457             break;
 458
 459         case eContextRegisterStore:
 460             strm.PutCString ("store register");
 461             break;
 462
 463         case eContextRegisterLoad:
 464             strm.PutCString ("load register");
 465             break;
 466
 467         case eContextRelativeBranchImmediate:
 468             strm.PutCString ("relative branch immediate");
 469             break;
 470
 471         case eContextAbsoluteBranchRegister:
 472             strm.PutCString ("absolute branch register");
 473             break;
 474
 475         case eContextSupervisorCall:
 476             strm.PutCString ("supervisor call");
 477             break;
 478
 479         case eContextTableBranchReadMemory:
 480             strm.PutCString ("table branch read memory");
 481             break;
 482
 483         case eContextWriteRegisterRandomBits:
 484             strm.PutCString ("write random bits to a register");
 485             break;
 486
 487         case eContextWriteMemoryRandomBits:
 488             strm.PutCString ("write random bits to a memory address");
 489             break;
 490
 491         case eContextArithmetic:
 492             strm.PutCString ("arithmetic");
 493             break;
 494
 495         case eContextReturnFromException:
 496             strm.PutCString ("return from exception");
 497             break;
 498
 499         default:
 500             strm.PutCString ("unrecognized context.");
 501             break;
 502     }
 503
 504     switch (info_type)
 505     {
 506     case eInfoTypeRegisterPlusOffset:
 507         {
 508             strm.Printf (" (reg_plus_offset = %s%+" PRId64 ")",
 509                          info.RegisterPlusOffset.reg.name,
 510                          info.RegisterPlusOffset.signed_offset);
 511         }
 512         break;
 513
 514     case eInfoTypeRegisterPlusIndirectOffset:
 515         {
 516             strm.Printf (" (reg_plus_reg = %s + %s)",
 517                          info.RegisterPlusIndirectOffset.base_reg.name,
 518                          info.RegisterPlusIndirectOffset.offset_reg.name);
 519         }
 520         break;
 521
 522     case eInfoTypeRegisterToRegisterPlusOffset:
 523         {
 524             strm.Printf (" (base_and_imm_offset = %s%+" PRId64 ", data_reg = %s)",
 525                          info.RegisterToRegisterPlusOffset.base_reg.name,
 526                          info.RegisterToRegisterPlusOffset.offset,
 527                          info.RegisterToRegisterPlusOffset.data_reg.name);
 528         }
 529         break;
 530
 531     case eInfoTypeRegisterToRegisterPlusIndirectOffset:
 532         {
 533             strm.Printf (" (base_and_reg_offset = %s + %s, data_reg = %s)",
 534                          info.RegisterToRegisterPlusIndirectOffset.base_reg.name,
 535                          info.RegisterToRegisterPlusIndirectOffset.offset_reg.name,
 536                          info.RegisterToRegisterPlusIndirectOffset.data_reg.name);
 537         }
 538         break;
 539
 540     case eInfoTypeRegisterRegisterOperands:
 541         {
 542             strm.Printf (" (register to register binary op: %s and %s)",
 543                          info.RegisterRegisterOperands.operand1.name,
 544                          info.RegisterRegisterOperands.operand2.name);
 545         }
 546         break;
 547
 548     case eInfoTypeOffset:
 549         strm.Printf (" (signed_offset = %+" PRId64 ")", info.signed_offset);
 550         break;
 551
 552     case eInfoTypeRegister:
 553         strm.Printf (" (reg = %s)", info.reg.name);
 554         break;
 555
 556     case eInfoTypeImmediate:
 557         strm.Printf (" (unsigned_immediate = %" PRIu64 " (0x%16.16" PRIx64 "))",
 558                      info.unsigned_immediate,
 559                      info.unsigned_immediate);
 560         break;
 561
 562     case eInfoTypeImmediateSigned:
 563         strm.Printf (" (signed_immediate = %+" PRId64 " (0x%16.16" PRIx64 "))",
 564                      info.signed_immediate,
 565                      info.signed_immediate);
 566         break;
 567
 568     case eInfoTypeAddress:
 569         strm.Printf (" (address = 0x%" PRIx64 ")", info.address);
 570         break;
 571
 572     case eInfoTypeISAAndImmediate:
 573         strm.Printf (" (isa = %u, unsigned_immediate = %u (0x%8.8x))",
 574                      info.ISAAndImmediate.isa,
 575                      info.ISAAndImmediate.unsigned_data32,
 576                      info.ISAAndImmediate.unsigned_data32);
 577         break;
 578
 579     case eInfoTypeISAAndImmediateSigned:
 580         strm.Printf (" (isa = %u, signed_immediate = %i (0x%8.8x))",
 581                      info.ISAAndImmediateSigned.isa,
 582                      info.ISAAndImmediateSigned.signed_data32,
 583                      info.ISAAndImmediateSigned.signed_data32);
 584         break;
 585
 586     case eInfoTypeISA:
 587         strm.Printf (" (isa = %u)", info.isa);
 588         break;
 589
 590     case eInfoTypeNoArgs:
 591         break;
 592     }
 593 }
 594
 595 bool
 596 EmulateInstruction::SetInstruction (const Opcode &opcode, const Address &inst_addr, Target *target)
 597 {
 598     m_opcode = opcode;
 599     m_addr = LLDB_INVALID_ADDRESS;
 600     if (inst_addr.IsValid())
 601     {
 602         if (target)
 603             m_addr = inst_addr.GetLoadAddress (target);
 604         if (m_addr == LLDB_INVALID_ADDRESS)
 605             m_addr = inst_addr.GetFileAddress ();
 606     }
 607     return true;
 608 }
 609
 610 bool
 611 EmulateInstruction::GetBestRegisterKindAndNumber (const RegisterInfo *reg_info,
 612                                                   lldb::RegisterKind &reg_kind,
 613                                                   uint32_t &reg_num)
 614 {
 615     // Generic and DWARF should be the two most popular register kinds when
 616     // emulating instructions since they are the most platform agnostic...
 617     reg_num = reg_info->kinds[eRegisterKindGeneric];
 618     if (reg_num != LLDB_INVALID_REGNUM)
 619     {
 620         reg_kind = eRegisterKindGeneric;
 621         return true;
 622     }
 623
 624     reg_num = reg_info->kinds[eRegisterKindDWARF];
 625     if (reg_num != LLDB_INVALID_REGNUM)
 626     {
 627         reg_kind = eRegisterKindDWARF;
 628         return true;
 629     }
 630
 631     reg_num = reg_info->kinds[eRegisterKindLLDB];
 632     if (reg_num != LLDB_INVALID_REGNUM)
 633     {
 634         reg_kind = eRegisterKindLLDB;
 635         return true;
 636     }
 637
 638     reg_num = reg_info->kinds[eRegisterKindGCC];
 639     if (reg_num != LLDB_INVALID_REGNUM)
 640     {
 641         reg_kind = eRegisterKindGCC;
 642         return true;
 643     }
 644
 645     reg_num = reg_info->kinds[eRegisterKindGDB];
 646     if (reg_num != LLDB_INVALID_REGNUM)
 647     {
 648         reg_kind = eRegisterKindGDB;
 649         return true;
 650     }
 651     return false;
 652 }
 653
 654 uint32_t
 655 EmulateInstruction::GetInternalRegisterNumber (RegisterContext *reg_ctx, const RegisterInfo &reg_info)
 656 {
 657     lldb::RegisterKind reg_kind;
 658     uint32_t reg_num;
 659     if (reg_ctx && GetBestRegisterKindAndNumber (&reg_info, reg_kind, reg_num))
 660         return reg_ctx->ConvertRegisterKindToRegisterNumber (reg_kind, reg_num);
 661     return LLDB_INVALID_REGNUM;
 662 }
 663
 664
 665 bool
 666 EmulateInstruction::CreateFunctionEntryUnwind (UnwindPlan &unwind_plan)
 667 {
 668     unwind_plan.Clear();
 669     return false;
 670 }
 671
 672