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