lldb/source/Plugins/JITLoader/GDB/JITLoaderGDB.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-exception
   6 //
   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
  33 using namespace lldb;
  34 using namespace lldb_private;
  35
  36 LLDB_PLUGIN_DEFINE(JITLoaderGDB)
  37
  38 // Debug Interface Structures
  39 enum jit_actions_t { JIT_NOACTION = 0, JIT_REGISTER_FN, JIT_UNREGISTER_FN };
  40
  41 template <typename ptr_t> struct jit_code_entry {
  42   ptr_t next_entry;   // pointer
  43   ptr_t prev_entry;   // pointer
  44   ptr_t symfile_addr; // pointer
  45   uint64_t symfile_size;
  46 };
  47
  48 template <typename ptr_t> struct jit_descriptor {
  49   uint32_t version;
  50   uint32_t action_flag; // Values are jit_action_t
  51   ptr_t relevant_entry; // pointer
  52   ptr_t first_entry;    // pointer
  53 };
  54
  55 namespace {
  56 enum EnableJITLoaderGDB {
  57   eEnableJITLoaderGDBDefault,
  58   eEnableJITLoaderGDBOn,
  59   eEnableJITLoaderGDBOff,
  60 };
  61
  62 static 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_jitloadergdb
  82 #include "JITLoaderGDBProperties.inc"
  83
  84 enum {
  85 #define LLDB_PROPERTIES_jitloadergdb
  86 #include "JITLoaderGDBPropertiesEnum.inc"
  87   ePropertyEnableJITBreakpoint
  88 };
  89
  90 class PluginProperties : public Properties {
  91 public:
  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 } // namespace
 109
 110 static PluginProperties &GetGlobalPluginProperties() {
 111   static PluginProperties g_settings;
 112   return g_settings;
 113 }
 114
 115 template <typename ptr_t>
 116 static 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
 146 JITLoaderGDB::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
 151 JITLoaderGDB::~JITLoaderGDB() {
 152   if (LLDB_BREAK_ID_IS_VALID(m_jit_break_id))
 153     m_process->GetTarget().RemoveBreakpointByID(m_jit_break_id);
 154 }
 155
 156 void 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
 166 void JITLoaderGDB::DidAttach() {
 167   Target &target = m_process->GetTarget();
 168   ModuleList &module_list = target.GetImages();
 169   SetJITBreakpoint(module_list);
 170 }
 171
 172 void JITLoaderGDB::DidLaunch() {
 173   Target &target = m_process->GetTarget();
 174   ModuleList &module_list = target.GetImages();
 175   SetJITBreakpoint(module_list);
 176 }
 177
 178 void JITLoaderGDB::ModulesDidLoad(ModuleList &module_list) {
 179   if (!DidSetJITBreakpoint() && m_process->IsAlive())
 180     SetJITBreakpoint(module_list);
 181 }
 182
 183 // Setup the JIT Breakpoint
 184 void 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
 216 bool 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
 226 static void updateSectionLoadAddress(const SectionList &section_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 heuristic
 266         vmaddrheuristic += section_sp->GetByteSize();
 267       }
 268     }
 269   }
 270 }
 271
 272 bool JITLoaderGDB::ReadJITDescriptor(bool all_entries) {
 273   if (m_process->GetTarget().GetArchitecture().GetAddressByteSize() == 8)
 274     return ReadJITDescriptorImpl<uint64_t>(all_entries);
 275   else
 276     return ReadJITDescriptorImpl<uint32_t>(all_entries);
 277 }
 278
 279 template <typename ptr_t>
 280 bool 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%" PRIx64
 321                 " (%" 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 away
 335         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.GetSectionLoadList().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 do
 390     } else {
 391       assert(false && "Unknown jit action");
 392     }
 393
 394     if (all_entries)
 395       jit_relevant_entry = (addr_t)jit_entry.next_entry;
 396     else
 397       jit_relevant_entry = 0;
 398   }
 399
 400   return false; // Continue Running.
 401 }
 402
 403 // PluginInterface protocol
 404 JITLoaderSP 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
 424 llvm::StringRef JITLoaderGDB::GetPluginDescriptionStatic() {
 425   return "JIT loader plug-in that watches for JIT events using the GDB "
 426          "interface.";
 427 }
 428
 429 void JITLoaderGDB::Initialize() {
 430   PluginManager::RegisterPlugin(GetPluginNameStatic(),
 431                                 GetPluginDescriptionStatic(), CreateInstance,
 432                                 DebuggerInitialize);
 433 }
 434
 435 void JITLoaderGDB::Terminate() {
 436   PluginManager::UnregisterPlugin(CreateInstance);
 437 }
 438
 439 bool JITLoaderGDB::DidSetJITBreakpoint() const {
 440   return LLDB_BREAK_ID_IS_VALID(m_jit_break_id);
 441 }
 442
 443 addr_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 }