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/LLDBLog.h"
27 #include "lldb/Utility/Log.h"
29 #include "llvm/Support/MathExtras.h"
30 
31 #include <memory>
32 
33 using namespace lldb;
34 using namespace lldb_private;
35 
37 
38 // Debug Interface Structures
40 
41 template <typename ptr_t> struct jit_code_entry {
42  ptr_t next_entry; // pointer
43  ptr_t prev_entry; // pointer
44  ptr_t symfile_addr; // pointer
45  uint64_t symfile_size;
46 };
47 
48 template <typename ptr_t> struct jit_descriptor {
50  uint32_t action_flag; // Values are jit_action_t
51  ptr_t relevant_entry; // pointer
52  ptr_t first_entry; // pointer
53 };
54 
55 namespace {
56 enum EnableJITLoaderGDB {
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 } // namespace
108 
109 static PluginProperties &GetGlobalPluginProperties() {
110  static PluginProperties g_settings;
111  return g_settings;
112 }
113 
114 template <typename ptr_t>
115 static bool ReadJITEntry(const addr_t from_addr, Process *process,
116  jit_code_entry<ptr_t> *entry) {
117  lldbassert(from_addr % sizeof(ptr_t) == 0);
118 
119  ArchSpec::Core core = process->GetTarget().GetArchitecture().GetCore();
120  bool i386_target = ArchSpec::kCore_x86_32_first <= core &&
121  core <= ArchSpec::kCore_x86_32_last;
122  uint8_t uint64_align_bytes = i386_target ? 4 : 8;
123  const size_t data_byte_size =
124  llvm::alignTo(sizeof(ptr_t) * 3, uint64_align_bytes) + sizeof(uint64_t);
125 
126  Status error;
127  DataBufferHeap data(data_byte_size, 0);
128  size_t bytes_read = process->ReadMemory(from_addr, data.GetBytes(),
129  data.GetByteSize(), error);
130  if (bytes_read != data_byte_size || !error.Success())
131  return false;
132 
133  DataExtractor extractor(data.GetBytes(), data.GetByteSize(),
134  process->GetByteOrder(), sizeof(ptr_t));
135  lldb::offset_t offset = 0;
136  entry->next_entry = extractor.GetAddress(&offset);
137  entry->prev_entry = extractor.GetAddress(&offset);
138  entry->symfile_addr = extractor.GetAddress(&offset);
139  offset = llvm::alignTo(offset, uint64_align_bytes);
140  entry->symfile_size = extractor.GetU64(&offset);
141 
142  return true;
143 }
144 
146  : JITLoader(process), m_jit_objects(),
147  m_jit_break_id(LLDB_INVALID_BREAK_ID),
148  m_jit_descriptor_addr(LLDB_INVALID_ADDRESS) {}
149 
153 }
154 
156  if (!PluginManager::GetSettingForJITLoaderPlugin(
157  debugger, PluginProperties::GetSettingName())) {
158  const bool is_global_setting = true;
159  PluginManager::CreateSettingForJITLoaderPlugin(
160  debugger, GetGlobalPluginProperties().GetValueProperties(),
161  ConstString("Properties for the JIT LoaderGDB plug-in."),
162  is_global_setting);
163  }
164 }
165 
167  Target &target = m_process->GetTarget();
168  ModuleList &module_list = target.GetImages();
169  SetJITBreakpoint(module_list);
170 }
171 
173  Target &target = m_process->GetTarget();
174  ModuleList &module_list = target.GetImages();
175  SetJITBreakpoint(module_list);
176 }
177 
180  SetJITBreakpoint(module_list);
181 }
182 
183 // Setup the JIT Breakpoint
185  if (DidSetJITBreakpoint())
186  return;
187 
188  Log *log = GetLog(LLDBLog::JITLoader);
189  LLDB_LOGF(log, "JITLoaderGDB::%s looking for JIT register hook",
190  __FUNCTION__);
191 
192  addr_t jit_addr = GetSymbolAddress(
193  module_list, ConstString("__jit_debug_register_code"), eSymbolTypeCode);
194  if (jit_addr == LLDB_INVALID_ADDRESS)
195  return;
196 
198  module_list, ConstString("__jit_debug_descriptor"), eSymbolTypeData);
200  LLDB_LOGF(log, "JITLoaderGDB::%s failed to find JIT descriptor address",
201  __FUNCTION__);
202  return;
203  }
204 
205  LLDB_LOGF(log, "JITLoaderGDB::%s setting JIT breakpoint", __FUNCTION__);
206 
207  Breakpoint *bp =
208  m_process->GetTarget().CreateBreakpoint(jit_addr, true, false).get();
209  bp->SetCallback(JITDebugBreakpointHit, this, true);
210  bp->SetBreakpointKind("jit-debug-register");
211  m_jit_break_id = bp->GetID();
212 
213  ReadJITDescriptor(true);
214 }
215 
217  StoppointCallbackContext *context,
218  user_id_t break_id,
219  user_id_t break_loc_id) {
220  Log *log = GetLog(LLDBLog::JITLoader);
221  LLDB_LOGF(log, "JITLoaderGDB::%s hit JIT breakpoint", __FUNCTION__);
222  JITLoaderGDB *instance = static_cast<JITLoaderGDB *>(baton);
223  return instance->ReadJITDescriptor(false);
224 }
225 
226 static void updateSectionLoadAddress(const SectionList &section_list,
227  Target &target, uint64_t symbolfile_addr,
228  uint64_t symbolfile_size,
229  uint64_t &vmaddrheuristic,
230  uint64_t &min_addr, uint64_t &max_addr) {
231  const uint32_t num_sections = section_list.GetSize();
232  for (uint32_t i = 0; i < num_sections; ++i) {
233  SectionSP section_sp(section_list.GetSectionAtIndex(i));
234  if (section_sp) {
235  if (section_sp->IsFake()) {
236  uint64_t lower = (uint64_t)-1;
237  uint64_t upper = 0;
238  updateSectionLoadAddress(section_sp->GetChildren(), target,
239  symbolfile_addr, symbolfile_size,
240  vmaddrheuristic, lower, upper);
241  if (lower < min_addr)
242  min_addr = lower;
243  if (upper > max_addr)
244  max_addr = upper;
245  const lldb::addr_t slide_amount = lower - section_sp->GetFileAddress();
246  section_sp->Slide(slide_amount, false);
247  section_sp->GetChildren().Slide(-slide_amount, false);
248  section_sp->SetByteSize(upper - lower);
249  } else {
250  vmaddrheuristic += 2 << section_sp->GetLog2Align();
251  uint64_t lower;
252  if (section_sp->GetFileAddress() > vmaddrheuristic)
253  lower = section_sp->GetFileAddress();
254  else {
255  lower = symbolfile_addr + section_sp->GetFileOffset();
256  section_sp->SetFileAddress(symbolfile_addr +
257  section_sp->GetFileOffset());
258  }
259  target.SetSectionLoadAddress(section_sp, lower, true);
260  uint64_t upper = lower + section_sp->GetByteSize();
261  if (lower < min_addr)
262  min_addr = lower;
263  if (upper > max_addr)
264  max_addr = upper;
265  // This is an upper bound, but a good enough heuristic
266  vmaddrheuristic += section_sp->GetByteSize();
267  }
268  }
269  }
270 }
271 
272 bool JITLoaderGDB::ReadJITDescriptor(bool all_entries) {
274  return ReadJITDescriptorImpl<uint64_t>(all_entries);
275  else
276  return ReadJITDescriptorImpl<uint32_t>(all_entries);
277 }
278 
279 template <typename ptr_t>
280 bool JITLoaderGDB::ReadJITDescriptorImpl(bool all_entries) {
282  return false;
283 
284  Log *log = GetLog(LLDBLog::JITLoader);
285  Target &target = m_process->GetTarget();
286  ModuleList &module_list = target.GetImages();
287 
288  jit_descriptor<ptr_t> jit_desc;
289  const size_t jit_desc_size = sizeof(jit_desc);
290  Status error;
291  size_t bytes_read = m_process->ReadMemory(m_jit_descriptor_addr, &jit_desc,
292  jit_desc_size, error);
293  if (bytes_read != jit_desc_size || !error.Success()) {
294  LLDB_LOGF(log, "JITLoaderGDB::%s failed to read JIT descriptor",
295  __FUNCTION__);
296  return false;
297  }
298 
299  jit_actions_t jit_action = (jit_actions_t)jit_desc.action_flag;
300  addr_t jit_relevant_entry = (addr_t)jit_desc.relevant_entry;
301  if (all_entries) {
302  jit_action = JIT_REGISTER_FN;
303  jit_relevant_entry = (addr_t)jit_desc.first_entry;
304  }
305 
306  while (jit_relevant_entry != 0) {
307  jit_code_entry<ptr_t> jit_entry;
308  if (!ReadJITEntry(jit_relevant_entry, m_process, &jit_entry)) {
309  LLDB_LOGF(log, "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  LLDB_LOGF(log,
320  "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  // Object formats (like ELF) have no representation for a JIT type.
331  // We will get it wrong, if we deduce it from the header.
332  module_sp->GetObjectFile()->SetType(ObjectFile::eTypeJIT);
333 
334  // load the symbol table right away
335  module_sp->GetObjectFile()->GetSymtab();
336 
337  m_jit_objects.insert(std::make_pair(symbolfile_addr, module_sp));
338  if (auto image_object_file =
339  llvm::dyn_cast<ObjectFileMachO>(module_sp->GetObjectFile())) {
340  const SectionList *section_list = image_object_file->GetSectionList();
341  if (section_list) {
342  uint64_t vmaddrheuristic = 0;
343  uint64_t lower = (uint64_t)-1;
344  uint64_t upper = 0;
345  updateSectionLoadAddress(*section_list, target, symbolfile_addr,
346  symbolfile_size, vmaddrheuristic, lower,
347  upper);
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  LLDB_LOGF(log,
361  "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  LLDB_LOGF(log, "JITLoaderGDB::%s unregistering JIT entry at 0x%" PRIx64,
367  __FUNCTION__, symbolfile_addr);
368 
369  JITObjectMap::iterator it = m_jit_objects.find(symbolfile_addr);
370  if (it != m_jit_objects.end()) {
371  module_sp = it->second;
372  ObjectFile *image_object_file = module_sp->GetObjectFile();
373  if (image_object_file) {
374  const SectionList *section_list = image_object_file->GetSectionList();
375  if (section_list) {
376  const uint32_t num_sections = section_list->GetSize();
377  for (uint32_t i = 0; i < num_sections; ++i) {
378  SectionSP section_sp(section_list->GetSectionAtIndex(i));
379  if (section_sp) {
380  target.GetSectionLoadList().SetSectionUnloaded(section_sp);
381  }
382  }
383  }
384  }
385  module_list.Remove(module_sp);
386  m_jit_objects.erase(it);
387  }
388  } else if (jit_action == JIT_NOACTION) {
389  // Nothing to do
390  } else {
391  assert(false && "Unknown jit action");
392  }
393 
394  if (all_entries)
395  jit_relevant_entry = (addr_t)jit_entry.next_entry;
396  else
397  jit_relevant_entry = 0;
398  }
399 
400  return false; // Continue Running.
401 }
402 
403 // PluginInterface protocol
404 JITLoaderSP JITLoaderGDB::CreateInstance(Process *process, bool force) {
405  JITLoaderSP jit_loader_sp;
406  bool enable;
407  switch (GetGlobalPluginProperties().GetEnable()) {
408  case EnableJITLoaderGDB::eEnableJITLoaderGDBOn:
409  enable = true;
410  break;
411  case EnableJITLoaderGDB::eEnableJITLoaderGDBOff:
412  enable = false;
413  break;
414  case EnableJITLoaderGDB::eEnableJITLoaderGDBDefault:
415  ArchSpec arch(process->GetTarget().GetArchitecture());
416  enable = arch.GetTriple().getVendor() != llvm::Triple::Apple;
417  break;
418  }
419  if (enable)
420  jit_loader_sp = std::make_shared<JITLoaderGDB>(process);
421  return jit_loader_sp;
422 }
423 
425  return "JIT loader plug-in that watches for JIT events using the GDB "
426  "interface.";
427 }
428 
430  PluginManager::RegisterPlugin(GetPluginNameStatic(),
433 }
434 
436  PluginManager::UnregisterPlugin(CreateInstance);
437 }
438 
441 }
442 
444  ConstString name,
445  SymbolType symbol_type) const {
446  SymbolContextList target_symbols;
447  Target &target = m_process->GetTarget();
448 
449  module_list.FindSymbolsWithNameAndType(name, symbol_type, target_symbols);
450  if (target_symbols.IsEmpty())
451  return LLDB_INVALID_ADDRESS;
452 
453  SymbolContext sym_ctx;
454  target_symbols.GetContextAtIndex(0, sym_ctx);
455 
456  const Address jit_descriptor_addr = sym_ctx.symbol->GetAddress();
457  if (!jit_descriptor_addr.IsValid())
458  return LLDB_INVALID_ADDRESS;
459 
460  const addr_t jit_addr = jit_descriptor_addr.GetLoadAddress(&target);
461  return jit_addr;
462 }
JITLoaderGDB::~JITLoaderGDB
~JITLoaderGDB() override
Definition: JITLoaderGDB.cpp:150
jit_code_entry::symfile_size
uint64_t symfile_size
Definition: JITLoaderGDB.cpp:45
LLDB_BREAK_ID_IS_VALID
#define LLDB_BREAK_ID_IS_VALID(bid)
Definition: lldb-defines.h:39
lldb_private::DataBufferHeap::GetByteSize
lldb::offset_t GetByteSize() const override
Definition: DataBufferHeap.cpp:43
JITLoaderGDB.h
lldb_private::ArchSpec
Definition: ArchSpec.h:32
lldb_private::DataExtractor::GetAddress
uint64_t GetAddress(lldb::offset_t *offset_ptr) const
Extract an address from *offset_ptr.
Definition: DataExtractor.cpp:649
lldb_private::StoppointCallbackContext
General Outline: When we hit a breakpoint we need to package up whatever information is needed to eva...
Definition: StoppointCallbackContext.h:26
lldb_private::Stoppoint::GetID
lldb::break_id_t GetID() const
Definition: Stoppoint.cpp:22
lldb_private::Address::IsValid
bool IsValid() const
Check if the object state is valid.
Definition: Address.h:345
lldb::eSymbolTypeCode
@ eSymbolTypeCode
Definition: lldb-enumerations.h:623
lldb_private::Process::ReadMemory
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:1925
ModuleSpec.h
JITLoaderGDB::Terminate
static void Terminate()
Definition: JITLoaderGDB.cpp:435
lldb_private::Breakpoint::SetBreakpointKind
void SetBreakpointKind(const char *kind)
Set the "kind" description for a breakpoint.
Definition: Breakpoint.h:453
lldb_private::ArchSpec::GetCore
Core GetCore() const
Definition: ArchSpec.h:442
lldb_private::SectionList::GetSize
size_t GetSize() const
Definition: Section.h:74
jit_code_entry
Definition: JITLoaderGDB.cpp:41
lldb_private::Process::ReadModuleFromMemory
lldb::ModuleSP ReadModuleFromMemory(const FileSpec &file_spec, lldb::addr_t header_addr, size_t size_to_read=512)
Definition: Process.cpp:2357
LLDB_LOGF
#define LLDB_LOGF(log,...)
Definition: Log.h:344
lldb_private::Process
Definition: Process.h:338
Module.h
lldb_private::Process::GetTarget
Target & GetTarget()
Get the target object pointer for this module.
Definition: Process.h:1219
lldb_private::JITLoader::m_process
Process * m_process
Definition: JITLoader.h:63
lldb::eSymbolTypeData
@ eSymbolTypeData
Definition: lldb-enumerations.h:625
lldb_private::SymbolContextList
Definition: SymbolContext.h:379
lldb_private::SymbolContextList::GetContextAtIndex
bool GetContextAtIndex(size_t idx, SymbolContext &sc) const
Get accessor for a symbol context at index idx.
Definition: SymbolContext.cpp:1258
SectionLoadList.h
lldb_private::SectionList
Definition: Section.h:34
lldb::offset_t
uint64_t offset_t
Definition: lldb-types.h:87
lldb_private::Process::IsAlive
virtual bool IsAlive()
Check if a process is still alive.
Definition: Process.cpp:1085
JITLoaderGDB::CreateInstance
static lldb::JITLoaderSP CreateInstance(lldb_private::Process *process, bool force)
Definition: JITLoaderGDB.cpp:404
updateSectionLoadAddress
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)
Definition: JITLoaderGDB.cpp:226
lldb_private::Target::CreateBreakpoint
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:353
lldb_private::ArchSpec::GetTriple
llvm::Triple & GetTriple()
Architecture triple accessor.
Definition: ArchSpec.h:463
lldb::addr_t
uint64_t addr_t
Definition: lldb-types.h:83
lldb_private::SymbolContext
Definition: SymbolContext.h:33
lldb_private::Target
Definition: Target.h:469
Section.h
JITLoaderGDB::DebuggerInitialize
static void DebuggerInitialize(lldb_private::Debugger &debugger)
Definition: JITLoaderGDB.cpp:155
lldb_private::DataExtractor::GetU64
uint64_t GetU64(lldb::offset_t *offset_ptr) const
Extract a uint64_t value from *offset_ptr.
Definition: DataExtractor.cpp:474
lldb_private::Target::GetImages
const ModuleList & GetImages() const
Get accessor for the images for this process.
Definition: Target.h:947
Process.h
JITLoaderGDB::GetPluginNameStatic
static llvm::StringRef GetPluginNameStatic()
Definition: JITLoaderGDB.h:28
JITLoaderGDB::DidSetJITBreakpoint
bool DidSetJITBreakpoint() const
Definition: JITLoaderGDB.cpp:439
lldb_private::ArchSpec::Core
Core
Definition: ArchSpec.h:117
lldb_private::ModuleList::FindSymbolsWithNameAndType
void FindSymbolsWithNameAndType(ConstString name, lldb::SymbolType symbol_type, SymbolContextList &sc_list) const
Definition: ModuleList.cpp:509
Target.h
lldb_private::Properties
Definition: UserSettingsController.h:33
JIT_UNREGISTER_FN
@ JIT_UNREGISTER_FN
Definition: JITLoaderGDB.cpp:39
lldb_private::FileSpec
Definition: FileSpec.h:55
error
static llvm::raw_ostream & error(Stream &strm)
Definition: CommandReturnObject.cpp:17
lldb_private::SymbolContext::symbol
Symbol * symbol
The Symbol for a given query.
Definition: SymbolContext.h:323
lldb_private::ObjectFile::GetSectionList
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:588
JITLoaderGDB::JITDebugBreakpointHit
static bool JITDebugBreakpointHit(void *baton, lldb_private::StoppointCallbackContext *context, lldb::user_id_t break_id, lldb::user_id_t break_loc_id)
Definition: JITLoaderGDB.cpp:216
LLDBAssert.h
lldb_private::ModuleList::Remove
bool Remove(const lldb::ModuleSP &module_sp, bool notify=true)
Remove a module from the module list.
lldb_private::DataExtractor
Definition: DataExtractor.h:48
lldb_private::ModuleList
Definition: ModuleList.h:82
Log.h
lldb_private::Target::SetSectionLoadAddress
bool SetSectionLoadAddress(const lldb::SectionSP &section, lldb::addr_t load_addr, bool warn_multiple=false)
Definition: Target.cpp:2983
JITLoaderGDB::Initialize
static void Initialize()
Definition: JITLoaderGDB.cpp:429
StreamString.h
JITLoaderGDB::m_jit_objects
JITObjectMap m_jit_objects
Definition: JITLoaderGDB.h:72
lldb_private::ConstString
Definition: ConstString.h:39
jit_code_entry::prev_entry
ptr_t prev_entry
Definition: JITLoaderGDB.cpp:43
JITLoaderGDB::ReadJITDescriptorImpl
bool ReadJITDescriptorImpl(bool all_entries)
Definition: JITLoaderGDB.cpp:280
lldb_private::SectionList::GetSectionAtIndex
lldb::SectionSP GetSectionAtIndex(size_t idx) const
Definition: Section.cpp:538
JIT_NOACTION
@ JIT_NOACTION
Definition: JITLoaderGDB.cpp:39
jit_descriptor::relevant_entry
ptr_t relevant_entry
Definition: JITLoaderGDB.cpp:51
lldb_private::Debugger
Definition: Debugger.h:74
JITLoaderGDB::m_jit_break_id
lldb::user_id_t m_jit_break_id
Definition: JITLoaderGDB.h:74
jit_descriptor::version
uint32_t version
Definition: JITLoaderGDB.cpp:49
ReadJITEntry
static bool ReadJITEntry(const addr_t from_addr, Process *process, jit_code_entry< ptr_t > *entry)
Definition: JITLoaderGDB.cpp:115
JITLoaderGDB::DidLaunch
void DidLaunch() override
Called after launching a process.
Definition: JITLoaderGDB.cpp:172
lldb::SymbolType
SymbolType
Symbol types.
Definition: lldb-enumerations.h:619
OptionValueProperties.h
lldb_private::ArchSpec::GetAddressByteSize
uint32_t GetAddressByteSize() const
Returns the size in bytes of an address of the current architecture.
Definition: ArchSpec.cpp:694
JITLoaderGDB::GetPluginDescriptionStatic
static llvm::StringRef GetPluginDescriptionStatic()
Definition: JITLoaderGDB.cpp:424
ObjectFile.h
LLDB_INVALID_BREAK_ID
#define LLDB_INVALID_BREAK_ID
Definition: lldb-defines.h:37
JITLoaderGDB::ModulesDidLoad
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.
Definition: JITLoaderGDB.cpp:178
Symbol.h
lldbassert
#define lldbassert(x)
Definition: LLDBAssert.h:15
jit_actions_t
jit_actions_t
Definition: JITLoaderGDB.cpp:39
lldb_private::Target::GetArchitecture
const ArchSpec & GetArchitecture() const
Definition: Target.h:989
lldb_private::Status
Definition: Status.h:44
uint32_t
lldb_private::JITLoader
Definition: JITLoader.h:27
JITLoaderGDB::ReadJITDescriptor
bool ReadJITDescriptor(bool all_entries)
Definition: JITLoaderGDB.cpp:272
lldb_private::Address
Definition: Address.h:59
lldb_private::Target::ModulesDidLoad
void ModulesDidLoad(ModuleList &module_list)
Definition: Target.cpp:1645
lldb_private::Breakpoint::SetCallback
void SetCallback(BreakpointHitCallback callback, void *baton, bool is_synchronous=false)
Set the callback action invoked when the breakpoint is hit.
Definition: Breakpoint.cpp:418
lldb_private::ModuleList::AppendIfNeeded
bool AppendIfNeeded(const lldb::ModuleSP &new_module, bool notify=true)
Append a module to the module list, if it is not already there.
lldb_private::Address::GetLoadAddress
lldb::addr_t GetLoadAddress(Target *target) const
Get the load address.
Definition: Address.cpp:311
PluginManager.h
lldb_private::Target::RemoveBreakpointByID
bool RemoveBreakpointByID(lldb::break_id_t break_id)
Definition: Target.cpp:953
lldb_private::Target::GetSectionLoadList
SectionLoadList & GetSectionLoadList()
Definition: Target.h:1102
LLDB_INVALID_ADDRESS
#define LLDB_INVALID_ADDRESS
Definition: lldb-defines.h:74
JITLoaderGDB
Definition: JITLoaderGDB.h:17
JITLoaderGDB::GetSymbolAddress
lldb::addr_t GetSymbolAddress(lldb_private::ModuleList &module_list, lldb_private::ConstString name, lldb::SymbolType symbol_type) const
Definition: JITLoaderGDB.cpp:443
lldb_private::SymbolContextList::IsEmpty
bool IsEmpty() const
Definition: SymbolContext.cpp:1276
lldb_private::SectionLoadList::SetSectionUnloaded
bool SetSectionUnloaded(const lldb::SectionSP &section_sp, lldb::addr_t load_addr)
Definition: SectionLoadList.cpp:183
lldb::user_id_t
uint64_t user_id_t
Definition: lldb-types.h:84
SymbolContext.h
ObjectFileMachO.h
jit_code_entry::next_entry
ptr_t next_entry
Definition: JITLoaderGDB.cpp:42
jit_descriptor::first_entry
ptr_t first_entry
Definition: JITLoaderGDB.cpp:52
lldb_private
A class that represents a running process on the host machine.
Definition: SBCommandInterpreterRunOptions.h:16
Breakpoint.h
JITLoaderGDB::JITLoaderGDB
JITLoaderGDB(lldb_private::Process *process)
Definition: JITLoaderGDB.cpp:145
JITLoaderGDB::DidAttach
void DidAttach() override
Called after attaching a process.
Definition: JITLoaderGDB.cpp:166
JIT_REGISTER_FN
@ JIT_REGISTER_FN
Definition: JITLoaderGDB.cpp:39
lldb_private::Process::GetByteOrder
lldb::ByteOrder GetByteOrder() const
Definition: Process.cpp:3362
LLDB_PLUGIN_DEFINE
#define LLDB_PLUGIN_DEFINE(PluginName)
Definition: PluginManager.h:31
lldb_private::Log
Definition: Log.h:115
SymbolVendor.h
lldb_private::GetLog
Log * GetLog(Cat mask)
Retrieve the Log object for the channel associated with the given log enum.
Definition: Log.h:309
lldb_private::DataBufferHeap
Definition: DataBufferHeap.h:30
jit_descriptor
Definition: JITLoaderGDB.cpp:48
JITLoaderGDB::SetJITBreakpoint
void SetJITBreakpoint(lldb_private::ModuleList &module_list)
Definition: JITLoaderGDB.cpp:184
lldb
Definition: SBAddress.h:15
LLDBLog.h
lldb_private::ObjectFile
Definition: ObjectFile.h:60
jit_descriptor::action_flag
uint32_t action_flag
Definition: JITLoaderGDB.cpp:50
lldb_private::ModuleList::Append
void Append(const lldb::ModuleSP &module_sp, bool notify=true)
Append a module to the module list.
DataBufferHeap.h
lldb_private::Breakpoint
General Outline: A breakpoint has four main parts, a filter, a resolver, the list of breakpoint locat...
Definition: Breakpoint.h:80
jit_code_entry::symfile_addr
ptr_t symfile_addr
Definition: JITLoaderGDB.cpp:44
GetGlobalPluginProperties
static PluginProperties & GetGlobalPluginProperties()
Definition: JITLoaderGDB.cpp:109
JITLoaderGDB::m_jit_descriptor_addr
lldb::addr_t m_jit_descriptor_addr
Definition: JITLoaderGDB.h:75
lldb_private::Symbol::GetAddress
Address GetAddress() const
Definition: Symbol.h:73