contrib/llvm-project/lldb/source/Plugins/JITLoader/GDB/JITLoaderGDB.cpp

   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 &section_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 }