llvm-project/lldb/source/Core/EmulateInstruction.cpp

585 lines
19 KiB
C++

//===-- EmulateInstruction.cpp --------------------------------------------===//
//
// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
// See https://llvm.org/LICENSE.txt for license information.
// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
//
//===----------------------------------------------------------------------===//
#include "lldb/Core/EmulateInstruction.h"
#include "lldb/Core/Address.h"
#include "lldb/Core/DumpRegisterValue.h"
#include "lldb/Core/PluginManager.h"
#include "lldb/Core/StreamFile.h"
#include "lldb/Symbol/UnwindPlan.h"
#include "lldb/Target/Process.h"
#include "lldb/Target/RegisterContext.h"
#include "lldb/Target/StackFrame.h"
#include "lldb/Utility/ConstString.h"
#include "lldb/Utility/DataExtractor.h"
#include "lldb/Utility/RegisterValue.h"
#include "lldb/Utility/Status.h"
#include "lldb/Utility/Stream.h"
#include "lldb/Utility/StreamString.h"
#include "lldb/lldb-forward.h"
#include "lldb/lldb-private-interfaces.h"
#include "llvm/ADT/StringRef.h"
#include <cstring>
#include <memory>
#include <cinttypes>
#include <cstdio>
namespace lldb_private {
class Target;
}
using namespace lldb;
using namespace lldb_private;
EmulateInstruction *
EmulateInstruction::FindPlugin(const ArchSpec &arch,
InstructionType supported_inst_type,
const char *plugin_name) {
EmulateInstructionCreateInstance create_callback = nullptr;
if (plugin_name) {
create_callback =
PluginManager::GetEmulateInstructionCreateCallbackForPluginName(
plugin_name);
if (create_callback) {
EmulateInstruction *emulate_insn_ptr =
create_callback(arch, supported_inst_type);
if (emulate_insn_ptr)
return emulate_insn_ptr;
}
} else {
for (uint32_t idx = 0;
(create_callback =
PluginManager::GetEmulateInstructionCreateCallbackAtIndex(idx)) !=
nullptr;
++idx) {
EmulateInstruction *emulate_insn_ptr =
create_callback(arch, supported_inst_type);
if (emulate_insn_ptr)
return emulate_insn_ptr;
}
}
return nullptr;
}
EmulateInstruction::EmulateInstruction(const ArchSpec &arch) : m_arch(arch) {}
bool EmulateInstruction::ReadRegister(const RegisterInfo *reg_info,
RegisterValue &reg_value) {
if (m_read_reg_callback != nullptr)
return m_read_reg_callback(this, m_baton, reg_info, reg_value);
return false;
}
bool EmulateInstruction::ReadRegister(lldb::RegisterKind reg_kind,
uint32_t reg_num,
RegisterValue &reg_value) {
RegisterInfo reg_info;
if (GetRegisterInfo(reg_kind, reg_num, reg_info))
return ReadRegister(&reg_info, reg_value);
return false;
}
uint64_t EmulateInstruction::ReadRegisterUnsigned(lldb::RegisterKind reg_kind,
uint32_t reg_num,
uint64_t fail_value,
bool *success_ptr) {
RegisterValue reg_value;
if (ReadRegister(reg_kind, reg_num, reg_value))
return reg_value.GetAsUInt64(fail_value, success_ptr);
if (success_ptr)
*success_ptr = false;
return fail_value;
}
uint64_t EmulateInstruction::ReadRegisterUnsigned(const RegisterInfo *reg_info,
uint64_t fail_value,
bool *success_ptr) {
RegisterValue reg_value;
if (ReadRegister(reg_info, reg_value))
return reg_value.GetAsUInt64(fail_value, success_ptr);
if (success_ptr)
*success_ptr = false;
return fail_value;
}
bool EmulateInstruction::WriteRegister(const Context &context,
const RegisterInfo *reg_info,
const RegisterValue &reg_value) {
if (m_write_reg_callback != nullptr)
return m_write_reg_callback(this, m_baton, context, reg_info, reg_value);
return false;
}
bool EmulateInstruction::WriteRegister(const Context &context,
lldb::RegisterKind reg_kind,
uint32_t reg_num,
const RegisterValue &reg_value) {
RegisterInfo reg_info;
if (GetRegisterInfo(reg_kind, reg_num, reg_info))
return WriteRegister(context, &reg_info, reg_value);
return false;
}
bool EmulateInstruction::WriteRegisterUnsigned(const Context &context,
lldb::RegisterKind reg_kind,
uint32_t reg_num,
uint64_t uint_value) {
RegisterInfo reg_info;
if (GetRegisterInfo(reg_kind, reg_num, reg_info)) {
RegisterValue reg_value;
if (reg_value.SetUInt(uint_value, reg_info.byte_size))
return WriteRegister(context, &reg_info, reg_value);
}
return false;
}
bool EmulateInstruction::WriteRegisterUnsigned(const Context &context,
const RegisterInfo *reg_info,
uint64_t uint_value) {
if (reg_info != nullptr) {
RegisterValue reg_value;
if (reg_value.SetUInt(uint_value, reg_info->byte_size))
return WriteRegister(context, reg_info, reg_value);
}
return false;
}
size_t EmulateInstruction::ReadMemory(const Context &context, lldb::addr_t addr,
void *dst, size_t dst_len) {
if (m_read_mem_callback != nullptr)
return m_read_mem_callback(this, m_baton, context, addr, dst, dst_len) ==
dst_len;
return false;
}
uint64_t EmulateInstruction::ReadMemoryUnsigned(const Context &context,
lldb::addr_t addr,
size_t byte_size,
uint64_t fail_value,
bool *success_ptr) {
uint64_t uval64 = 0;
bool success = false;
if (byte_size <= 8) {
uint8_t buf[sizeof(uint64_t)];
size_t bytes_read =
m_read_mem_callback(this, m_baton, context, addr, buf, byte_size);
if (bytes_read == byte_size) {
lldb::offset_t offset = 0;
DataExtractor data(buf, byte_size, GetByteOrder(), GetAddressByteSize());
uval64 = data.GetMaxU64(&offset, byte_size);
success = true;
}
}
if (success_ptr)
*success_ptr = success;
if (!success)
uval64 = fail_value;
return uval64;
}
bool EmulateInstruction::WriteMemoryUnsigned(const Context &context,
lldb::addr_t addr, uint64_t uval,
size_t uval_byte_size) {
StreamString strm(Stream::eBinary, GetAddressByteSize(), GetByteOrder());
strm.PutMaxHex64(uval, uval_byte_size);
size_t bytes_written = m_write_mem_callback(
this, m_baton, context, addr, strm.GetString().data(), uval_byte_size);
return (bytes_written == uval_byte_size);
}
bool EmulateInstruction::WriteMemory(const Context &context, lldb::addr_t addr,
const void *src, size_t src_len) {
if (m_write_mem_callback != nullptr)
return m_write_mem_callback(this, m_baton, context, addr, src, src_len) ==
src_len;
return false;
}
void EmulateInstruction::SetBaton(void *baton) { m_baton = baton; }
void EmulateInstruction::SetCallbacks(
ReadMemoryCallback read_mem_callback,
WriteMemoryCallback write_mem_callback,
ReadRegisterCallback read_reg_callback,
WriteRegisterCallback write_reg_callback) {
m_read_mem_callback = read_mem_callback;
m_write_mem_callback = write_mem_callback;
m_read_reg_callback = read_reg_callback;
m_write_reg_callback = write_reg_callback;
}
void EmulateInstruction::SetReadMemCallback(
ReadMemoryCallback read_mem_callback) {
m_read_mem_callback = read_mem_callback;
}
void EmulateInstruction::SetWriteMemCallback(
WriteMemoryCallback write_mem_callback) {
m_write_mem_callback = write_mem_callback;
}
void EmulateInstruction::SetReadRegCallback(
ReadRegisterCallback read_reg_callback) {
m_read_reg_callback = read_reg_callback;
}
void EmulateInstruction::SetWriteRegCallback(
WriteRegisterCallback write_reg_callback) {
m_write_reg_callback = write_reg_callback;
}
//
// Read & Write Memory and Registers callback functions.
//
size_t EmulateInstruction::ReadMemoryFrame(EmulateInstruction *instruction,
void *baton, const Context &context,
lldb::addr_t addr, void *dst,
size_t dst_len) {
if (baton == nullptr || dst == nullptr || dst_len == 0)
return 0;
StackFrame *frame = (StackFrame *)baton;
ProcessSP process_sp(frame->CalculateProcess());
if (process_sp) {
Status error;
return process_sp->ReadMemory(addr, dst, dst_len, error);
}
return 0;
}
size_t EmulateInstruction::WriteMemoryFrame(EmulateInstruction *instruction,
void *baton, const Context &context,
lldb::addr_t addr, const void *src,
size_t src_len) {
if (baton == nullptr || src == nullptr || src_len == 0)
return 0;
StackFrame *frame = (StackFrame *)baton;
ProcessSP process_sp(frame->CalculateProcess());
if (process_sp) {
Status error;
return process_sp->WriteMemory(addr, src, src_len, error);
}
return 0;
}
bool EmulateInstruction::ReadRegisterFrame(EmulateInstruction *instruction,
void *baton,
const RegisterInfo *reg_info,
RegisterValue &reg_value) {
if (baton == nullptr)
return false;
StackFrame *frame = (StackFrame *)baton;
return frame->GetRegisterContext()->ReadRegister(reg_info, reg_value);
}
bool EmulateInstruction::WriteRegisterFrame(EmulateInstruction *instruction,
void *baton, const Context &context,
const RegisterInfo *reg_info,
const RegisterValue &reg_value) {
if (baton == nullptr)
return false;
StackFrame *frame = (StackFrame *)baton;
return frame->GetRegisterContext()->WriteRegister(reg_info, reg_value);
}
size_t EmulateInstruction::ReadMemoryDefault(EmulateInstruction *instruction,
void *baton,
const Context &context,
lldb::addr_t addr, void *dst,
size_t length) {
StreamFile strm(stdout, false);
strm.Printf(" Read from Memory (address = 0x%" PRIx64 ", length = %" PRIu64
", context = ",
addr, (uint64_t)length);
context.Dump(strm, instruction);
strm.EOL();
*((uint64_t *)dst) = 0xdeadbeef;
return length;
}
size_t EmulateInstruction::WriteMemoryDefault(EmulateInstruction *instruction,
void *baton,
const Context &context,
lldb::addr_t addr,
const void *dst, size_t length) {
StreamFile strm(stdout, false);
strm.Printf(" Write to Memory (address = 0x%" PRIx64 ", length = %" PRIu64
", context = ",
addr, (uint64_t)length);
context.Dump(strm, instruction);
strm.EOL();
return length;
}
bool EmulateInstruction::ReadRegisterDefault(EmulateInstruction *instruction,
void *baton,
const RegisterInfo *reg_info,
RegisterValue &reg_value) {
StreamFile strm(stdout, false);
strm.Printf(" Read Register (%s)\n", reg_info->name);
lldb::RegisterKind reg_kind;
uint32_t reg_num;
if (GetBestRegisterKindAndNumber(reg_info, reg_kind, reg_num))
reg_value.SetUInt64((uint64_t)reg_kind << 24 | reg_num);
else
reg_value.SetUInt64(0);
return true;
}
bool EmulateInstruction::WriteRegisterDefault(EmulateInstruction *instruction,
void *baton,
const Context &context,
const RegisterInfo *reg_info,
const RegisterValue &reg_value) {
StreamFile strm(stdout, false);
strm.Printf(" Write to Register (name = %s, value = ", reg_info->name);
DumpRegisterValue(reg_value, &strm, reg_info, false, false, eFormatDefault);
strm.PutCString(", context = ");
context.Dump(strm, instruction);
strm.EOL();
return true;
}
void EmulateInstruction::Context::Dump(Stream &strm,
EmulateInstruction *instruction) const {
switch (type) {
case eContextReadOpcode:
strm.PutCString("reading opcode");
break;
case eContextImmediate:
strm.PutCString("immediate");
break;
case eContextPushRegisterOnStack:
strm.PutCString("push register");
break;
case eContextPopRegisterOffStack:
strm.PutCString("pop register");
break;
case eContextAdjustStackPointer:
strm.PutCString("adjust sp");
break;
case eContextSetFramePointer:
strm.PutCString("set frame pointer");
break;
case eContextAdjustBaseRegister:
strm.PutCString("adjusting (writing value back to) a base register");
break;
case eContextRegisterPlusOffset:
strm.PutCString("register + offset");
break;
case eContextRegisterStore:
strm.PutCString("store register");
break;
case eContextRegisterLoad:
strm.PutCString("load register");
break;
case eContextRelativeBranchImmediate:
strm.PutCString("relative branch immediate");
break;
case eContextAbsoluteBranchRegister:
strm.PutCString("absolute branch register");
break;
case eContextSupervisorCall:
strm.PutCString("supervisor call");
break;
case eContextTableBranchReadMemory:
strm.PutCString("table branch read memory");
break;
case eContextWriteRegisterRandomBits:
strm.PutCString("write random bits to a register");
break;
case eContextWriteMemoryRandomBits:
strm.PutCString("write random bits to a memory address");
break;
case eContextArithmetic:
strm.PutCString("arithmetic");
break;
case eContextReturnFromException:
strm.PutCString("return from exception");
break;
default:
strm.PutCString("unrecognized context.");
break;
}
switch (info_type) {
case eInfoTypeRegisterPlusOffset:
strm.Printf(" (reg_plus_offset = %s%+" PRId64 ")",
info.RegisterPlusOffset.reg.name,
info.RegisterPlusOffset.signed_offset);
break;
case eInfoTypeRegisterPlusIndirectOffset:
strm.Printf(" (reg_plus_reg = %s + %s)",
info.RegisterPlusIndirectOffset.base_reg.name,
info.RegisterPlusIndirectOffset.offset_reg.name);
break;
case eInfoTypeRegisterToRegisterPlusOffset:
strm.Printf(" (base_and_imm_offset = %s%+" PRId64 ", data_reg = %s)",
info.RegisterToRegisterPlusOffset.base_reg.name,
info.RegisterToRegisterPlusOffset.offset,
info.RegisterToRegisterPlusOffset.data_reg.name);
break;
case eInfoTypeRegisterToRegisterPlusIndirectOffset:
strm.Printf(" (base_and_reg_offset = %s + %s, data_reg = %s)",
info.RegisterToRegisterPlusIndirectOffset.base_reg.name,
info.RegisterToRegisterPlusIndirectOffset.offset_reg.name,
info.RegisterToRegisterPlusIndirectOffset.data_reg.name);
break;
case eInfoTypeRegisterRegisterOperands:
strm.Printf(" (register to register binary op: %s and %s)",
info.RegisterRegisterOperands.operand1.name,
info.RegisterRegisterOperands.operand2.name);
break;
case eInfoTypeOffset:
strm.Printf(" (signed_offset = %+" PRId64 ")", info.signed_offset);
break;
case eInfoTypeRegister:
strm.Printf(" (reg = %s)", info.reg.name);
break;
case eInfoTypeImmediate:
strm.Printf(" (unsigned_immediate = %" PRIu64 " (0x%16.16" PRIx64 "))",
info.unsigned_immediate, info.unsigned_immediate);
break;
case eInfoTypeImmediateSigned:
strm.Printf(" (signed_immediate = %+" PRId64 " (0x%16.16" PRIx64 "))",
info.signed_immediate, info.signed_immediate);
break;
case eInfoTypeAddress:
strm.Printf(" (address = 0x%" PRIx64 ")", info.address);
break;
case eInfoTypeISAAndImmediate:
strm.Printf(" (isa = %u, unsigned_immediate = %u (0x%8.8x))",
info.ISAAndImmediate.isa, info.ISAAndImmediate.unsigned_data32,
info.ISAAndImmediate.unsigned_data32);
break;
case eInfoTypeISAAndImmediateSigned:
strm.Printf(" (isa = %u, signed_immediate = %i (0x%8.8x))",
info.ISAAndImmediateSigned.isa,
info.ISAAndImmediateSigned.signed_data32,
info.ISAAndImmediateSigned.signed_data32);
break;
case eInfoTypeISA:
strm.Printf(" (isa = %u)", info.isa);
break;
case eInfoTypeNoArgs:
break;
}
}
bool EmulateInstruction::SetInstruction(const Opcode &opcode,
const Address &inst_addr,
Target *target) {
m_opcode = opcode;
m_addr = LLDB_INVALID_ADDRESS;
if (inst_addr.IsValid()) {
if (target != nullptr)
m_addr = inst_addr.GetLoadAddress(target);
if (m_addr == LLDB_INVALID_ADDRESS)
m_addr = inst_addr.GetFileAddress();
}
return true;
}
bool EmulateInstruction::GetBestRegisterKindAndNumber(
const RegisterInfo *reg_info, lldb::RegisterKind &reg_kind,
uint32_t &reg_num) {
// Generic and DWARF should be the two most popular register kinds when
// emulating instructions since they are the most platform agnostic...
reg_num = reg_info->kinds[eRegisterKindGeneric];
if (reg_num != LLDB_INVALID_REGNUM) {
reg_kind = eRegisterKindGeneric;
return true;
}
reg_num = reg_info->kinds[eRegisterKindDWARF];
if (reg_num != LLDB_INVALID_REGNUM) {
reg_kind = eRegisterKindDWARF;
return true;
}
reg_num = reg_info->kinds[eRegisterKindLLDB];
if (reg_num != LLDB_INVALID_REGNUM) {
reg_kind = eRegisterKindLLDB;
return true;
}
reg_num = reg_info->kinds[eRegisterKindEHFrame];
if (reg_num != LLDB_INVALID_REGNUM) {
reg_kind = eRegisterKindEHFrame;
return true;
}
reg_num = reg_info->kinds[eRegisterKindProcessPlugin];
if (reg_num != LLDB_INVALID_REGNUM) {
reg_kind = eRegisterKindProcessPlugin;
return true;
}
return false;
}
uint32_t
EmulateInstruction::GetInternalRegisterNumber(RegisterContext *reg_ctx,
const RegisterInfo &reg_info) {
lldb::RegisterKind reg_kind;
uint32_t reg_num;
if (reg_ctx && GetBestRegisterKindAndNumber(&reg_info, reg_kind, reg_num))
return reg_ctx->ConvertRegisterKindToRegisterNumber(reg_kind, reg_num);
return LLDB_INVALID_REGNUM;
}
bool EmulateInstruction::CreateFunctionEntryUnwind(UnwindPlan &unwind_plan) {
unwind_plan.Clear();
return false;
}