This is an archive of the discontinued LLVM Phabricator instance.

Differential D15954

[old ELF] Remove AMDGPU target
ClosedPublic

Authored by • tstellarAMD on Jan 7 2016, 8:55 AM.

Details

Reviewers
ruiu
• rafael
Commits
rG3b8cde69aa44: [old ELF] Remove AMDGPU target
rLLD257390: [old ELF] Remove AMDGPU target
rL257390: [old ELF] Remove AMDGPU target
Summary

This is no longer needed now that the new ELF implementation supports AMDGPU.

Diff Detail

Repository
rL LLVM

Event Timeline

• tstellarAMD updated this revision to Diff 44219.Jan 7 2016, 8:55 AM
• tstellarAMD retitled this revision from to [old ELF] Remove AMDGPU target.
• tstellarAMD updated this object.
• tstellarAMD added reviewers: ruiu, • rafael.
• tstellarAMD added a subscriber: llvm-commits.
• tstellarAMD added a parent revision: D15953: Driver: Pass -flavor gnu to lld for AMDGPU rather than -flavor gnu-old.Jan 7 2016, 8:57 AM
ruiu accepted this revision.Jan 7 2016, 9:08 AM
ruiu edited edge metadata.

LGTM

This revision is now accepted and ready to land.Jan 7 2016, 9:08 AM
Closed by commit rL257390: [old ELF] Remove AMDGPU target (authored by tstellar). · Explain WhyJan 11 2016, 1:44 PM
This revision was automatically updated to reflect the committed changes.

Revision Contents

Diff 44546

lld/trunk/lib/Driver/CMakeLists.txt

Show All 19 Linesadd_lld_library(lldDriver
LINK_LIBS LINK_LIBS
lldConfig lldConfig
lldMachO lldMachO
lldCOFF lldCOFF
lldELF lldELF
lldELF2 lldELF2
lldAArch64ELFTarget lldAArch64ELFTarget
lldAMDGPUELFTarget
lldARMELFTarget lldARMELFTarget
lldHexagonELFTarget lldHexagonELFTarget
lldMipsELFTarget lldMipsELFTarget
lldX86ELFTarget lldX86ELFTarget
lldExampleSubTarget lldExampleSubTarget
lldX86_64ELFTarget lldX86_64ELFTarget
lldCore lldCore
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 319 Lines • ▼ Show 20 Linesvoid GnuLdDriver::addPlatformSearchDirs(ELFLinkingContext &ctx,
} }
ctx.addSearchPath("=/usr/lib"); ctx.addSearchPath("=/usr/lib");
} }
std::unique_ptr<ELFLinkingContext> std::unique_ptr<ELFLinkingContext>
GnuLdDriver::createELFLinkingContext(llvm::Triple triple) { GnuLdDriver::createELFLinkingContext(llvm::Triple triple) {
std::unique_ptr<ELFLinkingContext> p; std::unique_ptr<ELFLinkingContext> p;
if ((p = elf::createAArch64LinkingContext(triple))) return p; if ((p = elf::createAArch64LinkingContext(triple))) return p;
if ((p = elf::createAMDGPULinkingContext(triple))) return p;
if ((p = elf::createARMLinkingContext(triple))) return p; if ((p = elf::createARMLinkingContext(triple))) return p;
if ((p = elf::createExampleLinkingContext(triple))) return p; if ((p = elf::createExampleLinkingContext(triple))) return p;
if ((p = elf::createHexagonLinkingContext(triple))) return p; if ((p = elf::createHexagonLinkingContext(triple))) return p;
if ((p = elf::createMipsLinkingContext(triple))) return p; if ((p = elf::createMipsLinkingContext(triple))) return p;
if ((p = elf::createX86LinkingContext(triple))) return p; if ((p = elf::createX86LinkingContext(triple))) return p;
if ((p = elf::createX86_64LinkingContext(triple))) return p; if ((p = elf::createX86_64LinkingContext(triple))) return p;
return nullptr; return nullptr;
} }
▲ Show 20 Lines • Show All 447 Lines • Show Last 20 Lines

lld/trunk/lib/ReaderWriter/ELF/AMDGPU/AMDGPUExecutableWriter.h

//===- lib/ReaderWriter/ELF/AMDGPU/AMDGPUExecutableWriter.h ---------------===//
//
// The LLVM Linker
//
// This file is distributed under the University of Illinois Open Source
// License. See LICENSE.TXT for details.
//
//===----------------------------------------------------------------------===//
#ifndef AMDGPU_EXECUTABLE_WRITER_H
#define AMDGPU_EXECUTABLE_WRITER_H
#include "ExecutableWriter.h"
#include "AMDGPULinkingContext.h"
#include "AMDGPUSymbolTable.h"
#include "AMDGPUTargetHandler.h"
namespace lld {
namespace elf {
class AMDGPUTargetLayout;
class AMDGPUExecutableWriter : public ExecutableWriter<ELF64LE> {
public:
AMDGPUExecutableWriter(AMDGPULinkingContext &ctx, AMDGPUTargetLayout &layout);
unique_bump_ptr<SymbolTable<ELF64LE>> createSymbolTable() override {
return unique_bump_ptr<SymbolTable<ELF64LE>>(new (this->_alloc)
AMDGPUSymbolTable(_ctx));
}
void createImplicitFiles(std::vector<std::unique_ptr<File>> &Result) override;
void finalizeDefaultAtomValues() override;
private:
AMDGPULinkingContext &_ctx;
};
} // namespace elf
} // namespace lld
#endif // AMDGPU_EXECUTABLE_WRITER_H

lld/trunk/lib/ReaderWriter/ELF/AMDGPU/AMDGPUExecutableWriter.cpp

//===- lib/ReaderWriter/ELF/AMDGPU/AMDGPUExecutableWriter.cpp -------------===//
//
// The LLVM Linker
//
// This file is distributed under the University of Illinois Open Source
// License. See LICENSE.TXT for details.
//
//===----------------------------------------------------------------------===//
#include "AMDGPUExecutableWriter.h"
using namespace lld;
using namespace lld::elf;
AMDGPUExecutableWriter::AMDGPUExecutableWriter(AMDGPULinkingContext &ctx,
AMDGPUTargetLayout &layout)
: ExecutableWriter(ctx, layout), _ctx(ctx) {}
void AMDGPUExecutableWriter::createImplicitFiles(
std::vector<std::unique_ptr<File>> &Result) {
// ExecutableWriter::createImplicitFiles() adds C runtime symbols that we
// don't need, so we use the OutputELFWriter implementation instead.
OutputELFWriter<ELF64LE>::createImplicitFiles(Result);
}
void AMDGPUExecutableWriter::finalizeDefaultAtomValues() {
// ExecutableWriter::finalizeDefaultAtomValues() assumes the presence of
// C runtime symbols. However, since we skip the call to
// ExecutableWriter::createImplicitFiles(), these symbols are never added
// and ExectuableWriter::finalizeDefaultAtomValues() will crash if we call
// it.
OutputELFWriter<ELF64LE>::finalizeDefaultAtomValues();
}

lld/trunk/lib/ReaderWriter/ELF/AMDGPU/AMDGPULinkingContext.h

//===- lib/ReaderWriter/ELF/AMDGPU/AMDGPULinkingContext.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_AMDGPU_AMDGPU_LINKING_CONTEXT_H
#define LLD_READER_WRITER_ELF_AMDGPU_AMDGPU_LINKING_CONTEXT_H
#include "OutputELFWriter.h"
#include "lld/ReaderWriter/ELFLinkingContext.h"
#include "llvm/Object/ELF.h"
#include "llvm/Support/ELF.h"
namespace lld {
namespace elf {
class AMDGPULinkingContext final : public ELFLinkingContext {
public:
AMDGPULinkingContext(llvm::Triple triple);
int getMachineType() const override { return llvm::ELF::EM_AMDGPU; }
void registerRelocationNames(Registry &r) override;
StringRef entrySymbolName() const override;
};
void setAMDGPUELFHeader(ELFHeader<ELF64LE> &elfHeader);
} // elf
} // lld
#endif // LLD_READER_WRITER_ELF_AMDGPU_AMDGPU_LINKING_CONTEXT_H

lld/trunk/lib/ReaderWriter/ELF/AMDGPU/AMDGPULinkingContext.cpp

//===- lib/ReaderWriter/ELF/AMDGPU/AMDGPULinkingContext.cpp ---------------===//
//
// The LLVM Linker
//
// This file is distributed under the University of Illinois Open Source
// License. See LICENSE.TXT for details.
//
//===------------------------------------------------------------------------===//
#include "AMDGPULinkingContext.h"
#include "AMDGPUTargetHandler.h"
namespace lld {
namespace elf {
std::unique_ptr<ELFLinkingContext>
createAMDGPULinkingContext(llvm::Triple triple) {
if (triple.getArch() == llvm::Triple::amdgcn)
return llvm::make_unique<AMDGPULinkingContext>(triple);
return nullptr;
}
AMDGPULinkingContext::AMDGPULinkingContext(llvm::Triple triple)
: ELFLinkingContext(triple, llvm::make_unique<AMDGPUTargetHandler>(*this)) {
}
static const Registry::KindStrings kindStrings[] = {LLD_KIND_STRING_END};
void AMDGPULinkingContext::registerRelocationNames(Registry &registry) {
registry.addKindTable(Reference::KindNamespace::ELF,
Reference::KindArch::AMDGPU, kindStrings);
}
void setAMDGPUELFHeader(ELFHeader<ELF64LE> &elfHeader) {
elfHeader.e_ident(llvm::ELF::EI_OSABI, ELFOSABI_AMDGPU_HSA);
}
StringRef AMDGPULinkingContext::entrySymbolName() const { return ""; }
} // namespace elf
} // namespace lld

lld/trunk/lib/ReaderWriter/ELF/AMDGPU/AMDGPURelocationHandler.h

//===- lld/ReaderWriter/ELF/AMDGPU/AMDGPURelocationHandler.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_AMDGPU_AMDGPU_RELOCATION_HANDLER_H
#define LLD_READER_WRITER_ELF_AMDGPU_AMDGPU_RELOCATION_HANDLER_H
#include "lld/ReaderWriter/ELFLinkingContext.h"
#include <system_error>
namespace lld {
namespace elf {
class AMDGPUTargetHandler;
class AMDGPUTargetLayout;
class AMDGPUTargetRelocationHandler final : public TargetRelocationHandler {
public:
AMDGPUTargetRelocationHandler(AMDGPUTargetLayout &layout) { }
std::error_code applyRelocation(ELFWriter &, llvm::FileOutputBuffer &,
const AtomLayout &,
const Reference &) const override;
};
} // elf
} // lld
#endif

lld/trunk/lib/ReaderWriter/ELF/AMDGPU/AMDGPURelocationHandler.cpp

//===- lib/ReaderWriter/ELF/AMDGPU/AMDGPURelocationHandler.cpp -----------===//
//
// The LLVM Linker
//
// This file is distributed under the University of Illinois Open Source
// License. See LICENSE.TXT for details.
//
//===----------------------------------------------------------------------===//
#include "AMDGPURelocationHandler.h"
using namespace lld;
using namespace lld::elf;
std::error_code AMDGPUTargetRelocationHandler::applyRelocation(
ELFWriter &writer, llvm::FileOutputBuffer &buf, const AtomLayout &atom,
const Reference &ref) const {
return std::error_code();
}

lld/trunk/lib/ReaderWriter/ELF/AMDGPU/AMDGPUSymbolTable.h

//===--------- lib/ReaderWriter/ELF/AMDGPU/AMDGPUSymbolTable.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_AMDGPU_AMDGPU_SYMBOL_TABLE_H
#define LLD_READER_WRITER_ELF_AMDGPU_AMDGPU_SYMBOL_TABLE_H
#include "TargetLayout.h"
namespace lld {
namespace elf {
/// \brief The SymbolTable class represents the symbol table in a ELF file
class AMDGPUSymbolTable : public SymbolTable<ELF64LE> {
public:
typedef llvm::object::Elf_Sym_Impl<ELF64LE> Elf_Sym;
AMDGPUSymbolTable(const ELFLinkingContext &ctx);
void addDefinedAtom(Elf_Sym &sym, const DefinedAtom *da,
int64_t addr) override;
};
} // elf
} // lld
#endif

lld/trunk/lib/ReaderWriter/ELF/AMDGPU/AMDGPUSymbolTable.cpp

//===--------- lib/ReaderWriter/ELF/AMDGPU/AMDGPUSymbolTable.cpp ----------===//
//
// The LLVM Linker
//
// This file is distributed under the University of Illinois Open Source
// License. See LICENSE.TXT for details.
//
//===----------------------------------------------------------------------===//
#include "AMDGPUSymbolTable.h"
#include "ELFFile.h"
#include "Atoms.h"
#include "SectionChunks.h"
using namespace lld;
using namespace lld::elf;
AMDGPUSymbolTable::AMDGPUSymbolTable(const ELFLinkingContext &ctx)
: SymbolTable(ctx, ".symtab", TargetLayout<ELF64LE>::ORDER_SYMBOL_TABLE) {}
void AMDGPUSymbolTable::addDefinedAtom(Elf_Sym &sym, const DefinedAtom *da,
int64_t addr) {
SymbolTable::addDefinedAtom(sym, da, addr);
// FIXME: Only do this for kernel functions.
sym.setType(STT_AMDGPU_HSA_KERNEL);
// Make st_value section relative.
// FIXME: This is hack to give kernel symbols a section relative offset.
// Because of this hack only on kernel can be included in a binary file.
sym.st_value = 0;
}

lld/trunk/lib/ReaderWriter/ELF/AMDGPU/AMDGPUTargetHandler.h

//===- lib/ReaderWriter/ELF/AMDGPU/AMDGPUTargetHandler.h ------------------===//
//
// The LLVM Linker
//
// This file is distributed under the University of Illinois Open Source
// License. See LICENSE.TXT for details.
//
//===----------------------------------------------------------------------===//
#ifndef AMDGPU_TARGET_HANDLER_H
#define AMDGPU_TARGET_HANDLER_H
#include "ELFFile.h"
#include "ELFReader.h"
#include "AMDGPURelocationHandler.h"
#include "TargetLayout.h"
namespace lld {
namespace elf {
class AMDGPULinkingContext;
class HSATextSection : public AtomSection<ELF64LE> {
public:
HSATextSection(const ELFLinkingContext &ctx);
};
/// \brief TargetLayout for AMDGPU
class AMDGPUTargetLayout final : public TargetLayout<ELF64LE> {
public:
AMDGPUTargetLayout(AMDGPULinkingContext &ctx) : TargetLayout(ctx) {}
void assignSectionsToSegments() override;
/// \brief Gets or creates a section.
AtomSection<ELF64LE> *
createSection(StringRef name, int32_t contentType,
DefinedAtom::ContentPermissions contentPermissions,
TargetLayout::SectionOrder sectionOrder) override {
if (name == ".hsatext")
return new (_allocator) HSATextSection(_ctx);
if (name == ".note")
contentType = DefinedAtom::typeRONote;
return TargetLayout::createSection(name, contentType, contentPermissions,
sectionOrder);
}
};
/// \brief TargetHandler for AMDGPU
class AMDGPUTargetHandler final : public TargetHandler {
public:
AMDGPUTargetHandler(AMDGPULinkingContext &targetInfo);
const TargetRelocationHandler &getRelocationHandler() const override {
return *_relocationHandler;
}
std::unique_ptr<Reader> getObjReader() override {
return llvm::make_unique<ELFReader<ELFFile<ELF64LE>>>(_ctx);
}
std::unique_ptr<Reader> getDSOReader() override {
return llvm::make_unique<ELFReader<DynamicFile<ELF64LE>>>(_ctx);
}
std::unique_ptr<Writer> getWriter() override;
private:
AMDGPULinkingContext &_ctx;
std::unique_ptr<AMDGPUTargetLayout> _targetLayout;
std::unique_ptr<AMDGPUTargetRelocationHandler> _relocationHandler;
};
void finalizeAMDGPURuntimeAtomValues(AMDGPUTargetLayout &layout);
} // end namespace elf
} // end namespace lld
#endif

lld/trunk/lib/ReaderWriter/ELF/AMDGPU/AMDGPUTargetHandler.cpp

//===- lib/ReaderWriter/ELF/AMDGPU/AMDGPUTargetHandler.cpp -------*- C++ -*-===//
//
// The LLVM Linker
//
// This file is distributed under the University of Illinois Open Source
// License. See LICENSE.TXT for details.
//
//===----------------------------------------------------------------------===//
#include "TargetLayout.h"
#include "AMDGPUExecutableWriter.h"
#include "AMDGPULinkingContext.h"
#include "AMDGPUTargetHandler.h"
#include "llvm/Support/ELF.h"
namespace lld {
namespace elf {
AMDGPUTargetHandler::AMDGPUTargetHandler(AMDGPULinkingContext &ctx)
: _ctx(ctx), _targetLayout(new AMDGPUTargetLayout(ctx)),
_relocationHandler(new AMDGPUTargetRelocationHandler(*_targetLayout)) {}
std::unique_ptr<Writer> AMDGPUTargetHandler::getWriter() {
switch (_ctx.getOutputELFType()) {
case llvm::ELF::ET_EXEC:
return llvm::make_unique<AMDGPUExecutableWriter>(_ctx, *_targetLayout);
case llvm::ELF::ET_DYN:
llvm_unreachable("TODO: support dynamic libraries");
case llvm::ELF::ET_REL:
llvm_unreachable("TODO: support -r mode");
default:
llvm_unreachable("unsupported output type");
}
}
HSATextSection::HSATextSection(const ELFLinkingContext &ctx)
: AtomSection(ctx, ".hsatext", DefinedAtom::typeCode, 0, 0) {
_type = SHT_PROGBITS;
_flags = SHF_ALLOC | SHF_WRITE | SHF_EXECINSTR | SHF_AMDGPU_HSA_AGENT |
SHF_AMDGPU_HSA_CODE;
// FIXME: What alignment should we use here?
_alignment = 4096;
}
void AMDGPUTargetLayout::assignSectionsToSegments() {
TargetLayout::assignSectionsToSegments();
for (OutputSection<ELF64LE> *osi : _outputSections) {
for (Section<ELF64LE> *section : osi->sections()) {
StringRef InputSectionName = section->inputSectionName();
if (InputSectionName != ".hsatext")
continue;
auto *segment = new (_allocator) Segment<ELF64LE>(
_ctx, "PT_AMDGPU_HSA_LOAD_CODE_AGENT", PT_AMDGPU_HSA_LOAD_CODE_AGENT);
_segments.push_back(segment);
assert(segment);
segment->append(section);
}
}
}
} // namespace elf
} // namespace lld

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

add_lld_library(lldAMDGPUELFTarget
AMDGPUExecutableWriter.cpp
AMDGPULinkingContext.cpp
AMDGPURelocationHandler.cpp
AMDGPUSymbolTable.cpp
AMDGPUTargetHandler.cpp
LINK_LIBS
lldELF
lldReaderWriter
lldCore
LLVMObject
LLVMSupport
)

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

Show All 21 Lines
include_directories(.) include_directories(.)
add_subdirectory(X86) add_subdirectory(X86)
add_subdirectory(X86_64) add_subdirectory(X86_64)
add_subdirectory(Mips) add_subdirectory(Mips)
add_subdirectory(Hexagon) add_subdirectory(Hexagon)
add_subdirectory(AArch64) add_subdirectory(AArch64)
add_subdirectory(ARM) add_subdirectory(ARM)
add_subdirectory(AMDGPU)

lld/trunk/lib/ReaderWriter/ELF/ELFLinkingContext.cpp

Show First 20 Lines • Show All 55 Lines • ▼ Show 20 Linesuint16_t ELFLinkingContext::getOutputMachine() const {
case llvm::Triple::mipsel: case llvm::Triple::mipsel:
case llvm::Triple::mips64: case llvm::Triple::mips64:
case llvm::Triple::mips64el: case llvm::Triple::mips64el:
return llvm::ELF::EM_MIPS; return llvm::ELF::EM_MIPS;
case llvm::Triple::aarch64: case llvm::Triple::aarch64:
return llvm::ELF::EM_AARCH64; return llvm::ELF::EM_AARCH64;
case llvm::Triple::arm: case llvm::Triple::arm:
return llvm::ELF::EM_ARM; return llvm::ELF::EM_ARM;
case llvm::Triple::amdgcn:
return llvm::ELF::EM_AMDGPU;
default: default:
llvm_unreachable("Unhandled arch"); llvm_unreachable("Unhandled arch");
} }
} }
StringRef ELFLinkingContext::entrySymbolName() const { StringRef ELFLinkingContext::entrySymbolName() const {
if (_outputELFType == llvm::ELF::ET_EXEC && _entrySymbolName.empty()) if (_outputELFType == llvm::ELF::ET_EXEC && _entrySymbolName.empty())
return "_start"; return "_start";
▲ Show 20 Lines • Show All 192 Lines • Show Last 20 Lines

lld/trunk/test/old-elf/AMDGPU/hsa.test

# RUN: yaml2obj -format=elf %s > %t.obj
# RUN: lld -flavor old-gnu -target amdgcn--hsa %t.obj -o %t.exe --noinhibit-exec
# RUN: llvm-readobj -h -program-headers -s -symbols %t.exe | FileCheck %s
# CHECK: ElfHeader {
# CHECK: Ident {
# CHECK: Class: 64-bit (0x2)
# CHECK: DataEncoding: LittleEndian (0x1)
# CHECK: Machine: EM_AMDGPU (0xE0)
# CHECK: Section {
# CHECK: Name: .hsatext
# CHECK: Type: SHT_PROGBITS (0x1)
# CHECK: Flags [ (0xC00007
# CHECK: SHF_ALLOC (0x2)
# CHECK: SHF_AMDGPU_HSA_AGENT (0x800000)
# CHECK: SHF_AMDGPU_HSA_CODE (0x400000)
# CHECK: SHF_EXECINSTR (0x4)
# CHECK: SHF_WRITE (0x1)
#
# CHECK: Symbol {
# CHECK: Name: kernel
# CHECK: Value: 0x0
# CHECK: Binding: Local (0x0)
# CHECK: Type: AMDGPU_HSA_KERNEL (0xA)
# CHECK: ProgramHeader {
# CHECK: Type: PT_AMDGPU_HSA_LOAD_CODE_AGENT (0x60000003)
---
FileHeader:
Class: ELFCLASS64
Data: ELFDATA2LSB
OSABI: ELFOSABI_GNU
Type: ET_REL
Machine: EM_AMDGPU
Sections:
- Name: .hsatext
Type: SHT_PROGBITS
Flags: [ SHF_ALLOC, SHF_EXECINSTR ]
AddressAlign: 0x0000000000000004
Content: ''
- Name: .note
Type: SHT_NOTE
AddressAlign: 0x0000000000000001
Content: '00'
Symbols:
Local:
- Name: kernel
Type: STT_GNU_IFUNC
Section: .hsatext
...
lld/trunk/lib/ReaderWriter/ELF/CMakeLists.txt