contrib/llvm-project/lldb/source/Expression/IRExecutionUnit.cpp

   1 //===-- IRExecutionUnit.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 #include "llvm/ExecutionEngine/ExecutionEngine.h"
  10 #include "llvm/ExecutionEngine/ObjectCache.h"
  11 #include "llvm/IR/Constants.h"
  12 #include "llvm/IR/LLVMContext.h"
  13 #include "llvm/IR/Module.h"
  14 #include "llvm/Support/SourceMgr.h"
  15 #include "llvm/Support/raw_ostream.h"
  16
  17 #include "lldb/Core/Debugger.h"
  18 #include "lldb/Core/Disassembler.h"
  19 #include "lldb/Core/Module.h"
  20 #include "lldb/Core/Section.h"
  21 #include "lldb/Expression/IRExecutionUnit.h"
  22 #include "lldb/Symbol/CompileUnit.h"
  23 #include "lldb/Symbol/SymbolContext.h"
  24 #include "lldb/Symbol/SymbolFile.h"
  25 #include "lldb/Symbol/SymbolVendor.h"
  26 #include "lldb/Target/ExecutionContext.h"
  27 #include "lldb/Target/LanguageRuntime.h"
  28 #include "lldb/Target/Target.h"
  29 #include "lldb/Utility/DataBufferHeap.h"
  30 #include "lldb/Utility/DataExtractor.h"
  31 #include "lldb/Utility/LLDBAssert.h"
  32 #include "lldb/Utility/Log.h"
  33
  34 #include "lldb/../../source/Plugins/Language/CPlusPlus/CPlusPlusLanguage.h"
  35 #include "lldb/../../source/Plugins/ObjectFile/JIT/ObjectFileJIT.h"
  36
  37 using namespace lldb_private;
  38
  39 IRExecutionUnit::IRExecutionUnit(std::unique_ptr<llvm::LLVMContext> &context_up,
  40                                  std::unique_ptr<llvm::Module> &module_up,
  41                                  ConstString &name,
  42                                  const lldb::TargetSP &target_sp,
  43                                  const SymbolContext &sym_ctx,
  44                                  std::vector<std::string> &cpu_features)
  45     : IRMemoryMap(target_sp), m_context_up(context_up.release()),
  46       m_module_up(module_up.release()), m_module(m_module_up.get()),
  47       m_cpu_features(cpu_features), m_name(name), m_sym_ctx(sym_ctx),
  48       m_did_jit(false), m_function_load_addr(LLDB_INVALID_ADDRESS),
  49       m_function_end_load_addr(LLDB_INVALID_ADDRESS),
  50       m_reported_allocations(false) {}
  51
  52 lldb::addr_t IRExecutionUnit::WriteNow(const uint8_t *bytes, size_t size,
  53                                        Status &error) {
  54   const bool zero_memory = false;
  55   lldb::addr_t allocation_process_addr =
  56       Malloc(size, 8, lldb::ePermissionsWritable | lldb::ePermissionsReadable,
  57              eAllocationPolicyMirror, zero_memory, error);
  58
  59   if (!error.Success())
  60     return LLDB_INVALID_ADDRESS;
  61
  62   WriteMemory(allocation_process_addr, bytes, size, error);
  63
  64   if (!error.Success()) {
  65     Status err;
  66     Free(allocation_process_addr, err);
  67
  68     return LLDB_INVALID_ADDRESS;
  69   }
  70
  71   if (Log *log =
  72           lldb_private::GetLogIfAllCategoriesSet(LIBLLDB_LOG_EXPRESSIONS)) {
  73     DataBufferHeap my_buffer(size, 0);
  74     Status err;
  75     ReadMemory(my_buffer.GetBytes(), allocation_process_addr, size, err);
  76
  77     if (err.Success()) {
  78       DataExtractor my_extractor(my_buffer.GetBytes(), my_buffer.GetByteSize(),
  79                                  lldb::eByteOrderBig, 8);
  80       my_extractor.PutToLog(log, 0, my_buffer.GetByteSize(),
  81                             allocation_process_addr, 16,
  82                             DataExtractor::TypeUInt8);
  83     }
  84   }
  85
  86   return allocation_process_addr;
  87 }
  88
  89 void IRExecutionUnit::FreeNow(lldb::addr_t allocation) {
  90   if (allocation == LLDB_INVALID_ADDRESS)
  91     return;
  92
  93   Status err;
  94
  95   Free(allocation, err);
  96 }
  97
  98 Status IRExecutionUnit::DisassembleFunction(Stream &stream,
  99                                             lldb::ProcessSP &process_wp) {
 100   Log *log(lldb_private::GetLogIfAllCategoriesSet(LIBLLDB_LOG_EXPRESSIONS));
 101
 102   ExecutionContext exe_ctx(process_wp);
 103
 104   Status ret;
 105
 106   ret.Clear();
 107
 108   lldb::addr_t func_local_addr = LLDB_INVALID_ADDRESS;
 109   lldb::addr_t func_remote_addr = LLDB_INVALID_ADDRESS;
 110
 111   for (JittedFunction &function : m_jitted_functions) {
 112     if (function.m_name == m_name) {
 113       func_local_addr = function.m_local_addr;
 114       func_remote_addr = function.m_remote_addr;
 115     }
 116   }
 117
 118   if (func_local_addr == LLDB_INVALID_ADDRESS) {
 119     ret.SetErrorToGenericError();
 120     ret.SetErrorStringWithFormat("Couldn't find function %s for disassembly",
 121                                  m_name.AsCString());
 122     return ret;
 123   }
 124
 125   if (log)
 126     log->Printf("Found function, has local address 0x%" PRIx64
 127                 " and remote address 0x%" PRIx64,
 128                 (uint64_t)func_local_addr, (uint64_t)func_remote_addr);
 129
 130   std::pair<lldb::addr_t, lldb::addr_t> func_range;
 131
 132   func_range = GetRemoteRangeForLocal(func_local_addr);
 133
 134   if (func_range.first == 0 && func_range.second == 0) {
 135     ret.SetErrorToGenericError();
 136     ret.SetErrorStringWithFormat("Couldn't find code range for function %s",
 137                                  m_name.AsCString());
 138     return ret;
 139   }
 140
 141   if (log)
 142     log->Printf("Function's code range is [0x%" PRIx64 "+0x%" PRIx64 "]",
 143                 func_range.first, func_range.second);
 144
 145   Target *target = exe_ctx.GetTargetPtr();
 146   if (!target) {
 147     ret.SetErrorToGenericError();
 148     ret.SetErrorString("Couldn't find the target");
 149     return ret;
 150   }
 151
 152   lldb::DataBufferSP buffer_sp(new DataBufferHeap(func_range.second, 0));
 153
 154   Process *process = exe_ctx.GetProcessPtr();
 155   Status err;
 156   process->ReadMemory(func_remote_addr, buffer_sp->GetBytes(),
 157                       buffer_sp->GetByteSize(), err);
 158
 159   if (!err.Success()) {
 160     ret.SetErrorToGenericError();
 161     ret.SetErrorStringWithFormat("Couldn't read from process: %s",
 162                                  err.AsCString("unknown error"));
 163     return ret;
 164   }
 165
 166   ArchSpec arch(target->GetArchitecture());
 167
 168   const char *plugin_name = nullptr;
 169   const char *flavor_string = nullptr;
 170   lldb::DisassemblerSP disassembler_sp =
 171       Disassembler::FindPlugin(arch, flavor_string, plugin_name);
 172
 173   if (!disassembler_sp) {
 174     ret.SetErrorToGenericError();
 175     ret.SetErrorStringWithFormat(
 176         "Unable to find disassembler plug-in for %s architecture.",
 177         arch.GetArchitectureName());
 178     return ret;
 179   }
 180
 181   if (!process) {
 182     ret.SetErrorToGenericError();
 183     ret.SetErrorString("Couldn't find the process");
 184     return ret;
 185   }
 186
 187   DataExtractor extractor(buffer_sp, process->GetByteOrder(),
 188                           target->GetArchitecture().GetAddressByteSize());
 189
 190   if (log) {
 191     log->Printf("Function data has contents:");
 192     extractor.PutToLog(log, 0, extractor.GetByteSize(), func_remote_addr, 16,
 193                        DataExtractor::TypeUInt8);
 194   }
 195
 196   disassembler_sp->DecodeInstructions(Address(func_remote_addr), extractor, 0,
 197                                       UINT32_MAX, false, false);
 198
 199   InstructionList &instruction_list = disassembler_sp->GetInstructionList();
 200   instruction_list.Dump(&stream, true, true, &exe_ctx);
 201   return ret;
 202 }
 203
 204 static void ReportInlineAsmError(const llvm::SMDiagnostic &diagnostic,
 205                                  void *Context, unsigned LocCookie) {
 206   Status *err = static_cast<Status *>(Context);
 207
 208   if (err && err->Success()) {
 209     err->SetErrorToGenericError();
 210     err->SetErrorStringWithFormat("Inline assembly error: %s",
 211                                   diagnostic.getMessage().str().c_str());
 212   }
 213 }
 214
 215 void IRExecutionUnit::ReportSymbolLookupError(ConstString name) {
 216   m_failed_lookups.push_back(name);
 217 }
 218
 219 void IRExecutionUnit::GetRunnableInfo(Status &error, lldb::addr_t &func_addr,
 220                                       lldb::addr_t &func_end) {
 221   lldb::ProcessSP process_sp(GetProcessWP().lock());
 222
 223   static std::recursive_mutex s_runnable_info_mutex;
 224
 225   func_addr = LLDB_INVALID_ADDRESS;
 226   func_end = LLDB_INVALID_ADDRESS;
 227
 228   if (!process_sp) {
 229     error.SetErrorToGenericError();
 230     error.SetErrorString("Couldn't write the JIT compiled code into the "
 231                          "process because the process is invalid");
 232     return;
 233   }
 234
 235   if (m_did_jit) {
 236     func_addr = m_function_load_addr;
 237     func_end = m_function_end_load_addr;
 238
 239     return;
 240   };
 241
 242   std::lock_guard<std::recursive_mutex> guard(s_runnable_info_mutex);
 243
 244   m_did_jit = true;
 245
 246   Log *log(lldb_private::GetLogIfAllCategoriesSet(LIBLLDB_LOG_EXPRESSIONS));
 247
 248   std::string error_string;
 249
 250   if (log) {
 251     std::string s;
 252     llvm::raw_string_ostream oss(s);
 253
 254     m_module->print(oss, nullptr);
 255
 256     oss.flush();
 257
 258     log->Printf("Module being sent to JIT: \n%s", s.c_str());
 259   }
 260
 261   m_module_up->getContext().setInlineAsmDiagnosticHandler(ReportInlineAsmError,
 262                                                           &error);
 263
 264   llvm::EngineBuilder builder(std::move(m_module_up));
 265   llvm::Triple triple(m_module->getTargetTriple());
 266
 267   builder.setEngineKind(llvm::EngineKind::JIT)
 268       .setErrorStr(&error_string)
 269       .setRelocationModel(triple.isOSBinFormatMachO()
 270                               ? llvm::Reloc::PIC_
 271                               : llvm::Reloc::Static)
 272       .setMCJITMemoryManager(
 273           std::unique_ptr<MemoryManager>(new MemoryManager(*this)))
 274       .setOptLevel(llvm::CodeGenOpt::Less);
 275
 276   llvm::StringRef mArch;
 277   llvm::StringRef mCPU;
 278   llvm::SmallVector<std::string, 0> mAttrs;
 279
 280   for (std::string &feature : m_cpu_features)
 281     mAttrs.push_back(feature);
 282
 283   llvm::TargetMachine *target_machine =
 284       builder.selectTarget(triple, mArch, mCPU, mAttrs);
 285
 286   m_execution_engine_up.reset(builder.create(target_machine));
 287
 288   if (!m_execution_engine_up) {
 289     error.SetErrorToGenericError();
 290     error.SetErrorStringWithFormat("Couldn't JIT the function: %s",
 291                                    error_string.c_str());
 292     return;
 293   }
 294
 295   m_strip_underscore =
 296       (m_execution_engine_up->getDataLayout().getGlobalPrefix() == '_');
 297
 298   class ObjectDumper : public llvm::ObjectCache {
 299   public:
 300     void notifyObjectCompiled(const llvm::Module *module,
 301                               llvm::MemoryBufferRef object) override {
 302       int fd = 0;
 303       llvm::SmallVector<char, 256> result_path;
 304       std::string object_name_model =
 305           "jit-object-" + module->getModuleIdentifier() + "-%%%.o";
 306       (void)llvm::sys::fs::createUniqueFile(object_name_model, fd, result_path);
 307       llvm::raw_fd_ostream fds(fd, true);
 308       fds.write(object.getBufferStart(), object.getBufferSize());
 309     }
 310
 311     std::unique_ptr<llvm::MemoryBuffer>
 312     getObject(const llvm::Module *module) override {
 313       // Return nothing - we're just abusing the object-cache mechanism to dump
 314       // objects.
 315       return nullptr;
 316     }
 317   };
 318
 319   if (process_sp->GetTarget().GetEnableSaveObjects()) {
 320     m_object_cache_up = llvm::make_unique<ObjectDumper>();
 321     m_execution_engine_up->setObjectCache(m_object_cache_up.get());
 322   }
 323
 324   // Make sure we see all sections, including ones that don't have
 325   // relocations...
 326   m_execution_engine_up->setProcessAllSections(true);
 327
 328   m_execution_engine_up->DisableLazyCompilation();
 329
 330   for (llvm::Function &function : *m_module) {
 331     if (function.isDeclaration() || function.hasPrivateLinkage())
 332       continue;
 333
 334     const bool external =
 335         function.hasExternalLinkage() || function.hasLinkOnceODRLinkage();
 336
 337     void *fun_ptr = m_execution_engine_up->getPointerToFunction(&function);
 338
 339     if (!error.Success()) {
 340       // We got an error through our callback!
 341       return;
 342     }
 343
 344     if (!fun_ptr) {
 345       error.SetErrorToGenericError();
 346       error.SetErrorStringWithFormat(
 347           "'%s' was in the JITted module but wasn't lowered",
 348           function.getName().str().c_str());
 349       return;
 350     }
 351     m_jitted_functions.push_back(JittedFunction(
 352         function.getName().str().c_str(), external, (lldb::addr_t)fun_ptr));
 353   }
 354
 355   CommitAllocations(process_sp);
 356   ReportAllocations(*m_execution_engine_up);
 357
 358   // We have to do this after calling ReportAllocations because for the MCJIT,
 359   // getGlobalValueAddress will cause the JIT to perform all relocations.  That
 360   // can only be done once, and has to happen after we do the remapping from
 361   // local -> remote. That means we don't know the local address of the
 362   // Variables, but we don't need that for anything, so that's okay.
 363
 364   std::function<void(llvm::GlobalValue &)> RegisterOneValue = [this](
 365       llvm::GlobalValue &val) {
 366     if (val.hasExternalLinkage() && !val.isDeclaration()) {
 367       uint64_t var_ptr_addr =
 368           m_execution_engine_up->getGlobalValueAddress(val.getName().str());
 369
 370       lldb::addr_t remote_addr = GetRemoteAddressForLocal(var_ptr_addr);
 371
 372       // This is a really unfortunae API that sometimes returns local addresses
 373       // and sometimes returns remote addresses, based on whether the variable
 374       // was relocated during ReportAllocations or not.
 375
 376       if (remote_addr == LLDB_INVALID_ADDRESS) {
 377         remote_addr = var_ptr_addr;
 378       }
 379
 380       if (var_ptr_addr != 0)
 381         m_jitted_global_variables.push_back(JittedGlobalVariable(
 382             val.getName().str().c_str(), LLDB_INVALID_ADDRESS, remote_addr));
 383     }
 384   };
 385
 386   for (llvm::GlobalVariable &global_var : m_module->getGlobalList()) {
 387     RegisterOneValue(global_var);
 388   }
 389
 390   for (llvm::GlobalAlias &global_alias : m_module->getAliasList()) {
 391     RegisterOneValue(global_alias);
 392   }
 393
 394   WriteData(process_sp);
 395
 396   if (m_failed_lookups.size()) {
 397     StreamString ss;
 398
 399     ss.PutCString("Couldn't lookup symbols:\n");
 400
 401     bool emitNewLine = false;
 402
 403     for (ConstString failed_lookup : m_failed_lookups) {
 404       if (emitNewLine)
 405         ss.PutCString("\n");
 406       emitNewLine = true;
 407       ss.PutCString("  ");
 408       ss.PutCString(Mangled(failed_lookup)
 409                         .GetDemangledName(lldb::eLanguageTypeObjC_plus_plus)
 410                         .AsCString());
 411     }
 412
 413     m_failed_lookups.clear();
 414
 415     error.SetErrorString(ss.GetString());
 416
 417     return;
 418   }
 419
 420   m_function_load_addr = LLDB_INVALID_ADDRESS;
 421   m_function_end_load_addr = LLDB_INVALID_ADDRESS;
 422
 423   for (JittedFunction &jitted_function : m_jitted_functions) {
 424     jitted_function.m_remote_addr =
 425         GetRemoteAddressForLocal(jitted_function.m_local_addr);
 426
 427     if (!m_name.IsEmpty() && jitted_function.m_name == m_name) {
 428       AddrRange func_range =
 429           GetRemoteRangeForLocal(jitted_function.m_local_addr);
 430       m_function_end_load_addr = func_range.first + func_range.second;
 431       m_function_load_addr = jitted_function.m_remote_addr;
 432     }
 433   }
 434
 435   if (log) {
 436     log->Printf("Code can be run in the target.");
 437
 438     StreamString disassembly_stream;
 439
 440     Status err = DisassembleFunction(disassembly_stream, process_sp);
 441
 442     if (!err.Success()) {
 443       log->Printf("Couldn't disassemble function : %s",
 444                   err.AsCString("unknown error"));
 445     } else {
 446       log->Printf("Function disassembly:\n%s", disassembly_stream.GetData());
 447     }
 448
 449     log->Printf("Sections: ");
 450     for (AllocationRecord &record : m_records) {
 451       if (record.m_process_address != LLDB_INVALID_ADDRESS) {
 452         record.dump(log);
 453
 454         DataBufferHeap my_buffer(record.m_size, 0);
 455         Status err;
 456         ReadMemory(my_buffer.GetBytes(), record.m_process_address,
 457                    record.m_size, err);
 458
 459         if (err.Success()) {
 460           DataExtractor my_extractor(my_buffer.GetBytes(),
 461                                      my_buffer.GetByteSize(),
 462                                      lldb::eByteOrderBig, 8);
 463           my_extractor.PutToLog(log, 0, my_buffer.GetByteSize(),
 464                                 record.m_process_address, 16,
 465                                 DataExtractor::TypeUInt8);
 466         }
 467       } else {
 468         record.dump(log);
 469
 470         DataExtractor my_extractor((const void *)record.m_host_address,
 471                                    record.m_size, lldb::eByteOrderBig, 8);
 472         my_extractor.PutToLog(log, 0, record.m_size, record.m_host_address, 16,
 473                               DataExtractor::TypeUInt8);
 474       }
 475     }
 476   }
 477
 478   func_addr = m_function_load_addr;
 479   func_end = m_function_end_load_addr;
 480
 481   return;
 482 }
 483
 484 IRExecutionUnit::~IRExecutionUnit() {
 485   m_module_up.reset();
 486   m_execution_engine_up.reset();
 487   m_context_up.reset();
 488 }
 489
 490 IRExecutionUnit::MemoryManager::MemoryManager(IRExecutionUnit &parent)
 491     : m_default_mm_up(new llvm::SectionMemoryManager()), m_parent(parent) {}
 492
 493 IRExecutionUnit::MemoryManager::~MemoryManager() {}
 494
 495 lldb::SectionType IRExecutionUnit::GetSectionTypeFromSectionName(
 496     const llvm::StringRef &name, IRExecutionUnit::AllocationKind alloc_kind) {
 497   lldb::SectionType sect_type = lldb::eSectionTypeCode;
 498   switch (alloc_kind) {
 499   case AllocationKind::Stub:
 500     sect_type = lldb::eSectionTypeCode;
 501     break;
 502   case AllocationKind::Code:
 503     sect_type = lldb::eSectionTypeCode;
 504     break;
 505   case AllocationKind::Data:
 506     sect_type = lldb::eSectionTypeData;
 507     break;
 508   case AllocationKind::Global:
 509     sect_type = lldb::eSectionTypeData;
 510     break;
 511   case AllocationKind::Bytes:
 512     sect_type = lldb::eSectionTypeOther;
 513     break;
 514   }
 515
 516   if (!name.empty()) {
 517     if (name.equals("__text") || name.equals(".text"))
 518       sect_type = lldb::eSectionTypeCode;
 519     else if (name.equals("__data") || name.equals(".data"))
 520       sect_type = lldb::eSectionTypeCode;
 521     else if (name.startswith("__debug_") || name.startswith(".debug_")) {
 522       const uint32_t name_idx = name[0] == '_' ? 8 : 7;
 523       llvm::StringRef dwarf_name(name.substr(name_idx));
 524       switch (dwarf_name[0]) {
 525       case 'a':
 526         if (dwarf_name.equals("abbrev"))
 527           sect_type = lldb::eSectionTypeDWARFDebugAbbrev;
 528         else if (dwarf_name.equals("aranges"))
 529           sect_type = lldb::eSectionTypeDWARFDebugAranges;
 530         else if (dwarf_name.equals("addr"))
 531           sect_type = lldb::eSectionTypeDWARFDebugAddr;
 532         break;
 533
 534       case 'f':
 535         if (dwarf_name.equals("frame"))
 536           sect_type = lldb::eSectionTypeDWARFDebugFrame;
 537         break;
 538
 539       case 'i':
 540         if (dwarf_name.equals("info"))
 541           sect_type = lldb::eSectionTypeDWARFDebugInfo;
 542         break;
 543
 544       case 'l':
 545         if (dwarf_name.equals("line"))
 546           sect_type = lldb::eSectionTypeDWARFDebugLine;
 547         else if (dwarf_name.equals("loc"))
 548           sect_type = lldb::eSectionTypeDWARFDebugLoc;
 549         else if (dwarf_name.equals("loclists"))
 550           sect_type = lldb::eSectionTypeDWARFDebugLocLists;
 551         break;
 552
 553       case 'm':
 554         if (dwarf_name.equals("macinfo"))
 555           sect_type = lldb::eSectionTypeDWARFDebugMacInfo;
 556         break;
 557
 558       case 'p':
 559         if (dwarf_name.equals("pubnames"))
 560           sect_type = lldb::eSectionTypeDWARFDebugPubNames;
 561         else if (dwarf_name.equals("pubtypes"))
 562           sect_type = lldb::eSectionTypeDWARFDebugPubTypes;
 563         break;
 564
 565       case 's':
 566         if (dwarf_name.equals("str"))
 567           sect_type = lldb::eSectionTypeDWARFDebugStr;
 568         else if (dwarf_name.equals("str_offsets"))
 569           sect_type = lldb::eSectionTypeDWARFDebugStrOffsets;
 570         break;
 571
 572       case 'r':
 573         if (dwarf_name.equals("ranges"))
 574           sect_type = lldb::eSectionTypeDWARFDebugRanges;
 575         break;
 576
 577       default:
 578         break;
 579       }
 580     } else if (name.startswith("__apple_") || name.startswith(".apple_"))
 581       sect_type = lldb::eSectionTypeInvalid;
 582     else if (name.equals("__objc_imageinfo"))
 583       sect_type = lldb::eSectionTypeOther;
 584   }
 585   return sect_type;
 586 }
 587
 588 uint8_t *IRExecutionUnit::MemoryManager::allocateCodeSection(
 589     uintptr_t Size, unsigned Alignment, unsigned SectionID,
 590     llvm::StringRef SectionName) {
 591   Log *log(lldb_private::GetLogIfAllCategoriesSet(LIBLLDB_LOG_EXPRESSIONS));
 592
 593   uint8_t *return_value = m_default_mm_up->allocateCodeSection(
 594       Size, Alignment, SectionID, SectionName);
 595
 596   m_parent.m_records.push_back(AllocationRecord(
 597       (uintptr_t)return_value,
 598       lldb::ePermissionsReadable | lldb::ePermissionsExecutable,
 599       GetSectionTypeFromSectionName(SectionName, AllocationKind::Code), Size,
 600       Alignment, SectionID, SectionName.str().c_str()));
 601
 602   if (log) {
 603     log->Printf("IRExecutionUnit::allocateCodeSection(Size=0x%" PRIx64
 604                 ", Alignment=%u, SectionID=%u) = %p",
 605                 (uint64_t)Size, Alignment, SectionID, (void *)return_value);
 606   }
 607
 608   if (m_parent.m_reported_allocations) {
 609     Status err;
 610     lldb::ProcessSP process_sp =
 611         m_parent.GetBestExecutionContextScope()->CalculateProcess();
 612
 613     m_parent.CommitOneAllocation(process_sp, err, m_parent.m_records.back());
 614   }
 615
 616   return return_value;
 617 }
 618
 619 uint8_t *IRExecutionUnit::MemoryManager::allocateDataSection(
 620     uintptr_t Size, unsigned Alignment, unsigned SectionID,
 621     llvm::StringRef SectionName, bool IsReadOnly) {
 622   Log *log(lldb_private::GetLogIfAllCategoriesSet(LIBLLDB_LOG_EXPRESSIONS));
 623
 624   uint8_t *return_value = m_default_mm_up->allocateDataSection(
 625       Size, Alignment, SectionID, SectionName, IsReadOnly);
 626
 627   uint32_t permissions = lldb::ePermissionsReadable;
 628   if (!IsReadOnly)
 629     permissions |= lldb::ePermissionsWritable;
 630   m_parent.m_records.push_back(AllocationRecord(
 631       (uintptr_t)return_value, permissions,
 632       GetSectionTypeFromSectionName(SectionName, AllocationKind::Data), Size,
 633       Alignment, SectionID, SectionName.str().c_str()));
 634   if (log) {
 635     log->Printf("IRExecutionUnit::allocateDataSection(Size=0x%" PRIx64
 636                 ", Alignment=%u, SectionID=%u) = %p",
 637                 (uint64_t)Size, Alignment, SectionID, (void *)return_value);
 638   }
 639
 640   if (m_parent.m_reported_allocations) {
 641     Status err;
 642     lldb::ProcessSP process_sp =
 643         m_parent.GetBestExecutionContextScope()->CalculateProcess();
 644
 645     m_parent.CommitOneAllocation(process_sp, err, m_parent.m_records.back());
 646   }
 647
 648   return return_value;
 649 }
 650
 651 static ConstString
 652 FindBestAlternateMangledName(ConstString demangled,
 653                              const lldb::LanguageType &lang_type,
 654                              const SymbolContext &sym_ctx) {
 655   CPlusPlusLanguage::MethodName cpp_name(demangled);
 656   std::string scope_qualified_name = cpp_name.GetScopeQualifiedName();
 657
 658   if (!scope_qualified_name.size())
 659     return ConstString();
 660
 661   if (!sym_ctx.module_sp)
 662     return ConstString();
 663
 664   SymbolVendor *sym_vendor = sym_ctx.module_sp->GetSymbolVendor();
 665   if (!sym_vendor)
 666     return ConstString();
 667
 668   lldb_private::SymbolFile *sym_file = sym_vendor->GetSymbolFile();
 669   if (!sym_file)
 670     return ConstString();
 671
 672   std::vector<ConstString> alternates;
 673   sym_file->GetMangledNamesForFunction(scope_qualified_name, alternates);
 674
 675   std::vector<ConstString> param_and_qual_matches;
 676   std::vector<ConstString> param_matches;
 677   for (size_t i = 0; i < alternates.size(); i++) {
 678     ConstString alternate_mangled_name = alternates[i];
 679     Mangled mangled(alternate_mangled_name, true);
 680     ConstString demangled = mangled.GetDemangledName(lang_type);
 681
 682     CPlusPlusLanguage::MethodName alternate_cpp_name(demangled);
 683     if (!cpp_name.IsValid())
 684       continue;
 685
 686     if (alternate_cpp_name.GetArguments() == cpp_name.GetArguments()) {
 687       if (alternate_cpp_name.GetQualifiers() == cpp_name.GetQualifiers())
 688         param_and_qual_matches.push_back(alternate_mangled_name);
 689       else
 690         param_matches.push_back(alternate_mangled_name);
 691     }
 692   }
 693
 694   if (param_and_qual_matches.size())
 695     return param_and_qual_matches[0]; // It is assumed that there will be only
 696                                       // one!
 697   else if (param_matches.size())
 698     return param_matches[0]; // Return one of them as a best match
 699   else
 700     return ConstString();
 701 }
 702
 703 struct IRExecutionUnit::SearchSpec {
 704   ConstString name;
 705   lldb::FunctionNameType mask;
 706
 707   SearchSpec(ConstString n,
 708              lldb::FunctionNameType m = lldb::eFunctionNameTypeFull)
 709       : name(n), mask(m) {}
 710 };
 711
 712 void IRExecutionUnit::CollectCandidateCNames(
 713     std::vector<IRExecutionUnit::SearchSpec> &C_specs,
 714     ConstString name) {
 715   if (m_strip_underscore && name.AsCString()[0] == '_')
 716     C_specs.insert(C_specs.begin(), ConstString(&name.AsCString()[1]));
 717   C_specs.push_back(SearchSpec(name));
 718 }
 719
 720 void IRExecutionUnit::CollectCandidateCPlusPlusNames(
 721     std::vector<IRExecutionUnit::SearchSpec> &CPP_specs,
 722     const std::vector<SearchSpec> &C_specs, const SymbolContext &sc) {
 723   for (const SearchSpec &C_spec : C_specs) {
 724     ConstString name = C_spec.name;
 725
 726     if (CPlusPlusLanguage::IsCPPMangledName(name.GetCString())) {
 727       Mangled mangled(name, true);
 728       ConstString demangled =
 729           mangled.GetDemangledName(lldb::eLanguageTypeC_plus_plus);
 730
 731       if (demangled) {
 732         ConstString best_alternate_mangled_name = FindBestAlternateMangledName(
 733             demangled, lldb::eLanguageTypeC_plus_plus, sc);
 734
 735         if (best_alternate_mangled_name) {
 736           CPP_specs.push_back(best_alternate_mangled_name);
 737         }
 738
 739         CPP_specs.push_back(SearchSpec(demangled, lldb::eFunctionNameTypeFull));
 740       }
 741     }
 742
 743     std::set<ConstString> alternates;
 744     CPlusPlusLanguage::FindAlternateFunctionManglings(name, alternates);
 745     CPP_specs.insert(CPP_specs.end(), alternates.begin(), alternates.end());
 746   }
 747 }
 748
 749 void IRExecutionUnit::CollectFallbackNames(
 750     std::vector<SearchSpec> &fallback_specs,
 751     const std::vector<SearchSpec> &C_specs) {
 752   // As a last-ditch fallback, try the base name for C++ names.  It's terrible,
 753   // but the DWARF doesn't always encode "extern C" correctly.
 754
 755   for (const SearchSpec &C_spec : C_specs) {
 756     ConstString name = C_spec.name;
 757
 758     if (CPlusPlusLanguage::IsCPPMangledName(name.GetCString())) {
 759       Mangled mangled_name(name);
 760       ConstString demangled_name =
 761           mangled_name.GetDemangledName(lldb::eLanguageTypeC_plus_plus);
 762       if (!demangled_name.IsEmpty()) {
 763         const char *demangled_cstr = demangled_name.AsCString();
 764         const char *lparen_loc = strchr(demangled_cstr, '(');
 765         if (lparen_loc) {
 766           llvm::StringRef base_name(demangled_cstr,
 767                                     lparen_loc - demangled_cstr);
 768           fallback_specs.push_back(ConstString(base_name));
 769         }
 770       }
 771     }
 772   }
 773 }
 774
 775 lldb::addr_t IRExecutionUnit::FindInSymbols(
 776     const std::vector<IRExecutionUnit::SearchSpec> &specs,
 777     const lldb_private::SymbolContext &sc,
 778     bool &symbol_was_missing_weak) {
 779   symbol_was_missing_weak = false;
 780   Target *target = sc.target_sp.get();
 781
 782   if (!target) {
 783     // we shouldn't be doing any symbol lookup at all without a target
 784     return LLDB_INVALID_ADDRESS;
 785   }
 786
 787   for (const SearchSpec &spec : specs) {
 788     SymbolContextList sc_list;
 789
 790     lldb::addr_t best_internal_load_address = LLDB_INVALID_ADDRESS;
 791
 792     std::function<bool(lldb::addr_t &, SymbolContextList &,
 793                        const lldb_private::SymbolContext &)>
 794         get_external_load_address = [&best_internal_load_address, target,
 795                                      &symbol_was_missing_weak](
 796             lldb::addr_t &load_address, SymbolContextList &sc_list,
 797             const lldb_private::SymbolContext &sc) -> lldb::addr_t {
 798       load_address = LLDB_INVALID_ADDRESS;
 799
 800       if (sc_list.GetSize() == 0)
 801         return false;
 802
 803       // missing_weak_symbol will be true only if we found only weak undefined
 804       // references to this symbol.
 805       symbol_was_missing_weak = true;
 806       for (auto candidate_sc : sc_list.SymbolContexts()) {
 807         // Only symbols can be weak undefined:
 808         if (!candidate_sc.symbol)
 809           symbol_was_missing_weak = false;
 810         else if (candidate_sc.symbol->GetType() != lldb::eSymbolTypeUndefined
 811                   || !candidate_sc.symbol->IsWeak())
 812           symbol_was_missing_weak = false;
 813
 814         const bool is_external =
 815             (candidate_sc.function) ||
 816             (candidate_sc.symbol && candidate_sc.symbol->IsExternal());
 817         if (candidate_sc.symbol) {
 818           load_address = candidate_sc.symbol->ResolveCallableAddress(*target);
 819
 820           if (load_address == LLDB_INVALID_ADDRESS) {
 821             if (target->GetProcessSP())
 822               load_address =
 823                   candidate_sc.symbol->GetAddress().GetLoadAddress(target);
 824             else
 825               load_address = candidate_sc.symbol->GetAddress().GetFileAddress();
 826           }
 827         }
 828
 829         if (load_address == LLDB_INVALID_ADDRESS && candidate_sc.function) {
 830           if (target->GetProcessSP())
 831             load_address = candidate_sc.function->GetAddressRange()
 832                                .GetBaseAddress()
 833                                .GetLoadAddress(target);
 834           else
 835             load_address = candidate_sc.function->GetAddressRange()
 836                                .GetBaseAddress()
 837                                .GetFileAddress();
 838         }
 839
 840         if (load_address != LLDB_INVALID_ADDRESS) {
 841           if (is_external) {
 842             return true;
 843           } else if (best_internal_load_address == LLDB_INVALID_ADDRESS) {
 844             best_internal_load_address = load_address;
 845             load_address = LLDB_INVALID_ADDRESS;
 846           }
 847         }
 848       }
 849
 850       // You test the address of a weak symbol against NULL to see if it is
 851       // present.  So we should return 0 for a missing weak symbol.
 852       if (symbol_was_missing_weak) {
 853         load_address = 0;
 854         return true;
 855       }
 856
 857       return false;
 858     };
 859
 860     if (sc.module_sp) {
 861       sc.module_sp->FindFunctions(spec.name, nullptr, spec.mask,
 862                                   true,  // include_symbols
 863                                   false, // include_inlines
 864                                   true,  // append
 865                                   sc_list);
 866     }
 867
 868     lldb::addr_t load_address = LLDB_INVALID_ADDRESS;
 869
 870     if (get_external_load_address(load_address, sc_list, sc)) {
 871       return load_address;
 872     } else {
 873       sc_list.Clear();
 874     }
 875
 876     if (sc_list.GetSize() == 0 && sc.target_sp) {
 877       sc.target_sp->GetImages().FindFunctions(spec.name, spec.mask,
 878                                               true,  // include_symbols
 879                                               false, // include_inlines
 880                                               true,  // append
 881                                               sc_list);
 882     }
 883
 884     if (get_external_load_address(load_address, sc_list, sc)) {
 885       return load_address;
 886     } else {
 887       sc_list.Clear();
 888     }
 889
 890     if (sc_list.GetSize() == 0 && sc.target_sp) {
 891       sc.target_sp->GetImages().FindSymbolsWithNameAndType(
 892           spec.name, lldb::eSymbolTypeAny, sc_list);
 893     }
 894
 895     if (get_external_load_address(load_address, sc_list, sc)) {
 896       return load_address;
 897     }
 898     // if there are any searches we try after this, add an sc_list.Clear() in
 899     // an "else" clause here
 900
 901     if (best_internal_load_address != LLDB_INVALID_ADDRESS) {
 902       return best_internal_load_address;
 903     }
 904   }
 905
 906   return LLDB_INVALID_ADDRESS;
 907 }
 908
 909 lldb::addr_t
 910 IRExecutionUnit::FindInRuntimes(const std::vector<SearchSpec> &specs,
 911                                 const lldb_private::SymbolContext &sc) {
 912   lldb::TargetSP target_sp = sc.target_sp;
 913
 914   if (!target_sp) {
 915     return LLDB_INVALID_ADDRESS;
 916   }
 917
 918   lldb::ProcessSP process_sp = sc.target_sp->GetProcessSP();
 919
 920   if (!process_sp) {
 921     return LLDB_INVALID_ADDRESS;
 922   }
 923
 924   for (const SearchSpec &spec : specs) {
 925     for (LanguageRuntime *runtime : process_sp->GetLanguageRuntimes()) {
 926       lldb::addr_t symbol_load_addr = runtime->LookupRuntimeSymbol(spec.name);
 927
 928       if (symbol_load_addr != LLDB_INVALID_ADDRESS)
 929         return symbol_load_addr;
 930     }
 931   }
 932
 933   return LLDB_INVALID_ADDRESS;
 934 }
 935
 936 lldb::addr_t IRExecutionUnit::FindInUserDefinedSymbols(
 937     const std::vector<SearchSpec> &specs,
 938     const lldb_private::SymbolContext &sc) {
 939   lldb::TargetSP target_sp = sc.target_sp;
 940
 941   for (const SearchSpec &spec : specs) {
 942     lldb::addr_t symbol_load_addr = target_sp->GetPersistentSymbol(spec.name);
 943
 944     if (symbol_load_addr != LLDB_INVALID_ADDRESS)
 945       return symbol_load_addr;
 946   }
 947
 948   return LLDB_INVALID_ADDRESS;
 949 }
 950
 951 lldb::addr_t
 952 IRExecutionUnit::FindSymbol(lldb_private::ConstString name, bool &missing_weak) {
 953   std::vector<SearchSpec> candidate_C_names;
 954   std::vector<SearchSpec> candidate_CPlusPlus_names;
 955
 956   CollectCandidateCNames(candidate_C_names, name);
 957
 958   lldb::addr_t ret = FindInSymbols(candidate_C_names, m_sym_ctx, missing_weak);
 959   if (ret != LLDB_INVALID_ADDRESS)
 960     return ret;
 961
 962   // If we find the symbol in runtimes or user defined symbols it can't be
 963   // a missing weak symbol.
 964   missing_weak = false;
 965   ret = FindInRuntimes(candidate_C_names, m_sym_ctx);
 966   if (ret != LLDB_INVALID_ADDRESS)
 967     return ret;
 968
 969   ret = FindInUserDefinedSymbols(candidate_C_names, m_sym_ctx);
 970   if (ret != LLDB_INVALID_ADDRESS)
 971     return ret;
 972
 973   CollectCandidateCPlusPlusNames(candidate_CPlusPlus_names, candidate_C_names,
 974                                  m_sym_ctx);
 975   ret = FindInSymbols(candidate_CPlusPlus_names, m_sym_ctx, missing_weak);
 976   if (ret != LLDB_INVALID_ADDRESS)
 977     return ret;
 978
 979   std::vector<SearchSpec> candidate_fallback_names;
 980
 981   CollectFallbackNames(candidate_fallback_names, candidate_C_names);
 982   ret = FindInSymbols(candidate_fallback_names, m_sym_ctx, missing_weak);
 983
 984   return ret;
 985 }
 986
 987 void IRExecutionUnit::GetStaticInitializers(
 988     std::vector<lldb::addr_t> &static_initializers) {
 989   if (llvm::GlobalVariable *global_ctors =
 990           m_module->getNamedGlobal("llvm.global_ctors")) {
 991     if (llvm::ConstantArray *ctor_array = llvm::dyn_cast<llvm::ConstantArray>(
 992             global_ctors->getInitializer())) {
 993       for (llvm::Use &ctor_use : ctor_array->operands()) {
 994         if (llvm::ConstantStruct *ctor_struct =
 995                 llvm::dyn_cast<llvm::ConstantStruct>(ctor_use)) {
 996           lldbassert(ctor_struct->getNumOperands() ==
 997                      3); // this is standardized
 998           if (llvm::Function *ctor_function =
 999                   llvm::dyn_cast<llvm::Function>(ctor_struct->getOperand(1))) {
1000             ConstString ctor_function_name_cs(ctor_function->getName().str());
1001
1002             for (JittedFunction &jitted_function : m_jitted_functions) {
1003               if (ctor_function_name_cs == jitted_function.m_name) {
1004                 if (jitted_function.m_remote_addr != LLDB_INVALID_ADDRESS) {
1005                   static_initializers.push_back(jitted_function.m_remote_addr);
1006                 }
1007                 break;
1008               }
1009             }
1010           }
1011         }
1012       }
1013     }
1014   }
1015 }
1016
1017 llvm::JITSymbol
1018 IRExecutionUnit::MemoryManager::findSymbol(const std::string &Name) {
1019     bool missing_weak = false;
1020     uint64_t addr = GetSymbolAddressAndPresence(Name, missing_weak);
1021     // This is a weak symbol:
1022     if (missing_weak)
1023       return llvm::JITSymbol(addr,
1024           llvm::JITSymbolFlags::Exported | llvm::JITSymbolFlags::Weak);
1025     else
1026       return llvm::JITSymbol(addr, llvm::JITSymbolFlags::Exported);
1027 }
1028
1029 uint64_t
1030 IRExecutionUnit::MemoryManager::getSymbolAddress(const std::string &Name) {
1031   bool missing_weak = false;
1032   return GetSymbolAddressAndPresence(Name, missing_weak);
1033 }
1034
1035 uint64_t
1036 IRExecutionUnit::MemoryManager::GetSymbolAddressAndPresence(
1037     const std::string &Name, bool &missing_weak) {
1038   Log *log(lldb_private::GetLogIfAllCategoriesSet(LIBLLDB_LOG_EXPRESSIONS));
1039
1040   ConstString name_cs(Name.c_str());
1041
1042   lldb::addr_t ret = m_parent.FindSymbol(name_cs, missing_weak);
1043
1044   if (ret == LLDB_INVALID_ADDRESS) {
1045     if (log)
1046       log->Printf(
1047           "IRExecutionUnit::getSymbolAddress(Name=\"%s\") = <not found>",
1048           Name.c_str());
1049
1050     m_parent.ReportSymbolLookupError(name_cs);
1051     return 0;
1052   } else {
1053     if (log)
1054       log->Printf("IRExecutionUnit::getSymbolAddress(Name=\"%s\") = %" PRIx64,
1055                   Name.c_str(), ret);
1056     return ret;
1057   }
1058 }
1059
1060 void *IRExecutionUnit::MemoryManager::getPointerToNamedFunction(
1061     const std::string &Name, bool AbortOnFailure) {
1062   return (void *)getSymbolAddress(Name);
1063 }
1064
1065 lldb::addr_t
1066 IRExecutionUnit::GetRemoteAddressForLocal(lldb::addr_t local_address) {
1067   Log *log(lldb_private::GetLogIfAllCategoriesSet(LIBLLDB_LOG_EXPRESSIONS));
1068
1069   for (AllocationRecord &record : m_records) {
1070     if (local_address >= record.m_host_address &&
1071         local_address < record.m_host_address + record.m_size) {
1072       if (record.m_process_address == LLDB_INVALID_ADDRESS)
1073         return LLDB_INVALID_ADDRESS;
1074
1075       lldb::addr_t ret =
1076           record.m_process_address + (local_address - record.m_host_address);
1077
1078       if (log) {
1079         log->Printf(
1080             "IRExecutionUnit::GetRemoteAddressForLocal() found 0x%" PRIx64
1081             " in [0x%" PRIx64 "..0x%" PRIx64 "], and returned 0x%" PRIx64
1082             " from [0x%" PRIx64 "..0x%" PRIx64 "].",
1083             local_address, (uint64_t)record.m_host_address,
1084             (uint64_t)record.m_host_address + (uint64_t)record.m_size, ret,
1085             record.m_process_address, record.m_process_address + record.m_size);
1086       }
1087
1088       return ret;
1089     }
1090   }
1091
1092   return LLDB_INVALID_ADDRESS;
1093 }
1094
1095 IRExecutionUnit::AddrRange
1096 IRExecutionUnit::GetRemoteRangeForLocal(lldb::addr_t local_address) {
1097   for (AllocationRecord &record : m_records) {
1098     if (local_address >= record.m_host_address &&
1099         local_address < record.m_host_address + record.m_size) {
1100       if (record.m_process_address == LLDB_INVALID_ADDRESS)
1101         return AddrRange(0, 0);
1102
1103       return AddrRange(record.m_process_address, record.m_size);
1104     }
1105   }
1106
1107   return AddrRange(0, 0);
1108 }
1109
1110 bool IRExecutionUnit::CommitOneAllocation(lldb::ProcessSP &process_sp,
1111                                           Status &error,
1112                                           AllocationRecord &record) {
1113   if (record.m_process_address != LLDB_INVALID_ADDRESS) {
1114     return true;
1115   }
1116
1117   switch (record.m_sect_type) {
1118   case lldb::eSectionTypeInvalid:
1119   case lldb::eSectionTypeDWARFDebugAbbrev:
1120   case lldb::eSectionTypeDWARFDebugAddr:
1121   case lldb::eSectionTypeDWARFDebugAranges:
1122   case lldb::eSectionTypeDWARFDebugCuIndex:
1123   case lldb::eSectionTypeDWARFDebugFrame:
1124   case lldb::eSectionTypeDWARFDebugInfo:
1125   case lldb::eSectionTypeDWARFDebugLine:
1126   case lldb::eSectionTypeDWARFDebugLoc:
1127   case lldb::eSectionTypeDWARFDebugLocLists:
1128   case lldb::eSectionTypeDWARFDebugMacInfo:
1129   case lldb::eSectionTypeDWARFDebugPubNames:
1130   case lldb::eSectionTypeDWARFDebugPubTypes:
1131   case lldb::eSectionTypeDWARFDebugRanges:
1132   case lldb::eSectionTypeDWARFDebugStr:
1133   case lldb::eSectionTypeDWARFDebugStrOffsets:
1134   case lldb::eSectionTypeDWARFAppleNames:
1135   case lldb::eSectionTypeDWARFAppleTypes:
1136   case lldb::eSectionTypeDWARFAppleNamespaces:
1137   case lldb::eSectionTypeDWARFAppleObjC:
1138   case lldb::eSectionTypeDWARFGNUDebugAltLink:
1139     error.Clear();
1140     break;
1141   default:
1142     const bool zero_memory = false;
1143     record.m_process_address =
1144         Malloc(record.m_size, record.m_alignment, record.m_permissions,
1145                eAllocationPolicyProcessOnly, zero_memory, error);
1146     break;
1147   }
1148
1149   return error.Success();
1150 }
1151
1152 bool IRExecutionUnit::CommitAllocations(lldb::ProcessSP &process_sp) {
1153   bool ret = true;
1154
1155   lldb_private::Status err;
1156
1157   for (AllocationRecord &record : m_records) {
1158     ret = CommitOneAllocation(process_sp, err, record);
1159
1160     if (!ret) {
1161       break;
1162     }
1163   }
1164
1165   if (!ret) {
1166     for (AllocationRecord &record : m_records) {
1167       if (record.m_process_address != LLDB_INVALID_ADDRESS) {
1168         Free(record.m_process_address, err);
1169         record.m_process_address = LLDB_INVALID_ADDRESS;
1170       }
1171     }
1172   }
1173
1174   return ret;
1175 }
1176
1177 void IRExecutionUnit::ReportAllocations(llvm::ExecutionEngine &engine) {
1178   m_reported_allocations = true;
1179
1180   for (AllocationRecord &record : m_records) {
1181     if (record.m_process_address == LLDB_INVALID_ADDRESS)
1182       continue;
1183
1184     if (record.m_section_id == eSectionIDInvalid)
1185       continue;
1186
1187     engine.mapSectionAddress((void *)record.m_host_address,
1188                              record.m_process_address);
1189   }
1190
1191   // Trigger re-application of relocations.
1192   engine.finalizeObject();
1193 }
1194
1195 bool IRExecutionUnit::WriteData(lldb::ProcessSP &process_sp) {
1196   bool wrote_something = false;
1197   for (AllocationRecord &record : m_records) {
1198     if (record.m_process_address != LLDB_INVALID_ADDRESS) {
1199       lldb_private::Status err;
1200       WriteMemory(record.m_process_address, (uint8_t *)record.m_host_address,
1201                   record.m_size, err);
1202       if (err.Success())
1203         wrote_something = true;
1204     }
1205   }
1206   return wrote_something;
1207 }
1208
1209 void IRExecutionUnit::AllocationRecord::dump(Log *log) {
1210   if (!log)
1211     return;
1212
1213   log->Printf("[0x%llx+0x%llx]->0x%llx (alignment %d, section ID %d, name %s)",
1214               (unsigned long long)m_host_address, (unsigned long long)m_size,
1215               (unsigned long long)m_process_address, (unsigned)m_alignment,
1216               (unsigned)m_section_id, m_name.c_str());
1217 }
1218
1219 lldb::ByteOrder IRExecutionUnit::GetByteOrder() const {
1220   ExecutionContext exe_ctx(GetBestExecutionContextScope());
1221   return exe_ctx.GetByteOrder();
1222 }
1223
1224 uint32_t IRExecutionUnit::GetAddressByteSize() const {
1225   ExecutionContext exe_ctx(GetBestExecutionContextScope());
1226   return exe_ctx.GetAddressByteSize();
1227 }
1228
1229 void IRExecutionUnit::PopulateSymtab(lldb_private::ObjectFile *obj_file,
1230                                      lldb_private::Symtab &symtab) {
1231   // No symbols yet...
1232 }
1233
1234 void IRExecutionUnit::PopulateSectionList(
1235     lldb_private::ObjectFile *obj_file,
1236     lldb_private::SectionList &section_list) {
1237   for (AllocationRecord &record : m_records) {
1238     if (record.m_size > 0) {
1239       lldb::SectionSP section_sp(new lldb_private::Section(
1240           obj_file->GetModule(), obj_file, record.m_section_id,
1241           ConstString(record.m_name), record.m_sect_type,
1242           record.m_process_address, record.m_size,
1243           record.m_host_address, // file_offset (which is the host address for
1244                                  // the data)
1245           record.m_size,         // file_size
1246           0,
1247           record.m_permissions)); // flags
1248       section_list.AddSection(section_sp);
1249     }
1250   }
1251 }
1252
1253 ArchSpec IRExecutionUnit::GetArchitecture() {
1254   ExecutionContext exe_ctx(GetBestExecutionContextScope());
1255   if(Target *target = exe_ctx.GetTargetPtr())
1256     return target->GetArchitecture();
1257   return ArchSpec();
1258 }
1259
1260 lldb::ModuleSP IRExecutionUnit::GetJITModule() {
1261   ExecutionContext exe_ctx(GetBestExecutionContextScope());
1262   Target *target = exe_ctx.GetTargetPtr();
1263   if (!target)
1264     return nullptr;
1265
1266   auto Delegate = std::static_pointer_cast<lldb_private::ObjectFileJITDelegate>(
1267       shared_from_this());
1268
1269   lldb::ModuleSP jit_module_sp =
1270       lldb_private::Module::CreateModuleFromObjectFile<ObjectFileJIT>(Delegate);
1271   if (!jit_module_sp)
1272     return nullptr;
1273
1274   bool changed = false;
1275   jit_module_sp->SetLoadAddress(*target, 0, true, changed);
1276   return jit_module_sp;
1277 }