diff options
Diffstat (limited to 'source/Expression/IRExecutionUnit.cpp')
| -rw-r--r-- | source/Expression/IRExecutionUnit.cpp | 497 |
1 files changed, 360 insertions, 137 deletions
diff --git a/source/Expression/IRExecutionUnit.cpp b/source/Expression/IRExecutionUnit.cpp index 17bd03ae6cb5..090f88fc1bfe 100644 --- a/source/Expression/IRExecutionUnit.cpp +++ b/source/Expression/IRExecutionUnit.cpp @@ -7,18 +7,16 @@ // //===----------------------------------------------------------------------===// -// C Includes -// C++ Includes -// Other libraries and framework includes #include "llvm/ExecutionEngine/ExecutionEngine.h" #include "llvm/IR/LLVMContext.h" #include "llvm/IR/Module.h" #include "llvm/Support/SourceMgr.h" -// Project includes #include "lldb/Core/DataBufferHeap.h" #include "lldb/Core/DataExtractor.h" #include "lldb/Core/Disassembler.h" #include "lldb/Core/Log.h" +#include "lldb/Core/Module.h" +#include "lldb/Core/Section.h" #include "lldb/Expression/IRExecutionUnit.h" #include "lldb/Target/ExecutionContext.h" #include "lldb/Target/Target.h" @@ -46,39 +44,39 @@ lldb::addr_t IRExecutionUnit::WriteNow (const uint8_t *bytes, size_t size, Error &error) -{ +{ lldb::addr_t allocation_process_addr = Malloc (size, 8, lldb::ePermissionsWritable | lldb::ePermissionsReadable, eAllocationPolicyMirror, error); - + if (!error.Success()) return LLDB_INVALID_ADDRESS; - + WriteMemory(allocation_process_addr, bytes, size, error); - + if (!error.Success()) { Error err; Free (allocation_process_addr, err); - + 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 (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; } @@ -87,9 +85,9 @@ IRExecutionUnit::FreeNow (lldb::addr_t allocation) { if (allocation == LLDB_INVALID_ADDRESS) return; - + Error err; - + Free(allocation, err); } @@ -98,16 +96,16 @@ IRExecutionUnit::DisassembleFunction (Stream &stream, lldb::ProcessSP &process_wp) { Log *log(lldb_private::GetLogIfAllCategoriesSet (LIBLLDB_LOG_EXPRESSIONS)); - + ExecutionContext exe_ctx(process_wp); - + Error ret; - + ret.Clear(); - + 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 (strstr(function.m_name.c_str(), m_name.AsCString())) @@ -116,31 +114,31 @@ IRExecutionUnit::DisassembleFunction (Stream &stream, 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 (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; - + 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 (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) { @@ -148,44 +146,44 @@ IRExecutionUnit::DisassembleFunction (Stream &stream, ret.SetErrorString("Couldn't find the target"); return ret; } - + lldb::DataBufferSP buffer_sp(new DataBufferHeap(func_range.second, 0)); - + Process *process = exe_ctx.GetProcessPtr(); Error err; process->ReadMemory(func_remote_addr, buffer_sp->GetBytes(), buffer_sp->GetByteSize(), err); - + if (!err.Success()) { ret.SetErrorToGenericError(); ret.SetErrorStringWithFormat("Couldn't read from process: %s", err.AsCString("unknown error")); return ret; } - + ArchSpec arch(target->GetArchitecture()); - + const char *plugin_name = NULL; const char *flavor_string = NULL; lldb::DisassemblerSP disassembler_sp = Disassembler::FindPlugin(arch, flavor_string, plugin_name); - + if (!disassembler_sp) { ret.SetErrorToGenericError(); ret.SetErrorStringWithFormat("Unable to find disassembler plug-in for %s architecture.", arch.GetArchitectureName()); return ret; } - + if (!process) { ret.SetErrorToGenericError(); ret.SetErrorString("Couldn't find the process"); return ret; } - + DataExtractor extractor(buffer_sp, process->GetByteOrder(), target->GetArchitecture().GetAddressByteSize()); - + if (log) { log->Printf("Function data has contents:"); @@ -196,12 +194,12 @@ IRExecutionUnit::DisassembleFunction (Stream &stream, 16, DataExtractor::TypeUInt8); } - + disassembler_sp->DecodeInstructions (Address (func_remote_addr), extractor, 0, UINT32_MAX, false, false); - + InstructionList &instruction_list = disassembler_sp->GetInstructionList(); const uint32_t max_opcode_byte_size = instruction_list.GetMaxOpcocdeByteSize(); - + for (size_t instruction_index = 0, num_instructions = instruction_list.GetSize(); instruction_index < num_instructions; ++instruction_index) @@ -223,7 +221,7 @@ IRExecutionUnit::DisassembleFunction (Stream &stream, static void ReportInlineAsmError(const llvm::SMDiagnostic &diagnostic, void *Context, unsigned LocCookie) { Error *err = static_cast<Error*>(Context); - + if (err && err->Success()) { err->SetErrorToGenericError(); @@ -237,52 +235,52 @@ IRExecutionUnit::GetRunnableInfo(Error &error, lldb::addr_t &func_end) { lldb::ProcessSP process_sp(GetProcessWP().lock()); - + static Mutex s_runnable_info_mutex(Mutex::Type::eMutexTypeRecursive); - + 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; } - + if (m_did_jit) { func_addr = m_function_load_addr; func_end = m_function_end_load_addr; - + return; }; - + Mutex::Locker runnable_info_mutex_locker(s_runnable_info_mutex); - + m_did_jit = true; - + Log *log(lldb_private::GetLogIfAllCategoriesSet (LIBLLDB_LOG_EXPRESSIONS)); - + std::string error_string; - + if (log) { std::string s; llvm::raw_string_ostream oss(s); - + m_module->print(oss, NULL); - + oss.flush(); - + log->Printf ("Module being sent to JIT: \n%s", s.c_str()); } - + llvm::Triple triple(m_module->getTargetTriple()); llvm::Function *function = m_module->getFunction (m_name.AsCString()); llvm::Reloc::Model relocModel; llvm::CodeModel::Model codeModel; - + if (triple.isOSBinFormatELF()) { relocModel = llvm::Reloc::Static; @@ -294,11 +292,11 @@ IRExecutionUnit::GetRunnableInfo(Error &error, relocModel = llvm::Reloc::PIC_; codeModel = llvm::CodeModel::Small; } - + m_module_ap->getContext().setInlineAsmDiagnosticHandler(ReportInlineAsmError, &error); - - llvm::EngineBuilder builder(m_module_ap.get()); - + + llvm::EngineBuilder builder(std::move(m_module_ap)); + builder.setEngineKind(llvm::EngineKind::JIT) .setErrorStr(&error_string) .setRelocationModel(relocModel) @@ -307,68 +305,67 @@ IRExecutionUnit::GetRunnableInfo(Error &error, .setAllocateGVsWithCode(true) .setCodeModel(codeModel) .setUseMCJIT(true); - + llvm::StringRef mArch; llvm::StringRef mCPU; llvm::SmallVector<std::string, 0> mAttrs; - + for (std::string &feature : m_cpu_features) mAttrs.push_back(feature); - + llvm::TargetMachine *target_machine = builder.selectTarget(triple, mArch, mCPU, mAttrs); - + 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; } - else - { - m_module_ap.release(); // ownership was transferred - } - + + // Make sure we see all sections, including ones that don't have relocations... + m_execution_engine_ap->setProcessAllSections(true); + m_execution_engine_ap->DisableLazyCompilation(); - + // We don't actually need the function pointer here, this just forces it to get resolved. - + void *fun_ptr = m_execution_engine_ap->getPointerToFunction(function); - + if (!error.Success()) { // We got an error through our callback! return; } - + if (!function) { error.SetErrorToGenericError(); error.SetErrorStringWithFormat("Couldn't find '%s' in the JITted module", m_name.AsCString()); return; } - + if (!fun_ptr) { error.SetErrorToGenericError(); error.SetErrorStringWithFormat("'%s' was in the JITted module but wasn't lowered", m_name.AsCString()); return; } - + m_jitted_functions.push_back (JittedFunction(m_name.AsCString(), (lldb::addr_t)fun_ptr)); - + CommitAllocations(process_sp); ReportAllocations(*m_execution_engine_ap); WriteData(process_sp); - + for (JittedFunction &jitted_function : m_jitted_functions) { jitted_function.m_remote_addr = GetRemoteAddressForLocal (jitted_function.m_local_addr); - + if (!jitted_function.m_name.compare(m_name.AsCString())) { AddrRange func_range = GetRemoteRangeForLocal(jitted_function.m_local_addr); @@ -376,15 +373,15 @@ IRExecutionUnit::GetRunnableInfo(Error &error, m_function_load_addr = jitted_function.m_remote_addr; } } - + if (log) { log->Printf("Code can be run in the target."); - + StreamString disassembly_stream; - + Error err = DisassembleFunction(disassembly_stream, process_sp); - + if (!err.Success()) { log->Printf("Couldn't disassemble function : %s", err.AsCString("unknown error")); @@ -393,18 +390,18 @@ IRExecutionUnit::GetRunnableInfo(Error &error, { log->Printf("Function disassembly:\n%s", disassembly_stream.GetData()); } - + log->Printf("Sections: "); for (AllocationRecord &record : m_records) { if (record.m_process_address != LLDB_INVALID_ADDRESS) { record.dump(log); - + 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); @@ -413,10 +410,10 @@ IRExecutionUnit::GetRunnableInfo(Error &error, } } } - + func_addr = m_function_load_addr; func_end = m_function_end_load_addr; - + return; } @@ -433,6 +430,9 @@ IRExecutionUnit::MemoryManager::MemoryManager (IRExecutionUnit &parent) : { } +IRExecutionUnit::MemoryManager::~MemoryManager () +{ +} void IRExecutionUnit::MemoryManager::setMemoryWritable () { @@ -464,15 +464,19 @@ IRExecutionUnit::MemoryManager::allocateStub(const llvm::GlobalValue* F, m_parent.m_records.push_back(AllocationRecord((uintptr_t)return_value, lldb::ePermissionsReadable | lldb::ePermissionsWritable, + GetSectionTypeFromSectionName (llvm::StringRef(), AllocationKind::Stub), StubSize, - Alignment)); + Alignment, + eSectionIDInvalid, + NULL)); if (log) { log->Printf("IRExecutionUnit::allocateStub (F=%p, StubSize=%u, Alignment=%u) = %p", - F, StubSize, Alignment, return_value); + static_cast<const void*>(F), StubSize, Alignment, + static_cast<void*>(return_value)); } - + return return_value; } @@ -484,24 +488,136 @@ IRExecutionUnit::MemoryManager::endFunctionBody(const llvm::Function *F, m_default_mm_ap->endFunctionBody(F, FunctionStart, FunctionEnd); } +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; + 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; + 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)); + switch (apple_name[0]) + { + case 'n': + if (apple_name.equals("names")) + sect_type = lldb::eSectionTypeDWARFAppleNames; + else if (apple_name.equals("namespac") || apple_name.equals("namespaces")) + sect_type = lldb::eSectionTypeDWARFAppleNamespaces; + break; + case 't': + if (apple_name.equals("types")) + sect_type = lldb::eSectionTypeDWARFAppleTypes; + break; + case 'o': + if (apple_name.equals("objc")) + sect_type = lldb::eSectionTypeDWARFAppleObjC; + break; + default: + break; + } +#else + sect_type = lldb::eSectionTypeInvalid; +#endif + } + else if (name.equals("__objc_imageinfo")) + sect_type = lldb::eSectionTypeOther; + } + return sect_type; +} + uint8_t * IRExecutionUnit::MemoryManager::allocateSpace(intptr_t Size, unsigned Alignment) { Log *log(lldb_private::GetLogIfAllCategoriesSet (LIBLLDB_LOG_EXPRESSIONS)); uint8_t *return_value = m_default_mm_ap->allocateSpace(Size, Alignment); - + m_parent.m_records.push_back(AllocationRecord((uintptr_t)return_value, lldb::ePermissionsReadable | lldb::ePermissionsWritable, + GetSectionTypeFromSectionName (llvm::StringRef(), AllocationKind::Bytes), Size, - Alignment)); - + Alignment, + eSectionIDInvalid, + NULL)); + if (log) { log->Printf("IRExecutionUnit::allocateSpace(Size=%" PRIu64 ", Alignment=%u) = %p", (uint64_t)Size, Alignment, return_value); } - + return return_value; } @@ -512,21 +628,23 @@ IRExecutionUnit::MemoryManager::allocateCodeSection(uintptr_t Size, llvm::StringRef SectionName) { Log *log(lldb_private::GetLogIfAllCategoriesSet (LIBLLDB_LOG_EXPRESSIONS)); - + 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)); - + SectionID, + SectionName.str().c_str())); + if (log) { log->Printf("IRExecutionUnit::allocateCodeSection(Size=0x%" PRIx64 ", Alignment=%u, SectionID=%u) = %p", (uint64_t)Size, Alignment, SectionID, return_value); } - + return return_value; } @@ -540,19 +658,21 @@ IRExecutionUnit::MemoryManager::allocateDataSection(uintptr_t Size, Log *log(lldb_private::GetLogIfAllCategoriesSet (LIBLLDB_LOG_EXPRESSIONS)); uint8_t *return_value = m_default_mm_ap->allocateDataSection(Size, Alignment, SectionID, SectionName, IsReadOnly); - + m_parent.m_records.push_back(AllocationRecord((uintptr_t)return_value, - lldb::ePermissionsReadable | lldb::ePermissionsWritable, + lldb::ePermissionsReadable | (IsReadOnly ? 0 : lldb::ePermissionsWritable), + GetSectionTypeFromSectionName (SectionName, AllocationKind::Data), Size, Alignment, - SectionID)); + SectionID, + SectionName.str().c_str())); if (log) { log->Printf("IRExecutionUnit::allocateDataSection(Size=0x%" PRIx64 ", Alignment=%u, SectionID=%u) = %p", (uint64_t)Size, Alignment, SectionID, return_value); } - - return return_value; + + return return_value; } uint8_t * @@ -562,18 +682,21 @@ IRExecutionUnit::MemoryManager::allocateGlobal(uintptr_t Size, Log *log(lldb_private::GetLogIfAllCategoriesSet (LIBLLDB_LOG_EXPRESSIONS)); uint8_t *return_value = m_default_mm_ap->allocateGlobal(Size, Alignment); - + m_parent.m_records.push_back(AllocationRecord((uintptr_t)return_value, lldb::ePermissionsReadable | lldb::ePermissionsWritable, + GetSectionTypeFromSectionName (llvm::StringRef(), AllocationKind::Global), Size, - Alignment)); - + Alignment, + eSectionIDInvalid, + NULL)); + if (log) { log->Printf("IRExecutionUnit::allocateGlobal(Size=0x%" PRIx64 ", Alignment=%u) = %p", (uint64_t)Size, Alignment, return_value); } - + return return_value; } @@ -595,9 +718,9 @@ IRExecutionUnit::GetRemoteAddressForLocal (lldb::addr_t local_address) { 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); - + if (log) { log->Printf("IRExecutionUnit::GetRemoteAddressForLocal() found 0x%" PRIx64 " in [0x%" PRIx64 "..0x%" PRIx64 "], and returned 0x%" PRIx64 " from [0x%" PRIx64 "..0x%" PRIx64 "].", @@ -608,7 +731,7 @@ IRExecutionUnit::GetRemoteAddressForLocal (lldb::addr_t local_address) record.m_process_address, record.m_process_address + record.m_size); } - + return ret; } } @@ -626,11 +749,11 @@ IRExecutionUnit::GetRemoteRangeForLocal (lldb::addr_t local_address) { 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); } @@ -638,28 +761,50 @@ bool IRExecutionUnit::CommitAllocations (lldb::ProcessSP &process_sp) { bool ret = true; - + lldb_private::Error err; - + for (AllocationRecord &record : m_records) { if (record.m_process_address != LLDB_INVALID_ADDRESS) continue; - - - record.m_process_address = Malloc(record.m_size, - record.m_alignment, - record.m_permissions, - eAllocationPolicyProcessOnly, - err); - + + switch (record.m_sect_type) + { + case lldb::eSectionTypeInvalid: + case lldb::eSectionTypeDWARFDebugAbbrev: + 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::eSectionTypeDWARFAppleNames: + case lldb::eSectionTypeDWARFAppleTypes: + case lldb::eSectionTypeDWARFAppleNamespaces: + case lldb::eSectionTypeDWARFAppleObjC: + err.Clear(); + break; + default: + record.m_process_address = Malloc (record.m_size, + record.m_alignment, + record.m_permissions, + eAllocationPolicyProcessOnly, + err); + break; + } + if (!err.Success()) { ret = false; break; } } - + if (!ret) { for (AllocationRecord &record : m_records) @@ -671,7 +816,7 @@ IRExecutionUnit::CommitAllocations (lldb::ProcessSP &process_sp) } } } - + return ret; } @@ -682,13 +827,13 @@ IRExecutionUnit::ReportAllocations (llvm::ExecutionEngine &engine) { if (record.m_process_address == LLDB_INVALID_ADDRESS) continue; - + if (record.m_section_id == eSectionIDInvalid) continue; - + engine.mapSectionAddress((void*)record.m_host_address, record.m_process_address); } - + // Trigger re-application of relocations. engine.finalizeObject(); } @@ -696,25 +841,26 @@ IRExecutionUnit::ReportAllocations (llvm::ExecutionEngine &engine) bool IRExecutionUnit::WriteData (lldb::ProcessSP &process_sp) { + bool wrote_something = false; for (AllocationRecord &record : m_records) { - if (record.m_process_address == LLDB_INVALID_ADDRESS) - return false; - - lldb_private::Error err; - - WriteMemory (record.m_process_address, (uint8_t*)record.m_host_address, record.m_size, err); + 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 true; + return wrote_something; } -void +void IRExecutionUnit::AllocationRecord::dump (Log *log) { if (!log) return; - + log->Printf("[0x%llx+0x%llx]->0x%llx (alignment %d, section ID %d)", (unsigned long long)m_host_address, (unsigned long long)m_size, @@ -722,3 +868,80 @@ IRExecutionUnit::AllocationRecord::dump (Log *log) (unsigned)m_alignment, (unsigned)m_section_id); } + + +lldb::ByteOrder +IRExecutionUnit::GetByteOrder () const +{ + ExecutionContext exe_ctx (GetBestExecutionContextScope()); + return exe_ctx.GetByteOrder(); +} + +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); + } + } +} + +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; + } + return lldb::ModuleSP(); +} |