d/freebsd-dev
1
0
Fork 0
Code Issues Pull Requests Packages Projects Releases Wiki Activity

Vendor import of lld trunk r291012:

Browse Source 
https://llvm.org/svn/llvm-project/lld/trunk@291012
This commit is contained in:
Dimitry Andric 2017-01-04 22:11:50 +00:00
parent d93e1dfac8
commit 5d4d137132
Notes: svn2git 2020-12-20 02:59:44 +00:00 
svn path=/vendor/lld/dist/; revision=311323
svn path=/vendor/lld/lld-trunk-r291012/dist/; revision=311334; tag=vendor/lld/lld-trunk-r291015
17 changed files with 121 additions and 76 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

12
COFF/PDB.cpp
View File

@ -13,6 +13,7 @@
#include "Error.h"
#include "SymbolTable.h"
#include "Symbols.h"
#include "llvm/DebugInfo/CodeView/CVDebugRecord.h"
#include "llvm/DebugInfo/CodeView/SymbolDumper.h"
#include "llvm/DebugInfo/CodeView/TypeDumper.h"
#include "llvm/DebugInfo/MSF/ByteStream.h"
@ -131,7 +132,8 @@ static void addTypeInfo(SymbolTable *Symtab,
// Creates a PDB file.
void coff::createPDB(StringRef Path, SymbolTable *Symtab,
ArrayRef<uint8_t> SectionTable) {
ArrayRef<uint8_t> SectionTable,
const llvm::codeview::DebugInfo *DI) {
if (Config->DumpPdb)
dumpCodeView(Symtab);
@ -146,11 +148,9 @@ void coff::createPDB(StringRef Path, SymbolTable *Symtab,
// Add an Info stream.
auto &InfoBuilder = Builder.getInfoBuilder();
InfoBuilder.setAge(1);
// Should be a random number, 0 for now.
InfoBuilder.setGuid({});
InfoBuilder.setAge(DI->PDB70.Age);
InfoBuilder.setGuid(
*reinterpret_cast<const pdb::PDB_UniqueId *>(&DI->PDB70.Signature));
// Should be the current time, but set 0 for reproducibilty.
InfoBuilder.setSignature(0);
InfoBuilder.setVersion(pdb::PdbRaw_ImplVer::PdbImplVC70);

9
COFF/PDB.h
View File

@ -13,12 +13,19 @@
#include "llvm/ADT/ArrayRef.h"
#include "llvm/ADT/StringRef.h"
namespace llvm {
namespace codeview {
union DebugInfo;
}
}
namespace lld {
namespace coff {
class SymbolTable;
void createPDB(llvm::StringRef Path, SymbolTable *Symtab,
llvm::ArrayRef<uint8_t> SectionTable);
llvm::ArrayRef<uint8_t> SectionTable,
const llvm::codeview::DebugInfo *DI);
}
}

2
COFF/Writer.cpp
View File

@ -304,7 +304,7 @@ void Writer::run() {
writeBuildId();
if (!Config->PDBPath.empty())
createPDB(Config->PDBPath, Symtab, SectionTable);
createPDB(Config->PDBPath, Symtab, SectionTable, BuildId->DI);
if (auto EC = Buffer->commit())
fatal(EC, "failed to write the output file");

2
ELF/InputFiles.cpp
View File

@ -461,7 +461,7 @@ SymbolBody *elf::ObjectFile<ELFT>::createSymbolBody(const Elf_Sym *Sym) {
StringRefZ Name = this->StringTable.data() + Sym->st_name;
if (Sym->st_shndx == SHN_UNDEF)
return new (BAlloc)
Undefined(Name, /*IsLocal=*/true, StOther, Type, this);
Undefined<ELFT>(Name, /*IsLocal=*/true, StOther, Type, this);
return new (BAlloc) DefinedRegular<ELFT>(Name, /*IsLocal=*/true, StOther,
Type, Value, Size, Sec, this);

15
ELF/LTO.cpp
View File

@ -96,12 +96,12 @@ BitcodeCompiler::BitcodeCompiler() : LTOObj(createLTO()) {}
BitcodeCompiler::~BitcodeCompiler() = default;
static void undefine(Symbol *S) {
replaceBody<Undefined>(S, S->body()->getName(), /*IsLocal=*/false,
STV_DEFAULT, S->body()->Type, nullptr);
template <class ELFT> static void undefine(Symbol *S) {
replaceBody<Undefined<ELFT>>(S, S->body()->getName(), /*IsLocal=*/false,
STV_DEFAULT, S->body()->Type, nullptr);
}
void BitcodeCompiler::add(BitcodeFile &F) {
template <class ELFT> void BitcodeCompiler::add(BitcodeFile &F) {
lto::InputFile &Obj = *F.Obj;
unsigned SymNum = 0;
std::vector<Symbol *> Syms = F.getSymbols();
@ -126,7 +126,7 @@ void BitcodeCompiler::add(BitcodeFile &F) {
R.VisibleToRegularObj =
Sym->IsUsedInRegularObj || (R.Prevailing && Sym->includeInDynsym());
if (R.Prevailing)
undefine(Sym);
undefine<ELFT>(Sym);
}
checkError(LTOObj->add(std::move(F.Obj), Resols));
}
@ -157,3 +157,8 @@ std::vector<InputFile *> BitcodeCompiler::compile() {
}
return Ret;
}
template void BitcodeCompiler::template add<ELF32LE>(BitcodeFile &);
template void BitcodeCompiler::template add<ELF32BE>(BitcodeFile &);
template void BitcodeCompiler::template add<ELF64LE>(BitcodeFile &);
template void BitcodeCompiler::template add<ELF64BE>(BitcodeFile &);

2
ELF/LTO.h
View File

@ -43,7 +43,7 @@ class BitcodeCompiler {
BitcodeCompiler();
~BitcodeCompiler();
void add(BitcodeFile &F);
template <class ELFT> void add(BitcodeFile &F);
std::vector<InputFile *> compile();
private:

6
ELF/SymbolTable.cpp
View File

@ -115,7 +115,7 @@ template <class ELFT> void SymbolTable<ELFT>::addCombinedLTOObject() {
// Compile bitcode files and replace bitcode symbols.
LTO.reset(new BitcodeCompiler);
for (BitcodeFile *F : BitcodeFiles)
LTO->add(*F);
LTO->add<ELFT>(*F);
for (InputFile *File : LTO->compile()) {
ObjectFile<ELFT> *Obj = cast<ObjectFile<ELFT>>(File);
@ -256,7 +256,7 @@ Symbol *SymbolTable<ELFT>::addUndefined(StringRef Name, bool IsLocal,
insert(Name, Type, getVisibility(StOther), CanOmitFromDynSym, File);
if (WasInserted) {
S->Binding = Binding;
replaceBody<Undefined>(S, Name, IsLocal, StOther, Type, File);
replaceBody<Undefined<ELFT>>(S, Name, IsLocal, StOther, Type, File);
return S;
}
if (Binding != STB_WEAK) {
@ -432,7 +432,7 @@ void SymbolTable<ELFT>::addShared(SharedFile<ELFT> *F, StringRef Name,
if (S->VersionId == VER_NDX_LOCAL)
S->VersionId = VER_NDX_GLOBAL;
}
if (WasInserted || isa<Undefined>(S->body())) {
if (WasInserted || isa<Undefined<ELFT>>(S->body())) {
replaceBody<SharedSymbol<ELFT>>(S, F, Name, Sym, Verdef);
if (!S->isWeak())
F->IsUsed = true;

12
ELF/Symbols.cpp
View File

@ -173,6 +173,8 @@ template <class ELFT> typename ELFT::uint SymbolBody::getThunkVA() const {
return DR->ThunkData->getVA();
if (const auto *S = dyn_cast<SharedSymbol<ELFT>>(this))
return S->ThunkData->getVA();
if (const auto *S = dyn_cast<Undefined<ELFT>>(this))
return S->ThunkData->getVA();
fatal("getThunkVA() not supported for Symbol class\n");
}
@ -232,8 +234,9 @@ template <class ELFT> bool DefinedRegular<ELFT>::isMipsPIC() const {
(Section->getFile()->getObj().getHeader()->e_flags & EF_MIPS_PIC);
}
Undefined::Undefined(StringRefZ Name, bool IsLocal, uint8_t StOther,
uint8_t Type, InputFile *File)
template <typename ELFT>
Undefined<ELFT>::Undefined(StringRefZ Name, bool IsLocal, uint8_t StOther,
uint8_t Type, InputFile *File)
: SymbolBody(SymbolBody::UndefinedKind, Name, IsLocal, StOther, Type) {
this->File = File;
}
@ -354,6 +357,11 @@ template uint32_t SymbolBody::template getSize<ELF32BE>() const;
template uint64_t SymbolBody::template getSize<ELF64LE>() const;
template uint64_t SymbolBody::template getSize<ELF64BE>() const;
template class elf::Undefined<ELF32LE>;
template class elf::Undefined<ELF32BE>;
template class elf::Undefined<ELF64LE>;
template class elf::Undefined<ELF64BE>;
template class elf::DefinedRegular<ELF32LE>;
template class elf::DefinedRegular<ELF32BE>;
template class elf::DefinedRegular<ELF64LE>;

11
ELF/Symbols.h
View File

@ -236,7 +236,7 @@ class DefinedSynthetic : public Defined {
const OutputSectionBase *Section;
};
class Undefined : public SymbolBody {
template <class ELFT> class Undefined : public SymbolBody {
public:
Undefined(StringRefZ Name, bool IsLocal, uint8_t StOther, uint8_t Type,
InputFile *F);
@ -245,6 +245,12 @@ class Undefined : public SymbolBody {
return S->kind() == UndefinedKind;
}
// If non-null the symbol has a Thunk that may be used as an alternative
// destination for callers of this Symbol. When linking a DSO undefined
// symbols are implicitly imported, the symbol lookup will be performed by
// the dynamic loader. A call to an undefined symbol will be given a PLT
// entry and on ARM this may need a Thunk if the caller is in Thumb state.
Thunk<ELFT> *ThunkData = nullptr;
InputFile *file() { return this->File; }
};
@ -416,7 +422,8 @@ struct Symbol {
// ELFT, and we verify this with the static_asserts in replaceBody.
llvm::AlignedCharArrayUnion<
DefinedCommon, DefinedRegular<llvm::object::ELF64LE>, DefinedSynthetic,
Undefined, SharedSymbol<llvm::object::ELF64LE>, LazyArchive, LazyObject>
Undefined<llvm::object::ELF64LE>, SharedSymbol<llvm::object::ELF64LE>,
LazyArchive, LazyObject>
Body;
SymbolBody *body() { return reinterpret_cast<SymbolBody *>(Body.buffer); }

7
ELF/Target.cpp
View File

@ -1730,8 +1730,11 @@ void ARMTargetInfo::writePlt(uint8_t *Buf, uint64_t GotEntryAddr,
RelExpr ARMTargetInfo::getThunkExpr(RelExpr Expr, uint32_t RelocType,
const InputFile &File,
const SymbolBody &S) const {
// If S is an undefined weak symbol we don't need a Thunk
if (S.isUndefined())
// If S is an undefined weak symbol in an executable we don't need a Thunk.
// In a DSO calls to undefined symbols, including weak ones get PLT entries
// which may need a thunk.
if (S.isUndefined() && !S.isLocal() && S.symbol()->isWeak()
&& !Config->Shared)
return Expr;
// A state change from ARM to Thumb and vice versa must go through an
// interworking thunk if the relocation type is not R_ARM_CALL or

2
ELF/Thunks.cpp
View File

@ -226,6 +226,8 @@ static void addThunkARM(uint32_t Reloc, SymbolBody &S, InputSection<ELFT> &IS) {
Sym->ThunkData = T;
else if (auto *Sym = dyn_cast<SharedSymbol<ELFT>>(&S))
Sym->ThunkData = T;
else if (auto *Sym = dyn_cast<Undefined<ELFT>>(&S))
Sym->ThunkData = T;
else
fatal("symbol not DefinedRegular or Shared");
}

22
ELF/Writer.cpp
View File

@ -625,15 +625,12 @@ void PhdrEntry::add(OutputSectionBase *Sec) {
}
template <class ELFT>
static Symbol *addOptionalSynthetic(StringRef Name, OutputSectionBase *Sec,
typename ELFT::uint Val,
uint8_t StOther = STV_HIDDEN) {
SymbolBody *S = Symtab<ELFT>::X->find(Name);
if (!S)
return nullptr;
if (!S->isUndefined() && !S->isShared())
return S->symbol();
return Symtab<ELFT>::X->addSynthetic(Name, Sec, Val, StOther);
static void addOptionalSynthetic(StringRef Name, OutputSectionBase *Sec,
typename ELFT::uint Val,
uint8_t StOther = STV_HIDDEN) {
if (SymbolBody *S = Symtab<ELFT>::X->find(Name))
if (S->isUndefined() || S->isShared())
Symtab<ELFT>::X->addSynthetic(Name, Sec, Val, StOther);
}
template <class ELFT>
@ -1447,8 +1444,13 @@ template <class ELFT> void Writer<ELFT>::setPhdrs() {
}
if (P.p_type == PT_LOAD)
P.p_align = Config->MaxPageSize;
else if (P.p_type == PT_GNU_RELRO)
else if (P.p_type == PT_GNU_RELRO) {
P.p_align = 1;
// The glibc dynamic loader rounds the size down, so we need to round up
// to protect the last page. This is a no-op on FreeBSD which always
// rounds up.
P.p_memsz = alignTo(P.p_memsz, Config->MaxPageSize);
}
// The TLS pointer goes after PT_TLS. At least glibc will align it,
// so round up the size to make sure the offsets are correct.

7
test/COFF/pdb.test
View File

@ -28,8 +28,13 @@
# CHECK-NEXT: - Stream: [ 8 ]
# CHECK-NEXT: - Stream: [ 4 ]
# CHECK-NEXT: PdbStream:
# Ensure that the Guid matches the RSDS record:
# PDBSignature: 0x53445352
# PDBGUID (38 9A CC F2 14 A4 7F A2 6C F0 08 04 47 CF 5C 48)
# PDBAge: 1
# CHECK-NEXT: Age: 1
# CHECK-NEXT: Guid: '{00000000-0000-0000-0000-000000000000}'
# Guid: '{389ACCF2-14A4-7FA2-6CF0-080447CF5C48}'
# CHECK-NEXT: Guid: '{{.*}}'
# CHECK-NEXT: Signature: 0
# CHECK-NEXT: Version: VC70
# CHECK-NEXT: NamedStreams:

44
test/ELF/arm-thumb-interwork-shared.s Normal file
View File

@ -0,0 +1,44 @@
// RUN: llvm-mc -filetype=obj -triple=thumbv7a-none-linux-gnueabi %s -o %t
// RUN: ld.lld %t --shared -o %t.so
// RUN: llvm-objdump -d -triple=thumbv7a-none-linux-gnueabi %t.so | FileCheck %s
// RUN: llvm-objdump -d -triple=armv7a-none-linux-gnueabi %t.so | FileCheck %s -check-prefix=PLT
// REQUIRES: arm
.syntax unified
.global sym1
.global elsewhere
.weak weakref
sym1:
b.w elsewhere
b.w weakref
// Check that we generate a thunk for an undefined symbol called via a plt
// entry.
// CHECK: Disassembly of section .text:
// CHECK-NEXT: sym1:
// CHECK: 1000: 00 f0 02 b8 b.w #4
// CHECK-NEXT: 1004: 00 f0 06 b8 b.w #12
// CHECK-NEXT: 1008: 40 f2 20 0c movw r12, #32
// CHECK-NEXT: 100c: c0 f2 00 0c movt r12, #0
// CHECK-NEXT: 1010: fc 44 add r12, pc
// CHECK-NEXT: 1012: 60 47 bx r12
// CHECK-NEXT: 1014: 40 f2 24 0c movw r12, #36
// CHECK-NEXT: 1018: c0 f2 00 0c movt r12, #0
// CHECK-NEXT: 101c: fc 44 add r12, pc
// CHECK-NEXT: 101e: 60 47 bx r12
// PLT: Disassembly of section .plt:
// PLT-NEXT: .plt:
// PLT: 1020: 04 e0 2d e5 str lr, [sp, #-4]!
// PLT-NEXT: 1024: 04 e0 9f e5 ldr lr, [pc, #4]
// PLT-NEXT: 1028: 0e e0 8f e0 add lr, pc, lr
// PLT-NEXT: 102c: 08 f0 be e5 ldr pc, [lr, #8]!
// PLT-NEXT: 1030: d0 1f 00 00
// PLT-NEXT: 1034: 04 c0 9f e5 ldr r12, [pc, #4]
// PLT-NEXT: 1038: 0f c0 8c e0 add r12, r12, pc
// PLT-NEXT: 103c: 00 f0 9c e5 ldr pc, [r12]
// PLT-NEXT: 1040: cc 1f 00 00
// PLT-NEXT: 1044: 04 c0 9f e5 ldr r12, [pc, #4]
// PLT-NEXT: 1048: 0f c0 8c e0 add r12, r12, pc
// PLT-NEXT: 104c: 00 f0 9c e5 ldr pc, [r12]
// PLT-NEXT: 1050: c0 1f 00 00

2
test/ELF/basic-mips.s
View File

@ -297,7 +297,7 @@ __start:
# CHECK-NEXT: VirtualAddress: 0x30000
# CHECK-NEXT: PhysicalAddress: 0x30000
# CHECK-NEXT: FileSize: 8
# CHECK-NEXT: MemSize: 8
# CHECK-NEXT: MemSize: 65536
# CHECK-NEXT: Flags [ (0x4)
# CHECK-NEXT: PF_R (0x4)
# CHECK-NEXT: ]

2
test/ELF/basic-ppc.s
View File

@ -295,7 +295,7 @@
// CHECK-NEXT: VirtualAddress: 0x2000
// CHECK-NEXT: PhysicalAddress: 0x2000
// CHECK-NEXT: FileSize: 48
// CHECK-NEXT: MemSize: 48
// CHECK-NEXT: MemSize: 4096
// CHECK-NEXT: Flags [ (0x4)
// CHECK-NEXT: PF_R (0x4)
// CHECK-NEXT: ]

40
test/ELF/string-table.s
View File

@ -1,6 +1,6 @@
// RUN: llvm-mc -filetype=obj -triple=x86_64-unknown-linux %s -o %t
// RUN: ld.lld %t -o %t2
// RUN: llvm-readobj -sections -section-data %t2 | FileCheck %s
// RUN: llvm-readobj -sections %t2 | FileCheck %s
// REQUIRES: x86
.global _start
@ -41,41 +41,3 @@ _start:
// CHECK-NEXT: Address: 0x0
// CHECK-NOT: Name: foobar
// Test that the string "bar" is merged into "foobar".
// CHECK: Section {
// CHECK: Index:
// CHECK: Name: .shstrtab
// CHECK-NEXT: Type: SHT_STRTAB
// CHECK-NEXT: Flags [
// CHECK-NEXT: ]
// CHECK-NEXT: Address: 0x0
// CHECK-NEXT: Offset:
// CHECK-NEXT: Size:
// CHECK-NEXT: Link: 0
// CHECK-NEXT: Info: 0
// CHECK-NEXT: AddressAlignment: 1
// CHECK-NEXT: EntrySize: 0
// CHECK-NEXT: SectionData (
// CHECK-NEXT: 0000: 00626172 002E7465 78740066 6F6F6261 |.bar..text.fooba|
// CHECK-NEXT: 0010: 72002E63 6F6D6D65 6E74002E 73796D74 |r..comment..symt|
// CHECK-NEXT: 0020: 6162002E 73687374 72746162 002E7374 |ab..shstrtab..st|
// CHECK-NEXT: 0030: 72746162 00 |rtab.|
// CHECK-NEXT: )
// CHECK-NEXT:}
// CHECK: Name: .strtab
// CHECK-NEXT: Type: SHT_STRTAB (0x3)
// CHECK-NEXT: Flags [ (0x0)
// CHECK-NEXT: ]
// CHECK-NEXT: Address: 0x0
// CHECK-NEXT: Offset:
// CHECK-NEXT: Size: 15
// CHECK-NEXT: Link: 0
// CHECK-NEXT: Info: 0
// CHECK-NEXT: AddressAlignment: 1
// CHECK-NEXT: EntrySize: 0
// CHECK-NEXT: SectionData (
// CHECK-NEXT: 0000: 00666F6F 62617200 5F737461 727400 |.foobar._start.|
// CHECK-NEXT: )
// CHECK-NEXT: }