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