This is an archive of the discontinued LLVM Phabricator instance.

Differential D7225

[lld] Remove PPC ELF target
ClosedPublic

Authored by garious on Jan 28 2015, 5:09 AM.

Details

Reviewers
ruiu
wnewton
shankarke
• shankar.easwaran
Commits
rGdf0f5cd47434: Remove PPC ELF target
rLLD227320: Remove PPC ELF target
rL227320: Remove PPC ELF target
Summary

As previously discussed here:
http://llvm.1065342.n5.nabble.com/lld-Removal-of-ELF-PowerPC-port-td76854.html#a76871

Diff Detail

Repository
rL LLVM

Event Timeline

garious updated this revision to Diff 18886.Jan 28 2015, 5:09 AM
garious retitled this revision from to [lld] Remove PPC ELF target.
garious updated this object.
garious edited the test plan for this revision. (Show Details)
garious added reviewers: ruiu, wnewton, shankarke.
garious set the repository for this revision to rL LLVM.
garious added a project: lld.
garious added a subscriber: Unknown Object (MLST).
• shankar.easwaran accepted this revision.Jan 28 2015, 5:56 AM
• shankar.easwaran added a reviewer: • shankar.easwaran.
This revision is now accepted and ready to land.Jan 28 2015, 5:56 AM
emaste added a subscriber: emaste.Jan 28 2015, 6:43 AM
wnewton accepted this revision.Jan 28 2015, 6:53 AM
wnewton edited edge metadata.

LGTM

Closed by commit rL227320: Remove PPC ELF target (authored by garious). · Explain WhyJan 28 2015, 8:39 AM
This revision was automatically updated to reflect the committed changes.
ruiu edited edge metadata.Jan 28 2015, 9:38 AM

LGTM

Revision Contents

PathSize
lld/
trunk/
include/
lld/
ReaderWriter/
1 line
lib/
Driver/
1 line
1 line
ReaderWriter/
ELF/
1 line
2 lines
Mips/
2 lines
PPC/
9 lines
15 lines
41 lines
60 lines
32 lines
29 lines
67 lines
93 lines
test/
elf/
14 lines
tools/
lld/
2 lines

Diff 18894

lld/trunk/include/lld/ReaderWriter/ELFTargets.h

Show All 20 Lines public: \
static std::unique_ptr<ELFLinkingContext> create(llvm::Triple); \ static std::unique_ptr<ELFLinkingContext> create(llvm::Triple); \
}; };
// FIXME: #include "llvm/Config/Targets.def" // FIXME: #include "llvm/Config/Targets.def"
LLVM_TARGET(AArch64) LLVM_TARGET(AArch64)
LLVM_TARGET(ARM) LLVM_TARGET(ARM)
LLVM_TARGET(Hexagon) LLVM_TARGET(Hexagon)
LLVM_TARGET(Mips) LLVM_TARGET(Mips)
LLVM_TARGET(PPC)
LLVM_TARGET(X86) LLVM_TARGET(X86)
LLVM_TARGET(X86_64) LLVM_TARGET(X86_64)
#undef LLVM_TARGET #undef LLVM_TARGET
} // end namespace elf } // end namespace elf
} // end namespace lld } // end namespace lld
#endif #endif

lld/trunk/lib/Driver/CMakeLists.txt

Show All 22 Lines LINK_LIBS
lldPasses lldPasses
lldMachO lldMachO
lldPECOFF lldPECOFF
lldELF lldELF
lldAArch64ELFTarget lldAArch64ELFTarget
lldARMELFTarget lldARMELFTarget
lldHexagonELFTarget lldHexagonELFTarget
lldMipsELFTarget lldMipsELFTarget
lldPPCELFTarget
lldX86ELFTarget lldX86ELFTarget
lldX86_64ELFTarget lldX86_64ELFTarget
lldCore lldCore
lldNative lldNative
lldReaderWriter lldReaderWriter
lldYAML lldYAML
LLVMObject LLVMObject
LLVMOption LLVMOption
LLVMSupport LLVMSupport
) )
add_dependencies(lldDriver DriverOptionsTableGen) add_dependencies(lldDriver DriverOptionsTableGen)

lld/trunk/lib/Driver/GnuLdDriver.cpp

Show First 20 Lines • Show All 323 Lines • ▼ Show 20 Lines
std::unique_ptr<ELFLinkingContext> std::unique_ptr<ELFLinkingContext>
createELFLinkingContext(llvm::Triple triple) { createELFLinkingContext(llvm::Triple triple) {
std::unique_ptr<ELFLinkingContext> p; std::unique_ptr<ELFLinkingContext> p;
// FIXME: #include "llvm/Config/Targets.def" // FIXME: #include "llvm/Config/Targets.def"
LLVM_TARGET(AArch64) LLVM_TARGET(AArch64)
LLVM_TARGET(ARM) LLVM_TARGET(ARM)
LLVM_TARGET(Hexagon) LLVM_TARGET(Hexagon)
LLVM_TARGET(Mips) LLVM_TARGET(Mips)
LLVM_TARGET(PPC)
LLVM_TARGET(X86) LLVM_TARGET(X86)
LLVM_TARGET(X86_64) LLVM_TARGET(X86_64)
return nullptr; return nullptr;
} }
#undef LLVM_TARGET #undef LLVM_TARGET
bool GnuLdDriver::parse(int argc, const char *argv[], bool GnuLdDriver::parse(int argc, const char *argv[],
std::unique_ptr<ELFLinkingContext> &context, std::unique_ptr<ELFLinkingContext> &context,
▲ Show 20 Lines • Show All 398 Lines • Show Last 20 Lines

lld/trunk/lib/ReaderWriter/ELF/CMakeLists.txt

add_llvm_library(lldELF add_llvm_library(lldELF
ArrayOrderPass.cpp ArrayOrderPass.cpp
ELFLinkingContext.cpp ELFLinkingContext.cpp
Reader.cpp Reader.cpp
Writer.cpp Writer.cpp
LINK_LIBS LINK_LIBS
lldCore lldCore
lldPasses lldPasses
lldYAML lldYAML
LLVMSupport LLVMSupport
) )
include_directories(.) include_directories(.)
add_subdirectory(X86) add_subdirectory(X86)
add_subdirectory(X86_64) add_subdirectory(X86_64)
add_subdirectory(PPC)
add_subdirectory(Mips) add_subdirectory(Mips)
add_subdirectory(Hexagon) add_subdirectory(Hexagon)
add_subdirectory(AArch64) add_subdirectory(AArch64)
add_subdirectory(ARM) add_subdirectory(ARM)

lld/trunk/lib/ReaderWriter/ELF/Makefile

##===- lld/lib/ReaderWriter/ELF/Makefile --------------*- Makefile -*-===## ##===- lld/lib/ReaderWriter/ELF/Makefile --------------*- Makefile -*-===##
# #
# The LLVM Compiler Infrastructure # The LLVM Compiler Infrastructure
# #
# This file is distributed under the University of Illinois Open Source # This file is distributed under the University of Illinois Open Source
# License. See LICENSE.TXT for details. # License. See LICENSE.TXT for details.
# #
##===----------------------------------------------------------------------===## ##===----------------------------------------------------------------------===##
LLD_LEVEL := ../../.. LLD_LEVEL := ../../..
LIBRARYNAME := lldELF LIBRARYNAME := lldELF
USEDLIBS = lldPasses.a USEDLIBS = lldPasses.a
CPP.Flags += -I$(PROJ_SRC_DIR)/$(LLD_LEVEL)/lib/ReaderWriter/ELF CPP.Flags += -I$(PROJ_SRC_DIR)/$(LLD_LEVEL)/lib/ReaderWriter/ELF
# these link against this lib # these link against this lib
PARALLEL_DIRS := Hexagon PPC X86 X86_64 Mips AArch64 ARM PARALLEL_DIRS := Hexagon X86 X86_64 Mips AArch64 ARM
include $(LLD_LEVEL)/Makefile include $(LLD_LEVEL)/Makefile

lld/trunk/lib/ReaderWriter/ELF/Mips/Makefile

##===- lld/lib/ReaderWriter/ELF/PPC/Makefile ----------*- Makefile -*-===## ##===- lld/lib/ReaderWriter/ELF/Mips/Makefile ----------*- Makefile -*-===##
# #
# The LLVM Compiler Infrastructure # The LLVM Compiler Infrastructure
# #
# This file is distributed under the University of Illinois Open Source # This file is distributed under the University of Illinois Open Source
# License. See LICENSE.TXT for details. # License. See LICENSE.TXT for details.
# #
##===----------------------------------------------------------------------===## ##===----------------------------------------------------------------------===##
LLD_LEVEL := ../../../.. LLD_LEVEL := ../../../..
LIBRARYNAME := lldMipsELFTarget LIBRARYNAME := lldMipsELFTarget
USEDLIBS = lldCore.a USEDLIBS = lldCore.a
CPP.Flags += -I$(PROJ_SRC_DIR)/$(LLD_LEVEL)/lib/ReaderWriter/ELF CPP.Flags += -I$(PROJ_SRC_DIR)/$(LLD_LEVEL)/lib/ReaderWriter/ELF
include $(LLD_LEVEL)/Makefile include $(LLD_LEVEL)/Makefile

lld/trunk/lib/ReaderWriter/ELF/PPC/CMakeLists.txt

add_llvm_library(lldPPCELFTarget
PPCLinkingContext.cpp
PPCTargetHandler.cpp
LINK_LIBS
lldCore
lldELF
LLVMObject
LLVMSupport
)

lld/trunk/lib/ReaderWriter/ELF/PPC/Makefile

##===- lld/lib/ReaderWriter/ELF/PPC/Makefile ----------*- Makefile -*-===##
#
# The LLVM Compiler Infrastructure
#
# This file is distributed under the University of Illinois Open Source
# License. See LICENSE.TXT for details.
#
##===----------------------------------------------------------------------===##
LLD_LEVEL := ../../../..
LIBRARYNAME := lldPPCELFTarget
USEDLIBS = lldCore.a
CPP.Flags += -I$(PROJ_SRC_DIR)/$(LLD_LEVEL)/lib/ReaderWriter/ELF
include $(LLD_LEVEL)/Makefile

lld/trunk/lib/ReaderWriter/ELF/PPC/PPCELFFile.h

//===- lib/ReaderWriter/ELF/PPCELFFile.h -------------------------------===//
//
// The LLVM Linker
//
// This file is distributed under the University of Illinois Open Source
// License. See LICENSE.TXT for details.
//
//===----------------------------------------------------------------------===//
#ifndef LLD_READER_WRITER_ELF_PPC_ELF_FILE_H
#define LLD_READER_WRITER_ELF_PPC_ELF_FILE_H
#include "ELFReader.h"
namespace lld {
namespace elf {
class PPCLinkingContext;
template <class ELFT> class PPCELFFile : public ELFFile<ELFT> {
public:
PPCELFFile(std::unique_ptr<MemoryBuffer> mb, bool atomizeStrings)
: ELFFile<ELFT>(std::move(mb), atomizeStrings) {}
static ErrorOr<std::unique_ptr<PPCELFFile>>
create(std::unique_ptr<MemoryBuffer> mb, bool atomizeStrings) {
return std::unique_ptr<PPCELFFile<ELFT>>(
new PPCELFFile<ELFT>(std::move(mb), atomizeStrings));
}
};
template <class ELFT> class PPCDynamicFile : public DynamicFile<ELFT> {
public:
PPCDynamicFile(const PPCLinkingContext &context, StringRef name)
: DynamicFile<ELFT>(context, name) {}
};
} // elf
} // lld
#endif // LLD_READER_WRITER_ELF_PPC_ELF_FILE_H

lld/trunk/lib/ReaderWriter/ELF/PPC/PPCELFReader.h

//===- lib/ReaderWriter/ELF/PPC/PPCELFReader.h ----------------------------===//
//
// The LLVM Linker
//
// This file is distributed under the University of Illinois Open Source
// License. See LICENSE.TXT for details.
//
//===----------------------------------------------------------------------===//
#ifndef LLD_READER_WRITER_PPC_PPC_ELF_READER_H
#define LLD_READER_WRITER_PPC_PPC_ELF_READER_H
#include "ELFReader.h"
#include "PPCELFFile.h"
namespace lld {
namespace elf {
typedef llvm::object::ELFType<llvm::support::big, 2, false> PPCELFType;
struct PPCDynamicFileCreateELFTraits {
typedef llvm::ErrorOr<std::unique_ptr<lld::SharedLibraryFile>> result_type;
template <class ELFT>
static result_type create(std::unique_ptr<llvm::MemoryBuffer> mb,
bool useUndefines) {
return lld::elf::PPCDynamicFile<ELFT>::create(std::move(mb), useUndefines);
}
};
struct PPCELFFileCreateELFTraits {
typedef llvm::ErrorOr<std::unique_ptr<lld::File>> result_type;
template <class ELFT>
static result_type create(std::unique_ptr<llvm::MemoryBuffer> mb,
bool atomizeStrings) {
return lld::elf::PPCELFFile<ELFT>::create(std::move(mb), atomizeStrings);
}
};
class PPCELFObjectReader
: public ELFObjectReader<PPCELFType, PPCELFFileCreateELFTraits> {
public:
PPCELFObjectReader(bool atomizeStrings)
: ELFObjectReader<PPCELFType, PPCELFFileCreateELFTraits>(
atomizeStrings, llvm::ELF::EM_PPC) {}
};
class PPCELFDSOReader
: public ELFDSOReader<PPCELFType, PPCDynamicFileCreateELFTraits> {
public:
PPCELFDSOReader(bool useUndefines)
: ELFDSOReader<PPCELFType, PPCDynamicFileCreateELFTraits>(
useUndefines, llvm::ELF::EM_PPC) {}
};
} // namespace elf
} // namespace lld
#endif // LLD_READER_WRITER_PPC_PPC_ELF_READER_H

lld/trunk/lib/ReaderWriter/ELF/PPC/PPCLinkingContext.h

//===- lib/ReaderWriter/ELF/PPC/PPCLinkingContext.h -----------------------===//
//
// The LLVM Linker
//
// This file is distributed under the University of Illinois Open Source
// License. See LICENSE.TXT for details.
//
//===----------------------------------------------------------------------===//
#ifndef LLD_READER_WRITER_ELF_PPC_PPC_LINKING_CONTEXT_H
#define LLD_READER_WRITER_ELF_PPC_PPC_LINKING_CONTEXT_H
#include "lld/ReaderWriter/ELFLinkingContext.h"
#include "llvm/Object/ELF.h"
#include "llvm/Support/ELF.h"
namespace lld {
namespace elf {
class PPCLinkingContext final : public ELFLinkingContext {
public:
static std::unique_ptr<ELFLinkingContext> create(llvm::Triple);
PPCLinkingContext(llvm::Triple triple);
/// \brief PPC has no relative relocations defined
bool isRelativeReloc(const Reference &) const override { return false; }
};
} // elf
} // lld
#endif // LLD_READER_WRITER_ELF_PPC_PPC_LINKING_CONTEXT_H

lld/trunk/lib/ReaderWriter/ELF/PPC/PPCLinkingContext.cpp

//===- lib/ReaderWriter/ELF/PPC/PPCLinkingContext.cpp ---------------------===//
//
// The LLVM Linker
//
// This file is distributed under the University of Illinois Open Source
// License. See LICENSE.TXT for details.
//
//===----------------------------------------------------------------------===//
#include "PPCLinkingContext.h"
#include "PPCTargetHandler.h"
#include "lld/Core/LLVM.h"
#include "llvm/ADT/StringSwitch.h"
#include "llvm/Support/ErrorOr.h"
using namespace lld;
std::unique_ptr<ELFLinkingContext>
elf::PPCLinkingContext::create(llvm::Triple triple) {
if (triple.getArch() == llvm::Triple::ppc)
return std::unique_ptr<ELFLinkingContext>(
new elf::PPCLinkingContext(triple));
return nullptr;
}
elf::PPCLinkingContext::PPCLinkingContext(llvm::Triple triple)
: ELFLinkingContext(triple, std::unique_ptr<TargetHandlerBase>(
new PPCTargetHandler(*this))) {}

lld/trunk/lib/ReaderWriter/ELF/PPC/PPCTargetHandler.h

//===- lib/ReaderWriter/ELF/PPC/PPCTargetHandler.h ------------------------===//
//
// The LLVM Linker
//
// This file is distributed under the University of Illinois Open Source
// License. See LICENSE.TXT for details.
//
//===----------------------------------------------------------------------===//
#ifndef LLD_READER_WRITER_ELF_PPC_PPC_TARGET_HANDLER_H
#define LLD_READER_WRITER_ELF_PPC_PPC_TARGET_HANDLER_H
#include "DefaultTargetHandler.h"
#include "PPCELFReader.h"
#include "TargetLayout.h"
namespace lld {
namespace elf {
class PPCLinkingContext;
template <class ELFT> class PPCTargetLayout : public TargetLayout<ELFT> {
public:
PPCTargetLayout(PPCLinkingContext &context) : TargetLayout<ELFT>(context) {}
};
class PPCTargetRelocationHandler final : public TargetRelocationHandler {
public:
std::error_code applyRelocation(ELFWriter &, llvm::FileOutputBuffer &,
const lld::AtomLayout &,
const Reference &) const override;
};
class PPCTargetHandler final
: public DefaultTargetHandler<PPCELFType> {
public:
PPCTargetHandler(PPCLinkingContext &context);
PPCTargetLayout<PPCELFType> &getTargetLayout() override {
return *(_ppcTargetLayout.get());
}
void registerRelocationNames(Registry &registry) override;
const PPCTargetRelocationHandler &getRelocationHandler() const override {
return *(_ppcRelocationHandler.get());
}
std::unique_ptr<Reader> getObjReader(bool atomizeStrings) override {
return std::unique_ptr<Reader>(new PPCELFObjectReader(atomizeStrings));
}
std::unique_ptr<Reader> getDSOReader(bool useShlibUndefines) override {
return std::unique_ptr<Reader>(new PPCELFDSOReader(useShlibUndefines));
}
std::unique_ptr<Writer> getWriter() override;
private:
static const Registry::KindStrings kindStrings[];
PPCLinkingContext &_ppcLinkingContext;
std::unique_ptr<PPCTargetLayout<PPCELFType>> _ppcTargetLayout;
std::unique_ptr<PPCTargetRelocationHandler> _ppcRelocationHandler;
};
} // end namespace elf
} // end namespace lld
#endif

lld/trunk/lib/ReaderWriter/ELF/PPC/PPCTargetHandler.cpp

//===- lib/ReaderWriter/ELF/PPC/PPCTargetHandler.cpp ----------------------===//
//
// The LLVM Linker
//
// This file is distributed under the University of Illinois Open Source
// License. See LICENSE.TXT for details.
//
//===----------------------------------------------------------------------===//
#include "PPCTargetHandler.h"
#include "PPCLinkingContext.h"
using namespace lld;
using namespace elf;
using namespace llvm::ELF;
/// \brief The following relocation routines are derived from the
/// SYSTEM V APPLICATION BINARY INTERFACE: PowerPC Processor Supplement
/// Symbols used:
/// A: Added used to compute the value, r_addend
/// P: Place address of the field being relocated, r_offset
/// S: Value of the symbol whose index resides in the relocation entry.
/// \brief low24 (S + A - P) >> 2 : Verify
static int relocB24PCREL(uint8_t *location, uint64_t P, uint64_t S,
uint64_t A) {
int32_t result = (uint32_t)(((S + A) - P));
if ((result < 0x1000000) && (result > -0x1000000)) {
result &= ~-(0x1000000);
*reinterpret_cast<llvm::support::ubig32_t *>(location) = result |
(uint32_t)*reinterpret_cast<llvm::support::ubig32_t *>(location);
return 0;
}
return 1;
}
std::error_code PPCTargetRelocationHandler::applyRelocation(
ELFWriter &writer, llvm::FileOutputBuffer &buf, const lld::AtomLayout &atom,
const Reference &ref) const {
uint8_t *atomContent = buf.getBufferStart() + atom._fileOffset;
uint8_t *location = atomContent + ref.offsetInAtom();
uint64_t targetVAddress = writer.addressOfAtom(ref.target());
uint64_t relocVAddress = atom._virtualAddr + ref.offsetInAtom();
if (ref.kindNamespace() != Reference::KindNamespace::ELF)
return std::error_code();
assert(ref.kindArch() == Reference::KindArch::PowerPC);
switch (ref.kindValue()) {
case R_PPC_REL24:
relocB24PCREL(location, relocVAddress, targetVAddress, ref.addend());
break;
default:
return make_unhandled_reloc_error();
}
return std::error_code();
}
PPCTargetHandler::PPCTargetHandler(PPCLinkingContext &context)
: _ppcLinkingContext(context),
_ppcTargetLayout(new PPCTargetLayout<PPCELFType>(context)),
_ppcRelocationHandler(new PPCTargetRelocationHandler()) {}
void PPCTargetHandler::registerRelocationNames(Registry &registry) {
registry.addKindTable(Reference::KindNamespace::ELF,
Reference::KindArch::PowerPC, kindStrings);
}
std::unique_ptr<Writer> PPCTargetHandler::getWriter() {
switch (_ppcLinkingContext.getOutputELFType()) {
case llvm::ELF::ET_EXEC:
return std::unique_ptr<Writer>(new elf::ExecutableWriter<PPCELFType>(
_ppcLinkingContext, *_ppcTargetLayout.get()));
case llvm::ELF::ET_DYN:
return std::unique_ptr<Writer>(new elf::DynamicLibraryWriter<PPCELFType>(
_ppcLinkingContext, *_ppcTargetLayout.get()));
case llvm::ELF::ET_REL:
llvm_unreachable("TODO: support -r mode");
default:
llvm_unreachable("unsupported output type");
}
}
#define ELF_RELOC(name, value) LLD_KIND_STRING_ENTRY(name),
const Registry::KindStrings PPCTargetHandler::kindStrings[] = {
#include "llvm/Support/ELFRelocs/PowerPC.def"
LLD_KIND_STRING_END
};
#undef ELF_RELOC

lld/trunk/test/elf/ppc.test

RUN: lld -flavor gnu -target powerpc %p/Inputs/branch-test.ppc %p/Inputs/target-test.ppc -o %t1 --noinhibit-exec
RUN: llvm-readobj -h %t1 | FileCheck -check-prefix=ppc-readobj %s
ppc-readobj: ElfHeader {
ppc-readobj: Ident {
ppc-readobj: Class: 32-bit (0x1)
ppc-readobj: DataEncoding: BigEndian (0x2)
ppc-readobj: FileVersion: 1
ppc-readobj: OS/ABI: SystemV (0x0)
ppc-readobj: ABIVersion: 0
ppc-readobj: }
ppc-readobj: Type: Executable (0x2)
ppc-readobj: Machine: EM_PPC (0x14)

lld/trunk/tools/lld/Makefile

Show All 16 Lines
#include /Makefile.config #include /Makefile.config
LEVEL := $(LLD_LEVEL)/../.. LEVEL := $(LLD_LEVEL)/../..
include $(LEVEL)/Makefile.config include $(LEVEL)/Makefile.config
LINK_COMPONENTS := $(TARGETS_TO_BUILD) LINK_COMPONENTS := $(TARGETS_TO_BUILD)
USEDLIBS = lldDriver.a lldConfig.a \ USEDLIBS = lldDriver.a lldConfig.a \
lldELF.a lldMachO.a lldPasses.a lldPECOFF.a lldYAML.a \ lldELF.a lldMachO.a lldPasses.a lldPECOFF.a lldYAML.a \
lldReaderWriter.a lldCore.a lldNative.a \ lldReaderWriter.a lldCore.a lldNative.a \
lldHexagonELFTarget.a lldPPCELFTarget.a lldMipsELFTarget.a \ lldHexagonELFTarget.a lldMipsELFTarget.a \
lldX86ELFTarget.a lldX86_64ELFTarget.a lldAArch64ELFTarget.a \ lldX86ELFTarget.a lldX86_64ELFTarget.a lldAArch64ELFTarget.a \
lldARMELFTarget.a \ lldARMELFTarget.a \
LLVMOption.a LLVMOption.a
include $(LLD_LEVEL)/Makefile include $(LLD_LEVEL)/Makefile
lld/trunk/lib/ReaderWriter/ELF/PPC/PPCELFReader.h