| //===-- RuntimeDyldImpl.h - Run-time dynamic linker for MC-JIT ------*- C++ -*-===// |
| // |
| // The LLVM Compiler Infrastructure |
| // |
| // This file is distributed under the University of Illinois Open Source |
| // License. See LICENSE.TXT for details. |
| // |
| //===----------------------------------------------------------------------===// |
| // |
| // Interface for the implementations of runtime dynamic linker facilities. |
| // |
| //===----------------------------------------------------------------------===// |
| |
| #ifndef LLVM_RUNTIME_DYLD_IMPL_H |
| #define LLVM_RUNTIME_DYLD_IMPL_H |
| |
| #include "llvm/ExecutionEngine/RuntimeDyld.h" |
| #include "llvm/Object/MachOObject.h" |
| #include "llvm/ADT/IndexedMap.h" |
| #include "llvm/ADT/StringMap.h" |
| #include "llvm/ADT/Twine.h" |
| #include "llvm/ADT/SmallVector.h" |
| #include "llvm/ExecutionEngine/ExecutionEngine.h" |
| #include "llvm/Support/Format.h" |
| #include "llvm/Support/Memory.h" |
| #include "llvm/Support/MemoryBuffer.h" |
| #include "llvm/Support/system_error.h" |
| #include "llvm/Support/raw_ostream.h" |
| #include "llvm/Support/Debug.h" |
| #include "llvm/Support/ErrorHandling.h" |
| |
| using namespace llvm; |
| using namespace llvm::object; |
| |
| namespace llvm { |
| class RuntimeDyldImpl { |
| protected: |
| unsigned CPUType; |
| unsigned CPUSubtype; |
| |
| // The MemoryManager to load objects into. |
| RTDyldMemoryManager *MemMgr; |
| |
| // For each section, we have a MemoryBlock of it's data. |
| // Indexed by SectionID. |
| SmallVector<sys::MemoryBlock, 32> Sections; |
| // For each section, the address it will be considered to live at for |
| // relocations. The same as the pointer the above memory block for hosted |
| // JITs. Indexed by SectionID. |
| SmallVector<uint64_t, 32> SectionLoadAddress; |
| |
| // Master symbol table. As modules are loaded and external symbols are |
| // resolved, their addresses are stored here as a SectionID/Offset pair. |
| typedef std::pair<unsigned, uint64_t> SymbolLoc; |
| StringMap<SymbolLoc> SymbolTable; |
| |
| bool HasError; |
| std::string ErrorStr; |
| |
| // Set the error state and record an error string. |
| bool Error(const Twine &Msg) { |
| ErrorStr = Msg.str(); |
| HasError = true; |
| return true; |
| } |
| |
| uint8_t *getSectionAddress(unsigned SectionID) { |
| return (uint8_t*)Sections[SectionID].base(); |
| } |
| void extractFunction(StringRef Name, uint8_t *StartAddress, |
| uint8_t *EndAddress); |
| |
| public: |
| RuntimeDyldImpl(RTDyldMemoryManager *mm) : MemMgr(mm), HasError(false) {} |
| |
| virtual ~RuntimeDyldImpl(); |
| |
| virtual bool loadObject(MemoryBuffer *InputBuffer) = 0; |
| |
| void *getSymbolAddress(StringRef Name) { |
| // FIXME: Just look up as a function for now. Overly simple of course. |
| // Work in progress. |
| if (SymbolTable.find(Name) == SymbolTable.end()) |
| return 0; |
| SymbolLoc Loc = SymbolTable.lookup(Name); |
| return getSectionAddress(Loc.first) + Loc.second; |
| } |
| |
| virtual void resolveRelocations(); |
| |
| virtual void reassignSectionAddress(unsigned SectionID, uint64_t Addr) = 0; |
| |
| // Is the linker in an error state? |
| bool hasError() { return HasError; } |
| |
| // Mark the error condition as handled and continue. |
| void clearError() { HasError = false; } |
| |
| // Get the error message. |
| StringRef getErrorString() { return ErrorStr; } |
| |
| virtual bool isCompatibleFormat(const MemoryBuffer *InputBuffer) const = 0; |
| }; |
| |
| class RuntimeDyldELF : public RuntimeDyldImpl { |
| // For each symbol, keep a list of relocations based on it. Anytime |
| // its address is reassigned (the JIT re-compiled the function, e.g.), |
| // the relocations get re-resolved. |
| struct RelocationEntry { |
| // Function or section this relocation is contained in. |
| std::string Target; |
| // Offset into the target function or section for the relocation. |
| uint32_t Offset; |
| // Relocation type |
| uint32_t Type; |
| // Addend encoded in the instruction itself, if any. |
| int32_t Addend; |
| // Has the relocation been recalcuated as an offset within a function? |
| bool IsFunctionRelative; |
| // Has this relocation been resolved previously? |
| bool isResolved; |
| |
| RelocationEntry(StringRef t, |
| uint32_t offset, |
| uint32_t type, |
| int32_t addend, |
| bool isFunctionRelative) |
| : Target(t) |
| , Offset(offset) |
| , Type(type) |
| , Addend(addend) |
| , IsFunctionRelative(isFunctionRelative) |
| , isResolved(false) { } |
| }; |
| typedef SmallVector<RelocationEntry, 4> RelocationList; |
| StringMap<RelocationList> Relocations; |
| unsigned Arch; |
| |
| void resolveRelocations(); |
| |
| void resolveX86_64Relocation(StringRef Name, |
| uint8_t *Addr, |
| const RelocationEntry &RE); |
| |
| void resolveX86Relocation(StringRef Name, |
| uint8_t *Addr, |
| const RelocationEntry &RE); |
| |
| void resolveArmRelocation(StringRef Name, |
| uint8_t *Addr, |
| const RelocationEntry &RE); |
| |
| void resolveRelocation(StringRef Name, |
| uint8_t *Addr, |
| const RelocationEntry &RE); |
| |
| public: |
| RuntimeDyldELF(RTDyldMemoryManager *mm) : RuntimeDyldImpl(mm) {} |
| |
| bool loadObject(MemoryBuffer *InputBuffer); |
| |
| void reassignSymbolAddress(StringRef Name, uint8_t *Addr); |
| void reassignSectionAddress(unsigned SectionID, uint64_t Addr); |
| |
| bool isCompatibleFormat(const MemoryBuffer *InputBuffer) const; |
| }; |
| |
| |
| class RuntimeDyldMachO : public RuntimeDyldImpl { |
| |
| // For each symbol, keep a list of relocations based on it. Anytime |
| // its address is reassigned (the JIT re-compiled the function, e.g.), |
| // the relocations get re-resolved. |
| // The symbol (or section) the relocation is sourced from is the Key |
| // in the relocation list where it's stored. |
| struct RelocationEntry { |
| unsigned SectionID; // Section the relocation is contained in. |
| uint64_t Offset; // Offset into the section for the relocation. |
| uint32_t Data; // Second word of the raw macho relocation entry. |
| int64_t Addend; // Addend encoded in the instruction itself, if any, |
| // plus the offset into the source section for |
| // the symbol once the relocation is resolvable. |
| |
| RelocationEntry(unsigned id, uint64_t offset, uint32_t data, int64_t addend) |
| : SectionID(id), Offset(offset), Data(data), Addend(addend) {} |
| }; |
| typedef SmallVector<RelocationEntry, 4> RelocationList; |
| // Relocations to sections already loaded. Indexed by SectionID which is the |
| // source of the address. The target where the address will be writen is |
| // SectionID/Offset in the relocation itself. |
| IndexedMap<RelocationList> Relocations; |
| // Relocations to symbols that are not yet resolved. Must be external |
| // relocations by definition. Indexed by symbol name. |
| StringMap<RelocationList> UnresolvedRelocations; |
| |
| bool resolveRelocation(uint8_t *Address, uint64_t Value, bool isPCRel, |
| unsigned Type, unsigned Size, int64_t Addend); |
| bool resolveX86_64Relocation(uintptr_t Address, uintptr_t Value, bool isPCRel, |
| unsigned Type, unsigned Size, int64_t Addend); |
| bool resolveARMRelocation(uintptr_t Address, uintptr_t Value, bool isPCRel, |
| unsigned Type, unsigned Size, int64_t Addend); |
| |
| bool loadSegment32(const MachOObject *Obj, |
| const MachOObject::LoadCommandInfo *SegmentLCI, |
| const InMemoryStruct<macho::SymtabLoadCommand> &SymtabLC); |
| bool loadSegment64(const MachOObject *Obj, |
| const MachOObject::LoadCommandInfo *SegmentLCI, |
| const InMemoryStruct<macho::SymtabLoadCommand> &SymtabLC); |
| bool processSymbols32(const MachOObject *Obj, |
| SmallVectorImpl<unsigned> &SectionMap, |
| SmallVectorImpl<StringRef> &SymbolNames, |
| const InMemoryStruct<macho::SymtabLoadCommand> &SymtabLC); |
| bool processSymbols64(const MachOObject *Obj, |
| SmallVectorImpl<unsigned> &SectionMap, |
| SmallVectorImpl<StringRef> &SymbolNames, |
| const InMemoryStruct<macho::SymtabLoadCommand> &SymtabLC); |
| |
| void resolveSymbol(StringRef Name); |
| |
| public: |
| RuntimeDyldMachO(RTDyldMemoryManager *mm) : RuntimeDyldImpl(mm) {} |
| |
| bool loadObject(MemoryBuffer *InputBuffer); |
| |
| void reassignSectionAddress(unsigned SectionID, uint64_t Addr); |
| |
| static bool isKnownFormat(const MemoryBuffer *InputBuffer); |
| |
| bool isCompatibleFormat(const MemoryBuffer *InputBuffer) const { |
| return isKnownFormat(InputBuffer); |
| } |
| }; |
| |
| } // end namespace llvm |
| |
| |
| #endif |