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