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 enum jit_actions_t { JIT_NOACTION = 0, JIT_REGISTER_FN, JIT_UNREGISTER_FN }; 39 40 template <typename ptr_t> struct jit_code_entry { 41 ptr_t next_entry; // pointer 42 ptr_t prev_entry; // pointer 43 ptr_t symfile_addr; // pointer 44 uint64_t symfile_size; 45 }; 46 47 template <typename ptr_t> struct jit_descriptor { 48 uint32_t version; 49 uint32_t action_flag; // Values are jit_action_t 50 ptr_t relevant_entry; // pointer 51 ptr_t first_entry; // pointer 52 }; 53 54 namespace { 55 56 enum EnableJITLoaderGDB { 57 eEnableJITLoaderGDBDefault, 58 eEnableJITLoaderGDBOn, 59 eEnableJITLoaderGDBOff, 60 }; 61 62 static constexpr OptionEnumValueElement g_enable_jit_loader_gdb_enumerators[] = { 63 {eEnableJITLoaderGDBDefault, "default", "Enable JIT compilation interface " 64 "for all platforms except macOS"}, 65 {eEnableJITLoaderGDBOn, "on", "Enable JIT compilation interface"}, 66 {eEnableJITLoaderGDBOff, "off", "Disable JIT compilation interface"} 67 }; 68 69 static constexpr PropertyDefinition g_properties[] = { 70 {"enable", OptionValue::eTypeEnum, true, 71 eEnableJITLoaderGDBDefault, nullptr, 72 OptionEnumValues(g_enable_jit_loader_gdb_enumerators), 73 "Enable GDB's JIT compilation interface (default: enabled on " 74 "all platforms except macOS)"}}; 75 76 enum { ePropertyEnable, ePropertyEnableJITBreakpoint }; 77 78 class PluginProperties : public Properties { 79 public: 80 static ConstString GetSettingName() { 81 return JITLoaderGDB::GetPluginNameStatic(); 82 } 83 84 PluginProperties() { 85 m_collection_sp = std::make_shared<OptionValueProperties>(GetSettingName()); 86 m_collection_sp->Initialize(g_properties); 87 } 88 89 EnableJITLoaderGDB GetEnable() const { 90 return (EnableJITLoaderGDB)m_collection_sp->GetPropertyAtIndexAsEnumeration( 91 nullptr, ePropertyEnable, 92 g_properties[ePropertyEnable].default_uint_value); 93 } 94 }; 95 96 typedef std::shared_ptr<PluginProperties> JITLoaderGDBPropertiesSP; 97 98 static const JITLoaderGDBPropertiesSP &GetGlobalPluginProperties() { 99 static const auto g_settings_sp(std::make_shared<PluginProperties>()); 100 return g_settings_sp; 101 } 102 103 template <typename ptr_t> 104 bool ReadJITEntry(const addr_t from_addr, Process *process, 105 jit_code_entry<ptr_t> *entry) { 106 lldbassert(from_addr % sizeof(ptr_t) == 0); 107 108 ArchSpec::Core core = process->GetTarget().GetArchitecture().GetCore(); 109 bool i386_target = ArchSpec::kCore_x86_32_first <= core && 110 core <= ArchSpec::kCore_x86_32_last; 111 uint8_t uint64_align_bytes = i386_target ? 4 : 8; 112 const size_t data_byte_size = 113 llvm::alignTo(sizeof(ptr_t) * 3, uint64_align_bytes) + sizeof(uint64_t); 114 115 Status error; 116 DataBufferHeap data(data_byte_size, 0); 117 size_t bytes_read = process->ReadMemory(from_addr, data.GetBytes(), 118 data.GetByteSize(), error); 119 if (bytes_read != data_byte_size || !error.Success()) 120 return false; 121 122 DataExtractor extractor(data.GetBytes(), data.GetByteSize(), 123 process->GetByteOrder(), sizeof(ptr_t)); 124 lldb::offset_t offset = 0; 125 entry->next_entry = extractor.GetPointer(&offset); 126 entry->prev_entry = extractor.GetPointer(&offset); 127 entry->symfile_addr = extractor.GetPointer(&offset); 128 offset = llvm::alignTo(offset, uint64_align_bytes); 129 entry->symfile_size = extractor.GetU64(&offset); 130 131 return true; 132 } 133 134 } // anonymous namespace end 135 136 JITLoaderGDB::JITLoaderGDB(lldb_private::Process *process) 137 : JITLoader(process), m_jit_objects(), 138 m_jit_break_id(LLDB_INVALID_BREAK_ID), 139 m_jit_descriptor_addr(LLDB_INVALID_ADDRESS) {} 140 141 JITLoaderGDB::~JITLoaderGDB() { 142 if (LLDB_BREAK_ID_IS_VALID(m_jit_break_id)) 143 m_process->GetTarget().RemoveBreakpointByID(m_jit_break_id); 144 } 145 146 void JITLoaderGDB::DebuggerInitialize(Debugger &debugger) { 147 if (!PluginManager::GetSettingForJITLoaderPlugin( 148 debugger, PluginProperties::GetSettingName())) { 149 const bool is_global_setting = true; 150 PluginManager::CreateSettingForJITLoaderPlugin( 151 debugger, GetGlobalPluginProperties()->GetValueProperties(), 152 ConstString("Properties for the JIT LoaderGDB plug-in."), 153 is_global_setting); 154 } 155 } 156 157 void JITLoaderGDB::DidAttach() { 158 Target &target = m_process->GetTarget(); 159 ModuleList &module_list = target.GetImages(); 160 SetJITBreakpoint(module_list); 161 } 162 163 void JITLoaderGDB::DidLaunch() { 164 Target &target = m_process->GetTarget(); 165 ModuleList &module_list = target.GetImages(); 166 SetJITBreakpoint(module_list); 167 } 168 169 void JITLoaderGDB::ModulesDidLoad(ModuleList &module_list) { 170 if (!DidSetJITBreakpoint() && m_process->IsAlive()) 171 SetJITBreakpoint(module_list); 172 } 173 174 // Setup the JIT Breakpoint 175 void JITLoaderGDB::SetJITBreakpoint(lldb_private::ModuleList &module_list) { 176 if (DidSetJITBreakpoint()) 177 return; 178 179 Log *log(GetLogIfAnyCategoriesSet(LIBLLDB_LOG_JIT_LOADER)); 180 if (log) 181 log->Printf("JITLoaderGDB::%s looking for JIT register hook", __FUNCTION__); 182 183 addr_t jit_addr = GetSymbolAddress( 184 module_list, ConstString("__jit_debug_register_code"), eSymbolTypeAny); 185 if (jit_addr == LLDB_INVALID_ADDRESS) 186 return; 187 188 m_jit_descriptor_addr = GetSymbolAddress( 189 module_list, ConstString("__jit_debug_descriptor"), eSymbolTypeData); 190 if (m_jit_descriptor_addr == LLDB_INVALID_ADDRESS) { 191 if (log) 192 log->Printf("JITLoaderGDB::%s failed to find JIT descriptor address", 193 __FUNCTION__); 194 return; 195 } 196 197 if (log) 198 log->Printf("JITLoaderGDB::%s setting JIT breakpoint", __FUNCTION__); 199 200 Breakpoint *bp = 201 m_process->GetTarget().CreateBreakpoint(jit_addr, true, false).get(); 202 bp->SetCallback(JITDebugBreakpointHit, this, true); 203 bp->SetBreakpointKind("jit-debug-register"); 204 m_jit_break_id = bp->GetID(); 205 206 ReadJITDescriptor(true); 207 } 208 209 bool JITLoaderGDB::JITDebugBreakpointHit(void *baton, 210 StoppointCallbackContext *context, 211 user_id_t break_id, 212 user_id_t break_loc_id) { 213 Log *log(GetLogIfAnyCategoriesSet(LIBLLDB_LOG_JIT_LOADER)); 214 if (log) 215 log->Printf("JITLoaderGDB::%s hit JIT breakpoint", __FUNCTION__); 216 JITLoaderGDB *instance = static_cast<JITLoaderGDB *>(baton); 217 return instance->ReadJITDescriptor(false); 218 } 219 220 static void updateSectionLoadAddress(const SectionList §ion_list, 221 Target &target, uint64_t symbolfile_addr, 222 uint64_t symbolfile_size, 223 uint64_t &vmaddrheuristic, 224 uint64_t &min_addr, uint64_t &max_addr) { 225 const uint32_t num_sections = section_list.GetSize(); 226 for (uint32_t i = 0; i < num_sections; ++i) { 227 SectionSP section_sp(section_list.GetSectionAtIndex(i)); 228 if (section_sp) { 229 if (section_sp->IsFake()) { 230 uint64_t lower = (uint64_t)-1; 231 uint64_t upper = 0; 232 updateSectionLoadAddress(section_sp->GetChildren(), target, 233 symbolfile_addr, symbolfile_size, 234 vmaddrheuristic, lower, upper); 235 if (lower < min_addr) 236 min_addr = lower; 237 if (upper > max_addr) 238 max_addr = upper; 239 const lldb::addr_t slide_amount = lower - section_sp->GetFileAddress(); 240 section_sp->Slide(slide_amount, false); 241 section_sp->GetChildren().Slide(-slide_amount, false); 242 section_sp->SetByteSize(upper - lower); 243 } else { 244 vmaddrheuristic += 2 << section_sp->GetLog2Align(); 245 uint64_t lower; 246 if (section_sp->GetFileAddress() > vmaddrheuristic) 247 lower = section_sp->GetFileAddress(); 248 else { 249 lower = symbolfile_addr + section_sp->GetFileOffset(); 250 section_sp->SetFileAddress(symbolfile_addr + 251 section_sp->GetFileOffset()); 252 } 253 target.SetSectionLoadAddress(section_sp, lower, true); 254 uint64_t upper = lower + section_sp->GetByteSize(); 255 if (lower < min_addr) 256 min_addr = lower; 257 if (upper > max_addr) 258 max_addr = upper; 259 // This is an upper bound, but a good enough heuristic 260 vmaddrheuristic += section_sp->GetByteSize(); 261 } 262 } 263 } 264 } 265 266 bool JITLoaderGDB::ReadJITDescriptor(bool all_entries) { 267 if (m_process->GetTarget().GetArchitecture().GetAddressByteSize() == 8) 268 return ReadJITDescriptorImpl<uint64_t>(all_entries); 269 else 270 return ReadJITDescriptorImpl<uint32_t>(all_entries); 271 } 272 273 template <typename ptr_t> 274 bool JITLoaderGDB::ReadJITDescriptorImpl(bool all_entries) { 275 if (m_jit_descriptor_addr == LLDB_INVALID_ADDRESS) 276 return false; 277 278 Log *log(GetLogIfAnyCategoriesSet(LIBLLDB_LOG_JIT_LOADER)); 279 Target &target = m_process->GetTarget(); 280 ModuleList &module_list = target.GetImages(); 281 282 jit_descriptor<ptr_t> jit_desc; 283 const size_t jit_desc_size = sizeof(jit_desc); 284 Status error; 285 size_t bytes_read = m_process->DoReadMemory(m_jit_descriptor_addr, &jit_desc, 286 jit_desc_size, error); 287 if (bytes_read != jit_desc_size || !error.Success()) { 288 if (log) 289 log->Printf("JITLoaderGDB::%s failed to read JIT descriptor", 290 __FUNCTION__); 291 return false; 292 } 293 294 jit_actions_t jit_action = (jit_actions_t)jit_desc.action_flag; 295 addr_t jit_relevant_entry = (addr_t)jit_desc.relevant_entry; 296 if (all_entries) { 297 jit_action = JIT_REGISTER_FN; 298 jit_relevant_entry = (addr_t)jit_desc.first_entry; 299 } 300 301 while (jit_relevant_entry != 0) { 302 jit_code_entry<ptr_t> jit_entry; 303 if (!ReadJITEntry(jit_relevant_entry, m_process, &jit_entry)) { 304 if (log) 305 log->Printf("JITLoaderGDB::%s failed to read JIT entry at 0x%" PRIx64, 306 __FUNCTION__, jit_relevant_entry); 307 return false; 308 } 309 310 const addr_t &symbolfile_addr = (addr_t)jit_entry.symfile_addr; 311 const size_t &symbolfile_size = (size_t)jit_entry.symfile_size; 312 ModuleSP module_sp; 313 314 if (jit_action == JIT_REGISTER_FN) { 315 if (log) 316 log->Printf("JITLoaderGDB::%s registering JIT entry at 0x%" PRIx64 317 " (%" PRIu64 " bytes)", 318 __FUNCTION__, symbolfile_addr, (uint64_t)symbolfile_size); 319 320 char jit_name[64]; 321 snprintf(jit_name, 64, "JIT(0x%" PRIx64 ")", symbolfile_addr); 322 module_sp = m_process->ReadModuleFromMemory( 323 FileSpec(jit_name), symbolfile_addr, symbolfile_size); 324 325 if (module_sp && module_sp->GetObjectFile()) { 326 // Object formats (like ELF) have no representation for a JIT type. 327 // We will get it wrong, if we deduce it from the header. 328 module_sp->GetObjectFile()->SetType(ObjectFile::eTypeJIT); 329 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