diff options
Diffstat (limited to 'contrib/llvm/tools/lldb/source/Expression/IRExecutionUnit.cpp')
| -rw-r--r-- | contrib/llvm/tools/lldb/source/Expression/IRExecutionUnit.cpp | 2054 |
1 files changed, 968 insertions, 1086 deletions
diff --git a/contrib/llvm/tools/lldb/source/Expression/IRExecutionUnit.cpp b/contrib/llvm/tools/lldb/source/Expression/IRExecutionUnit.cpp index 103d763..f18d96b 100644 --- a/contrib/llvm/tools/lldb/source/Expression/IRExecutionUnit.cpp +++ b/contrib/llvm/tools/lldb/source/Expression/IRExecutionUnit.cpp @@ -8,6 +8,7 @@ //===----------------------------------------------------------------------===// #include "llvm/ExecutionEngine/ExecutionEngine.h" +#include "llvm/ExecutionEngine/ObjectCache.h" #include "llvm/IR/Constants.h" #include "llvm/IR/LLVMContext.h" #include "llvm/IR/Module.h" @@ -21,575 +22,575 @@ #include "lldb/Core/Log.h" #include "lldb/Core/Module.h" #include "lldb/Core/Section.h" +#include "lldb/Expression/IRExecutionUnit.h" #include "lldb/Symbol/CompileUnit.h" #include "lldb/Symbol/SymbolContext.h" -#include "lldb/Symbol/SymbolVendor.h" #include "lldb/Symbol/SymbolFile.h" -#include "lldb/Expression/IRExecutionUnit.h" +#include "lldb/Symbol/SymbolVendor.h" #include "lldb/Target/ExecutionContext.h" -#include "lldb/Target/Target.h" #include "lldb/Target/ObjCLanguageRuntime.h" +#include "lldb/Target/Target.h" #include "lldb/Utility/LLDBAssert.h" #include "lldb/../../source/Plugins/Language/CPlusPlus/CPlusPlusLanguage.h" using namespace lldb_private; -IRExecutionUnit::IRExecutionUnit (std::unique_ptr<llvm::LLVMContext> &context_ap, - std::unique_ptr<llvm::Module> &module_ap, - ConstString &name, - const lldb::TargetSP &target_sp, - const SymbolContext &sym_ctx, - std::vector<std::string> &cpu_features) : - IRMemoryMap(target_sp), - m_context_ap(context_ap.release()), - m_module_ap(module_ap.release()), - m_module(m_module_ap.get()), - m_cpu_features(cpu_features), - m_name(name), - m_sym_ctx(sym_ctx), - m_did_jit(false), - m_function_load_addr(LLDB_INVALID_ADDRESS), - m_function_end_load_addr(LLDB_INVALID_ADDRESS), - m_reported_allocations(false) -{ -} - -lldb::addr_t -IRExecutionUnit::WriteNow (const uint8_t *bytes, - size_t size, - Error &error) -{ - const bool zero_memory = false; - lldb::addr_t allocation_process_addr = Malloc (size, - 8, - lldb::ePermissionsWritable | lldb::ePermissionsReadable, - eAllocationPolicyMirror, - zero_memory, - error); - - if (!error.Success()) - return LLDB_INVALID_ADDRESS; +IRExecutionUnit::IRExecutionUnit(std::unique_ptr<llvm::LLVMContext> &context_ap, + std::unique_ptr<llvm::Module> &module_ap, + ConstString &name, + const lldb::TargetSP &target_sp, + const SymbolContext &sym_ctx, + std::vector<std::string> &cpu_features) + : IRMemoryMap(target_sp), m_context_ap(context_ap.release()), + m_module_ap(module_ap.release()), m_module(m_module_ap.get()), + m_cpu_features(cpu_features), m_name(name), m_sym_ctx(sym_ctx), + m_did_jit(false), m_function_load_addr(LLDB_INVALID_ADDRESS), + m_function_end_load_addr(LLDB_INVALID_ADDRESS), + m_reported_allocations(false) {} + +lldb::addr_t IRExecutionUnit::WriteNow(const uint8_t *bytes, size_t size, + Error &error) { + const bool zero_memory = false; + lldb::addr_t allocation_process_addr = + Malloc(size, 8, lldb::ePermissionsWritable | lldb::ePermissionsReadable, + eAllocationPolicyMirror, zero_memory, error); + + if (!error.Success()) + return LLDB_INVALID_ADDRESS; - WriteMemory(allocation_process_addr, bytes, size, error); + WriteMemory(allocation_process_addr, bytes, size, error); - if (!error.Success()) - { - Error err; - Free (allocation_process_addr, err); + if (!error.Success()) { + Error err; + Free(allocation_process_addr, err); - return LLDB_INVALID_ADDRESS; - } + return LLDB_INVALID_ADDRESS; + } - if (Log *log = lldb_private::GetLogIfAllCategoriesSet (LIBLLDB_LOG_EXPRESSIONS)) - { - DataBufferHeap my_buffer(size, 0); - Error err; - ReadMemory(my_buffer.GetBytes(), allocation_process_addr, size, err); + if (Log *log = + lldb_private::GetLogIfAllCategoriesSet(LIBLLDB_LOG_EXPRESSIONS)) { + DataBufferHeap my_buffer(size, 0); + Error err; + ReadMemory(my_buffer.GetBytes(), allocation_process_addr, size, err); - if (err.Success()) - { - DataExtractor my_extractor(my_buffer.GetBytes(), my_buffer.GetByteSize(), lldb::eByteOrderBig, 8); - my_extractor.PutToLog(log, 0, my_buffer.GetByteSize(), allocation_process_addr, 16, DataExtractor::TypeUInt8); - } + if (err.Success()) { + DataExtractor my_extractor(my_buffer.GetBytes(), my_buffer.GetByteSize(), + lldb::eByteOrderBig, 8); + my_extractor.PutToLog(log, 0, my_buffer.GetByteSize(), + allocation_process_addr, 16, + DataExtractor::TypeUInt8); } + } - return allocation_process_addr; + return allocation_process_addr; } -void -IRExecutionUnit::FreeNow (lldb::addr_t allocation) -{ - if (allocation == LLDB_INVALID_ADDRESS) - return; +void IRExecutionUnit::FreeNow(lldb::addr_t allocation) { + if (allocation == LLDB_INVALID_ADDRESS) + return; - Error err; + Error err; - Free(allocation, err); + Free(allocation, err); } -Error -IRExecutionUnit::DisassembleFunction (Stream &stream, - lldb::ProcessSP &process_wp) -{ - Log *log(lldb_private::GetLogIfAllCategoriesSet (LIBLLDB_LOG_EXPRESSIONS)); +Error IRExecutionUnit::DisassembleFunction(Stream &stream, + lldb::ProcessSP &process_wp) { + Log *log(lldb_private::GetLogIfAllCategoriesSet(LIBLLDB_LOG_EXPRESSIONS)); - ExecutionContext exe_ctx(process_wp); + ExecutionContext exe_ctx(process_wp); - Error ret; + Error ret; - ret.Clear(); + ret.Clear(); - lldb::addr_t func_local_addr = LLDB_INVALID_ADDRESS; - lldb::addr_t func_remote_addr = LLDB_INVALID_ADDRESS; + lldb::addr_t func_local_addr = LLDB_INVALID_ADDRESS; + lldb::addr_t func_remote_addr = LLDB_INVALID_ADDRESS; - for (JittedFunction &function : m_jitted_functions) - { - if (function.m_name == m_name) - { - func_local_addr = function.m_local_addr; - func_remote_addr = function.m_remote_addr; - } + for (JittedFunction &function : m_jitted_functions) { + if (function.m_name == m_name) { + func_local_addr = function.m_local_addr; + func_remote_addr = function.m_remote_addr; } + } - if (func_local_addr == LLDB_INVALID_ADDRESS) - { - ret.SetErrorToGenericError(); - ret.SetErrorStringWithFormat("Couldn't find function %s for disassembly", m_name.AsCString()); - return ret; - } + if (func_local_addr == LLDB_INVALID_ADDRESS) { + ret.SetErrorToGenericError(); + ret.SetErrorStringWithFormat("Couldn't find function %s for disassembly", + m_name.AsCString()); + return ret; + } - if (log) - log->Printf("Found function, has local address 0x%" PRIx64 " and remote address 0x%" PRIx64, (uint64_t)func_local_addr, (uint64_t)func_remote_addr); + if (log) + log->Printf("Found function, has local address 0x%" PRIx64 + " and remote address 0x%" PRIx64, + (uint64_t)func_local_addr, (uint64_t)func_remote_addr); - std::pair <lldb::addr_t, lldb::addr_t> func_range; + std::pair<lldb::addr_t, lldb::addr_t> func_range; - func_range = GetRemoteRangeForLocal(func_local_addr); + func_range = GetRemoteRangeForLocal(func_local_addr); - if (func_range.first == 0 && func_range.second == 0) - { - ret.SetErrorToGenericError(); - ret.SetErrorStringWithFormat("Couldn't find code range for function %s", m_name.AsCString()); - return ret; - } + if (func_range.first == 0 && func_range.second == 0) { + ret.SetErrorToGenericError(); + ret.SetErrorStringWithFormat("Couldn't find code range for function %s", + m_name.AsCString()); + return ret; + } - if (log) - log->Printf("Function's code range is [0x%" PRIx64 "+0x%" PRIx64 "]", func_range.first, func_range.second); - - Target *target = exe_ctx.GetTargetPtr(); - if (!target) - { - ret.SetErrorToGenericError(); - ret.SetErrorString("Couldn't find the target"); - return ret; - } + if (log) + log->Printf("Function's code range is [0x%" PRIx64 "+0x%" PRIx64 "]", + func_range.first, func_range.second); - lldb::DataBufferSP buffer_sp(new DataBufferHeap(func_range.second, 0)); + Target *target = exe_ctx.GetTargetPtr(); + if (!target) { + ret.SetErrorToGenericError(); + ret.SetErrorString("Couldn't find the target"); + return ret; + } - Process *process = exe_ctx.GetProcessPtr(); - Error err; - process->ReadMemory(func_remote_addr, buffer_sp->GetBytes(), buffer_sp->GetByteSize(), err); + lldb::DataBufferSP buffer_sp(new DataBufferHeap(func_range.second, 0)); - if (!err.Success()) - { - ret.SetErrorToGenericError(); - ret.SetErrorStringWithFormat("Couldn't read from process: %s", err.AsCString("unknown error")); - return ret; - } + Process *process = exe_ctx.GetProcessPtr(); + Error err; + process->ReadMemory(func_remote_addr, buffer_sp->GetBytes(), + buffer_sp->GetByteSize(), err); - ArchSpec arch(target->GetArchitecture()); + if (!err.Success()) { + ret.SetErrorToGenericError(); + ret.SetErrorStringWithFormat("Couldn't read from process: %s", + err.AsCString("unknown error")); + return ret; + } - const char *plugin_name = NULL; - const char *flavor_string = NULL; - lldb::DisassemblerSP disassembler_sp = Disassembler::FindPlugin(arch, flavor_string, plugin_name); + ArchSpec arch(target->GetArchitecture()); - if (!disassembler_sp) - { - ret.SetErrorToGenericError(); - ret.SetErrorStringWithFormat("Unable to find disassembler plug-in for %s architecture.", arch.GetArchitectureName()); - return ret; - } + const char *plugin_name = NULL; + const char *flavor_string = NULL; + lldb::DisassemblerSP disassembler_sp = + Disassembler::FindPlugin(arch, flavor_string, plugin_name); - if (!process) - { - ret.SetErrorToGenericError(); - ret.SetErrorString("Couldn't find the process"); - return ret; - } + if (!disassembler_sp) { + ret.SetErrorToGenericError(); + ret.SetErrorStringWithFormat( + "Unable to find disassembler plug-in for %s architecture.", + arch.GetArchitectureName()); + return ret; + } - DataExtractor extractor(buffer_sp, - process->GetByteOrder(), - target->GetArchitecture().GetAddressByteSize()); + if (!process) { + ret.SetErrorToGenericError(); + ret.SetErrorString("Couldn't find the process"); + return ret; + } - if (log) - { - log->Printf("Function data has contents:"); - extractor.PutToLog (log, - 0, - extractor.GetByteSize(), - func_remote_addr, - 16, - DataExtractor::TypeUInt8); - } + DataExtractor extractor(buffer_sp, process->GetByteOrder(), + target->GetArchitecture().GetAddressByteSize()); - disassembler_sp->DecodeInstructions (Address (func_remote_addr), extractor, 0, UINT32_MAX, false, false); + if (log) { + log->Printf("Function data has contents:"); + extractor.PutToLog(log, 0, extractor.GetByteSize(), func_remote_addr, 16, + DataExtractor::TypeUInt8); + } - InstructionList &instruction_list = disassembler_sp->GetInstructionList(); - instruction_list.Dump(&stream, true, true, &exe_ctx); - return ret; + disassembler_sp->DecodeInstructions(Address(func_remote_addr), extractor, 0, + UINT32_MAX, false, false); + + InstructionList &instruction_list = disassembler_sp->GetInstructionList(); + instruction_list.Dump(&stream, true, true, &exe_ctx); + return ret; } -static void ReportInlineAsmError(const llvm::SMDiagnostic &diagnostic, void *Context, unsigned LocCookie) -{ - Error *err = static_cast<Error*>(Context); +static void ReportInlineAsmError(const llvm::SMDiagnostic &diagnostic, + void *Context, unsigned LocCookie) { + Error *err = static_cast<Error *>(Context); - if (err && err->Success()) - { - err->SetErrorToGenericError(); - err->SetErrorStringWithFormat("Inline assembly error: %s", diagnostic.getMessage().str().c_str()); - } + if (err && err->Success()) { + err->SetErrorToGenericError(); + err->SetErrorStringWithFormat("Inline assembly error: %s", + diagnostic.getMessage().str().c_str()); + } } -void -IRExecutionUnit::ReportSymbolLookupError(const ConstString &name) -{ - m_failed_lookups.push_back(name); +void IRExecutionUnit::ReportSymbolLookupError(const ConstString &name) { + m_failed_lookups.push_back(name); } -void -IRExecutionUnit::GetRunnableInfo(Error &error, - lldb::addr_t &func_addr, - lldb::addr_t &func_end) -{ - lldb::ProcessSP process_sp(GetProcessWP().lock()); +void IRExecutionUnit::GetRunnableInfo(Error &error, lldb::addr_t &func_addr, + lldb::addr_t &func_end) { + lldb::ProcessSP process_sp(GetProcessWP().lock()); - static std::recursive_mutex s_runnable_info_mutex; + static std::recursive_mutex s_runnable_info_mutex; - func_addr = LLDB_INVALID_ADDRESS; - func_end = LLDB_INVALID_ADDRESS; - - if (!process_sp) - { - error.SetErrorToGenericError(); - error.SetErrorString("Couldn't write the JIT compiled code into the process because the process is invalid"); - return; - } + func_addr = LLDB_INVALID_ADDRESS; + func_end = LLDB_INVALID_ADDRESS; - if (m_did_jit) - { - func_addr = m_function_load_addr; - func_end = m_function_end_load_addr; + if (!process_sp) { + error.SetErrorToGenericError(); + error.SetErrorString("Couldn't write the JIT compiled code into the " + "process because the process is invalid"); + return; + } - return; - }; + if (m_did_jit) { + func_addr = m_function_load_addr; + func_end = m_function_end_load_addr; - std::lock_guard<std::recursive_mutex> guard(s_runnable_info_mutex); + return; + }; - m_did_jit = true; + std::lock_guard<std::recursive_mutex> guard(s_runnable_info_mutex); - Log *log(lldb_private::GetLogIfAllCategoriesSet (LIBLLDB_LOG_EXPRESSIONS)); + m_did_jit = true; - std::string error_string; + Log *log(lldb_private::GetLogIfAllCategoriesSet(LIBLLDB_LOG_EXPRESSIONS)); - if (log) - { - std::string s; - llvm::raw_string_ostream oss(s); + std::string error_string; - m_module->print(oss, NULL); + if (log) { + std::string s; + llvm::raw_string_ostream oss(s); - oss.flush(); + m_module->print(oss, NULL); - log->Printf ("Module being sent to JIT: \n%s", s.c_str()); - } + oss.flush(); - llvm::Triple triple(m_module->getTargetTriple()); - llvm::Reloc::Model relocModel; - llvm::CodeModel::Model codeModel; + log->Printf("Module being sent to JIT: \n%s", s.c_str()); + } - if (triple.isOSBinFormatELF()) - { - relocModel = llvm::Reloc::Static; - } - else - { - relocModel = llvm::Reloc::PIC_; - } + llvm::Triple triple(m_module->getTargetTriple()); + llvm::Reloc::Model relocModel; + llvm::CodeModel::Model codeModel; - // This will be small for 32-bit and large for 64-bit. - codeModel = llvm::CodeModel::JITDefault; + if (triple.isOSBinFormatELF()) { + relocModel = llvm::Reloc::Static; + } else { + relocModel = llvm::Reloc::PIC_; + } - m_module_ap->getContext().setInlineAsmDiagnosticHandler(ReportInlineAsmError, &error); + // This will be small for 32-bit and large for 64-bit. + codeModel = llvm::CodeModel::JITDefault; - llvm::EngineBuilder builder(std::move(m_module_ap)); + m_module_ap->getContext().setInlineAsmDiagnosticHandler(ReportInlineAsmError, + &error); - builder.setEngineKind(llvm::EngineKind::JIT) - .setErrorStr(&error_string) - .setRelocationModel(relocModel) - .setMCJITMemoryManager(std::unique_ptr<MemoryManager>(new MemoryManager(*this))) - .setCodeModel(codeModel) - .setOptLevel(llvm::CodeGenOpt::Less); + llvm::EngineBuilder builder(std::move(m_module_ap)); - llvm::StringRef mArch; - llvm::StringRef mCPU; - llvm::SmallVector<std::string, 0> mAttrs; + builder.setEngineKind(llvm::EngineKind::JIT) + .setErrorStr(&error_string) + .setRelocationModel(relocModel) + .setMCJITMemoryManager( + std::unique_ptr<MemoryManager>(new MemoryManager(*this))) + .setCodeModel(codeModel) + .setOptLevel(llvm::CodeGenOpt::Less) + .setUseOrcMCJITReplacement(true); - for (std::string &feature : m_cpu_features) - mAttrs.push_back(feature); + llvm::StringRef mArch; + llvm::StringRef mCPU; + llvm::SmallVector<std::string, 0> mAttrs; - llvm::TargetMachine *target_machine = builder.selectTarget(triple, - mArch, - mCPU, - mAttrs); + for (std::string &feature : m_cpu_features) + mAttrs.push_back(feature); - m_execution_engine_ap.reset(builder.create(target_machine)); + llvm::TargetMachine *target_machine = + builder.selectTarget(triple, mArch, mCPU, mAttrs); - m_strip_underscore = (m_execution_engine_ap->getDataLayout().getGlobalPrefix() == '_'); + m_execution_engine_ap.reset(builder.create(target_machine)); - if (!m_execution_engine_ap.get()) - { - error.SetErrorToGenericError(); - error.SetErrorStringWithFormat("Couldn't JIT the function: %s", error_string.c_str()); - return; - } + m_strip_underscore = + (m_execution_engine_ap->getDataLayout().getGlobalPrefix() == '_'); - // Make sure we see all sections, including ones that don't have relocations... - m_execution_engine_ap->setProcessAllSections(true); - - m_execution_engine_ap->DisableLazyCompilation(); - - for (llvm::Function &function : *m_module) - { - if (function.isDeclaration() || function.hasPrivateLinkage()) - continue; - - const bool external = function.hasExternalLinkage() || function.hasLinkOnceODRLinkage(); - - void *fun_ptr = m_execution_engine_ap->getPointerToFunction(&function); - - if (!error.Success()) - { - // We got an error through our callback! - return; - } - - if (!fun_ptr) - { - error.SetErrorToGenericError(); - error.SetErrorStringWithFormat("'%s' was in the JITted module but wasn't lowered", function.getName().str().c_str()); - return; - } - m_jitted_functions.push_back (JittedFunction(function.getName().str().c_str(), external, (lldb::addr_t)fun_ptr)); + if (!m_execution_engine_ap.get()) { + error.SetErrorToGenericError(); + error.SetErrorStringWithFormat("Couldn't JIT the function: %s", + error_string.c_str()); + return; + } + + class ObjectDumper : public llvm::ObjectCache { + public: + void notifyObjectCompiled(const llvm::Module *module, + llvm::MemoryBufferRef object) override { + int fd = 0; + llvm::SmallVector<char, 256> result_path; + std::string object_name_model = + "jit-object-" + module->getModuleIdentifier() + "-%%%.o"; + (void)llvm::sys::fs::createUniqueFile(object_name_model, fd, result_path); + llvm::raw_fd_ostream fds(fd, true); + fds.write(object.getBufferStart(), object.getBufferSize()); } - CommitAllocations(process_sp); - ReportAllocations(*m_execution_engine_ap); - - // We have to do this after calling ReportAllocations because for the MCJIT, getGlobalValueAddress - // will cause the JIT to perform all relocations. That can only be done once, and has to happen - // after we do the remapping from local -> remote. - // That means we don't know the local address of the Variables, but we don't need that for anything, - // so that's okay. - - std::function<void (llvm::GlobalValue &)> RegisterOneValue = [this] (llvm::GlobalValue &val) { - if (val.hasExternalLinkage() && !val.isDeclaration()) - { - uint64_t var_ptr_addr = m_execution_engine_ap->getGlobalValueAddress(val.getName().str()); - - lldb::addr_t remote_addr = GetRemoteAddressForLocal(var_ptr_addr); - - // This is a really unfortunae API that sometimes returns local addresses and sometimes returns remote addresses, based on whether - // the variable was relocated during ReportAllocations or not. - - if (remote_addr == LLDB_INVALID_ADDRESS) - { - remote_addr = var_ptr_addr; - } - - if (var_ptr_addr != 0) - m_jitted_global_variables.push_back (JittedGlobalVariable (val.getName().str().c_str(), LLDB_INVALID_ADDRESS, remote_addr)); - } - }; - - for (llvm::GlobalVariable &global_var : m_module->getGlobalList()) - { - RegisterOneValue(global_var); + std::unique_ptr<llvm::MemoryBuffer> + getObject(const llvm::Module *module) override { + // Return nothing - we're just abusing the object-cache mechanism to dump + // objects. + return nullptr; } - - for (llvm::GlobalAlias &global_alias : m_module->getAliasList()) - { - RegisterOneValue(global_alias); - } - - WriteData(process_sp); + }; - if (m_failed_lookups.size()) - { - StreamString ss; + if (process_sp->GetTarget().GetEnableSaveObjects()) { + m_object_cache_ap = llvm::make_unique<ObjectDumper>(); + m_execution_engine_ap->setObjectCache(m_object_cache_ap.get()); + } - ss.PutCString("Couldn't lookup symbols:\n"); + // Make sure we see all sections, including ones that don't have + // relocations... + m_execution_engine_ap->setProcessAllSections(true); - bool emitNewLine = false; + m_execution_engine_ap->DisableLazyCompilation(); - for (const ConstString &failed_lookup : m_failed_lookups) - { - if (emitNewLine) - ss.PutCString("\n"); - emitNewLine = true; - ss.PutCString(" "); - ss.PutCString(Mangled(failed_lookup).GetDemangledName(lldb::eLanguageTypeObjC_plus_plus).AsCString()); - } + for (llvm::Function &function : *m_module) { + if (function.isDeclaration() || function.hasPrivateLinkage()) + continue; - m_failed_lookups.clear(); + const bool external = + function.hasExternalLinkage() || function.hasLinkOnceODRLinkage(); - error.SetErrorString(ss.GetData()); + void *fun_ptr = m_execution_engine_ap->getPointerToFunction(&function); - return; + if (!error.Success()) { + // We got an error through our callback! + return; } - m_function_load_addr = LLDB_INVALID_ADDRESS; - m_function_end_load_addr = LLDB_INVALID_ADDRESS; - - for (JittedFunction &jitted_function : m_jitted_functions) - { - jitted_function.m_remote_addr = GetRemoteAddressForLocal (jitted_function.m_local_addr); - - if (!m_name.IsEmpty() && jitted_function.m_name == m_name) - { - AddrRange func_range = GetRemoteRangeForLocal(jitted_function.m_local_addr); - m_function_end_load_addr = func_range.first + func_range.second; - m_function_load_addr = jitted_function.m_remote_addr; - } + if (!fun_ptr) { + error.SetErrorToGenericError(); + error.SetErrorStringWithFormat( + "'%s' was in the JITted module but wasn't lowered", + function.getName().str().c_str()); + return; } + m_jitted_functions.push_back(JittedFunction( + function.getName().str().c_str(), external, (lldb::addr_t)fun_ptr)); + } + + CommitAllocations(process_sp); + ReportAllocations(*m_execution_engine_ap); + + // We have to do this after calling ReportAllocations because for the MCJIT, + // getGlobalValueAddress + // will cause the JIT to perform all relocations. That can only be done once, + // and has to happen + // after we do the remapping from local -> remote. + // That means we don't know the local address of the Variables, but we don't + // need that for anything, + // so that's okay. + + std::function<void(llvm::GlobalValue &)> RegisterOneValue = [this]( + llvm::GlobalValue &val) { + if (val.hasExternalLinkage() && !val.isDeclaration()) { + uint64_t var_ptr_addr = + m_execution_engine_ap->getGlobalValueAddress(val.getName().str()); + + lldb::addr_t remote_addr = GetRemoteAddressForLocal(var_ptr_addr); + + // This is a really unfortunae API that sometimes returns local addresses + // and sometimes returns remote addresses, based on whether + // the variable was relocated during ReportAllocations or not. + + if (remote_addr == LLDB_INVALID_ADDRESS) { + remote_addr = var_ptr_addr; + } + + if (var_ptr_addr != 0) + m_jitted_global_variables.push_back(JittedGlobalVariable( + val.getName().str().c_str(), LLDB_INVALID_ADDRESS, remote_addr)); + } + }; - if (log) - { - log->Printf("Code can be run in the target."); - - StreamString disassembly_stream; + for (llvm::GlobalVariable &global_var : m_module->getGlobalList()) { + RegisterOneValue(global_var); + } - Error err = DisassembleFunction(disassembly_stream, process_sp); + for (llvm::GlobalAlias &global_alias : m_module->getAliasList()) { + RegisterOneValue(global_alias); + } - if (!err.Success()) - { - log->Printf("Couldn't disassemble function : %s", err.AsCString("unknown error")); - } - else - { - log->Printf("Function disassembly:\n%s", disassembly_stream.GetData()); - } + WriteData(process_sp); - log->Printf("Sections: "); - for (AllocationRecord &record : m_records) - { - if (record.m_process_address != LLDB_INVALID_ADDRESS) - { - record.dump(log); + if (m_failed_lookups.size()) { + StreamString ss; - DataBufferHeap my_buffer(record.m_size, 0); - Error err; - ReadMemory(my_buffer.GetBytes(), record.m_process_address, record.m_size, err); + ss.PutCString("Couldn't lookup symbols:\n"); - if (err.Success()) - { - DataExtractor my_extractor(my_buffer.GetBytes(), my_buffer.GetByteSize(), lldb::eByteOrderBig, 8); - my_extractor.PutToLog(log, 0, my_buffer.GetByteSize(), record.m_process_address, 16, DataExtractor::TypeUInt8); - } - } - else - { - record.dump(log); + bool emitNewLine = false; - DataExtractor my_extractor ((const void*)record.m_host_address, record.m_size, lldb::eByteOrderBig, 8); - my_extractor.PutToLog(log, 0, record.m_size, record.m_host_address, 16, DataExtractor::TypeUInt8); - } - } + for (const ConstString &failed_lookup : m_failed_lookups) { + if (emitNewLine) + ss.PutCString("\n"); + emitNewLine = true; + ss.PutCString(" "); + ss.PutCString(Mangled(failed_lookup) + .GetDemangledName(lldb::eLanguageTypeObjC_plus_plus) + .AsCString()); } - func_addr = m_function_load_addr; - func_end = m_function_end_load_addr; + m_failed_lookups.clear(); - return; -} + error.SetErrorString(ss.GetString()); -IRExecutionUnit::~IRExecutionUnit () -{ - m_module_ap.reset(); - m_execution_engine_ap.reset(); - m_context_ap.reset(); -} + return; + } -IRExecutionUnit::MemoryManager::MemoryManager (IRExecutionUnit &parent) : - m_default_mm_ap (new llvm::SectionMemoryManager()), - m_parent (parent) -{ -} + m_function_load_addr = LLDB_INVALID_ADDRESS; + m_function_end_load_addr = LLDB_INVALID_ADDRESS; -IRExecutionUnit::MemoryManager::~MemoryManager () -{ -} + for (JittedFunction &jitted_function : m_jitted_functions) { + jitted_function.m_remote_addr = + GetRemoteAddressForLocal(jitted_function.m_local_addr); -lldb::SectionType -IRExecutionUnit::GetSectionTypeFromSectionName (const llvm::StringRef &name, IRExecutionUnit::AllocationKind alloc_kind) -{ - lldb::SectionType sect_type = lldb::eSectionTypeCode; - switch (alloc_kind) - { - case AllocationKind::Stub: sect_type = lldb::eSectionTypeCode; break; - case AllocationKind::Code: sect_type = lldb::eSectionTypeCode; break; - case AllocationKind::Data: sect_type = lldb::eSectionTypeData; break; - case AllocationKind::Global:sect_type = lldb::eSectionTypeData; break; - case AllocationKind::Bytes: sect_type = lldb::eSectionTypeOther; break; + if (!m_name.IsEmpty() && jitted_function.m_name == m_name) { + AddrRange func_range = + GetRemoteRangeForLocal(jitted_function.m_local_addr); + m_function_end_load_addr = func_range.first + func_range.second; + m_function_load_addr = jitted_function.m_remote_addr; } + } - if (!name.empty()) - { - if (name.equals("__text") || name.equals(".text")) - sect_type = lldb::eSectionTypeCode; - else if (name.equals("__data") || name.equals(".data")) - sect_type = lldb::eSectionTypeCode; - else if (name.startswith("__debug_") || name.startswith(".debug_")) - { - const uint32_t name_idx = name[0] == '_' ? 8 : 7; - llvm::StringRef dwarf_name(name.substr(name_idx)); - switch (dwarf_name[0]) - { - case 'a': - if (dwarf_name.equals("abbrev")) - sect_type = lldb::eSectionTypeDWARFDebugAbbrev; - else if (dwarf_name.equals("aranges")) - sect_type = lldb::eSectionTypeDWARFDebugAranges; - else if (dwarf_name.equals("addr")) - sect_type = lldb::eSectionTypeDWARFDebugAddr; - break; + if (log) { + log->Printf("Code can be run in the target."); - case 'f': - if (dwarf_name.equals("frame")) - sect_type = lldb::eSectionTypeDWARFDebugFrame; - break; + StreamString disassembly_stream; - case 'i': - if (dwarf_name.equals("info")) - sect_type = lldb::eSectionTypeDWARFDebugInfo; - break; + Error err = DisassembleFunction(disassembly_stream, process_sp); - case 'l': - if (dwarf_name.equals("line")) - sect_type = lldb::eSectionTypeDWARFDebugLine; - else if (dwarf_name.equals("loc")) - sect_type = lldb::eSectionTypeDWARFDebugLoc; - break; + if (!err.Success()) { + log->Printf("Couldn't disassemble function : %s", + err.AsCString("unknown error")); + } else { + log->Printf("Function disassembly:\n%s", disassembly_stream.GetData()); + } - case 'm': - if (dwarf_name.equals("macinfo")) - sect_type = lldb::eSectionTypeDWARFDebugMacInfo; - break; + log->Printf("Sections: "); + for (AllocationRecord &record : m_records) { + if (record.m_process_address != LLDB_INVALID_ADDRESS) { + record.dump(log); - case 'p': - if (dwarf_name.equals("pubnames")) - sect_type = lldb::eSectionTypeDWARFDebugPubNames; - else if (dwarf_name.equals("pubtypes")) - sect_type = lldb::eSectionTypeDWARFDebugPubTypes; - break; + DataBufferHeap my_buffer(record.m_size, 0); + Error err; + ReadMemory(my_buffer.GetBytes(), record.m_process_address, + record.m_size, err); + + if (err.Success()) { + DataExtractor my_extractor(my_buffer.GetBytes(), + my_buffer.GetByteSize(), + lldb::eByteOrderBig, 8); + my_extractor.PutToLog(log, 0, my_buffer.GetByteSize(), + record.m_process_address, 16, + DataExtractor::TypeUInt8); + } + } else { + record.dump(log); + + DataExtractor my_extractor((const void *)record.m_host_address, + record.m_size, lldb::eByteOrderBig, 8); + my_extractor.PutToLog(log, 0, record.m_size, record.m_host_address, 16, + DataExtractor::TypeUInt8); + } + } + } - case 's': - if (dwarf_name.equals("str")) - sect_type = lldb::eSectionTypeDWARFDebugStr; - else if (dwarf_name.equals("str_offsets")) - sect_type = lldb::eSectionTypeDWARFDebugStrOffsets; - break; + func_addr = m_function_load_addr; + func_end = m_function_end_load_addr; - case 'r': - if (dwarf_name.equals("ranges")) - sect_type = lldb::eSectionTypeDWARFDebugRanges; - break; + return; +} - default: - break; - } - } - else if (name.startswith("__apple_") || name.startswith(".apple_")) - { +IRExecutionUnit::~IRExecutionUnit() { + m_module_ap.reset(); + m_execution_engine_ap.reset(); + m_context_ap.reset(); +} + +IRExecutionUnit::MemoryManager::MemoryManager(IRExecutionUnit &parent) + : m_default_mm_ap(new llvm::SectionMemoryManager()), m_parent(parent) {} + +IRExecutionUnit::MemoryManager::~MemoryManager() {} + +lldb::SectionType IRExecutionUnit::GetSectionTypeFromSectionName( + const llvm::StringRef &name, IRExecutionUnit::AllocationKind alloc_kind) { + lldb::SectionType sect_type = lldb::eSectionTypeCode; + switch (alloc_kind) { + case AllocationKind::Stub: + sect_type = lldb::eSectionTypeCode; + break; + case AllocationKind::Code: + sect_type = lldb::eSectionTypeCode; + break; + case AllocationKind::Data: + sect_type = lldb::eSectionTypeData; + break; + case AllocationKind::Global: + sect_type = lldb::eSectionTypeData; + break; + case AllocationKind::Bytes: + sect_type = lldb::eSectionTypeOther; + break; + } + + if (!name.empty()) { + if (name.equals("__text") || name.equals(".text")) + sect_type = lldb::eSectionTypeCode; + else if (name.equals("__data") || name.equals(".data")) + sect_type = lldb::eSectionTypeCode; + else if (name.startswith("__debug_") || name.startswith(".debug_")) { + const uint32_t name_idx = name[0] == '_' ? 8 : 7; + llvm::StringRef dwarf_name(name.substr(name_idx)); + switch (dwarf_name[0]) { + case 'a': + if (dwarf_name.equals("abbrev")) + sect_type = lldb::eSectionTypeDWARFDebugAbbrev; + else if (dwarf_name.equals("aranges")) + sect_type = lldb::eSectionTypeDWARFDebugAranges; + else if (dwarf_name.equals("addr")) + sect_type = lldb::eSectionTypeDWARFDebugAddr; + break; + + case 'f': + if (dwarf_name.equals("frame")) + sect_type = lldb::eSectionTypeDWARFDebugFrame; + break; + + case 'i': + if (dwarf_name.equals("info")) + sect_type = lldb::eSectionTypeDWARFDebugInfo; + break; + + case 'l': + if (dwarf_name.equals("line")) + sect_type = lldb::eSectionTypeDWARFDebugLine; + else if (dwarf_name.equals("loc")) + sect_type = lldb::eSectionTypeDWARFDebugLoc; + break; + + case 'm': + if (dwarf_name.equals("macinfo")) + sect_type = lldb::eSectionTypeDWARFDebugMacInfo; + break; + + case 'p': + if (dwarf_name.equals("pubnames")) + sect_type = lldb::eSectionTypeDWARFDebugPubNames; + else if (dwarf_name.equals("pubtypes")) + sect_type = lldb::eSectionTypeDWARFDebugPubTypes; + break; + + case 's': + if (dwarf_name.equals("str")) + sect_type = lldb::eSectionTypeDWARFDebugStr; + else if (dwarf_name.equals("str_offsets")) + sect_type = lldb::eSectionTypeDWARFDebugStrOffsets; + break; + + case 'r': + if (dwarf_name.equals("ranges")) + sect_type = lldb::eSectionTypeDWARFDebugRanges; + break; + + default: + break; + } + } else if (name.startswith("__apple_") || name.startswith(".apple_")) { #if 0 const uint32_t name_idx = name[0] == '_' ? 8 : 7; llvm::StringRef apple_name(name.substr(name_idx)); @@ -613,776 +614,657 @@ IRExecutionUnit::GetSectionTypeFromSectionName (const llvm::StringRef &name, IRE break; } #else - sect_type = lldb::eSectionTypeInvalid; + sect_type = lldb::eSectionTypeInvalid; #endif - } - else if (name.equals("__objc_imageinfo")) - sect_type = lldb::eSectionTypeOther; - } - return sect_type; + } else if (name.equals("__objc_imageinfo")) + sect_type = lldb::eSectionTypeOther; + } + return sect_type; } -uint8_t * -IRExecutionUnit::MemoryManager::allocateCodeSection(uintptr_t Size, - unsigned Alignment, - unsigned SectionID, - llvm::StringRef SectionName) -{ - Log *log(lldb_private::GetLogIfAllCategoriesSet (LIBLLDB_LOG_EXPRESSIONS)); +uint8_t *IRExecutionUnit::MemoryManager::allocateCodeSection( + uintptr_t Size, unsigned Alignment, unsigned SectionID, + llvm::StringRef SectionName) { + Log *log(lldb_private::GetLogIfAllCategoriesSet(LIBLLDB_LOG_EXPRESSIONS)); - uint8_t *return_value = m_default_mm_ap->allocateCodeSection(Size, Alignment, SectionID, SectionName); + uint8_t *return_value = m_default_mm_ap->allocateCodeSection( + Size, Alignment, SectionID, SectionName); - m_parent.m_records.push_back(AllocationRecord((uintptr_t)return_value, - lldb::ePermissionsReadable | lldb::ePermissionsExecutable, - GetSectionTypeFromSectionName (SectionName, AllocationKind::Code), - Size, - Alignment, - SectionID, - SectionName.str().c_str())); + m_parent.m_records.push_back(AllocationRecord( + (uintptr_t)return_value, + lldb::ePermissionsReadable | lldb::ePermissionsExecutable, + GetSectionTypeFromSectionName(SectionName, AllocationKind::Code), Size, + Alignment, SectionID, SectionName.str().c_str())); - if (log) - { - log->Printf("IRExecutionUnit::allocateCodeSection(Size=0x%" PRIx64 ", Alignment=%u, SectionID=%u) = %p", - (uint64_t)Size, Alignment, SectionID, (void *)return_value); - } - - if (m_parent.m_reported_allocations) - { - Error err; - lldb::ProcessSP process_sp = m_parent.GetBestExecutionContextScope()->CalculateProcess(); - - m_parent.CommitOneAllocation(process_sp, err, m_parent.m_records.back()); - } + if (log) { + log->Printf("IRExecutionUnit::allocateCodeSection(Size=0x%" PRIx64 + ", Alignment=%u, SectionID=%u) = %p", + (uint64_t)Size, Alignment, SectionID, (void *)return_value); + } + + if (m_parent.m_reported_allocations) { + Error err; + lldb::ProcessSP process_sp = + m_parent.GetBestExecutionContextScope()->CalculateProcess(); + + m_parent.CommitOneAllocation(process_sp, err, m_parent.m_records.back()); + } - return return_value; + return return_value; } -uint8_t * -IRExecutionUnit::MemoryManager::allocateDataSection(uintptr_t Size, - unsigned Alignment, - unsigned SectionID, - llvm::StringRef SectionName, - bool IsReadOnly) -{ - Log *log(lldb_private::GetLogIfAllCategoriesSet (LIBLLDB_LOG_EXPRESSIONS)); - - uint8_t *return_value = m_default_mm_ap->allocateDataSection(Size, Alignment, SectionID, SectionName, IsReadOnly); - - uint32_t permissions = lldb::ePermissionsReadable; - if (!IsReadOnly) - permissions |= lldb::ePermissionsWritable; - m_parent.m_records.push_back(AllocationRecord((uintptr_t)return_value, - permissions, - GetSectionTypeFromSectionName (SectionName, AllocationKind::Data), - Size, - Alignment, - SectionID, - SectionName.str().c_str())); - if (log) - { - log->Printf("IRExecutionUnit::allocateDataSection(Size=0x%" PRIx64 ", Alignment=%u, SectionID=%u) = %p", - (uint64_t)Size, Alignment, SectionID, (void *)return_value); - } - - if (m_parent.m_reported_allocations) - { - Error err; - lldb::ProcessSP process_sp = m_parent.GetBestExecutionContextScope()->CalculateProcess(); - - m_parent.CommitOneAllocation(process_sp, err, m_parent.m_records.back()); - } +uint8_t *IRExecutionUnit::MemoryManager::allocateDataSection( + uintptr_t Size, unsigned Alignment, unsigned SectionID, + llvm::StringRef SectionName, bool IsReadOnly) { + Log *log(lldb_private::GetLogIfAllCategoriesSet(LIBLLDB_LOG_EXPRESSIONS)); + + uint8_t *return_value = m_default_mm_ap->allocateDataSection( + Size, Alignment, SectionID, SectionName, IsReadOnly); + + uint32_t permissions = lldb::ePermissionsReadable; + if (!IsReadOnly) + permissions |= lldb::ePermissionsWritable; + m_parent.m_records.push_back(AllocationRecord( + (uintptr_t)return_value, permissions, + GetSectionTypeFromSectionName(SectionName, AllocationKind::Data), Size, + Alignment, SectionID, SectionName.str().c_str())); + if (log) { + log->Printf("IRExecutionUnit::allocateDataSection(Size=0x%" PRIx64 + ", Alignment=%u, SectionID=%u) = %p", + (uint64_t)Size, Alignment, SectionID, (void *)return_value); + } + + if (m_parent.m_reported_allocations) { + Error err; + lldb::ProcessSP process_sp = + m_parent.GetBestExecutionContextScope()->CalculateProcess(); + + m_parent.CommitOneAllocation(process_sp, err, m_parent.m_records.back()); + } - return return_value; + return return_value; } static ConstString FindBestAlternateMangledName(const ConstString &demangled, const lldb::LanguageType &lang_type, - const SymbolContext &sym_ctx) -{ - CPlusPlusLanguage::MethodName cpp_name(demangled); - std::string scope_qualified_name = cpp_name.GetScopeQualifiedName(); - - if (!scope_qualified_name.size()) - return ConstString(); - - if (!sym_ctx.module_sp) - return ConstString(); - - SymbolVendor *sym_vendor = sym_ctx.module_sp->GetSymbolVendor(); - if (!sym_vendor) - return ConstString(); - - lldb_private::SymbolFile *sym_file = sym_vendor->GetSymbolFile(); - if (!sym_file) - return ConstString(); - - std::vector<ConstString> alternates; - sym_file->GetMangledNamesForFunction(scope_qualified_name, alternates); - - std::vector<ConstString> param_and_qual_matches; - std::vector<ConstString> param_matches; - for (size_t i = 0; i < alternates.size(); i++) - { - ConstString alternate_mangled_name = alternates[i]; - Mangled mangled(alternate_mangled_name, true); - ConstString demangled = mangled.GetDemangledName(lang_type); - - CPlusPlusLanguage::MethodName alternate_cpp_name(demangled); - if (!cpp_name.IsValid()) - continue; - - if (alternate_cpp_name.GetArguments() == cpp_name.GetArguments()) - { - if (alternate_cpp_name.GetQualifiers() == cpp_name.GetQualifiers()) - param_and_qual_matches.push_back(alternate_mangled_name); - else - param_matches.push_back(alternate_mangled_name); - } + const SymbolContext &sym_ctx) { + CPlusPlusLanguage::MethodName cpp_name(demangled); + std::string scope_qualified_name = cpp_name.GetScopeQualifiedName(); + + if (!scope_qualified_name.size()) + return ConstString(); + + if (!sym_ctx.module_sp) + return ConstString(); + + SymbolVendor *sym_vendor = sym_ctx.module_sp->GetSymbolVendor(); + if (!sym_vendor) + return ConstString(); + + lldb_private::SymbolFile *sym_file = sym_vendor->GetSymbolFile(); + if (!sym_file) + return ConstString(); + + std::vector<ConstString> alternates; + sym_file->GetMangledNamesForFunction(scope_qualified_name, alternates); + + std::vector<ConstString> param_and_qual_matches; + std::vector<ConstString> param_matches; + for (size_t i = 0; i < alternates.size(); i++) { + ConstString alternate_mangled_name = alternates[i]; + Mangled mangled(alternate_mangled_name, true); + ConstString demangled = mangled.GetDemangledName(lang_type); + + CPlusPlusLanguage::MethodName alternate_cpp_name(demangled); + if (!cpp_name.IsValid()) + continue; + + if (alternate_cpp_name.GetArguments() == cpp_name.GetArguments()) { + if (alternate_cpp_name.GetQualifiers() == cpp_name.GetQualifiers()) + param_and_qual_matches.push_back(alternate_mangled_name); + else + param_matches.push_back(alternate_mangled_name); } - - if (param_and_qual_matches.size()) - return param_and_qual_matches[0]; // It is assumed that there will be only one! - else if (param_matches.size()) - return param_matches[0]; // Return one of them as a best match - else - return ConstString(); + } + + if (param_and_qual_matches.size()) + return param_and_qual_matches[0]; // It is assumed that there will be only + // one! + else if (param_matches.size()) + return param_matches[0]; // Return one of them as a best match + else + return ConstString(); } -struct IRExecutionUnit::SearchSpec -{ - ConstString name; - uint32_t mask; +struct IRExecutionUnit::SearchSpec { + ConstString name; + uint32_t mask; - SearchSpec(ConstString n, uint32_t m = lldb::eFunctionNameTypeFull) : - name(n), - mask(m) - { - } + SearchSpec(ConstString n, uint32_t m = lldb::eFunctionNameTypeFull) + : name(n), mask(m) {} }; -void -IRExecutionUnit::CollectCandidateCNames(std::vector<IRExecutionUnit::SearchSpec> &C_specs, const ConstString &name) -{ - if (m_strip_underscore && name.AsCString()[0] == '_') - C_specs.insert(C_specs.begin(), ConstString(&name.AsCString()[1])); - C_specs.push_back(SearchSpec(name)); +void IRExecutionUnit::CollectCandidateCNames( + std::vector<IRExecutionUnit::SearchSpec> &C_specs, + const ConstString &name) { + if (m_strip_underscore && name.AsCString()[0] == '_') + C_specs.insert(C_specs.begin(), ConstString(&name.AsCString()[1])); + C_specs.push_back(SearchSpec(name)); } -void -IRExecutionUnit::CollectCandidateCPlusPlusNames(std::vector<IRExecutionUnit::SearchSpec> &CPP_specs, const std::vector<SearchSpec> &C_specs, const SymbolContext &sc) -{ - for (const SearchSpec &C_spec : C_specs) - { - const ConstString &name = C_spec.name; - - if (CPlusPlusLanguage::IsCPPMangledName(name.GetCString())) - { - Mangled mangled(name, true); - ConstString demangled = mangled.GetDemangledName(lldb::eLanguageTypeC_plus_plus); - - if (demangled) - { - ConstString best_alternate_mangled_name = FindBestAlternateMangledName(demangled, lldb::eLanguageTypeC_plus_plus, sc); - - if (best_alternate_mangled_name) - { - CPP_specs.push_back(best_alternate_mangled_name); - } +void IRExecutionUnit::CollectCandidateCPlusPlusNames( + std::vector<IRExecutionUnit::SearchSpec> &CPP_specs, + const std::vector<SearchSpec> &C_specs, const SymbolContext &sc) { + for (const SearchSpec &C_spec : C_specs) { + const ConstString &name = C_spec.name; - CPP_specs.push_back(SearchSpec(demangled, lldb::eFunctionNameTypeFull)); - } - } + if (CPlusPlusLanguage::IsCPPMangledName(name.GetCString())) { + Mangled mangled(name, true); + ConstString demangled = + mangled.GetDemangledName(lldb::eLanguageTypeC_plus_plus); - // Maybe we're looking for a const symbol but the debug info told us it was const... - if (!strncmp(name.GetCString(), "_ZN", 3) && - strncmp(name.GetCString(), "_ZNK", 4)) - { - std::string fixed_scratch("_ZNK"); - fixed_scratch.append(name.GetCString() + 3); - CPP_specs.push_back(ConstString(fixed_scratch.c_str())); - } + if (demangled) { + ConstString best_alternate_mangled_name = FindBestAlternateMangledName( + demangled, lldb::eLanguageTypeC_plus_plus, sc); - // Maybe we're looking for a static symbol but we thought it was global... - if (!strncmp(name.GetCString(), "_Z", 2) && - strncmp(name.GetCString(), "_ZL", 3)) - { - std::string fixed_scratch("_ZL"); - fixed_scratch.append(name.GetCString() + 2); - CPP_specs.push_back(ConstString(fixed_scratch.c_str())); + if (best_alternate_mangled_name) { + CPP_specs.push_back(best_alternate_mangled_name); } + CPP_specs.push_back(SearchSpec(demangled, lldb::eFunctionNameTypeFull)); + } } + + std::set<ConstString> alternates; + CPlusPlusLanguage::FindAlternateFunctionManglings(name, alternates); + CPP_specs.insert(CPP_specs.end(), alternates.begin(), alternates.end()); + } } -void -IRExecutionUnit::CollectFallbackNames(std::vector<SearchSpec> &fallback_specs, - const std::vector<SearchSpec> &C_specs) -{ - // As a last-ditch fallback, try the base name for C++ names. It's terrible, - // but the DWARF doesn't always encode "extern C" correctly. - - for (const SearchSpec &C_spec : C_specs) - { - const ConstString &name = C_spec.name; - - if (CPlusPlusLanguage::IsCPPMangledName(name.GetCString())) - { - Mangled mangled_name(name); - ConstString demangled_name = mangled_name.GetDemangledName(lldb::eLanguageTypeC_plus_plus); - if (!demangled_name.IsEmpty()) - { - const char *demangled_cstr = demangled_name.AsCString(); - const char *lparen_loc = strchr(demangled_cstr, '('); - if (lparen_loc) - { - llvm::StringRef base_name(demangled_cstr, lparen_loc-demangled_cstr); - fallback_specs.push_back(ConstString(base_name)); - } - } +void IRExecutionUnit::CollectFallbackNames( + std::vector<SearchSpec> &fallback_specs, + const std::vector<SearchSpec> &C_specs) { + // As a last-ditch fallback, try the base name for C++ names. It's terrible, + // but the DWARF doesn't always encode "extern C" correctly. + + for (const SearchSpec &C_spec : C_specs) { + const ConstString &name = C_spec.name; + + if (CPlusPlusLanguage::IsCPPMangledName(name.GetCString())) { + Mangled mangled_name(name); + ConstString demangled_name = + mangled_name.GetDemangledName(lldb::eLanguageTypeC_plus_plus); + if (!demangled_name.IsEmpty()) { + const char *demangled_cstr = demangled_name.AsCString(); + const char *lparen_loc = strchr(demangled_cstr, '('); + if (lparen_loc) { + llvm::StringRef base_name(demangled_cstr, + lparen_loc - demangled_cstr); + fallback_specs.push_back(ConstString(base_name)); } + } } + } } +lldb::addr_t IRExecutionUnit::FindInSymbols( + const std::vector<IRExecutionUnit::SearchSpec> &specs, + const lldb_private::SymbolContext &sc) { + Target *target = sc.target_sp.get(); -lldb::addr_t -IRExecutionUnit::FindInSymbols(const std::vector<IRExecutionUnit::SearchSpec> &specs, const lldb_private::SymbolContext &sc) -{ - Target *target = sc.target_sp.get(); - - if (!target) - { - // we shouldn't be doing any symbol lookup at all without a target - return LLDB_INVALID_ADDRESS; - } + if (!target) { + // we shouldn't be doing any symbol lookup at all without a target + return LLDB_INVALID_ADDRESS; + } - for (const SearchSpec &spec : specs) - { - SymbolContextList sc_list; + for (const SearchSpec &spec : specs) { + SymbolContextList sc_list; - lldb::addr_t best_internal_load_address = LLDB_INVALID_ADDRESS; + lldb::addr_t best_internal_load_address = LLDB_INVALID_ADDRESS; - std::function<bool (lldb::addr_t &, SymbolContextList &, const lldb_private::SymbolContext &)> get_external_load_address = - [&best_internal_load_address, target](lldb::addr_t &load_address, - SymbolContextList &sc_list, - const lldb_private::SymbolContext &sc) -> lldb::addr_t - { - load_address = LLDB_INVALID_ADDRESS; + std::function<bool(lldb::addr_t &, SymbolContextList &, + const lldb_private::SymbolContext &)> + get_external_load_address = [&best_internal_load_address, target]( + lldb::addr_t &load_address, SymbolContextList &sc_list, + const lldb_private::SymbolContext &sc) -> lldb::addr_t { + load_address = LLDB_INVALID_ADDRESS; - for (size_t si = 0, se = sc_list.GetSize(); si < se; ++si) - { - SymbolContext candidate_sc; - - sc_list.GetContextAtIndex(si, candidate_sc); - - const bool is_external = (candidate_sc.function) || - (candidate_sc.symbol && candidate_sc.symbol->IsExternal()); - if (candidate_sc.symbol) - { - load_address = candidate_sc.symbol->ResolveCallableAddress(*target); - - if (load_address == LLDB_INVALID_ADDRESS) - { - if (target->GetProcessSP()) - load_address = candidate_sc.symbol->GetAddress().GetLoadAddress(target); - else - load_address = candidate_sc.symbol->GetAddress().GetFileAddress(); - } - } + for (size_t si = 0, se = sc_list.GetSize(); si < se; ++si) { + SymbolContext candidate_sc; - if (load_address == LLDB_INVALID_ADDRESS && candidate_sc.function) - { - if (target->GetProcessSP()) - load_address = candidate_sc.function->GetAddressRange().GetBaseAddress().GetLoadAddress(target); - else - load_address = candidate_sc.function->GetAddressRange().GetBaseAddress().GetFileAddress(); - } + sc_list.GetContextAtIndex(si, candidate_sc); - if (load_address != LLDB_INVALID_ADDRESS) - { - if (is_external) - { - return true; - } - else if (best_internal_load_address == LLDB_INVALID_ADDRESS) - { - best_internal_load_address = load_address; - load_address = LLDB_INVALID_ADDRESS; - } - } - } + const bool is_external = + (candidate_sc.function) || + (candidate_sc.symbol && candidate_sc.symbol->IsExternal()); + if (candidate_sc.symbol) { + load_address = candidate_sc.symbol->ResolveCallableAddress(*target); - return false; - }; - - if (sc.module_sp) - { - sc.module_sp->FindFunctions(spec.name, - NULL, - spec.mask, - true, // include_symbols - false, // include_inlines - true, // append - sc_list); + if (load_address == LLDB_INVALID_ADDRESS) { + if (target->GetProcessSP()) + load_address = + candidate_sc.symbol->GetAddress().GetLoadAddress(target); + else + load_address = candidate_sc.symbol->GetAddress().GetFileAddress(); + } } - lldb::addr_t load_address = LLDB_INVALID_ADDRESS; - - if (get_external_load_address(load_address, sc_list, sc)) - { - return load_address; - } - else - { - sc_list.Clear(); + if (load_address == LLDB_INVALID_ADDRESS && candidate_sc.function) { + if (target->GetProcessSP()) + load_address = candidate_sc.function->GetAddressRange() + .GetBaseAddress() + .GetLoadAddress(target); + else + load_address = candidate_sc.function->GetAddressRange() + .GetBaseAddress() + .GetFileAddress(); } - if (sc_list.GetSize() == 0 && sc.target_sp) - { - sc.target_sp->GetImages().FindFunctions(spec.name, - spec.mask, - true, // include_symbols - false, // include_inlines - true, // append - sc_list); + if (load_address != LLDB_INVALID_ADDRESS) { + if (is_external) { + return true; + } else if (best_internal_load_address == LLDB_INVALID_ADDRESS) { + best_internal_load_address = load_address; + load_address = LLDB_INVALID_ADDRESS; + } } + } - if (get_external_load_address(load_address, sc_list, sc)) - { - return load_address; - } - else - { - sc_list.Clear(); - } + return false; + }; - if (sc_list.GetSize() == 0 && sc.target_sp) - { - sc.target_sp->GetImages().FindSymbolsWithNameAndType(spec.name, lldb::eSymbolTypeAny, sc_list); - } + if (sc.module_sp) { + sc.module_sp->FindFunctions(spec.name, NULL, spec.mask, + true, // include_symbols + false, // include_inlines + true, // append + sc_list); + } - if (get_external_load_address(load_address, sc_list, sc)) - { - return load_address; - } - // if there are any searches we try after this, add an sc_list.Clear() in an "else" clause here + lldb::addr_t load_address = LLDB_INVALID_ADDRESS; - if (best_internal_load_address != LLDB_INVALID_ADDRESS) - { - return best_internal_load_address; - } + if (get_external_load_address(load_address, sc_list, sc)) { + return load_address; + } else { + sc_list.Clear(); } - return LLDB_INVALID_ADDRESS; -} + if (sc_list.GetSize() == 0 && sc.target_sp) { + sc.target_sp->GetImages().FindFunctions(spec.name, spec.mask, + true, // include_symbols + false, // include_inlines + true, // append + sc_list); + } -lldb::addr_t -IRExecutionUnit::FindInRuntimes(const std::vector<SearchSpec> &specs, const lldb_private::SymbolContext &sc) -{ - lldb::TargetSP target_sp = sc.target_sp; + if (get_external_load_address(load_address, sc_list, sc)) { + return load_address; + } else { + sc_list.Clear(); + } - if (!target_sp) - { - return LLDB_INVALID_ADDRESS; + if (sc_list.GetSize() == 0 && sc.target_sp) { + sc.target_sp->GetImages().FindSymbolsWithNameAndType( + spec.name, lldb::eSymbolTypeAny, sc_list); } - lldb::ProcessSP process_sp = sc.target_sp->GetProcessSP(); + if (get_external_load_address(load_address, sc_list, sc)) { + return load_address; + } + // if there are any searches we try after this, add an sc_list.Clear() in an + // "else" clause here - if (!process_sp) - { - return LLDB_INVALID_ADDRESS; + if (best_internal_load_address != LLDB_INVALID_ADDRESS) { + return best_internal_load_address; } + } - ObjCLanguageRuntime *runtime = process_sp->GetObjCLanguageRuntime(); + return LLDB_INVALID_ADDRESS; +} - if (runtime) - { - for (const SearchSpec &spec : specs) - { - lldb::addr_t symbol_load_addr = runtime->LookupRuntimeSymbol(spec.name); +lldb::addr_t +IRExecutionUnit::FindInRuntimes(const std::vector<SearchSpec> &specs, + const lldb_private::SymbolContext &sc) { + lldb::TargetSP target_sp = sc.target_sp; - if (symbol_load_addr != LLDB_INVALID_ADDRESS) - return symbol_load_addr; - } - } + if (!target_sp) { + return LLDB_INVALID_ADDRESS; + } + + lldb::ProcessSP process_sp = sc.target_sp->GetProcessSP(); + if (!process_sp) { return LLDB_INVALID_ADDRESS; -} + } -lldb::addr_t -IRExecutionUnit::FindInUserDefinedSymbols(const std::vector<SearchSpec> &specs, const lldb_private::SymbolContext &sc) -{ - lldb::TargetSP target_sp = sc.target_sp; - - for (const SearchSpec &spec : specs) - { - lldb::addr_t symbol_load_addr = target_sp->GetPersistentSymbol(spec.name); - - if (symbol_load_addr != LLDB_INVALID_ADDRESS) - return symbol_load_addr; + ObjCLanguageRuntime *runtime = process_sp->GetObjCLanguageRuntime(); + + if (runtime) { + for (const SearchSpec &spec : specs) { + lldb::addr_t symbol_load_addr = runtime->LookupRuntimeSymbol(spec.name); + + if (symbol_load_addr != LLDB_INVALID_ADDRESS) + return symbol_load_addr; } - - return LLDB_INVALID_ADDRESS; + } + + return LLDB_INVALID_ADDRESS; +} + +lldb::addr_t IRExecutionUnit::FindInUserDefinedSymbols( + const std::vector<SearchSpec> &specs, + const lldb_private::SymbolContext &sc) { + lldb::TargetSP target_sp = sc.target_sp; + + for (const SearchSpec &spec : specs) { + lldb::addr_t symbol_load_addr = target_sp->GetPersistentSymbol(spec.name); + + if (symbol_load_addr != LLDB_INVALID_ADDRESS) + return symbol_load_addr; + } + + return LLDB_INVALID_ADDRESS; } lldb::addr_t -IRExecutionUnit::FindSymbol(const lldb_private::ConstString &name) -{ - std::vector<SearchSpec> candidate_C_names; - std::vector<SearchSpec> candidate_CPlusPlus_names; +IRExecutionUnit::FindSymbol(const lldb_private::ConstString &name) { + std::vector<SearchSpec> candidate_C_names; + std::vector<SearchSpec> candidate_CPlusPlus_names; - CollectCandidateCNames(candidate_C_names, name); + CollectCandidateCNames(candidate_C_names, name); - lldb::addr_t ret = FindInSymbols(candidate_C_names, m_sym_ctx); - if (ret == LLDB_INVALID_ADDRESS) - ret = FindInRuntimes(candidate_C_names, m_sym_ctx); + lldb::addr_t ret = FindInSymbols(candidate_C_names, m_sym_ctx); + if (ret == LLDB_INVALID_ADDRESS) + ret = FindInRuntimes(candidate_C_names, m_sym_ctx); - if (ret == LLDB_INVALID_ADDRESS) - ret = FindInUserDefinedSymbols(candidate_C_names, m_sym_ctx); + if (ret == LLDB_INVALID_ADDRESS) + ret = FindInUserDefinedSymbols(candidate_C_names, m_sym_ctx); - if (ret == LLDB_INVALID_ADDRESS) - { - CollectCandidateCPlusPlusNames(candidate_CPlusPlus_names, candidate_C_names, m_sym_ctx); - ret = FindInSymbols(candidate_CPlusPlus_names, m_sym_ctx); - } - - if (ret == LLDB_INVALID_ADDRESS) - { - std::vector<SearchSpec> candidate_fallback_names; + if (ret == LLDB_INVALID_ADDRESS) { + CollectCandidateCPlusPlusNames(candidate_CPlusPlus_names, candidate_C_names, + m_sym_ctx); + ret = FindInSymbols(candidate_CPlusPlus_names, m_sym_ctx); + } - CollectFallbackNames(candidate_fallback_names, candidate_C_names); - ret = FindInSymbols(candidate_fallback_names, m_sym_ctx); - } + if (ret == LLDB_INVALID_ADDRESS) { + std::vector<SearchSpec> candidate_fallback_names; - return ret; + CollectFallbackNames(candidate_fallback_names, candidate_C_names); + ret = FindInSymbols(candidate_fallback_names, m_sym_ctx); + } + + return ret; } -void -IRExecutionUnit::GetStaticInitializers(std::vector <lldb::addr_t> &static_initializers) -{ - if (llvm::GlobalVariable *global_ctors = m_module->getNamedGlobal("llvm.global_ctors")) - { - if (llvm::ConstantArray *ctor_array = llvm::dyn_cast<llvm::ConstantArray>(global_ctors->getInitializer())) - { - for (llvm::Use &ctor_use : ctor_array->operands()) - { - if (llvm::ConstantStruct *ctor_struct = llvm::dyn_cast<llvm::ConstantStruct>(ctor_use)) - { - lldbassert(ctor_struct->getNumOperands() == 3); // this is standardized - if (llvm::Function *ctor_function = llvm::dyn_cast<llvm::Function>(ctor_struct->getOperand(1))) - { - ctor_function->dump(); - - ConstString ctor_function_name_cs(ctor_function->getName().str()); - - for (JittedFunction &jitted_function : m_jitted_functions) - { - if (ctor_function_name_cs == jitted_function.m_name) - { - if (jitted_function.m_remote_addr != LLDB_INVALID_ADDRESS) - { - static_initializers.push_back(jitted_function.m_remote_addr); - } - break; - } - } - } +void IRExecutionUnit::GetStaticInitializers( + std::vector<lldb::addr_t> &static_initializers) { + if (llvm::GlobalVariable *global_ctors = + m_module->getNamedGlobal("llvm.global_ctors")) { + if (llvm::ConstantArray *ctor_array = llvm::dyn_cast<llvm::ConstantArray>( + global_ctors->getInitializer())) { + for (llvm::Use &ctor_use : ctor_array->operands()) { + if (llvm::ConstantStruct *ctor_struct = + llvm::dyn_cast<llvm::ConstantStruct>(ctor_use)) { + lldbassert(ctor_struct->getNumOperands() == + 3); // this is standardized + if (llvm::Function *ctor_function = + llvm::dyn_cast<llvm::Function>(ctor_struct->getOperand(1))) { + ConstString ctor_function_name_cs(ctor_function->getName().str()); + + for (JittedFunction &jitted_function : m_jitted_functions) { + if (ctor_function_name_cs == jitted_function.m_name) { + if (jitted_function.m_remote_addr != LLDB_INVALID_ADDRESS) { + static_initializers.push_back(jitted_function.m_remote_addr); } + break; + } } + } } + } } + } } uint64_t -IRExecutionUnit::MemoryManager::getSymbolAddress(const std::string &Name) -{ - Log *log(lldb_private::GetLogIfAllCategoriesSet (LIBLLDB_LOG_EXPRESSIONS)); +IRExecutionUnit::MemoryManager::getSymbolAddress(const std::string &Name) { + Log *log(lldb_private::GetLogIfAllCategoriesSet(LIBLLDB_LOG_EXPRESSIONS)); - ConstString name_cs(Name.c_str()); + ConstString name_cs(Name.c_str()); - lldb::addr_t ret = m_parent.FindSymbol(name_cs); + lldb::addr_t ret = m_parent.FindSymbol(name_cs); - if (ret == LLDB_INVALID_ADDRESS) - { - if (log) - log->Printf("IRExecutionUnit::getSymbolAddress(Name=\"%s\") = <not found>", - Name.c_str()); + if (ret == LLDB_INVALID_ADDRESS) { + if (log) + log->Printf( + "IRExecutionUnit::getSymbolAddress(Name=\"%s\") = <not found>", + Name.c_str()); - m_parent.ReportSymbolLookupError(name_cs); - return 0xbad0bad0; - } - else - { - if (log) - log->Printf("IRExecutionUnit::getSymbolAddress(Name=\"%s\") = %" PRIx64, - Name.c_str(), - ret); - return ret; - } + m_parent.ReportSymbolLookupError(name_cs); + return 0xbad0bad0; + } else { + if (log) + log->Printf("IRExecutionUnit::getSymbolAddress(Name=\"%s\") = %" PRIx64, + Name.c_str(), ret); + return ret; + } } -void * -IRExecutionUnit::MemoryManager::getPointerToNamedFunction(const std::string &Name, - bool AbortOnFailure) { - assert (sizeof(void *) == 8); +void *IRExecutionUnit::MemoryManager::getPointerToNamedFunction( + const std::string &Name, bool AbortOnFailure) { + assert(sizeof(void *) == 8); - return (void*)getSymbolAddress(Name); + return (void *)getSymbolAddress(Name); } lldb::addr_t -IRExecutionUnit::GetRemoteAddressForLocal (lldb::addr_t local_address) -{ - Log *log(lldb_private::GetLogIfAllCategoriesSet (LIBLLDB_LOG_EXPRESSIONS)); +IRExecutionUnit::GetRemoteAddressForLocal(lldb::addr_t local_address) { + Log *log(lldb_private::GetLogIfAllCategoriesSet(LIBLLDB_LOG_EXPRESSIONS)); - for (AllocationRecord &record : m_records) - { - if (local_address >= record.m_host_address && - local_address < record.m_host_address + record.m_size) - { - if (record.m_process_address == LLDB_INVALID_ADDRESS) - return LLDB_INVALID_ADDRESS; + for (AllocationRecord &record : m_records) { + if (local_address >= record.m_host_address && + local_address < record.m_host_address + record.m_size) { + if (record.m_process_address == LLDB_INVALID_ADDRESS) + return LLDB_INVALID_ADDRESS; - lldb::addr_t ret = record.m_process_address + (local_address - record.m_host_address); + lldb::addr_t ret = + record.m_process_address + (local_address - record.m_host_address); - if (log) - { - log->Printf("IRExecutionUnit::GetRemoteAddressForLocal() found 0x%" PRIx64 " in [0x%" PRIx64 "..0x%" PRIx64 "], and returned 0x%" PRIx64 " from [0x%" PRIx64 "..0x%" PRIx64 "].", - local_address, - (uint64_t)record.m_host_address, - (uint64_t)record.m_host_address + (uint64_t)record.m_size, - ret, - record.m_process_address, - record.m_process_address + record.m_size); - } + if (log) { + log->Printf( + "IRExecutionUnit::GetRemoteAddressForLocal() found 0x%" PRIx64 + " in [0x%" PRIx64 "..0x%" PRIx64 "], and returned 0x%" PRIx64 + " from [0x%" PRIx64 "..0x%" PRIx64 "].", + local_address, (uint64_t)record.m_host_address, + (uint64_t)record.m_host_address + (uint64_t)record.m_size, ret, + record.m_process_address, record.m_process_address + record.m_size); + } - return ret; - } + return ret; } + } - return LLDB_INVALID_ADDRESS; + return LLDB_INVALID_ADDRESS; } IRExecutionUnit::AddrRange -IRExecutionUnit::GetRemoteRangeForLocal (lldb::addr_t local_address) -{ - for (AllocationRecord &record : m_records) - { - if (local_address >= record.m_host_address && - local_address < record.m_host_address + record.m_size) - { - if (record.m_process_address == LLDB_INVALID_ADDRESS) - return AddrRange(0, 0); - - return AddrRange(record.m_process_address, record.m_size); - } +IRExecutionUnit::GetRemoteRangeForLocal(lldb::addr_t local_address) { + for (AllocationRecord &record : m_records) { + if (local_address >= record.m_host_address && + local_address < record.m_host_address + record.m_size) { + if (record.m_process_address == LLDB_INVALID_ADDRESS) + return AddrRange(0, 0); + + return AddrRange(record.m_process_address, record.m_size); } + } - return AddrRange (0, 0); + return AddrRange(0, 0); } -bool -IRExecutionUnit::CommitOneAllocation (lldb::ProcessSP &process_sp, - Error &error, - AllocationRecord &record) -{ - if (record.m_process_address != LLDB_INVALID_ADDRESS) - { - return true; - } - - switch (record.m_sect_type) - { - case lldb::eSectionTypeInvalid: - case lldb::eSectionTypeDWARFDebugAbbrev: - case lldb::eSectionTypeDWARFDebugAddr: - case lldb::eSectionTypeDWARFDebugAranges: - case lldb::eSectionTypeDWARFDebugFrame: - case lldb::eSectionTypeDWARFDebugInfo: - case lldb::eSectionTypeDWARFDebugLine: - case lldb::eSectionTypeDWARFDebugLoc: - case lldb::eSectionTypeDWARFDebugMacInfo: - case lldb::eSectionTypeDWARFDebugPubNames: - case lldb::eSectionTypeDWARFDebugPubTypes: - case lldb::eSectionTypeDWARFDebugRanges: - case lldb::eSectionTypeDWARFDebugStr: - case lldb::eSectionTypeDWARFDebugStrOffsets: - case lldb::eSectionTypeDWARFAppleNames: - case lldb::eSectionTypeDWARFAppleTypes: - case lldb::eSectionTypeDWARFAppleNamespaces: - case lldb::eSectionTypeDWARFAppleObjC: - error.Clear(); - break; - default: - const bool zero_memory = false; - record.m_process_address = Malloc (record.m_size, - record.m_alignment, - record.m_permissions, - eAllocationPolicyProcessOnly, - zero_memory, - error); - break; - } - - return error.Success(); +bool IRExecutionUnit::CommitOneAllocation(lldb::ProcessSP &process_sp, + Error &error, + AllocationRecord &record) { + if (record.m_process_address != LLDB_INVALID_ADDRESS) { + return true; + } + + switch (record.m_sect_type) { + case lldb::eSectionTypeInvalid: + case lldb::eSectionTypeDWARFDebugAbbrev: + case lldb::eSectionTypeDWARFDebugAddr: + case lldb::eSectionTypeDWARFDebugAranges: + case lldb::eSectionTypeDWARFDebugFrame: + case lldb::eSectionTypeDWARFDebugInfo: + case lldb::eSectionTypeDWARFDebugLine: + case lldb::eSectionTypeDWARFDebugLoc: + case lldb::eSectionTypeDWARFDebugMacInfo: + case lldb::eSectionTypeDWARFDebugPubNames: + case lldb::eSectionTypeDWARFDebugPubTypes: + case lldb::eSectionTypeDWARFDebugRanges: + case lldb::eSectionTypeDWARFDebugStr: + case lldb::eSectionTypeDWARFDebugStrOffsets: + case lldb::eSectionTypeDWARFAppleNames: + case lldb::eSectionTypeDWARFAppleTypes: + case lldb::eSectionTypeDWARFAppleNamespaces: + case lldb::eSectionTypeDWARFAppleObjC: + error.Clear(); + break; + default: + const bool zero_memory = false; + record.m_process_address = + Malloc(record.m_size, record.m_alignment, record.m_permissions, + eAllocationPolicyProcessOnly, zero_memory, error); + break; + } + + return error.Success(); } -bool -IRExecutionUnit::CommitAllocations (lldb::ProcessSP &process_sp) -{ - bool ret = true; +bool IRExecutionUnit::CommitAllocations(lldb::ProcessSP &process_sp) { + bool ret = true; - lldb_private::Error err; + lldb_private::Error err; - for (AllocationRecord &record : m_records) - { - ret = CommitOneAllocation(process_sp, err, record); - - if (!ret) - { - break; - } - } + for (AllocationRecord &record : m_records) { + ret = CommitOneAllocation(process_sp, err, record); - if (!ret) - { - for (AllocationRecord &record : m_records) - { - if (record.m_process_address != LLDB_INVALID_ADDRESS) - { - Free(record.m_process_address, err); - record.m_process_address = LLDB_INVALID_ADDRESS; - } - } + if (!ret) { + break; + } + } + + if (!ret) { + for (AllocationRecord &record : m_records) { + if (record.m_process_address != LLDB_INVALID_ADDRESS) { + Free(record.m_process_address, err); + record.m_process_address = LLDB_INVALID_ADDRESS; + } } + } - return ret; + return ret; } -void -IRExecutionUnit::ReportAllocations (llvm::ExecutionEngine &engine) -{ - m_reported_allocations = true; - - for (AllocationRecord &record : m_records) - { - if (record.m_process_address == LLDB_INVALID_ADDRESS) - continue; +void IRExecutionUnit::ReportAllocations(llvm::ExecutionEngine &engine) { + m_reported_allocations = true; - if (record.m_section_id == eSectionIDInvalid) - continue; + for (AllocationRecord &record : m_records) { + if (record.m_process_address == LLDB_INVALID_ADDRESS) + continue; - engine.mapSectionAddress((void*)record.m_host_address, record.m_process_address); - } + if (record.m_section_id == eSectionIDInvalid) + continue; - // Trigger re-application of relocations. - engine.finalizeObject(); -} + engine.mapSectionAddress((void *)record.m_host_address, + record.m_process_address); + } -bool -IRExecutionUnit::WriteData (lldb::ProcessSP &process_sp) -{ - bool wrote_something = false; - for (AllocationRecord &record : m_records) - { - if (record.m_process_address != LLDB_INVALID_ADDRESS) - { - lldb_private::Error err; - WriteMemory (record.m_process_address, (uint8_t*)record.m_host_address, record.m_size, err); - if (err.Success()) - wrote_something = true; - } - } - return wrote_something; + // Trigger re-application of relocations. + engine.finalizeObject(); } -void -IRExecutionUnit::AllocationRecord::dump (Log *log) -{ - if (!log) - return; - - log->Printf("[0x%llx+0x%llx]->0x%llx (alignment %d, section ID %d, name %s)", - (unsigned long long)m_host_address, - (unsigned long long)m_size, - (unsigned long long)m_process_address, - (unsigned)m_alignment, - (unsigned)m_section_id, - m_name.c_str()); +bool IRExecutionUnit::WriteData(lldb::ProcessSP &process_sp) { + bool wrote_something = false; + for (AllocationRecord &record : m_records) { + if (record.m_process_address != LLDB_INVALID_ADDRESS) { + lldb_private::Error err; + WriteMemory(record.m_process_address, (uint8_t *)record.m_host_address, + record.m_size, err); + if (err.Success()) + wrote_something = true; + } + } + return wrote_something; } +void IRExecutionUnit::AllocationRecord::dump(Log *log) { + if (!log) + return; -lldb::ByteOrder -IRExecutionUnit::GetByteOrder () const -{ - ExecutionContext exe_ctx (GetBestExecutionContextScope()); - return exe_ctx.GetByteOrder(); + log->Printf("[0x%llx+0x%llx]->0x%llx (alignment %d, section ID %d, name %s)", + (unsigned long long)m_host_address, (unsigned long long)m_size, + (unsigned long long)m_process_address, (unsigned)m_alignment, + (unsigned)m_section_id, m_name.c_str()); } -uint32_t -IRExecutionUnit::GetAddressByteSize () const -{ - ExecutionContext exe_ctx (GetBestExecutionContextScope()); - return exe_ctx.GetAddressByteSize(); +lldb::ByteOrder IRExecutionUnit::GetByteOrder() const { + ExecutionContext exe_ctx(GetBestExecutionContextScope()); + return exe_ctx.GetByteOrder(); } -void -IRExecutionUnit::PopulateSymtab (lldb_private::ObjectFile *obj_file, - lldb_private::Symtab &symtab) -{ - // No symbols yet... +uint32_t IRExecutionUnit::GetAddressByteSize() const { + ExecutionContext exe_ctx(GetBestExecutionContextScope()); + return exe_ctx.GetAddressByteSize(); } +void IRExecutionUnit::PopulateSymtab(lldb_private::ObjectFile *obj_file, + lldb_private::Symtab &symtab) { + // No symbols yet... +} -void -IRExecutionUnit::PopulateSectionList (lldb_private::ObjectFile *obj_file, - lldb_private::SectionList §ion_list) -{ - for (AllocationRecord &record : m_records) - { - if (record.m_size > 0) - { - lldb::SectionSP section_sp (new lldb_private::Section (obj_file->GetModule(), - obj_file, - record.m_section_id, - ConstString(record.m_name), - record.m_sect_type, - record.m_process_address, - record.m_size, - record.m_host_address, // file_offset (which is the host address for the data) - record.m_size, // file_size - 0, - record.m_permissions)); // flags - section_list.AddSection (section_sp); - } +void IRExecutionUnit::PopulateSectionList( + lldb_private::ObjectFile *obj_file, + lldb_private::SectionList §ion_list) { + for (AllocationRecord &record : m_records) { + if (record.m_size > 0) { + lldb::SectionSP section_sp(new lldb_private::Section( + obj_file->GetModule(), obj_file, record.m_section_id, + ConstString(record.m_name), record.m_sect_type, + record.m_process_address, record.m_size, + record.m_host_address, // file_offset (which is the host address for + // the data) + record.m_size, // file_size + 0, + record.m_permissions)); // flags + section_list.AddSection(section_sp); } + } } -bool -IRExecutionUnit::GetArchitecture (lldb_private::ArchSpec &arch) -{ - ExecutionContext exe_ctx (GetBestExecutionContextScope()); - Target *target = exe_ctx.GetTargetPtr(); - if (target) - arch = target->GetArchitecture(); - else - arch.Clear(); - return arch.IsValid(); +bool IRExecutionUnit::GetArchitecture(lldb_private::ArchSpec &arch) { + ExecutionContext exe_ctx(GetBestExecutionContextScope()); + Target *target = exe_ctx.GetTargetPtr(); + if (target) + arch = target->GetArchitecture(); + else + arch.Clear(); + return arch.IsValid(); } -lldb::ModuleSP -IRExecutionUnit::GetJITModule () -{ - ExecutionContext exe_ctx (GetBestExecutionContextScope()); - Target *target = exe_ctx.GetTargetPtr(); - if (target) - { - lldb::ModuleSP jit_module_sp = lldb_private::Module::CreateJITModule (std::static_pointer_cast<lldb_private::ObjectFileJITDelegate>(shared_from_this())); - if (jit_module_sp) - { - bool changed = false; - jit_module_sp->SetLoadAddress(*target, 0, true, changed); - } - return jit_module_sp; +lldb::ModuleSP IRExecutionUnit::GetJITModule() { + ExecutionContext exe_ctx(GetBestExecutionContextScope()); + Target *target = exe_ctx.GetTargetPtr(); + if (target) { + lldb::ModuleSP jit_module_sp = lldb_private::Module::CreateJITModule( + std::static_pointer_cast<lldb_private::ObjectFileJITDelegate>( + shared_from_this())); + if (jit_module_sp) { + bool changed = false; + jit_module_sp->SetLoadAddress(*target, 0, true, changed); } - return lldb::ModuleSP(); + return jit_module_sp; + } + return lldb::ModuleSP(); } |
