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 §ion_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