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