LLDB  mainline
JITLoaderGDB.cpp
Go to the documentation of this file.
1 //===-- JITLoaderGDB.cpp --------------------------------------------------===//
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 "JITLoaderGDB.h"
12 #include "lldb/Core/Module.h"
13 #include "lldb/Core/ModuleSpec.h"
15 #include "lldb/Core/Section.h"
17 #include "lldb/Symbol/ObjectFile.h"
18 #include "lldb/Symbol/Symbol.h"
21 #include "lldb/Target/Process.h"
23 #include "lldb/Target/Target.h"
26 #include "lldb/Utility/Log.h"
28 #include "llvm/Support/MathExtras.h"
29 
30 #include <memory>
31 
32 using namespace lldb;
33 using namespace lldb_private;
34 
36 
37 // Debug Interface Structures
39 
40 template <typename ptr_t> struct jit_code_entry {
41  ptr_t next_entry; // pointer
42  ptr_t prev_entry; // pointer
43  ptr_t symfile_addr; // pointer
44  uint64_t symfile_size;
45 };
46 
47 template <typename ptr_t> struct jit_descriptor {
49  uint32_t action_flag; // Values are jit_action_t
50  ptr_t relevant_entry; // pointer
51  ptr_t first_entry; // pointer
52 };
53 
54 namespace {
55 
57  eEnableJITLoaderGDBDefault,
58  eEnableJITLoaderGDBOn,
59  eEnableJITLoaderGDBOff,
60 };
61 
62 static constexpr OptionEnumValueElement g_enable_jit_loader_gdb_enumerators[] =
63  {
64  {
65  eEnableJITLoaderGDBDefault,
66  "default",
67  "Enable JIT compilation interface for all platforms except macOS",
68  },
69  {
70  eEnableJITLoaderGDBOn,
71  "on",
72  "Enable JIT compilation interface",
73  },
74  {
75  eEnableJITLoaderGDBOff,
76  "off",
77  "Disable JIT compilation interface",
78  },
79 };
80 
81 #define LLDB_PROPERTIES_jitloadergdb
82 #include "JITLoaderGDBProperties.inc"
83 
84 enum {
85 #define LLDB_PROPERTIES_jitloadergdb
86 #include "JITLoaderGDBPropertiesEnum.inc"
87  ePropertyEnableJITBreakpoint
88 };
89 
90 class PluginProperties : public Properties {
91 public:
92  static ConstString GetSettingName() {
94  }
95 
96  PluginProperties() {
97  m_collection_sp = std::make_shared<OptionValueProperties>(GetSettingName());
98  m_collection_sp->Initialize(g_jitloadergdb_properties);
99  }
100 
101  EnableJITLoaderGDB GetEnable() const {
102  return (EnableJITLoaderGDB)m_collection_sp->GetPropertyAtIndexAsEnumeration(
103  nullptr, ePropertyEnable,
104  g_jitloadergdb_properties[ePropertyEnable].default_uint_value);
105  }
106 };
107 
108 typedef std::shared_ptr<PluginProperties> JITLoaderGDBPropertiesSP;
109 
110 static const JITLoaderGDBPropertiesSP &GetGlobalPluginProperties() {
111  static const auto g_settings_sp(std::make_shared<PluginProperties>());
112  return g_settings_sp;
113 }
114 
115 template <typename ptr_t>
116 bool ReadJITEntry(const addr_t from_addr, Process *process,
117  jit_code_entry<ptr_t> *entry) {
118  lldbassert(from_addr % sizeof(ptr_t) == 0);
119 
120  ArchSpec::Core core = process->GetTarget().GetArchitecture().GetCore();
121  bool i386_target = ArchSpec::kCore_x86_32_first <= core &&
122  core <= ArchSpec::kCore_x86_32_last;
123  uint8_t uint64_align_bytes = i386_target ? 4 : 8;
124  const size_t data_byte_size =
125  llvm::alignTo(sizeof(ptr_t) * 3, uint64_align_bytes) + sizeof(uint64_t);
126 
127  Status error;
128  DataBufferHeap data(data_byte_size, 0);
129  size_t bytes_read = process->ReadMemory(from_addr, data.GetBytes(),
130  data.GetByteSize(), error);
131  if (bytes_read != data_byte_size || !error.Success())
132  return false;
133 
134  DataExtractor extractor(data.GetBytes(), data.GetByteSize(),
135  process->GetByteOrder(), sizeof(ptr_t));
136  lldb::offset_t offset = 0;
137  entry->next_entry = extractor.GetAddress(&offset);
138  entry->prev_entry = extractor.GetAddress(&offset);
139  entry->symfile_addr = extractor.GetAddress(&offset);
140  offset = llvm::alignTo(offset, uint64_align_bytes);
141  entry->symfile_size = extractor.GetU64(&offset);
142 
143  return true;
144 }
145 
146 } // anonymous namespace end
147 
149  : JITLoader(process), m_jit_objects(),
150  m_jit_break_id(LLDB_INVALID_BREAK_ID),
151  m_jit_descriptor_addr(LLDB_INVALID_ADDRESS) {}
152 
156 }
157 
159  if (!PluginManager::GetSettingForJITLoaderPlugin(
160  debugger, PluginProperties::GetSettingName())) {
161  const bool is_global_setting = true;
162  PluginManager::CreateSettingForJITLoaderPlugin(
163  debugger, GetGlobalPluginProperties()->GetValueProperties(),
164  ConstString("Properties for the JIT LoaderGDB plug-in."),
165  is_global_setting);
166  }
167 }
168 
170  Target &target = m_process->GetTarget();
171  ModuleList &module_list = target.GetImages();
172  SetJITBreakpoint(module_list);
173 }
174 
176  Target &target = m_process->GetTarget();
177  ModuleList &module_list = target.GetImages();
178  SetJITBreakpoint(module_list);
179 }
180 
183  SetJITBreakpoint(module_list);
184 }
185 
186 // Setup the JIT Breakpoint
188  if (DidSetJITBreakpoint())
189  return;
190 
192  LLDB_LOGF(log, "JITLoaderGDB::%s looking for JIT register hook",
193  __FUNCTION__);
194 
195  addr_t jit_addr = GetSymbolAddress(
196  module_list, ConstString("__jit_debug_register_code"), eSymbolTypeAny);
197  if (jit_addr == LLDB_INVALID_ADDRESS)
198  return;
199 
201  module_list, ConstString("__jit_debug_descriptor"), eSymbolTypeData);
203  LLDB_LOGF(log, "JITLoaderGDB::%s failed to find JIT descriptor address",
204  __FUNCTION__);
205  return;
206  }
207 
208  LLDB_LOGF(log, "JITLoaderGDB::%s setting JIT breakpoint", __FUNCTION__);
209 
210  Breakpoint *bp =
211  m_process->GetTarget().CreateBreakpoint(jit_addr, true, false).get();
212  bp->SetCallback(JITDebugBreakpointHit, this, true);
213  bp->SetBreakpointKind("jit-debug-register");
214  m_jit_break_id = bp->GetID();
215 
216  ReadJITDescriptor(true);
217 }
218 
220  StoppointCallbackContext *context,
221  user_id_t break_id,
222  user_id_t break_loc_id) {
224  LLDB_LOGF(log, "JITLoaderGDB::%s hit JIT breakpoint", __FUNCTION__);
225  JITLoaderGDB *instance = static_cast<JITLoaderGDB *>(baton);
226  return instance->ReadJITDescriptor(false);
227 }
228 
229 static void updateSectionLoadAddress(const SectionList &section_list,
230  Target &target, uint64_t symbolfile_addr,
231  uint64_t symbolfile_size,
232  uint64_t &vmaddrheuristic,
233  uint64_t &min_addr, uint64_t &max_addr) {
234  const uint32_t num_sections = section_list.GetSize();
235  for (uint32_t i = 0; i < num_sections; ++i) {
236  SectionSP section_sp(section_list.GetSectionAtIndex(i));
237  if (section_sp) {
238  if (section_sp->IsFake()) {
239  uint64_t lower = (uint64_t)-1;
240  uint64_t upper = 0;
241  updateSectionLoadAddress(section_sp->GetChildren(), target,
242  symbolfile_addr, symbolfile_size,
243  vmaddrheuristic, lower, upper);
244  if (lower < min_addr)
245  min_addr = lower;
246  if (upper > max_addr)
247  max_addr = upper;
248  const lldb::addr_t slide_amount = lower - section_sp->GetFileAddress();
249  section_sp->Slide(slide_amount, false);
250  section_sp->GetChildren().Slide(-slide_amount, false);
251  section_sp->SetByteSize(upper - lower);
252  } else {
253  vmaddrheuristic += 2 << section_sp->GetLog2Align();
254  uint64_t lower;
255  if (section_sp->GetFileAddress() > vmaddrheuristic)
256  lower = section_sp->GetFileAddress();
257  else {
258  lower = symbolfile_addr + section_sp->GetFileOffset();
259  section_sp->SetFileAddress(symbolfile_addr +
260  section_sp->GetFileOffset());
261  }
262  target.SetSectionLoadAddress(section_sp, lower, true);
263  uint64_t upper = lower + section_sp->GetByteSize();
264  if (lower < min_addr)
265  min_addr = lower;
266  if (upper > max_addr)
267  max_addr = upper;
268  // This is an upper bound, but a good enough heuristic
269  vmaddrheuristic += section_sp->GetByteSize();
270  }
271  }
272  }
273 }
274 
275 bool JITLoaderGDB::ReadJITDescriptor(bool all_entries) {
277  return ReadJITDescriptorImpl<uint64_t>(all_entries);
278  else
279  return ReadJITDescriptorImpl<uint32_t>(all_entries);
280 }
281 
282 template <typename ptr_t>
283 bool JITLoaderGDB::ReadJITDescriptorImpl(bool all_entries) {
285  return false;
286 
288  Target &target = m_process->GetTarget();
289  ModuleList &module_list = target.GetImages();
290 
291  jit_descriptor<ptr_t> jit_desc;
292  const size_t jit_desc_size = sizeof(jit_desc);
293  Status error;
294  size_t bytes_read = m_process->DoReadMemory(m_jit_descriptor_addr, &jit_desc,
295  jit_desc_size, error);
296  if (bytes_read != jit_desc_size || !error.Success()) {
297  LLDB_LOGF(log, "JITLoaderGDB::%s failed to read JIT descriptor",
298  __FUNCTION__);
299  return false;
300  }
301 
302  jit_actions_t jit_action = (jit_actions_t)jit_desc.action_flag;
303  addr_t jit_relevant_entry = (addr_t)jit_desc.relevant_entry;
304  if (all_entries) {
305  jit_action = JIT_REGISTER_FN;
306  jit_relevant_entry = (addr_t)jit_desc.first_entry;
307  }
308 
309  while (jit_relevant_entry != 0) {
310  jit_code_entry<ptr_t> jit_entry;
311  if (!ReadJITEntry(jit_relevant_entry, m_process, &jit_entry)) {
312  LLDB_LOGF(log, "JITLoaderGDB::%s failed to read JIT entry at 0x%" PRIx64,
313  __FUNCTION__, jit_relevant_entry);
314  return false;
315  }
316 
317  const addr_t &symbolfile_addr = (addr_t)jit_entry.symfile_addr;
318  const size_t &symbolfile_size = (size_t)jit_entry.symfile_size;
319  ModuleSP module_sp;
320 
321  if (jit_action == JIT_REGISTER_FN) {
322  LLDB_LOGF(log,
323  "JITLoaderGDB::%s registering JIT entry at 0x%" PRIx64
324  " (%" PRIu64 " bytes)",
325  __FUNCTION__, symbolfile_addr, (uint64_t)symbolfile_size);
326 
327  char jit_name[64];
328  snprintf(jit_name, 64, "JIT(0x%" PRIx64 ")", symbolfile_addr);
329  module_sp = m_process->ReadModuleFromMemory(
330  FileSpec(jit_name), symbolfile_addr, symbolfile_size);
331 
332  if (module_sp && module_sp->GetObjectFile()) {
333  // Object formats (like ELF) have no representation for a JIT type.
334  // We will get it wrong, if we deduce it from the header.
335  module_sp->GetObjectFile()->SetType(ObjectFile::eTypeJIT);
336 
337  // load the symbol table right away
338  module_sp->GetObjectFile()->GetSymtab();
339 
340  m_jit_objects.insert(std::make_pair(symbolfile_addr, module_sp));
341  if (auto image_object_file =
342  llvm::dyn_cast<ObjectFileMachO>(module_sp->GetObjectFile())) {
343  const SectionList *section_list = image_object_file->GetSectionList();
344  if (section_list) {
345  uint64_t vmaddrheuristic = 0;
346  uint64_t lower = (uint64_t)-1;
347  uint64_t upper = 0;
348  updateSectionLoadAddress(*section_list, target, symbolfile_addr,
349  symbolfile_size, vmaddrheuristic, lower,
350  upper);
351  }
352  } else {
353  bool changed = false;
354  module_sp->SetLoadAddress(target, 0, true, changed);
355  }
356 
357  module_list.AppendIfNeeded(module_sp);
358 
359  ModuleList module_list;
360  module_list.Append(module_sp);
361  target.ModulesDidLoad(module_list);
362  } else {
363  LLDB_LOGF(log,
364  "JITLoaderGDB::%s failed to load module for "
365  "JIT entry at 0x%" PRIx64,
366  __FUNCTION__, symbolfile_addr);
367  }
368  } else if (jit_action == JIT_UNREGISTER_FN) {
369  LLDB_LOGF(log, "JITLoaderGDB::%s unregistering JIT entry at 0x%" PRIx64,
370  __FUNCTION__, symbolfile_addr);
371 
372  JITObjectMap::iterator it = m_jit_objects.find(symbolfile_addr);
373  if (it != m_jit_objects.end()) {
374  module_sp = it->second;
375  ObjectFile *image_object_file = module_sp->GetObjectFile();
376  if (image_object_file) {
377  const SectionList *section_list = image_object_file->GetSectionList();
378  if (section_list) {
379  const uint32_t num_sections = section_list->GetSize();
380  for (uint32_t i = 0; i < num_sections; ++i) {
381  SectionSP section_sp(section_list->GetSectionAtIndex(i));
382  if (section_sp) {
383  target.GetSectionLoadList().SetSectionUnloaded(section_sp);
384  }
385  }
386  }
387  }
388  module_list.Remove(module_sp);
389  m_jit_objects.erase(it);
390  }
391  } else if (jit_action == JIT_NOACTION) {
392  // Nothing to do
393  } else {
394  assert(false && "Unknown jit action");
395  }
396 
397  if (all_entries)
398  jit_relevant_entry = (addr_t)jit_entry.next_entry;
399  else
400  jit_relevant_entry = 0;
401  }
402 
403  return false; // Continue Running.
404 }
405 
406 // PluginInterface protocol
408  static ConstString g_name("gdb");
409  return g_name;
410 }
411 
412 JITLoaderSP JITLoaderGDB::CreateInstance(Process *process, bool force) {
413  JITLoaderSP jit_loader_sp;
414  bool enable;
415  switch (GetGlobalPluginProperties()->GetEnable()) {
416  case EnableJITLoaderGDB::eEnableJITLoaderGDBOn:
417  enable = true;
418  break;
419  case EnableJITLoaderGDB::eEnableJITLoaderGDBOff:
420  enable = false;
421  break;
422  case EnableJITLoaderGDB::eEnableJITLoaderGDBDefault:
423  ArchSpec arch(process->GetTarget().GetArchitecture());
424  enable = arch.GetTriple().getVendor() != llvm::Triple::Apple;
425  break;
426  }
427  if (enable)
428  jit_loader_sp = std::make_shared<JITLoaderGDB>(process);
429  return jit_loader_sp;
430 }
431 
433  return "JIT loader plug-in that watches for JIT events using the GDB "
434  "interface.";
435 }
436 
438  return GetPluginNameStatic();
439 }
440 
442 
444  PluginManager::RegisterPlugin(GetPluginNameStatic(),
447 }
448 
450  PluginManager::UnregisterPlugin(CreateInstance);
451 }
452 
455 }
456 
458  ConstString name,
459  SymbolType symbol_type) const {
460  SymbolContextList target_symbols;
461  Target &target = m_process->GetTarget();
462 
463  module_list.FindSymbolsWithNameAndType(name, symbol_type, target_symbols);
464  if (target_symbols.IsEmpty())
465  return LLDB_INVALID_ADDRESS;
466 
467  SymbolContext sym_ctx;
468  target_symbols.GetContextAtIndex(0, sym_ctx);
469 
470  const Address jit_descriptor_addr = sym_ctx.symbol->GetAddress();
471  if (!jit_descriptor_addr.IsValid())
472  return LLDB_INVALID_ADDRESS;
473 
474  const addr_t jit_addr = jit_descriptor_addr.GetLoadAddress(&target);
475  return jit_addr;
476 }
A class to manage flag bits.
Definition: Debugger.h:70
An data extractor class.
Definition: DataExtractor.h:46
void ModulesDidLoad(lldb_private::ModuleList &module_list) override
Called after a new shared object has been loaded so that it can be probed for JIT entry point hooks...
Core GetCore() const
Definition: ArchSpec.h:413
bool RemoveBreakpointByID(lldb::break_id_t break_id)
Definition: Target.cpp:916
Defines a list of symbol context objects.
A class that represents a running process on the host machine.
const ArchSpec & GetArchitecture() const
Definition: Target.h:942
lldb::user_id_t m_jit_break_id
Definition: JITLoaderGDB.h:76
#define lldbassert(x)
Definition: LLDBAssert.h:15
uint32_t GetPluginVersion() override
Defines a symbol context baton that can be handed other debug core functions.
Definition: SymbolContext.h:33
uint32_t GetAddressByteSize() const
Returns the size in bytes of an address of the current architecture.
Definition: ArchSpec.cpp:730
lldb::addr_t GetLoadAddress(Target *target) const
Get the load address.
Definition: Address.cpp:310
bool ReadJITDescriptor(bool all_entries)
General Outline: A breakpoint has four main parts, a filter, a resolver, the list of breakpoint locat...
Definition: Breakpoint.h:78
SymbolType
Symbol types.
void DidLaunch() override
Called after launching a process.
static lldb::JITLoaderSP CreateInstance(lldb_private::Process *process, bool force)
uint64_t symfile_size
static void Terminate()
A file utility class.
Definition: FileSpec.h:56
An architecture specification class.
Definition: ArchSpec.h:33
bool SetSectionLoadAddress(const lldb::SectionSP &section, lldb::addr_t load_addr, bool warn_multiple=false)
Definition: Target.cpp:2735
lldb::addr_t GetSymbolAddress(lldb_private::ModuleList &module_list, lldb_private::ConstString name, lldb::SymbolType symbol_type) const
A plug-in interface definition class for object file parsers.
Definition: ObjectFile.h:58
void SetBreakpointKind(const char *kind)
Set the "kind" description for a breakpoint.
Definition: Breakpoint.h:441
lldb::ByteOrder GetByteOrder() const
Definition: Process.cpp:3427
EnableJITLoaderGDB
Address GetAddress() const
Definition: Symbol.h:73
static lldb_private::ConstString GetPluginNameStatic()
Symbol * symbol
The Symbol for a given query.
A subclass of DataBuffer that stores a data buffer on the heap.
llvm::Triple & GetTriple()
Architecture triple accessor.
Definition: ArchSpec.h:434
static void DebuggerInitialize(lldb_private::Debugger &debugger)
void SetCallback(BreakpointHitCallback callback, void *baton, bool is_synchronous=false)
Set the callback action invoked when the breakpoint is hit.
Definition: Breakpoint.cpp:433
bool Remove(const lldb::ModuleSP &module_sp, bool notify=true)
Remove a module from the module list.
jit_actions_t
void DidAttach() override
Called after attaching a process.
uint64_t GetAddress(lldb::offset_t *offset_ptr) const
Extract an address from *offset_ptr.
static void updateSectionLoadAddress(const SectionList &section_list, Target &target, uint64_t symbolfile_addr, uint64_t symbolfile_size, uint64_t &vmaddrheuristic, uint64_t &min_addr, uint64_t &max_addr)
#define LLDB_INVALID_ADDRESS
Invalid value definitions.
Definition: lldb-defines.h:85
uint64_t user_id_t
Definition: lldb-types.h:84
#define LLDB_PLUGIN_DEFINE(PluginName)
Definition: PluginManager.h:31
uint32_t action_flag
void Append(const lldb::ModuleSP &module_sp, bool notify=true)
Append a module to the module list.
~JITLoaderGDB() override
bool ReadJITDescriptorImpl(bool all_entries)
uint64_t offset_t
Definition: lldb-types.h:87
lldb::ModuleSP ReadModuleFromMemory(const FileSpec &file_spec, lldb::addr_t header_addr, size_t size_to_read=512)
Definition: Process.cpp:2489
A collection class for Module objects.
Definition: ModuleList.h:71
SectionLoadList & GetSectionLoadList()
Definition: Target.h:1013
lldb::break_id_t GetID() const
Definition: Stoppoint.cpp:22
void SetJITBreakpoint(lldb_private::ModuleList &module_list)
virtual SectionList * GetSectionList(bool update_module_section_list=true)
Gets the section list for the currently selected architecture (and object for archives).
Definition: ObjectFile.cpp:607
lldb::addr_t m_jit_descriptor_addr
Definition: JITLoaderGDB.h:77
A plug-in interface definition class for debugging a process.
Definition: Process.h:362
lldb::SectionSP GetSectionAtIndex(size_t idx) const
Definition: Section.cpp:476
bool Success() const
Test for success condition.
Definition: Status.cpp:288
bool IsValid() const
Check if the object state is valid.
Definition: Address.h:332
A section + offset based address class.
Definition: Address.h:59
void ModulesDidLoad(ModuleList &module_list)
Definition: Target.cpp:1609
uint32_t version
ptr_t prev_entry
bool GetContextAtIndex(size_t idx, SymbolContext &sc) const
Get accessor for a symbol context at index idx.
virtual size_t DoReadMemory(lldb::addr_t vm_addr, void *buf, size_t size, Status &error)=0
Actually do the reading of memory from a process.
const ModuleList & GetImages() const
Get accessor for the images for this process.
Definition: Target.h:900
#define LLDB_LOGF(log,...)
Definition: Log.h:249
Target & GetTarget()
Get the target object pointer for this module.
Definition: Process.h:1208
lldb_private::ConstString GetPluginName() override
uint64_t addr_t
Definition: lldb-types.h:83
void FindSymbolsWithNameAndType(ConstString name, lldb::SymbolType symbol_type, SymbolContextList &sc_list) const
Definition: ModuleList.cpp:452
JITLoaderGDB(lldb_private::Process *process)
bool DidSetJITBreakpoint() const
A uniqued constant string class.
Definition: ConstString.h:40
virtual bool IsAlive()
Check if a process is still alive.
Definition: Process.cpp:1193
Log * GetLogIfAnyCategoriesSet(uint32_t mask)
Definition: Logging.cpp:62
Definition: SBAddress.h:15
#define LIBLLDB_LOG_JIT_LOADER
Definition: Logging.h:41
size_t GetSize() const
Definition: Section.h:74
uint8_t * GetBytes() override
static bool JITDebugBreakpointHit(void *baton, lldb_private::StoppointCallbackContext *context, lldb::user_id_t break_id, lldb::user_id_t break_loc_id)
#define LLDB_INVALID_BREAK_ID
Definition: lldb-defines.h:49
static const char * GetPluginDescriptionStatic()
bool SetSectionUnloaded(const lldb::SectionSP &section_sp, lldb::addr_t load_addr)
General Outline: When we hit a breakpoint we need to package up whatever information is needed to eva...
JITObjectMap m_jit_objects
Definition: JITLoaderGDB.h:74
lldb::offset_t GetByteSize() const override
#define LLDB_BREAK_ID_IS_VALID(bid)
Definition: lldb-defines.h:51
bool AppendIfNeeded(const lldb::ModuleSP &module_sp, bool notify=true)
Append a module to the module list, if it is not already there.
static void Initialize()
ptr_t symfile_addr
lldb::BreakpointSP CreateBreakpoint(const FileSpecList *containingModules, const FileSpec &file, uint32_t line_no, uint32_t column, lldb::addr_t offset, LazyBool check_inlines, LazyBool skip_prologue, bool internal, bool request_hardware, LazyBool move_to_nearest_code)
Definition: Target.cpp:323
ptr_t next_entry
uint64_t GetU64(lldb::offset_t *offset_ptr) const
Extract a uint64_t value from *offset_ptr.
An error handling class.
Definition: Status.h:44
virtual size_t ReadMemory(lldb::addr_t vm_addr, void *buf, size_t size, Status &error)
Read of memory from a process.
Definition: Process.cpp:2020
A plug-in interface definition class for JIT loaders.
Definition: JITLoader.h:27