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 §ion_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 } 1278