1 //===-- EmulateInstruction.cpp ----------------------------------*- C++ -*-===//
3 // The LLVM Compiler Infrastructure
5 // This file is distributed under the University of Illinois Open Source
6 // License. See LICENSE.TXT for details.
8 //===----------------------------------------------------------------------===//
10 #include "lldb/Core/EmulateInstruction.h"
12 #include "lldb/Core/Address.h"
13 #include "lldb/Core/PluginManager.h"
14 #include "lldb/Core/RegisterValue.h"
15 #include "lldb/Core/StreamFile.h"
16 #include "lldb/Symbol/UnwindPlan.h"
17 #include "lldb/Target/Process.h"
18 #include "lldb/Target/RegisterContext.h"
19 #include "lldb/Target/StackFrame.h" // for StackFrame
20 #include "lldb/Utility/ConstString.h" // for ConstString
21 #include "lldb/Utility/DataExtractor.h"
22 #include "lldb/Utility/Status.h"
23 #include "lldb/Utility/Stream.h" // for Stream, Stream::::eBinary
24 #include "lldb/Utility/StreamString.h"
25 #include "lldb/lldb-forward.h" // for ProcessSP
26 #include "lldb/lldb-private-interfaces.h" // for EmulateInstructionCreateIn...
28 #include "llvm/ADT/StringRef.h" // for StringRef
31 #include <memory> // for shared_ptr
33 #include <inttypes.h> // for PRIx64, PRId64, PRIu64
34 #include <stdio.h> // for stdout
36 namespace lldb_private {
41 using namespace lldb_private;
44 EmulateInstruction::FindPlugin(const ArchSpec &arch,
45 InstructionType supported_inst_type,
46 const char *plugin_name) {
47 EmulateInstructionCreateInstance create_callback = nullptr;
49 ConstString const_plugin_name(plugin_name);
51 PluginManager::GetEmulateInstructionCreateCallbackForPluginName(
53 if (create_callback) {
54 EmulateInstruction *emulate_insn_ptr =
55 create_callback(arch, supported_inst_type);
57 return emulate_insn_ptr;
60 for (uint32_t idx = 0;
62 PluginManager::GetEmulateInstructionCreateCallbackAtIndex(idx)) !=
65 EmulateInstruction *emulate_insn_ptr =
66 create_callback(arch, supported_inst_type);
68 return emulate_insn_ptr;
74 EmulateInstruction::EmulateInstruction(const ArchSpec &arch)
75 : m_arch(arch), m_baton(nullptr), m_read_mem_callback(&ReadMemoryDefault),
76 m_write_mem_callback(&WriteMemoryDefault),
77 m_read_reg_callback(&ReadRegisterDefault),
78 m_write_reg_callback(&WriteRegisterDefault),
79 m_addr(LLDB_INVALID_ADDRESS) {
80 ::memset(&m_opcode, 0, sizeof(m_opcode));
83 bool EmulateInstruction::ReadRegister(const RegisterInfo *reg_info,
84 RegisterValue ®_value) {
85 if (m_read_reg_callback != nullptr)
86 return m_read_reg_callback(this, m_baton, reg_info, reg_value);
90 bool EmulateInstruction::ReadRegister(lldb::RegisterKind reg_kind,
92 RegisterValue ®_value) {
93 RegisterInfo reg_info;
94 if (GetRegisterInfo(reg_kind, reg_num, reg_info))
95 return ReadRegister(®_info, reg_value);
99 uint64_t EmulateInstruction::ReadRegisterUnsigned(lldb::RegisterKind reg_kind,
103 RegisterValue reg_value;
104 if (ReadRegister(reg_kind, reg_num, reg_value))
105 return reg_value.GetAsUInt64(fail_value, success_ptr);
107 *success_ptr = false;
111 uint64_t EmulateInstruction::ReadRegisterUnsigned(const RegisterInfo *reg_info,
114 RegisterValue reg_value;
115 if (ReadRegister(reg_info, reg_value))
116 return reg_value.GetAsUInt64(fail_value, success_ptr);
118 *success_ptr = false;
122 bool EmulateInstruction::WriteRegister(const Context &context,
123 const RegisterInfo *reg_info,
124 const RegisterValue ®_value) {
125 if (m_write_reg_callback != nullptr)
126 return m_write_reg_callback(this, m_baton, context, reg_info, reg_value);
130 bool EmulateInstruction::WriteRegister(const Context &context,
131 lldb::RegisterKind reg_kind,
133 const RegisterValue ®_value) {
134 RegisterInfo reg_info;
135 if (GetRegisterInfo(reg_kind, reg_num, reg_info))
136 return WriteRegister(context, ®_info, reg_value);
140 bool EmulateInstruction::WriteRegisterUnsigned(const Context &context,
141 lldb::RegisterKind reg_kind,
143 uint64_t uint_value) {
144 RegisterInfo reg_info;
145 if (GetRegisterInfo(reg_kind, reg_num, reg_info)) {
146 RegisterValue reg_value;
147 if (reg_value.SetUInt(uint_value, reg_info.byte_size))
148 return WriteRegister(context, ®_info, reg_value);
153 bool EmulateInstruction::WriteRegisterUnsigned(const Context &context,
154 const RegisterInfo *reg_info,
155 uint64_t uint_value) {
156 if (reg_info != nullptr) {
157 RegisterValue reg_value;
158 if (reg_value.SetUInt(uint_value, reg_info->byte_size))
159 return WriteRegister(context, reg_info, reg_value);
164 size_t EmulateInstruction::ReadMemory(const Context &context, lldb::addr_t addr,
165 void *dst, size_t dst_len) {
166 if (m_read_mem_callback != nullptr)
167 return m_read_mem_callback(this, m_baton, context, addr, dst, dst_len) ==
172 uint64_t EmulateInstruction::ReadMemoryUnsigned(const Context &context,
178 bool success = false;
179 if (byte_size <= 8) {
180 uint8_t buf[sizeof(uint64_t)];
182 m_read_mem_callback(this, m_baton, context, addr, buf, byte_size);
183 if (bytes_read == byte_size) {
184 lldb::offset_t offset = 0;
185 DataExtractor data(buf, byte_size, GetByteOrder(), GetAddressByteSize());
186 uval64 = data.GetMaxU64(&offset, byte_size);
192 *success_ptr = success;
199 bool EmulateInstruction::WriteMemoryUnsigned(const Context &context,
200 lldb::addr_t addr, uint64_t uval,
201 size_t uval_byte_size) {
202 StreamString strm(Stream::eBinary, GetAddressByteSize(), GetByteOrder());
203 strm.PutMaxHex64(uval, uval_byte_size);
205 size_t bytes_written = m_write_mem_callback(
206 this, m_baton, context, addr, strm.GetString().data(), uval_byte_size);
207 return (bytes_written == uval_byte_size);
210 bool EmulateInstruction::WriteMemory(const Context &context, lldb::addr_t addr,
211 const void *src, size_t src_len) {
212 if (m_write_mem_callback != nullptr)
213 return m_write_mem_callback(this, m_baton, context, addr, src, src_len) ==
218 void EmulateInstruction::SetBaton(void *baton) { m_baton = baton; }
220 void EmulateInstruction::SetCallbacks(
221 ReadMemoryCallback read_mem_callback,
222 WriteMemoryCallback write_mem_callback,
223 ReadRegisterCallback read_reg_callback,
224 WriteRegisterCallback write_reg_callback) {
225 m_read_mem_callback = read_mem_callback;
226 m_write_mem_callback = write_mem_callback;
227 m_read_reg_callback = read_reg_callback;
228 m_write_reg_callback = write_reg_callback;
231 void EmulateInstruction::SetReadMemCallback(
232 ReadMemoryCallback read_mem_callback) {
233 m_read_mem_callback = read_mem_callback;
236 void EmulateInstruction::SetWriteMemCallback(
237 WriteMemoryCallback write_mem_callback) {
238 m_write_mem_callback = write_mem_callback;
241 void EmulateInstruction::SetReadRegCallback(
242 ReadRegisterCallback read_reg_callback) {
243 m_read_reg_callback = read_reg_callback;
246 void EmulateInstruction::SetWriteRegCallback(
247 WriteRegisterCallback write_reg_callback) {
248 m_write_reg_callback = write_reg_callback;
252 // Read & Write Memory and Registers callback functions.
255 size_t EmulateInstruction::ReadMemoryFrame(EmulateInstruction *instruction,
256 void *baton, const Context &context,
257 lldb::addr_t addr, void *dst,
259 if (baton == nullptr || dst == nullptr || dst_len == 0)
262 StackFrame *frame = (StackFrame *)baton;
264 ProcessSP process_sp(frame->CalculateProcess());
267 return process_sp->ReadMemory(addr, dst, dst_len, error);
272 size_t EmulateInstruction::WriteMemoryFrame(EmulateInstruction *instruction,
273 void *baton, const Context &context,
274 lldb::addr_t addr, const void *src,
276 if (baton == nullptr || src == nullptr || src_len == 0)
279 StackFrame *frame = (StackFrame *)baton;
281 ProcessSP process_sp(frame->CalculateProcess());
284 return process_sp->WriteMemory(addr, src, src_len, error);
290 bool EmulateInstruction::ReadRegisterFrame(EmulateInstruction *instruction,
292 const RegisterInfo *reg_info,
293 RegisterValue ®_value) {
294 if (baton == nullptr)
297 StackFrame *frame = (StackFrame *)baton;
298 return frame->GetRegisterContext()->ReadRegister(reg_info, reg_value);
301 bool EmulateInstruction::WriteRegisterFrame(EmulateInstruction *instruction,
302 void *baton, const Context &context,
303 const RegisterInfo *reg_info,
304 const RegisterValue ®_value) {
305 if (baton == nullptr)
308 StackFrame *frame = (StackFrame *)baton;
309 return frame->GetRegisterContext()->WriteRegister(reg_info, reg_value);
312 size_t EmulateInstruction::ReadMemoryDefault(EmulateInstruction *instruction,
314 const Context &context,
315 lldb::addr_t addr, void *dst,
317 StreamFile strm(stdout, false);
318 strm.Printf(" Read from Memory (address = 0x%" PRIx64 ", length = %" PRIu64
320 addr, (uint64_t)length);
321 context.Dump(strm, instruction);
323 *((uint64_t *)dst) = 0xdeadbeef;
327 size_t EmulateInstruction::WriteMemoryDefault(EmulateInstruction *instruction,
329 const Context &context,
331 const void *dst, size_t length) {
332 StreamFile strm(stdout, false);
333 strm.Printf(" Write to Memory (address = 0x%" PRIx64 ", length = %" PRIu64
335 addr, (uint64_t)length);
336 context.Dump(strm, instruction);
341 bool EmulateInstruction::ReadRegisterDefault(EmulateInstruction *instruction,
343 const RegisterInfo *reg_info,
344 RegisterValue ®_value) {
345 StreamFile strm(stdout, false);
346 strm.Printf(" Read Register (%s)\n", reg_info->name);
347 lldb::RegisterKind reg_kind;
349 if (GetBestRegisterKindAndNumber(reg_info, reg_kind, reg_num))
350 reg_value.SetUInt64((uint64_t)reg_kind << 24 | reg_num);
352 reg_value.SetUInt64(0);
357 bool EmulateInstruction::WriteRegisterDefault(EmulateInstruction *instruction,
359 const Context &context,
360 const RegisterInfo *reg_info,
361 const RegisterValue ®_value) {
362 StreamFile strm(stdout, false);
363 strm.Printf(" Write to Register (name = %s, value = ", reg_info->name);
364 reg_value.Dump(&strm, reg_info, false, false, eFormatDefault);
365 strm.PutCString(", context = ");
366 context.Dump(strm, instruction);
371 void EmulateInstruction::Context::Dump(Stream &strm,
372 EmulateInstruction *instruction) const {
374 case eContextReadOpcode:
375 strm.PutCString("reading opcode");
378 case eContextImmediate:
379 strm.PutCString("immediate");
382 case eContextPushRegisterOnStack:
383 strm.PutCString("push register");
386 case eContextPopRegisterOffStack:
387 strm.PutCString("pop register");
390 case eContextAdjustStackPointer:
391 strm.PutCString("adjust sp");
394 case eContextSetFramePointer:
395 strm.PutCString("set frame pointer");
398 case eContextAdjustBaseRegister:
399 strm.PutCString("adjusting (writing value back to) a base register");
402 case eContextRegisterPlusOffset:
403 strm.PutCString("register + offset");
406 case eContextRegisterStore:
407 strm.PutCString("store register");
410 case eContextRegisterLoad:
411 strm.PutCString("load register");
414 case eContextRelativeBranchImmediate:
415 strm.PutCString("relative branch immediate");
418 case eContextAbsoluteBranchRegister:
419 strm.PutCString("absolute branch register");
422 case eContextSupervisorCall:
423 strm.PutCString("supervisor call");
426 case eContextTableBranchReadMemory:
427 strm.PutCString("table branch read memory");
430 case eContextWriteRegisterRandomBits:
431 strm.PutCString("write random bits to a register");
434 case eContextWriteMemoryRandomBits:
435 strm.PutCString("write random bits to a memory address");
438 case eContextArithmetic:
439 strm.PutCString("arithmetic");
442 case eContextReturnFromException:
443 strm.PutCString("return from exception");
447 strm.PutCString("unrecognized context.");
452 case eInfoTypeRegisterPlusOffset:
453 strm.Printf(" (reg_plus_offset = %s%+" PRId64 ")",
454 info.RegisterPlusOffset.reg.name,
455 info.RegisterPlusOffset.signed_offset);
458 case eInfoTypeRegisterPlusIndirectOffset:
459 strm.Printf(" (reg_plus_reg = %s + %s)",
460 info.RegisterPlusIndirectOffset.base_reg.name,
461 info.RegisterPlusIndirectOffset.offset_reg.name);
464 case eInfoTypeRegisterToRegisterPlusOffset:
465 strm.Printf(" (base_and_imm_offset = %s%+" PRId64 ", data_reg = %s)",
466 info.RegisterToRegisterPlusOffset.base_reg.name,
467 info.RegisterToRegisterPlusOffset.offset,
468 info.RegisterToRegisterPlusOffset.data_reg.name);
471 case eInfoTypeRegisterToRegisterPlusIndirectOffset:
472 strm.Printf(" (base_and_reg_offset = %s + %s, data_reg = %s)",
473 info.RegisterToRegisterPlusIndirectOffset.base_reg.name,
474 info.RegisterToRegisterPlusIndirectOffset.offset_reg.name,
475 info.RegisterToRegisterPlusIndirectOffset.data_reg.name);
478 case eInfoTypeRegisterRegisterOperands:
479 strm.Printf(" (register to register binary op: %s and %s)",
480 info.RegisterRegisterOperands.operand1.name,
481 info.RegisterRegisterOperands.operand2.name);
484 case eInfoTypeOffset:
485 strm.Printf(" (signed_offset = %+" PRId64 ")", info.signed_offset);
488 case eInfoTypeRegister:
489 strm.Printf(" (reg = %s)", info.reg.name);
492 case eInfoTypeImmediate:
493 strm.Printf(" (unsigned_immediate = %" PRIu64 " (0x%16.16" PRIx64 "))",
494 info.unsigned_immediate, info.unsigned_immediate);
497 case eInfoTypeImmediateSigned:
498 strm.Printf(" (signed_immediate = %+" PRId64 " (0x%16.16" PRIx64 "))",
499 info.signed_immediate, info.signed_immediate);
502 case eInfoTypeAddress:
503 strm.Printf(" (address = 0x%" PRIx64 ")", info.address);
506 case eInfoTypeISAAndImmediate:
507 strm.Printf(" (isa = %u, unsigned_immediate = %u (0x%8.8x))",
508 info.ISAAndImmediate.isa, info.ISAAndImmediate.unsigned_data32,
509 info.ISAAndImmediate.unsigned_data32);
512 case eInfoTypeISAAndImmediateSigned:
513 strm.Printf(" (isa = %u, signed_immediate = %i (0x%8.8x))",
514 info.ISAAndImmediateSigned.isa,
515 info.ISAAndImmediateSigned.signed_data32,
516 info.ISAAndImmediateSigned.signed_data32);
520 strm.Printf(" (isa = %u)", info.isa);
523 case eInfoTypeNoArgs:
528 bool EmulateInstruction::SetInstruction(const Opcode &opcode,
529 const Address &inst_addr,
532 m_addr = LLDB_INVALID_ADDRESS;
533 if (inst_addr.IsValid()) {
534 if (target != nullptr)
535 m_addr = inst_addr.GetLoadAddress(target);
536 if (m_addr == LLDB_INVALID_ADDRESS)
537 m_addr = inst_addr.GetFileAddress();
542 bool EmulateInstruction::GetBestRegisterKindAndNumber(
543 const RegisterInfo *reg_info, lldb::RegisterKind ®_kind,
545 // Generic and DWARF should be the two most popular register kinds when
546 // emulating instructions since they are the most platform agnostic...
547 reg_num = reg_info->kinds[eRegisterKindGeneric];
548 if (reg_num != LLDB_INVALID_REGNUM) {
549 reg_kind = eRegisterKindGeneric;
553 reg_num = reg_info->kinds[eRegisterKindDWARF];
554 if (reg_num != LLDB_INVALID_REGNUM) {
555 reg_kind = eRegisterKindDWARF;
559 reg_num = reg_info->kinds[eRegisterKindLLDB];
560 if (reg_num != LLDB_INVALID_REGNUM) {
561 reg_kind = eRegisterKindLLDB;
565 reg_num = reg_info->kinds[eRegisterKindEHFrame];
566 if (reg_num != LLDB_INVALID_REGNUM) {
567 reg_kind = eRegisterKindEHFrame;
571 reg_num = reg_info->kinds[eRegisterKindProcessPlugin];
572 if (reg_num != LLDB_INVALID_REGNUM) {
573 reg_kind = eRegisterKindProcessPlugin;
580 EmulateInstruction::GetInternalRegisterNumber(RegisterContext *reg_ctx,
581 const RegisterInfo ®_info) {
582 lldb::RegisterKind reg_kind;
584 if (reg_ctx && GetBestRegisterKindAndNumber(®_info, reg_kind, reg_num))
585 return reg_ctx->ConvertRegisterKindToRegisterNumber(reg_kind, reg_num);
586 return LLDB_INVALID_REGNUM;
589 bool EmulateInstruction::CreateFunctionEntryUnwind(UnwindPlan &unwind_plan) {