LLDB  mainline
JITLoaderGDB.cpp
Go to the documentation of this file.
1 //===-- JITLoaderGDB.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 
10 #include "llvm/Support/MathExtras.h"
11 
13 #include "lldb/Core/Module.h"
14 #include "lldb/Core/ModuleSpec.h"
16 #include "lldb/Core/Section.h"
18 #include "lldb/Symbol/ObjectFile.h"
19 #include "lldb/Symbol/Symbol.h"
22 #include "lldb/Target/Process.h"
24 #include "lldb/Target/Target.h"
27 #include "lldb/Utility/Log.h"
29 
30 #include "JITLoaderGDB.h"
31 
32 #include <memory>
33 
34 using namespace lldb;
35 using namespace lldb_private;
36 
37 // Debug Interface Structures
38 typedef enum {
43 
44 template <typename ptr_t> struct jit_code_entry {
45  ptr_t next_entry; // pointer
46  ptr_t prev_entry; // pointer
47  ptr_t symfile_addr; // pointer
48  uint64_t symfile_size;
49 };
50 
51 template <typename ptr_t> struct jit_descriptor {
53  uint32_t action_flag; // Values are jit_action_t
54  ptr_t relevant_entry; // pointer
55  ptr_t first_entry; // pointer
56 };
57 
58 namespace {
59 
61  eEnableJITLoaderGDBDefault,
62  eEnableJITLoaderGDBOn,
63  eEnableJITLoaderGDBOff,
64 };
65 
66 static constexpr OptionEnumValueElement g_enable_jit_loader_gdb_enumerators[] = {
67  {eEnableJITLoaderGDBDefault, "default", "Enable JIT compilation interface "
68  "for all platforms except macOS"},
69  {eEnableJITLoaderGDBOn, "on", "Enable JIT compilation interface"},
70  {eEnableJITLoaderGDBOff, "off", "Disable JIT compilation interface"}
71  };
72 
73 static constexpr PropertyDefinition g_properties[] = {
74  {"enable", OptionValue::eTypeEnum, true,
75  eEnableJITLoaderGDBDefault, nullptr,
76  OptionEnumValues(g_enable_jit_loader_gdb_enumerators),
77  "Enable GDB's JIT compilation interface (default: enabled on "
78  "all platforms except macOS)"}};
79 
80 enum { ePropertyEnable, ePropertyEnableJITBreakpoint };
81 
82 class PluginProperties : public Properties {
83 public:
84  static ConstString GetSettingName() {
86  }
87 
88  PluginProperties() {
89  m_collection_sp = std::make_shared<OptionValueProperties>(GetSettingName());
90  m_collection_sp->Initialize(g_properties);
91  }
92 
93  EnableJITLoaderGDB GetEnable() const {
94  return (EnableJITLoaderGDB)m_collection_sp->GetPropertyAtIndexAsEnumeration(
95  nullptr, ePropertyEnable,
96  g_properties[ePropertyEnable].default_uint_value);
97  }
98 };
99 
100 typedef std::shared_ptr<PluginProperties> JITLoaderGDBPropertiesSP;
101 
102 static const JITLoaderGDBPropertiesSP &GetGlobalPluginProperties() {
103  static const auto g_settings_sp(std::make_shared<PluginProperties>());
104  return g_settings_sp;
105 }
106 
107 template <typename ptr_t>
108 bool ReadJITEntry(const addr_t from_addr, Process *process,
109  jit_code_entry<ptr_t> *entry) {
110  lldbassert(from_addr % sizeof(ptr_t) == 0);
111 
112  ArchSpec::Core core = process->GetTarget().GetArchitecture().GetCore();
113  bool i386_target = ArchSpec::kCore_x86_32_first <= core &&
114  core <= ArchSpec::kCore_x86_32_last;
115  uint8_t uint64_align_bytes = i386_target ? 4 : 8;
116  const size_t data_byte_size =
117  llvm::alignTo(sizeof(ptr_t) * 3, uint64_align_bytes) + sizeof(uint64_t);
118 
119  Status error;
120  DataBufferHeap data(data_byte_size, 0);
121  size_t bytes_read = process->ReadMemory(from_addr, data.GetBytes(),
122  data.GetByteSize(), error);
123  if (bytes_read != data_byte_size || !error.Success())
124  return false;
125 
126  DataExtractor extractor(data.GetBytes(), data.GetByteSize(),
127  process->GetByteOrder(), sizeof(ptr_t));
128  lldb::offset_t offset = 0;
129  entry->next_entry = extractor.GetPointer(&offset);
130  entry->prev_entry = extractor.GetPointer(&offset);
131  entry->symfile_addr = extractor.GetPointer(&offset);
132  offset = llvm::alignTo(offset, uint64_align_bytes);
133  entry->symfile_size = extractor.GetU64(&offset);
134 
135  return true;
136 }
137 
138 } // anonymous namespace end
139 
141  : JITLoader(process), m_jit_objects(),
142  m_jit_break_id(LLDB_INVALID_BREAK_ID),
143  m_jit_descriptor_addr(LLDB_INVALID_ADDRESS) {}
144 
146  if (LLDB_BREAK_ID_IS_VALID(m_jit_break_id))
147  m_process->GetTarget().RemoveBreakpointByID(m_jit_break_id);
148 }
149 
151  if (!PluginManager::GetSettingForJITLoaderPlugin(
152  debugger, PluginProperties::GetSettingName())) {
153  const bool is_global_setting = true;
154  PluginManager::CreateSettingForJITLoaderPlugin(
155  debugger, GetGlobalPluginProperties()->GetValueProperties(),
156  ConstString("Properties for the JIT LoaderGDB plug-in."),
157  is_global_setting);
158  }
159 }
160 
162  Target &target = m_process->GetTarget();
163  ModuleList &module_list = target.GetImages();
164  SetJITBreakpoint(module_list);
165 }
166 
168  Target &target = m_process->GetTarget();
169  ModuleList &module_list = target.GetImages();
170  SetJITBreakpoint(module_list);
171 }
172 
174  if (!DidSetJITBreakpoint() && m_process->IsAlive())
175  SetJITBreakpoint(module_list);
176 }
177 
178 // Setup the JIT Breakpoint
179 void JITLoaderGDB::SetJITBreakpoint(lldb_private::ModuleList &module_list) {
180  if (DidSetJITBreakpoint())
181  return;
182 
184  if (log)
185  log->Printf("JITLoaderGDB::%s looking for JIT register hook", __FUNCTION__);
186 
187  addr_t jit_addr = GetSymbolAddress(
188  module_list, ConstString("__jit_debug_register_code"), eSymbolTypeAny);
189  if (jit_addr == LLDB_INVALID_ADDRESS)
190  return;
191 
192  m_jit_descriptor_addr = GetSymbolAddress(
193  module_list, ConstString("__jit_debug_descriptor"), eSymbolTypeData);
194  if (m_jit_descriptor_addr == LLDB_INVALID_ADDRESS) {
195  if (log)
196  log->Printf("JITLoaderGDB::%s failed to find JIT descriptor address",
197  __FUNCTION__);
198  return;
199  }
200 
201  if (log)
202  log->Printf("JITLoaderGDB::%s setting JIT breakpoint", __FUNCTION__);
203 
204  Breakpoint *bp =
205  m_process->GetTarget().CreateBreakpoint(jit_addr, true, false).get();
206  bp->SetCallback(JITDebugBreakpointHit, this, true);
207  bp->SetBreakpointKind("jit-debug-register");
208  m_jit_break_id = bp->GetID();
209 
210  ReadJITDescriptor(true);
211 }
212 
213 bool JITLoaderGDB::JITDebugBreakpointHit(void *baton,
214  StoppointCallbackContext *context,
215  user_id_t break_id,
216  user_id_t break_loc_id) {
218  if (log)
219  log->Printf("JITLoaderGDB::%s hit JIT breakpoint", __FUNCTION__);
220  JITLoaderGDB *instance = static_cast<JITLoaderGDB *>(baton);
221  return instance->ReadJITDescriptor(false);
222 }
223 
224 static void updateSectionLoadAddress(const SectionList &section_list,
225  Target &target, uint64_t symbolfile_addr,
226  uint64_t symbolfile_size,
227  uint64_t &vmaddrheuristic,
228  uint64_t &min_addr, uint64_t &max_addr) {
229  const uint32_t num_sections = section_list.GetSize();
230  for (uint32_t i = 0; i < num_sections; ++i) {
231  SectionSP section_sp(section_list.GetSectionAtIndex(i));
232  if (section_sp) {
233  if (section_sp->IsFake()) {
234  uint64_t lower = (uint64_t)-1;
235  uint64_t upper = 0;
236  updateSectionLoadAddress(section_sp->GetChildren(), target,
237  symbolfile_addr, symbolfile_size,
238  vmaddrheuristic, lower, upper);
239  if (lower < min_addr)
240  min_addr = lower;
241  if (upper > max_addr)
242  max_addr = upper;
243  const lldb::addr_t slide_amount = lower - section_sp->GetFileAddress();
244  section_sp->Slide(slide_amount, false);
245  section_sp->GetChildren().Slide(-slide_amount, false);
246  section_sp->SetByteSize(upper - lower);
247  } else {
248  vmaddrheuristic += 2 << section_sp->GetLog2Align();
249  uint64_t lower;
250  if (section_sp->GetFileAddress() > vmaddrheuristic)
251  lower = section_sp->GetFileAddress();
252  else {
253  lower = symbolfile_addr + section_sp->GetFileOffset();
254  section_sp->SetFileAddress(symbolfile_addr +
255  section_sp->GetFileOffset());
256  }
257  target.SetSectionLoadAddress(section_sp, lower, true);
258  uint64_t upper = lower + section_sp->GetByteSize();
259  if (lower < min_addr)
260  min_addr = lower;
261  if (upper > max_addr)
262  max_addr = upper;
263  // This is an upper bound, but a good enough heuristic
264  vmaddrheuristic += section_sp->GetByteSize();
265  }
266  }
267  }
268 }
269 
270 bool JITLoaderGDB::ReadJITDescriptor(bool all_entries) {
272  return ReadJITDescriptorImpl<uint64_t>(all_entries);
273  else
274  return ReadJITDescriptorImpl<uint32_t>(all_entries);
275 }
276 
277 template <typename ptr_t>
278 bool JITLoaderGDB::ReadJITDescriptorImpl(bool all_entries) {
279  if (m_jit_descriptor_addr == LLDB_INVALID_ADDRESS)
280  return false;
281 
283  Target &target = m_process->GetTarget();
284  ModuleList &module_list = target.GetImages();
285 
286  jit_descriptor<ptr_t> jit_desc;
287  const size_t jit_desc_size = sizeof(jit_desc);
288  Status error;
289  size_t bytes_read = m_process->DoReadMemory(m_jit_descriptor_addr, &jit_desc,
290  jit_desc_size, error);
291  if (bytes_read != jit_desc_size || !error.Success()) {
292  if (log)
293  log->Printf("JITLoaderGDB::%s failed to read JIT descriptor",
294  __FUNCTION__);
295  return false;
296  }
297 
298  jit_actions_t jit_action = (jit_actions_t)jit_desc.action_flag;
299  addr_t jit_relevant_entry = (addr_t)jit_desc.relevant_entry;
300  if (all_entries) {
301  jit_action = JIT_REGISTER_FN;
302  jit_relevant_entry = (addr_t)jit_desc.first_entry;
303  }
304 
305  while (jit_relevant_entry != 0) {
306  jit_code_entry<ptr_t> jit_entry;
307  if (!ReadJITEntry(jit_relevant_entry, m_process, &jit_entry)) {
308  if (log)
309  log->Printf("JITLoaderGDB::%s failed to read JIT entry at 0x%" PRIx64,
310  __FUNCTION__, jit_relevant_entry);
311  return false;
312  }
313 
314  const addr_t &symbolfile_addr = (addr_t)jit_entry.symfile_addr;
315  const size_t &symbolfile_size = (size_t)jit_entry.symfile_size;
316  ModuleSP module_sp;
317 
318  if (jit_action == JIT_REGISTER_FN) {
319  if (log)
320  log->Printf("JITLoaderGDB::%s registering JIT entry at 0x%" PRIx64
321  " (%" PRIu64 " bytes)",
322  __FUNCTION__, symbolfile_addr, (uint64_t)symbolfile_size);
323 
324  char jit_name[64];
325  snprintf(jit_name, 64, "JIT(0x%" PRIx64 ")", symbolfile_addr);
326  module_sp = m_process->ReadModuleFromMemory(
327  FileSpec(jit_name), symbolfile_addr, symbolfile_size);
328 
329  if (module_sp && module_sp->GetObjectFile()) {
330  // load the symbol table right away
331  module_sp->GetObjectFile()->GetSymtab();
332 
333  m_jit_objects.insert(std::make_pair(symbolfile_addr, module_sp));
334  if (module_sp->GetObjectFile()->GetPluginName() ==
335  ConstString("mach-o")) {
336  ObjectFile *image_object_file = module_sp->GetObjectFile();
337  if (image_object_file) {
338  const SectionList *section_list =
339  image_object_file->GetSectionList();
340  if (section_list) {
341  uint64_t vmaddrheuristic = 0;
342  uint64_t lower = (uint64_t)-1;
343  uint64_t upper = 0;
344  updateSectionLoadAddress(*section_list, target, symbolfile_addr,
345  symbolfile_size, vmaddrheuristic, lower,
346  upper);
347  }
348  }
349  } else {
350  bool changed = false;
351  module_sp->SetLoadAddress(target, 0, true, changed);
352  }
353 
354  module_list.AppendIfNeeded(module_sp);
355 
356  ModuleList module_list;
357  module_list.Append(module_sp);
358  target.ModulesDidLoad(module_list);
359  } else {
360  if (log)
361  log->Printf("JITLoaderGDB::%s failed to load module for "
362  "JIT entry at 0x%" PRIx64,
363  __FUNCTION__, symbolfile_addr);
364  }
365  } else if (jit_action == JIT_UNREGISTER_FN) {
366  if (log)
367  log->Printf("JITLoaderGDB::%s unregistering JIT entry at 0x%" PRIx64,
368  __FUNCTION__, symbolfile_addr);
369 
370  JITObjectMap::iterator it = m_jit_objects.find(symbolfile_addr);
371  if (it != m_jit_objects.end()) {
372  module_sp = it->second;
373  ObjectFile *image_object_file = module_sp->GetObjectFile();
374  if (image_object_file) {
375  const SectionList *section_list = image_object_file->GetSectionList();
376  if (section_list) {
377  const uint32_t num_sections = section_list->GetSize();
378  for (uint32_t i = 0; i < num_sections; ++i) {
379  SectionSP section_sp(section_list->GetSectionAtIndex(i));
380  if (section_sp) {
381  target.GetSectionLoadList().SetSectionUnloaded(section_sp);
382  }
383  }
384  }
385  }
386  module_list.Remove(module_sp);
387  m_jit_objects.erase(it);
388  }
389  } else if (jit_action == JIT_NOACTION) {
390  // Nothing to do
391  } else {
392  assert(false && "Unknown jit action");
393  }
394 
395  if (all_entries)
396  jit_relevant_entry = (addr_t)jit_entry.next_entry;
397  else
398  jit_relevant_entry = 0;
399  }
400 
401  return false; // Continue Running.
402 }
403 
404 // PluginInterface protocol
406  static ConstString g_name("gdb");
407  return g_name;
408 }
409 
410 JITLoaderSP JITLoaderGDB::CreateInstance(Process *process, bool force) {
411  JITLoaderSP jit_loader_sp;
412  bool enable;
413  switch (GetGlobalPluginProperties()->GetEnable()) {
414  case EnableJITLoaderGDB::eEnableJITLoaderGDBOn:
415  enable = true;
416  break;
417  case EnableJITLoaderGDB::eEnableJITLoaderGDBOff:
418  enable = false;
419  break;
420  case EnableJITLoaderGDB::eEnableJITLoaderGDBDefault:
421  ArchSpec arch(process->GetTarget().GetArchitecture());
422  enable = arch.GetTriple().getVendor() != llvm::Triple::Apple;
423  break;
424  }
425  if (enable)
426  jit_loader_sp = std::make_shared<JITLoaderGDB>(process);
427  return jit_loader_sp;
428 }
429 
431  return "JIT loader plug-in that watches for JIT events using the GDB "
432  "interface.";
433 }
434 
436  return GetPluginNameStatic();
437 }
438 
440 
442  PluginManager::RegisterPlugin(GetPluginNameStatic(),
445 }
446 
448  PluginManager::UnregisterPlugin(CreateInstance);
449 }
450 
451 bool JITLoaderGDB::DidSetJITBreakpoint() const {
452  return LLDB_BREAK_ID_IS_VALID(m_jit_break_id);
453 }
454 
455 addr_t JITLoaderGDB::GetSymbolAddress(ModuleList &module_list,
456  ConstString name,
457  SymbolType symbol_type) const {
458  SymbolContextList target_symbols;
459  Target &target = m_process->GetTarget();
460 
461  if (!module_list.FindSymbolsWithNameAndType(name, symbol_type,
462  target_symbols))
463  return LLDB_INVALID_ADDRESS;
464 
465  SymbolContext sym_ctx;
466  target_symbols.GetContextAtIndex(0, sym_ctx);
467 
468  const Address jit_descriptor_addr = sym_ctx.symbol->GetAddress();
469  if (!jit_descriptor_addr.IsValid())
470  return LLDB_INVALID_ADDRESS;
471 
472  const addr_t jit_addr = jit_descriptor_addr.GetLoadAddress(&target);
473  return jit_addr;
474 }
A class to manage flag bits.
Definition: Debugger.h:82
An data extractor class.
Definition: DataExtractor.h:47
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:410
bool RemoveBreakpointByID(lldb::break_id_t break_id)
Definition: Target.cpp:940
Defines a list of symbol context objects.
Enumerations for broadcasting.
Definition: SBLaunchInfo.h:14
const ArchSpec & GetArchitecture() const
Definition: Target.h:941
#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:742
lldb::addr_t GetLoadAddress(Target *target) const
Get the load address.
Definition: Address.cpp:292
General Outline: A breakpoint has four main parts, a filter, a resolver, the list of breakpoint locat...
Definition: Breakpoint.h:78
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:55
An architecture specification class.
Definition: ArchSpec.h:32
bool SetSectionLoadAddress(const lldb::SectionSP &section, lldb::addr_t load_addr, bool warn_multiple=false)
Definition: Target.cpp:2756
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:456
lldb::ByteOrder GetByteOrder() const
Definition: Process.cpp:3366
EnableJITLoaderGDB
Address GetAddress() const
Definition: Symbol.h:72
static constexpr PropertyDefinition g_properties[]
Definition: Debugger.cpp:198
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:431
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:421
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.
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
uint32_t action_flag
void Append(const lldb::ModuleSP &module_sp, bool notify=true)
Append a module to the module list.
~JITLoaderGDB() override
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:2435
A collection class for Module objects.
Definition: ModuleList.h:91
SectionLoadList & GetSectionLoadList()
Definition: Target.h:1012
lldb::break_id_t GetID() const
Definition: Stoppoint.cpp:22
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:605
size_t FindSymbolsWithNameAndType(ConstString name, lldb::SymbolType symbol_type, SymbolContextList &sc_list, bool append=false) const
Definition: ModuleList.cpp:457
A plug-in interface definition class for debugging a process.
Definition: Process.h:353
lldb::SectionSP GetSectionAtIndex(size_t idx) const
Definition: Section.cpp:497
bool Success() const
Test for success condition.
Definition: Status.cpp:287
bool IsValid() const
Check if the object state is valid.
Definition: Address.h:343
A section + offset based address class.
Definition: Address.h:80
void ModulesDidLoad(ModuleList &module_list)
Definition: Target.cpp:1651
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:899
Target & GetTarget()
Get the target object pointer for this module.
Definition: Process.h:1194
lldb_private::ConstString GetPluginName() override
uint64_t addr_t
Definition: lldb-types.h:83
JITLoaderGDB(lldb_private::Process *process)
A uniqued constant string class.
Definition: ConstString.h:38
virtual bool IsAlive()
Check if a process is still alive.
Definition: Process.cpp:1182
Log * GetLogIfAnyCategoriesSet(uint32_t mask)
Definition: Logging.cpp:61
Definition: SBAddress.h:15
#define LIBLLDB_LOG_JIT_LOADER
Definition: Logging.h:41
size_t GetSize() const
Definition: Section.h:83
uint8_t * GetBytes() override
#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...
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.
void Printf(const char *format,...) __attribute__((format(printf
Definition: Log.cpp:113
uint64_t GetPointer(lldb::offset_t *offset_ptr) const
Extract an pointer from *offset_ptr.
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:325
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:1966
A plug-in interface definition class for JIT loaders.
Definition: JITLoader.h:27