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 
12 #include "lldb/Breakpoint/Breakpoint.h"
13 #include "lldb/Core/Module.h"
14 #include "lldb/Core/ModuleSpec.h"
15 #include "lldb/Core/PluginManager.h"
16 #include "lldb/Core/Section.h"
17 #include "lldb/Interpreter/OptionValueProperties.h"
18 #include "lldb/Symbol/ObjectFile.h"
19 #include "lldb/Symbol/Symbol.h"
20 #include "lldb/Symbol/SymbolContext.h"
21 #include "lldb/Symbol/SymbolVendor.h"
22 #include "lldb/Target/Process.h"
23 #include "lldb/Target/SectionLoadList.h"
24 #include "lldb/Target/Target.h"
25 #include "lldb/Utility/DataBufferHeap.h"
26 #include "lldb/Utility/LLDBAssert.h"
27 #include "lldb/Utility/Log.h"
28 #include "lldb/Utility/StreamString.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 {
39   JIT_NOACTION = 0,
40   JIT_REGISTER_FN,
41   JIT_UNREGISTER_FN
42 } jit_actions_t;
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 {
52   uint32_t version;
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 
60 enum EnableJITLoaderGDB {
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() {
85     return JITLoaderGDB::GetPluginNameStatic();
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 
140 JITLoaderGDB::JITLoaderGDB(lldb_private::Process *process)
141     : JITLoader(process), m_jit_objects(),
142       m_jit_break_id(LLDB_INVALID_BREAK_ID),
143       m_jit_descriptor_addr(LLDB_INVALID_ADDRESS) {}
144 
145 JITLoaderGDB::~JITLoaderGDB() {
146   if (LLDB_BREAK_ID_IS_VALID(m_jit_break_id))
147     m_process->GetTarget().RemoveBreakpointByID(m_jit_break_id);
148 }
149 
150 void JITLoaderGDB::DebuggerInitialize(Debugger &debugger) {
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 
161 void JITLoaderGDB::DidAttach() {
162   Target &target = m_process->GetTarget();
163   ModuleList &module_list = target.GetImages();
164   SetJITBreakpoint(module_list);
165 }
166 
167 void JITLoaderGDB::DidLaunch() {
168   Target &target = m_process->GetTarget();
169   ModuleList &module_list = target.GetImages();
170   SetJITBreakpoint(module_list);
171 }
172 
173 void JITLoaderGDB::ModulesDidLoad(ModuleList &module_list) {
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 
183   Log *log(GetLogIfAnyCategoriesSet(LIBLLDB_LOG_JIT_LOADER));
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) {
217   Log *log(GetLogIfAnyCategoriesSet(LIBLLDB_LOG_JIT_LOADER));
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) {
271   if (m_process->GetTarget().GetArchitecture().GetAddressByteSize() == 8)
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 
282   Log *log(GetLogIfAnyCategoriesSet(LIBLLDB_LOG_JIT_LOADER));
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
405 lldb_private::ConstString JITLoaderGDB::GetPluginNameStatic() {
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 
430 const char *JITLoaderGDB::GetPluginDescriptionStatic() {
431   return "JIT loader plug-in that watches for JIT events using the GDB "
432          "interface.";
433 }
434 
435 lldb_private::ConstString JITLoaderGDB::GetPluginName() {
436   return GetPluginNameStatic();
437 }
438 
439 uint32_t JITLoaderGDB::GetPluginVersion() { return 1; }
440 
441 void JITLoaderGDB::Initialize() {
442   PluginManager::RegisterPlugin(GetPluginNameStatic(),
443                                 GetPluginDescriptionStatic(), CreateInstance,
444                                 DebuggerInitialize);
445 }
446 
447 void JITLoaderGDB::Terminate() {
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 }
475