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