From James.Molloy at arm.com Mon Jan 16 02:21:28 2012 From: James.Molloy at arm.com (James Molloy) Date: Mon, 16 Jan 2012 08:21:28 +0000 Subject: [llvm-commits] PATCH: ARM_TARGET1 relocation for C++ global constructors In-Reply-To: <273A4213-41FB-4517-980B-05538AC43A4D@apple.com> References: <000c01ccbff2$ee95d750$cbc185f0$%molloy@arm.com> <48F39386-B480-4DFF-8E69-2E0C28C1A253@apple.com> <000201ccd048$1e8afe30$5ba0fa90$%molloy@arm.com> <273A4213-41FB-4517-980B-05538AC43A4D@apple.com> Message-ID: Hi Jim, Thanks, I appreciate this. Anton, could you please ping me when your conflicting patch is applied and I'll commit mine then. Cheers, James -----Original Message----- From: Jim Grosbach [mailto:grosbach at apple.com] Sent: 14 January 2012 00:42 To: James Molloy Cc: llvm-commits at cs.uiuc.edu Subject: Re: [llvm-commits] PATCH: ARM_TARGET1 relocation for C++ global constructors Hi James, This looks fine to me. Thanks for your patience! -Jim On Jan 11, 2012, at 2:02 AM, James Molloy wrote: > Hi Jim, > > Patch attached - it special cases Darwin to use VK_None, which is the > default. > > Cheers, > > James > > -----Original Message----- > From: Jim Grosbach [mailto:grosbach at apple.com] > Sent: 10 January 2012 23:37 > To: James Molloy > Cc: Evan Cheng; llvm-commits at cs.uiuc.edu LLVM; Owen Anderson; Kevin Enderby > Subject: Re: [llvm-commits] PATCH: ARM_TARGET1 relocation for C++ global > constructors > > Hi James, > > It would really help to see the rest of it, if it's not too much trouble. Is > it really only 5 lines? I wouldn't expect it to be huge, but a bit more than > that to declare the variant kind, handle dumping it, and mapping it to the > appropriate relocation type. Perhaps not, though, which is pretty cool. iOS > does want the normal relocation, yes. > > -Jim > > > > On Jan 10, 2012, at 2:37 PM, James Molloy wrote: > >> Hi Jim, >> >> Apologies, I'd accidentally missed off about 5 lines from the patch, which > essentially just adds VK_ARM_TARGET1 and dumping facilities thereof. I'd run > the diff against the wrong revision of our downstream copy. >> >> Are you able to review the patch without those? I can get a fixed version > in the morning (0830 GMT). I know I missed out Darwin - I'm considering > adding a conditional on iOS to create a standard R_ABS relocation for darwin > as is currently done - would this be correct? >> >> I'm not a darwin person :/ >> >> Cheers >> >> James >> ________________________________________ >> From: Jim Grosbach [grosbach at apple.com] >> Sent: 10 January 2012 21:52 >> To: James Molloy >> Cc: Evan Cheng; llvm-commits at cs.uiuc.edu LLVM; Owen Anderson; Kevin > Enderby >> Subject: Re: [llvm-commits] PATCH: ARM_TARGET1 relocation for C++ global > constructors >> >> Hi James, >> >> There seems to be something missing from the patch? I don't see any > definition for VK_ARM_TARGET1, any handling for mapping the variant kind to > a relocation type or any of that sort of thing. >> >> -Jim >> >> On Jan 4, 2012, at 11:12 PM, Evan Cheng wrote: >> >>> Has this been reviewed? >>> >>> I'm not sure if this patch is correct for all platforms, e.g. iOS. Jim, > Kevin, and Owen, do you guys know? >>> >>> Evan >>> >>> On Dec 21, 2011, at 7:12 AM, James Molloy wrote: >>> >>>> Hi, >>>> >>>> Attached is a patch to cause the relocations for C++ global/static > constructor thunks to be outputted properly on ARM. The ABI states that > these thunks should have an R_ARM_TARGET1 relocation type applied to them > for portability reasons. Currently they're emitted as normal global > variables so get an R_ARM_ABS32. >>>> >>>> I've implemented this by creating a new overridable hook, > "EmitXXStructor()", in the AsmPrinter. For all targets this defaults to > EmitGlobalConstant as usual, but ARM overrides it to emit a constant with > this specific relocation type. >>>> >>>> Am I OK to commit? >>>> >>>> Cheers, >>>> >>>> James >>>> _______________________________________________ >>>> llvm-commits mailing list >>>> llvm-commits at cs.uiuc.edu >>>> http://lists.cs.uiuc.edu/mailman/listinfo/llvm-commits >>> >> >> >> >> -- IMPORTANT NOTICE: The contents of this email and any attachments are > confidential and may also be privileged. If you are not the intended > recipient, please notify the sender immediately and do not disclose the > contents to any other person, use it for any purpose, or store or copy the > information in any medium. Thank you. >> > > -- IMPORTANT NOTICE: The contents of this email and any attachments are confidential and may also be privileged. If you are not the intended recipient, please notify the sender immediately and do not disclose the contents to any other person, use it for any purpose, or store or copy the information in any medium. Thank you. From anton at korobeynikov.info Mon Jan 16 02:40:22 2012 From: anton at korobeynikov.info (Anton Korobeynikov) Date: Mon, 16 Jan 2012 12:40:22 +0400 Subject: [llvm-commits] PATCH: ARM_TARGET1 relocation for C++ global constructors In-Reply-To: References: <000c01ccbff2$ee95d750$cbc185f0$%molloy@arm.com> <48F39386-B480-4DFF-8E69-2E0C28C1A253@apple.com> <000201ccd048$1e8afe30$5ba0fa90$%molloy@arm.com> <273A4213-41FB-4517-980B-05538AC43A4D@apple.com> Message-ID: Hi James, > Thanks, I appreciate this. Anton, could you please ping me when your conflicting patch is applied and I'll commit mine then. Yes, surely. It's pending in llvm-commits for 6 days already. -- With best regards, Anton Korobeynikov Faculty of Mathematics and Mechanics, Saint Petersburg State University From eli.bendersky at intel.com Mon Jan 16 02:56:09 2012 From: eli.bendersky at intel.com (Eli Bendersky) Date: Mon, 16 Jan 2012 08:56:09 -0000 Subject: [llvm-commits] [llvm] r148231 - in /llvm/trunk: lib/ExecutionEngine/RuntimeDyld/ test/ test/ExecutionEngine/ tools/lli/ Message-ID: <20120116085610.C629A2A6C12C@llvm.org> Author: eliben Date: Mon Jan 16 02:56:09 2012 New Revision: 148231 URL: http://llvm.org/viewvc/llvm-project?rev=148231&view=rev Log: Adding a basic ELF dynamic loader and MC-JIT for ELF. Functionality is currently basic and will be enhanced with future patches. Patch developed by Andy Kaylor and Daniel Malea. Reviewed on llvm-commits. Added: llvm/trunk/lib/ExecutionEngine/RuntimeDyld/RuntimeDyldELF.cpp Modified: llvm/trunk/lib/ExecutionEngine/RuntimeDyld/CMakeLists.txt llvm/trunk/lib/ExecutionEngine/RuntimeDyld/RuntimeDyld.cpp llvm/trunk/lib/ExecutionEngine/RuntimeDyld/RuntimeDyldImpl.h llvm/trunk/test/ExecutionEngine/2002-12-16-ArgTest.ll llvm/trunk/test/ExecutionEngine/2003-01-04-ArgumentBug.ll llvm/trunk/test/ExecutionEngine/2003-01-04-LoopTest.ll llvm/trunk/test/ExecutionEngine/2003-01-04-PhiTest.ll llvm/trunk/test/ExecutionEngine/2003-01-09-SARTest.ll llvm/trunk/test/ExecutionEngine/2003-01-10-FUCOM.ll llvm/trunk/test/ExecutionEngine/2003-01-15-AlignmentTest.ll llvm/trunk/test/ExecutionEngine/2003-05-06-LivenessClobber.ll llvm/trunk/test/ExecutionEngine/2003-05-07-ArgumentTest.ll llvm/trunk/test/ExecutionEngine/2003-05-11-PHIRegAllocBug.ll llvm/trunk/test/ExecutionEngine/2003-06-04-bzip2-bug.ll llvm/trunk/test/ExecutionEngine/2003-06-05-PHIBug.ll llvm/trunk/test/ExecutionEngine/2003-08-15-AllocaAssertion.ll llvm/trunk/test/ExecutionEngine/2003-08-21-EnvironmentTest.ll llvm/trunk/test/ExecutionEngine/2003-08-23-RegisterAllocatePhysReg.ll llvm/trunk/test/ExecutionEngine/2003-10-18-PHINode-ConstantExpr-CondCode-Failure.ll llvm/trunk/test/ExecutionEngine/2005-12-02-TailCallBug.ll llvm/trunk/test/ExecutionEngine/2007-12-10-APIntLoadStore.ll llvm/trunk/test/ExecutionEngine/2008-06-05-APInt-OverAShr.ll llvm/trunk/test/ExecutionEngine/2010-01-15-UndefValue.ll llvm/trunk/test/ExecutionEngine/fpbitcast.ll llvm/trunk/test/ExecutionEngine/hello.ll llvm/trunk/test/ExecutionEngine/hello2.ll llvm/trunk/test/ExecutionEngine/simplesttest.ll llvm/trunk/test/ExecutionEngine/simpletest.ll llvm/trunk/test/ExecutionEngine/stubs.ll llvm/trunk/test/ExecutionEngine/test-arith.ll llvm/trunk/test/ExecutionEngine/test-branch.ll llvm/trunk/test/ExecutionEngine/test-call.ll llvm/trunk/test/ExecutionEngine/test-cast.ll llvm/trunk/test/ExecutionEngine/test-constantexpr.ll llvm/trunk/test/ExecutionEngine/test-fp.ll llvm/trunk/test/ExecutionEngine/test-loadstore.ll llvm/trunk/test/ExecutionEngine/test-logical.ll llvm/trunk/test/ExecutionEngine/test-loop.ll llvm/trunk/test/ExecutionEngine/test-phi.ll llvm/trunk/test/ExecutionEngine/test-ret.ll llvm/trunk/test/ExecutionEngine/test-setcond-fp.ll llvm/trunk/test/ExecutionEngine/test-setcond-int.ll llvm/trunk/test/ExecutionEngine/test-shift.ll llvm/trunk/test/lit.cfg llvm/trunk/tools/lli/lli.cpp Modified: llvm/trunk/lib/ExecutionEngine/RuntimeDyld/CMakeLists.txt URL: http://llvm.org/viewvc/llvm-project/llvm/trunk/lib/ExecutionEngine/RuntimeDyld/CMakeLists.txt?rev=148231&r1=148230&r2=148231&view=diff ============================================================================== --- llvm/trunk/lib/ExecutionEngine/RuntimeDyld/CMakeLists.txt (original) +++ llvm/trunk/lib/ExecutionEngine/RuntimeDyld/CMakeLists.txt Mon Jan 16 02:56:09 2012 @@ -1,4 +1,5 @@ add_llvm_library(LLVMRuntimeDyld RuntimeDyld.cpp RuntimeDyldMachO.cpp + RuntimeDyldELF.cpp ) Modified: llvm/trunk/lib/ExecutionEngine/RuntimeDyld/RuntimeDyld.cpp URL: http://llvm.org/viewvc/llvm-project/llvm/trunk/lib/ExecutionEngine/RuntimeDyld/RuntimeDyld.cpp?rev=148231&r1=148230&r2=148231&view=diff ============================================================================== --- llvm/trunk/lib/ExecutionEngine/RuntimeDyld/RuntimeDyld.cpp (original) +++ llvm/trunk/lib/ExecutionEngine/RuntimeDyld/RuntimeDyld.cpp Mon Jan 16 02:56:09 2012 @@ -13,6 +13,7 @@ #define DEBUG_TYPE "dyld" #include "RuntimeDyldImpl.h" +#include "llvm/Support/Path.h" using namespace llvm; using namespace llvm::object; @@ -64,12 +65,36 @@ bool RuntimeDyld::loadObject(MemoryBuffer *InputBuffer) { if (!Dyld) { - if (RuntimeDyldMachO::isKnownFormat(InputBuffer)) - Dyld = new RuntimeDyldMachO(MM); - else - report_fatal_error("Unknown object format!"); + sys::LLVMFileType type = sys::IdentifyFileType( + InputBuffer->getBufferStart(), + static_cast(InputBuffer->getBufferSize())); + switch (type) { + case sys::ELF_Relocatable_FileType: + case sys::ELF_Executable_FileType: + case sys::ELF_SharedObject_FileType: + case sys::ELF_Core_FileType: + Dyld = new RuntimeDyldELF(MM); + break; + case sys::Mach_O_Object_FileType: + case sys::Mach_O_Executable_FileType: + case sys::Mach_O_FixedVirtualMemorySharedLib_FileType: + case sys::Mach_O_Core_FileType: + case sys::Mach_O_PreloadExecutable_FileType: + case sys::Mach_O_DynamicallyLinkedSharedLib_FileType: + case sys::Mach_O_DynamicLinker_FileType: + case sys::Mach_O_Bundle_FileType: + case sys::Mach_O_DynamicallyLinkedSharedLibStub_FileType: + case sys::Mach_O_DSYMCompanion_FileType: + Dyld = new RuntimeDyldMachO(MM); + break; + case sys::Unknown_FileType: + case sys::Bitcode_FileType: + case sys::Archive_FileType: + case sys::COFF_FileType: + report_fatal_error("Incompatible object format!"); + } } else { - if(!Dyld->isCompatibleFormat(InputBuffer)) + if (!Dyld->isCompatibleFormat(InputBuffer)) report_fatal_error("Incompatible object format!"); } Added: llvm/trunk/lib/ExecutionEngine/RuntimeDyld/RuntimeDyldELF.cpp URL: http://llvm.org/viewvc/llvm-project/llvm/trunk/lib/ExecutionEngine/RuntimeDyld/RuntimeDyldELF.cpp?rev=148231&view=auto ============================================================================== --- llvm/trunk/lib/ExecutionEngine/RuntimeDyld/RuntimeDyldELF.cpp (added) +++ llvm/trunk/lib/ExecutionEngine/RuntimeDyld/RuntimeDyldELF.cpp Mon Jan 16 02:56:09 2012 @@ -0,0 +1,282 @@ +//===-- RuntimeDyldELF.cpp - 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. +// +//===----------------------------------------------------------------------===// +// +// Implementation of ELF support for the MC-JIT runtime dynamic linker. +// +//===----------------------------------------------------------------------===// + +#define DEBUG_TYPE "dyld" +#include "llvm/ADT/OwningPtr.h" +#include "llvm/ADT/StringRef.h" +#include "llvm/ADT/STLExtras.h" +#include "llvm/ADT/IntervalMap.h" +#include "RuntimeDyldImpl.h" +#include "llvm/Object/ObjectFile.h" +#include "llvm/Support/ELF.h" +#include "llvm/ADT/Triple.h" +using namespace llvm; +using namespace llvm::object; + +namespace llvm { + +namespace { + +// FIXME: this function should probably not live here... +// +// Returns the name and address of an unrelocated symbol in an ELF section +void getSymbolInfo(symbol_iterator Sym, uint64_t &Addr, StringRef &Name) { + //FIXME: error checking here required to catch corrupt ELF objects... + error_code Err = Sym->getName(Name); + + uint64_t AddrInSection; + Err = Sym->getAddress(AddrInSection); + + SectionRef empty_section; + section_iterator Section(empty_section); + Err = Sym->getSection(Section); + + StringRef SectionContents; + Section->getContents(SectionContents); + + Addr = reinterpret_cast(SectionContents.data()) + AddrInSection; +} + +} + +bool RuntimeDyldELF::loadObject(MemoryBuffer *InputBuffer) { + if (!isCompatibleFormat(InputBuffer)) + return true; + + OwningPtr Obj(ObjectFile::createELFObjectFile(InputBuffer)); + + Arch = Obj->getArch(); + + // Map address in the Object file image to function names + IntervalMap::Allocator A; + IntervalMap FuncMap(A); + + // This is a bit of a hack. The ObjectFile we've just loaded reports + // section addresses as 0 and doesn't provide access to the section + // offset (from which we could calculate the address. Instead, + // we're storing the address when it comes up in the ST_Debug case + // below. + // + StringMap DebugSymbolMap; + + symbol_iterator SymEnd = Obj->end_symbols(); + error_code Err; + for (symbol_iterator Sym = Obj->begin_symbols(); + Sym != SymEnd; Sym.increment(Err)) { + SymbolRef::Type Type; + Sym->getType(Type); + if (Type == SymbolRef::ST_Function) { + StringRef Name; + uint64_t Addr; + getSymbolInfo(Sym, Addr, Name); + + uint64_t Size; + Err = Sym->getSize(Size); + + uint8_t *Start; + uint8_t *End; + Start = reinterpret_cast(Addr); + End = reinterpret_cast(Addr + Size - 1); + + extractFunction(Name, Start, End); + FuncMap.insert(Addr, Addr + Size - 1, Name); + } else if (Type == SymbolRef::ST_Debug) { + // This case helps us find section addresses + StringRef Name; + uint64_t Addr; + getSymbolInfo(Sym, Addr, Name); + DebugSymbolMap[Name] = Addr; + } + } + + // Iterate through the relocations for this object + section_iterator SecEnd = Obj->end_sections(); + for (section_iterator Sec = Obj->begin_sections(); + Sec != SecEnd; Sec.increment(Err)) { + StringRef SecName; + uint64_t SecAddr; + Sec->getName(SecName); + // Ignore sections that aren't in our map + if (DebugSymbolMap.find(SecName) == DebugSymbolMap.end()) { + continue; + } + SecAddr = DebugSymbolMap[SecName]; + relocation_iterator RelEnd = Sec->end_relocations(); + for (relocation_iterator Rel = Sec->begin_relocations(); + Rel != RelEnd; Rel.increment(Err)) { + uint64_t RelOffset; + uint64_t RelType; + int64_t RelAddend; + SymbolRef RelSym; + StringRef SymName; + uint64_t SymAddr; + uint64_t SymOffset; + + Rel->getAddress(RelOffset); + Rel->getType(RelType); + Rel->getAdditionalInfo(RelAddend); + Rel->getSymbol(RelSym); + RelSym.getName(SymName); + RelSym.getAddress(SymAddr); + RelSym.getFileOffset(SymOffset); + + // If this relocation is inside a function, we want to store the + // function name and a function-relative offset + IntervalMap::iterator ContainingFunc + = FuncMap.find(SecAddr + RelOffset); + if (ContainingFunc.valid()) { + // Re-base the relocation to make it relative to the target function + RelOffset = (SecAddr + RelOffset) - ContainingFunc.start(); + Relocations[SymName].push_back(RelocationEntry(ContainingFunc.value(), + RelOffset, + RelType, + RelAddend, + true)); + } else { + Relocations[SymName].push_back(RelocationEntry(SecName, + RelOffset, + RelType, + RelAddend, + false)); + } + } + } + return false; +} + +void RuntimeDyldELF::resolveX86_64Relocation(StringRef Name, + uint8_t *Addr, + const RelocationEntry &RE) { + uint8_t *TargetAddr; + if (RE.IsFunctionRelative) { + StringMap::iterator ContainingFunc + = Functions.find(RE.Target); + assert(ContainingFunc != Functions.end() + && "Function for relocation not found"); + TargetAddr = reinterpret_cast(ContainingFunc->getValue().base()) + + RE.Offset; + } else { + // FIXME: Get the address of the target section and add that to RE.Offset + assert(0 && ("Non-function relocation not implemented yet!")); + } + + switch (RE.Type) { + default: + assert(0 && ("Relocation type not implemented yet!")); + break; + case ELF::R_X86_64_64: { + uint8_t **Target = reinterpret_cast(TargetAddr); + *Target = Addr + RE.Addend; + break; + } + case ELF::R_X86_64_32: + case ELF::R_X86_64_32S: { + uint64_t Value = reinterpret_cast(Addr) + RE.Addend; + // FIXME: Handle the possibility of this assertion failing + assert((RE.Type == ELF::R_X86_64_32 && !(Value & 0xFFFFFFFF00000000)) || + (RE.Type == ELF::R_X86_64_32S && + (Value & 0xFFFFFFFF00000000) == 0xFFFFFFFF00000000)); + uint32_t TruncatedAddr = (Value & 0xFFFFFFFF); + uint32_t *Target = reinterpret_cast(TargetAddr); + *Target = TruncatedAddr; + break; + } + case ELF::R_X86_64_PC32: { + uint32_t *Placeholder = reinterpret_cast(TargetAddr); + uint64_t RealOffset = *Placeholder + + reinterpret_cast(Addr) + + RE.Addend - reinterpret_cast(TargetAddr); + assert((RealOffset & 0xFFFFFFFF) == RealOffset); + uint32_t TruncOffset = (RealOffset & 0xFFFFFFFF); + *Placeholder = TruncOffset; + break; + } + } +} + +void RuntimeDyldELF::resolveX86Relocation(StringRef Name, + uint8_t *Addr, + const RelocationEntry &RE) { + uint8_t *TargetAddr; + if (RE.IsFunctionRelative) { + StringMap::iterator ContainingFunc + = Functions.find(RE.Target); + assert(ContainingFunc != Functions.end() + && "Function for relocation not found"); + TargetAddr = reinterpret_cast( + ContainingFunc->getValue().base()) + RE.Offset; + } else { + // FIXME: Get the address of the target section and add that to RE.Offset + assert(0 && ("Non-function relocation not implemented yet!")); + } + + switch (RE.Type) { + case ELF::R_386_32: { + uint8_t **Target = reinterpret_cast(TargetAddr); + *Target = Addr + RE.Addend; + break; + } + case ELF::R_386_PC32: { + uint32_t *Placeholder = reinterpret_cast(TargetAddr); + uint32_t RealOffset = *Placeholder + reinterpret_cast(Addr) + + RE.Addend - reinterpret_cast(TargetAddr); + *Placeholder = RealOffset; + break; + } + default: + // There are other relocation types, but it appears these are the + // only ones currently used by the LLVM ELF object writer + assert(0 && ("Relocation type not implemented yet!")); + break; + } +} + +void RuntimeDyldELF::resolveArmRelocation(StringRef Name, + uint8_t *Addr, + const RelocationEntry &RE) { +} + +void RuntimeDyldELF::resolveRelocation(StringRef Name, + uint8_t *Addr, + const RelocationEntry &RE) { + switch (Arch) { + case Triple::x86_64: + resolveX86_64Relocation(Name, Addr, RE); + break; + case Triple::x86: + resolveX86Relocation(Name, Addr, RE); + break; + case Triple::arm: + resolveArmRelocation(Name, Addr, RE); + break; + default: + assert(0 && "Unsupported CPU type!"); + break; + } +} + +void RuntimeDyldELF::reassignSymbolAddress(StringRef Name, uint8_t *Addr) { + SymbolTable[Name] = Addr; + + RelocationList &Relocs = Relocations[Name]; + for (unsigned i = 0, e = Relocs.size(); i != e; ++i) { + RelocationEntry &RE = Relocs[i]; + resolveRelocation(Name, Addr, RE); + } +} + +bool RuntimeDyldELF::isCompatibleFormat(const MemoryBuffer *InputBuffer) const { + StringRef Magic = InputBuffer->getBuffer().slice(0, ELF::EI_NIDENT); + return (memcmp(Magic.data(), ELF::ElfMagic, strlen(ELF::ElfMagic))) == 0; +} +} // namespace llvm Modified: llvm/trunk/lib/ExecutionEngine/RuntimeDyld/RuntimeDyldImpl.h URL: http://llvm.org/viewvc/llvm-project/llvm/trunk/lib/ExecutionEngine/RuntimeDyld/RuntimeDyldImpl.h?rev=148231&r1=148230&r2=148231&view=diff ============================================================================== --- llvm/trunk/lib/ExecutionEngine/RuntimeDyld/RuntimeDyldImpl.h (original) +++ llvm/trunk/lib/ExecutionEngine/RuntimeDyld/RuntimeDyldImpl.h Mon Jan 16 02:56:09 2012 @@ -94,6 +94,66 @@ 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 RelocationList; + StringMap Relocations; + unsigned Arch; + + 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); + + bool isCompatibleFormat(const MemoryBuffer *InputBuffer) const; +}; + class RuntimeDyldMachO : public RuntimeDyldImpl { Modified: llvm/trunk/test/ExecutionEngine/2002-12-16-ArgTest.ll URL: http://llvm.org/viewvc/llvm-project/llvm/trunk/test/ExecutionEngine/2002-12-16-ArgTest.ll?rev=148231&r1=148230&r2=148231&view=diff ============================================================================== --- llvm/trunk/test/ExecutionEngine/2002-12-16-ArgTest.ll (original) +++ llvm/trunk/test/ExecutionEngine/2002-12-16-ArgTest.ll Mon Jan 16 02:56:09 2012 @@ -1,4 +1,5 @@ -; RUN: lli %s > /dev/null +; RUN: %lli %s > /dev/null +; XFAIL: mcjit @.LC0 = internal global [10 x i8] c"argc: %d\0A\00" ; <[10 x i8]*> [#uses=1] Modified: llvm/trunk/test/ExecutionEngine/2003-01-04-ArgumentBug.ll URL: http://llvm.org/viewvc/llvm-project/llvm/trunk/test/ExecutionEngine/2003-01-04-ArgumentBug.ll?rev=148231&r1=148230&r2=148231&view=diff ============================================================================== --- llvm/trunk/test/ExecutionEngine/2003-01-04-ArgumentBug.ll (original) +++ llvm/trunk/test/ExecutionEngine/2003-01-04-ArgumentBug.ll Mon Jan 16 02:56:09 2012 @@ -1,5 +1,6 @@ -; RUN: lli %s > /dev/null +; RUN: %lli %s > /dev/null ; XFAIL: arm +; XFAIL: mcjit define i32 @foo(i32 %X, i32 %Y, double %A) { %cond212 = fcmp une double %A, 1.000000e+00 ; [#uses=1] Modified: llvm/trunk/test/ExecutionEngine/2003-01-04-LoopTest.ll URL: http://llvm.org/viewvc/llvm-project/llvm/trunk/test/ExecutionEngine/2003-01-04-LoopTest.ll?rev=148231&r1=148230&r2=148231&view=diff ============================================================================== --- llvm/trunk/test/ExecutionEngine/2003-01-04-LoopTest.ll (original) +++ llvm/trunk/test/ExecutionEngine/2003-01-04-LoopTest.ll Mon Jan 16 02:56:09 2012 @@ -1,5 +1,6 @@ -; RUN: lli %s > /dev/null +; RUN: %lli %s > /dev/null ; XFAIL: arm +; XFAIL: mcjit define i32 @main() { call i32 @mylog( i32 4 ) ; :1 [#uses=0] Modified: llvm/trunk/test/ExecutionEngine/2003-01-04-PhiTest.ll URL: http://llvm.org/viewvc/llvm-project/llvm/trunk/test/ExecutionEngine/2003-01-04-PhiTest.ll?rev=148231&r1=148230&r2=148231&view=diff ============================================================================== --- llvm/trunk/test/ExecutionEngine/2003-01-04-PhiTest.ll (original) +++ llvm/trunk/test/ExecutionEngine/2003-01-04-PhiTest.ll Mon Jan 16 02:56:09 2012 @@ -1,4 +1,4 @@ -; RUN: lli %s > /dev/null +; RUN: %lli %s > /dev/null define i32 @main() { ;