[llvm-commits] [PATCH 9/10] Initial support for PowerPC64 MCJIT
Jim Grosbach
grosbach at apple.com
Mon Sep 17 14:58:36 PDT 2012
Hello,
First off, this is awesome to see PPC getting MC-ified. Thank you for working on this!
I don't know PPC well enough to comment on the architecture specific aspects of this, but a few general comments inline below:
> From 4ffb3e57d5fd34aec32fec662c9ee3581e186882 Mon Sep 17 00:00:00 2001
> From: Adhemerval Zanella <azanella at linux.vnet.ibm.com>
> Date: Mon, 17 Sep 2012 12:32:35 -0500
> Subject: [PATCH 10/11] Initial support for PowerPC64 MCJIT
>
> ---
> lib/ExecutionEngine/RuntimeDyld/RuntimeDyld.cpp | 18 ++
> lib/ExecutionEngine/RuntimeDyld/RuntimeDyldELF.cpp | 279 +++++++++++++++++++-
> lib/ExecutionEngine/RuntimeDyld/RuntimeDyldELF.h | 11 +
> lib/ExecutionEngine/RuntimeDyld/RuntimeDyldImpl.h | 2 +
> 4 files changed, 308 insertions(+), 2 deletions(-)
>
> diff --git a/lib/ExecutionEngine/RuntimeDyld/RuntimeDyld.cpp b/lib/ExecutionEngine/RuntimeDyld/RuntimeDyld.cpp
> index 880129d..d824845 100644
> --- a/lib/ExecutionEngine/RuntimeDyld/RuntimeDyld.cpp
> +++ b/lib/ExecutionEngine/RuntimeDyld/RuntimeDyld.cpp
> @@ -362,6 +362,24 @@ uint8_t *RuntimeDyldImpl::createStubFunction(uint8_t *Addr) {
> StubAddr++;
> *StubAddr = NopInstr;
> return Addr;
> + } else if (Arch == Triple::ppc64) {
> + // PowerPC64 stub: the address points to a function descriptor
> + // instead of the function itself. Load the function address
> + // on r11 and sets it to control register. Also loads the function
> + // TOC in r2 and environment pointer to r11.
> + uint32_t *StubAddr = (uint32_t*)Addr;
> + *(StubAddr+0) = 0x3D800000; // lis r12, highest(addr)
> + *(StubAddr+1) = 0x618C0000; // ori r12, higher(addr)
> + *(StubAddr+2) = 0x798C07C6; // sldi r12, r12, 32
> + *(StubAddr+3) = 0x658C0000; // oris r12, r12, h(addr)
> + *(StubAddr+4) = 0x618C0000; // ori r12, r12, l(addr)
> + *(StubAddr+5) = 0xF8410028; // std r2, 40(r1)
> + *(StubAddr+6) = 0xE96C0000; // ld r11, 0(r12)
> + *(StubAddr+7) = 0xE84C0008; // ld r2, 0(r12)
> + *(StubAddr+8) = 0x7D6903A6; // mtctr r11
> + *(StubAddr+9) = 0xE96C0010; // ld r11, 16(r2)
> + *(StubAddr+10) = 0x4E800420; // bctr
Is StubAddr guaranteed to be 32-bit aligned? Typically not.
> + return Addr;
> }
> return Addr;
> }
> diff --git a/lib/ExecutionEngine/RuntimeDyld/RuntimeDyldELF.cpp b/lib/ExecutionEngine/RuntimeDyld/RuntimeDyldELF.cpp
> index a1c0e40..ba0dd3c 100644
> --- a/lib/ExecutionEngine/RuntimeDyld/RuntimeDyldELF.cpp
> +++ b/lib/ExecutionEngine/RuntimeDyld/RuntimeDyldELF.cpp
> @@ -27,6 +27,14 @@ using namespace llvm::object;
>
> namespace {
>
> +static inline
> +error_code Check(error_code Err) {
> + if (Err) {
> + report_fatal_error(Err.message());
> + }
> + return Err;
> +}
> +
> template<support::endianness target_endianness, bool is64Bits>
> class DyldELFObject : public ELFObjectFile<target_endianness, is64Bits> {
> LLVM_ELF_IMPORT_TYPES(target_endianness, is64Bits)
> @@ -343,6 +351,183 @@ void RuntimeDyldELF::resolveMIPSRelocation(uint8_t *LocalAddress,
> }
> }
>
> +// Return the .TOC. section address to R_PPC64_TOC relocations.
> +uint64_t RuntimeDyldELF::findPPC64TOC() const
> +{
> + // The TOC consists of sections .got, .toc, .tocbss, .plt in that
> + // order. The TOC starts where the first of these sections starts.
> + SectionList::const_iterator it = Sections.begin();
> + for (; it != Sections.end(); ++it) {
> + if ((*it).Name == ".got")
LLVM style is to use the "->" operator here. e.g., "it->Name".
> + break;
> + if ((*it).Name == ".toc")
> + break;
> + if ((*it).Name == ".tocbss")
> + break;
> + if ((*it).Name == ".plt")
> + break;
> + }
> + if (it == Sections.end()) {
> + // This may happen for
> + // * references to TOC base base (sym at toc, .odp relocation) without
> + // a .toc directive.
> + // In this case lets just use the first section (which is usually
Can omit "lets" here. If you prefer w/ it, it's missing an apostrophe (i.e., "let's").
> + // the .odp) since the code won't reference the .toc base
> + // directly.
> + it = Sections.begin();
> + }
> + assert (it != Sections.end());
> + // Per the ppc64-elf-linux ABI, The TOC base if TOC value plus 0x8000
> + // thus permitting a full 64 Kbytes segment.
> + return (*it).LoadAddress + 0x8000;
> +}
> +
> +// Returns the sections and offset associated with the ODP entry referenced
> +// by Symbol.
> +void RuntimeDyldELF::findOPDEntrySection(ObjectImage &Obj,
> + ObjSectionToIDMap &LocalSections,
> + RelocationValueRef &Rel)
> +{
Open brace goes on the same line as the close paren of the decl.
> + // Get the ELF symbol value (st_value) to compare with Relocation offset in
> + // .opd entries
> +
> + error_code err;
> + for (section_iterator si = Obj.begin_sections(),
> + se = Obj.end_sections(); si != se; si.increment(err)) {
> + StringRef SectionName;
> + Check(si->getName(SectionName));
> + if (SectionName != ".opd")
> + continue;
> +
> + for (relocation_iterator i = si->begin_relocations(),
> + e = si->end_relocations(); i != e;) {
> + Check(err);
> +
> + // The R_PPC64_ADDR64 relocation indicates the first field
> + // of a .opd entry
> + uint64_t TypeFunc;
> + Check(i->getType(TypeFunc));
> + if (TypeFunc != ELF::R_PPC64_ADDR64) {
> + i.increment(err);
> + continue;
> + }
> +
> + SymbolRef TargetSymbol;
> + Check(i->getSymbol(TargetSymbol));
> + uint64_t TargetSymbolOffset;
> + Check(i->getOffset(TargetSymbolOffset));
> + int64_t TargetAdditionalInfo;
> + Check(i->getAdditionalInfo(TargetAdditionalInfo));
> +
> + i = i.increment(err);
> + if (i == e)
> + break;
> + Check(err);
> +
> + // Just check if following relocation is a R_PPC64_TOC
> + uint64_t TypeTOC;
> + Check(i->getType(TypeTOC));
> + if (TypeTOC != ELF::R_PPC64_TOC)
> + continue;
> +
> + // Finally compares the Symbol value and the target symbol offset
> + // to check if this .opd entry refers to the symbol the relocation
> + // points to.
> + if (Rel.Addend != (intptr_t)TargetSymbolOffset)
> + continue;
> +
> + section_iterator tsi(Obj.end_sections());
> + Check(TargetSymbol.getSection(tsi));
> + Rel.SectionID = findOrEmitSection(Obj, (*tsi), true, LocalSections);
> + Rel.Addend = (intptr_t)TargetAdditionalInfo;
> + return;
> + }
> + }
> + llvm_unreachable("Attempting to get address of ODP entry!");
> +}
> +
> +static inline
> +uint16_t ppc_lo (uint64_t value)
> +{
> + return value & 0xffff;
> +}
> +
> +static inline
> +uint16_t ppc_hi (uint64_t value)
> +{
> + return (value >> 16) & 0xffff;
> +}
> +
> +static inline
> +uint16_t ppc_higher (uint64_t value)
> +{
> + return (value >> 32) & 0xffff;
> +}
> +
> +static inline
> +uint16_t ppc_highest (uint64_t value)
> +{
> + return (value >> 48) & 0xffff;
> +}
The names for these functions are a) ambiguous and b) not following LLVM's naming guidelines. Please review: http://llvm.org/docs/CodingStandards.html#coding-standards
> +
> +void RuntimeDyldELF::resolvePPC64Relocation(uint8_t *LocalAddress,
> + uint64_t FinalAddress,
> + uint64_t Value,
> + uint32_t Type,
> + int64_t Addend) {
> + uint64_t* RelocAddr = (uint64_t*)LocalAddress;
> + switch (Type) {
> + default:
> + llvm_unreachable("Relocation type not implemented yet!");
> + break;
> + case ELF::R_PPC64_ADDR16_LO :
> + *((uint16_t*)RelocAddr+1) = ppc_lo (Value + Addend);
LocalAddress is not guaranteed to be 16-bit aligned. Ditto on below references.
> + break;
> + case ELF::R_PPC64_ADDR16_HI :
> + *((uint16_t*)RelocAddr+1) = ppc_hi (Value + Addend);
> + break;
> + case ELF::R_PPC64_ADDR16_HIGHER :
> + *((uint16_t*)RelocAddr+1) = ppc_higher (Value + Addend);
> + break;
> + case ELF::R_PPC64_ADDR16_HIGHEST :
> + *((uint16_t*)RelocAddr+1) = ppc_highest (Value + Addend);
> + break;
> + case ELF::R_PPC64_ADDR14 :
> + {
> + assert(((Value + Addend) & 3) == 0);
> + uint16_t *insn = ((uint16_t*)RelocAddr+1);
> + *insn = (*insn & 3) | ((Value + Addend) & 0xfffc);
> + } break;
> + case ELF::R_PPC64_REL24 :
> + {
> + int32_t delta = static_cast<int32_t>(Value - FinalAddress + Addend);
> + if (SignExtend32<24>(delta) != delta)
> + llvm_unreachable("Relocation R_PPC64_REL24 overflow");
> + // Generates a 'bl <address>' instruction
> + *(uint32_t*)(RelocAddr) = 0x48000001 | (delta & 0x03FFFFFC);
> + } break;
> + case ELF::R_PPC64_ADDR64 :
> + *RelocAddr = Value + Addend;
> + break;
> + case ELF::R_PPC64_TOC :
> + *RelocAddr = findPPC64TOC();
> + break;
> + case ELF::R_PPC64_TOC16 :
> + {
> + uint64_t TOCStart = findPPC64TOC();
> + Value = ppc_lo((Value + Addend) - TOCStart);
> + *((uint16_t*)RelocAddr) = ppc_lo (Value);
> + } break;
> + case ELF::R_PPC64_TOC16_DS :
> + {
> + uint64_t TOCStart = findPPC64TOC();
> + Value = ((Value + Addend) - TOCStart);
> + *((uint16_t*)RelocAddr) = ppc_lo (Value);
> + } break;
> + }
> +}
> +
> +
> void RuntimeDyldELF::resolveRelocation(uint8_t *LocalAddress,
> uint64_t FinalAddress,
> uint64_t Value,
> @@ -369,6 +554,9 @@ void RuntimeDyldELF::resolveRelocation(uint8_t *LocalAddress,
> (uint32_t)(Value & 0xffffffffL), Type,
> (uint32_t)(Addend & 0xffffffffL));
> break;
> + case Triple::ppc64:
> + resolvePPC64Relocation(LocalAddress, FinalAddress, Value, Type, Addend);
> + break;
> default: llvm_unreachable("Unsupported CPU type!");
> }
> }
> @@ -393,6 +581,8 @@ void RuntimeDyldELF::processRelocationRef(const ObjRelocationInfo &Rel,
> RelocationValueRef Value;
> // First search for the symbol in the local symbol table
> SymbolTableMap::const_iterator lsi = Symbols.find(TargetName.data());
> + SymbolRef::Type SymType;
> + Symbol.getType(SymType);
> if (lsi != Symbols.end()) {
> Value.SectionID = lsi->second.first;
> Value.Addend = lsi->second.second;
> @@ -404,8 +594,6 @@ void RuntimeDyldELF::processRelocationRef(const ObjRelocationInfo &Rel,
> Value.SectionID = gsi->second.first;
> Value.Addend = gsi->second.second;
> } else {
> - SymbolRef::Type SymType;
> - Symbol.getType(SymType);
> switch (SymType) {
> case SymbolRef::ST_Debug: {
> // TODO: Now ELF SymbolRef::ST_Debug = STT_SECTION, it's not obviously
> @@ -513,6 +701,93 @@ void RuntimeDyldELF::processRelocationRef(const ObjRelocationInfo &Rel,
> Section.StubOffset, RelType, 0);
> Section.StubOffset += getMaxStubSize();
> }
> + } else if (Arch == Triple::ppc64) {
> + if (RelType == ELF::R_PPC64_REL24) {
> + // A PPC branch relocation will need a stub function if the target is
> + // an external symbol (Symbol::ST_Unknown) or if the target address
> + // is not within the signed 24-bits branch address.
> + SectionEntry &Section = Sections[Rel.SectionID];
> + uint8_t *Target = Section.Address + Rel.Offset;
> + bool RangeOverflow = false;
> + if (SymType != SymbolRef::ST_Unknown) {
> + // A function call may points to the .opd entry, so the final symbol value
> + // in calculated based in the relocation values in .opd section.
> + findOPDEntrySection(Obj, ObjSectionToID, Value);
> + uint8_t *RelocTarget = Sections[Value.SectionID].Address + Value.Addend;
> + int32_t delta = static_cast<int32_t>(Target - RelocTarget);
> + // If it is within 24-bits branch range, just set the branch target
> + if (SignExtend32<24>(delta) == delta) {
> + RelocationEntry RE(Rel.SectionID, Rel.Offset, RelType, Value.Addend);
> + if (Value.SymbolName)
> + addRelocationForSymbol(RE, Value.SymbolName);
> + else
> + addRelocationForSection(RE, Value.SectionID);
> + } else {
> + RangeOverflow = true;
> + }
> + }
> + if (SymType == SymbolRef::ST_Unknown || RangeOverflow == true) {
> + // It is an external symbol (SymbolRef::ST_Unknown) or within a range
> + // larger than 24-bits.
> + StubMap::const_iterator i = Stubs.find(Value);
> + if (i != Stubs.end()) {
> + // Symbol function stub already created, just relocate to it
> + resolveRelocation(Target, (uint64_t)Target, (uint64_t)Section.Address
> + + i->second, RelType, 0);
> + DEBUG(dbgs() << " Stub function found\n");
> + } else {
> + // Create a new stub function.
> + DEBUG(dbgs() << " Create a new stub function\n");
> + Stubs[Value] = Section.StubOffset;
> + uint8_t *StubTargetAddr = createStubFunction(Section.Address +
> + Section.StubOffset);
> + RelocationEntry RE(Rel.SectionID, StubTargetAddr - Section.Address,
> + ELF::R_PPC64_ADDR64, Value.Addend);
> +
> + // Generates the 64-bits address loads as exemplified in section
> + // 4.5.1 in PPC64 ELF ABI.
> + RelocationEntry REhst(Rel.SectionID,
> + StubTargetAddr - Section.Address,
> + ELF::R_PPC64_ADDR16_HIGHEST, Value.Addend);
> + RelocationEntry REhr(Rel.SectionID,
> + StubTargetAddr - Section.Address + 4,
> + ELF::R_PPC64_ADDR16_HIGHER, Value.Addend);
> + RelocationEntry REh(Rel.SectionID,
> + StubTargetAddr - Section.Address + 12,
> + ELF::R_PPC64_ADDR16_HI, Value.Addend);
> + RelocationEntry REl(Rel.SectionID,
> + StubTargetAddr - Section.Address + 16,
> + ELF::R_PPC64_ADDR16_LO, Value.Addend);
> +
> + if (Value.SymbolName) {
> + addRelocationForSymbol(REhst, Value.SymbolName);
> + addRelocationForSymbol(REhr, Value.SymbolName);
> + addRelocationForSymbol(REh, Value.SymbolName);
> + addRelocationForSymbol(REl, Value.SymbolName);
> + } else {
> + addRelocationForSection(REhst, Value.SectionID);
> + addRelocationForSection(REhr, Value.SectionID);
> + addRelocationForSection(REh, Value.SectionID);
> + addRelocationForSection(REl, Value.SectionID);
> + }
> +
> + resolveRelocation(Target, (uint64_t)Target, (uint64_t)Section.Address
> + + Section.StubOffset, RelType, 0);
> + if (SymType == SymbolRef::ST_Unknown)
> + // Restore the TOC for external calls
> + *((uint32_t*)Target+1) = 0xE8410028; // ld r2,40(r1)
> + Section.StubOffset += getMaxStubSize();
> + }
> + }
> + } else {
> + RelocationEntry RE(Rel.SectionID, Rel.Offset, RelType, Value.Addend);
> + // Extra check to avoid relocation againt empty symbols (usually
> + // the R_PPC64_TOC).
> + if (Value.SymbolName && !TargetName.empty())
> + addRelocationForSymbol(RE, Value.SymbolName);
> + else
> + addRelocationForSection(RE, Value.SectionID);
> + }
> } else {
> RelocationEntry RE(Rel.SectionID, Rel.Offset, RelType, Value.Addend);
> if (Value.SymbolName)
> diff --git a/lib/ExecutionEngine/RuntimeDyld/RuntimeDyldELF.h b/lib/ExecutionEngine/RuntimeDyld/RuntimeDyldELF.h
> index eade49e..997351b 100644
> --- a/lib/ExecutionEngine/RuntimeDyld/RuntimeDyldELF.h
> +++ b/lib/ExecutionEngine/RuntimeDyld/RuntimeDyldELF.h
> @@ -48,6 +48,12 @@ protected:
> uint32_t Type,
> int32_t Addend);
>
> + void resolvePPC64Relocation(uint8_t *LocalAddress,
> + uint64_t FinalAddress,
> + uint64_t Value,
> + uint32_t Type,
> + int64_t Addend);
> +
> virtual void resolveRelocation(uint8_t *LocalAddress,
> uint64_t FinalAddress,
> uint64_t Value,
> @@ -63,6 +69,11 @@ protected:
> virtual ObjectImage *createObjectImage(const MemoryBuffer *InputBuffer);
> virtual void handleObjectLoaded(ObjectImage *Obj);
>
> + uint64_t findPPC64TOC() const;
> + void findOPDEntrySection(ObjectImage &Obj,
> + ObjSectionToIDMap &LocalSections,
> + RelocationValueRef &Rel);
> +
> public:
> RuntimeDyldELF(RTDyldMemoryManager *mm)
> : RuntimeDyldImpl(mm), LoadedObject(0) {}
> diff --git a/lib/ExecutionEngine/RuntimeDyld/RuntimeDyldImpl.h b/lib/ExecutionEngine/RuntimeDyld/RuntimeDyldImpl.h
> index b29ff40..47807eb 100644
> --- a/lib/ExecutionEngine/RuntimeDyld/RuntimeDyldImpl.h
> +++ b/lib/ExecutionEngine/RuntimeDyld/RuntimeDyldImpl.h
> @@ -166,6 +166,8 @@ protected:
> return 8; // 32-bit instruction and 32-bit address
> else if (Arch == Triple::mipsel)
> return 16;
> + else if (Arch == Triple::ppc64)
> + return 44;
> else
> return 0;
> }
> --
> 1.7.1
>
On Sep 17, 2012, at 1:21 PM, Adhemerval Zanella <azanella at linux.vnet.ibm.com> wrote:
> This is the initial support of MCJIT for PPC64-elf-abi. I didn't add any testcase
> because I focused on existing ones. It correctly runs the following ones:
>
> ExecutionEngine/2003-01-04-ArgumentBug.ll
> ExecutionEngine/2003-01-04-LoopTest.ll
> ExecutionEngine/2003-01-04-PhiTest.ll
> ExecutionEngine/2003-01-09-SARTest.ll
> ExecutionEngine/2003-01-10-FUCOM.ll
> ExecutionEngine/2003-01-15-AlignmentTest.ll
> ExecutionEngine/2003-05-11-PHIRegAllocBug.ll
> ExecutionEngine/2003-06-04-bzip2-bug.ll
> ExecutionEngine/2003-06-05-PHIBug.ll
> ExecutionEngine/2003-08-15-AllocaAssertion.ll
> ExecutionEngine/2003-08-21-EnvironmentTest.ll
> ExecutionEngine/2003-08-23-RegisterAllocatePhysReg.ll
> ExecutionEngine/2003-10-18-PHINode-ConstantExpr-CondCode-Failure.ll
> ExecutionEngine/simplesttest.ll
> ExecutionEngine/simpletest.ll
> ExecutionEngine/stubs.ll
> ExecutionEngine/test-arith.ll
> ExecutionEngine/test-branch.ll
> ExecutionEngine/test-call-no-external-funcs.ll
> ExecutionEngine/test-cast.ll
> ExecutionEngine/test-common-symbols.ll
> ExecutionEngine/test-constantexpr.ll
> ExecutionEngine/test-fp-no-external-funcs.ll
> ExecutionEngine/test-fp.ll
> ExecutionEngine/test-global-init-nonzero.ll
> ExecutionEngine/test-global.ll
> ExecutionEngine/test-loadstore.ll
> ExecutionEngine/test-local.ll
> ExecutionEngine/test-logical.ll
> ExecutionEngine/test-loop.ll
> ExecutionEngine/test-phi.ll
> ExecutionEngine/test-ret.ll
> ExecutionEngine/test-return.ll
> ExecutionEngine/test-setcond-fp.ll
> ExecutionEngine/test-setcond-int.ll
> ExecutionEngine/test-shift.ll
>
> --
> Adhemerval Zanella Netto
> Software Engineer
> Linux Technology Center Brazil
> Toolchain / GLIBC on Power Architecture
> azanella at linux.vnet.ibm.com / azanella at br.ibm.com
> +55 61 8642-9890
>
> <0010-Initial-support-for-PowerPC64-MCJIT.patch>_______________________________________________
> llvm-commits mailing list
> llvm-commits at cs.uiuc.edu
> http://lists.cs.uiuc.edu/mailman/listinfo/llvm-commits
-------------- next part --------------
An HTML attachment was scrubbed...
URL: <http://lists.llvm.org/pipermail/llvm-commits/attachments/20120917/2ffdea54/attachment.html>
More information about the llvm-commits
mailing list