From 5d4d137132d719d0d20d119375b205d6a2c721ee Mon Sep 17 00:00:00 2001 From: Dimitry Andric Date: Wed, 4 Jan 2017 22:11:50 +0000 Subject: [PATCH] Vendor import of lld trunk r291012: https://llvm.org/svn/llvm-project/lld/trunk@291012 --- COFF/PDB.cpp | 12 ++++---- COFF/PDB.h | 9 +++++- COFF/Writer.cpp | 2 +- ELF/InputFiles.cpp | 2 +- ELF/LTO.cpp | 15 ++++++--- ELF/LTO.h | 2 +- ELF/SymbolTable.cpp | 6 ++-- ELF/Symbols.cpp | 12 ++++++-- ELF/Symbols.h | 11 +++++-- ELF/Target.cpp | 7 +++-- ELF/Thunks.cpp | 2 ++ ELF/Writer.cpp | 22 ++++++++------ test/COFF/pdb.test | 7 ++++- test/ELF/arm-thumb-interwork-shared.s | 44 +++++++++++++++++++++++++++ test/ELF/basic-mips.s | 2 +- test/ELF/basic-ppc.s | 2 +- test/ELF/string-table.s | 40 +----------------------- 17 files changed, 121 insertions(+), 76 deletions(-) create mode 100644 test/ELF/arm-thumb-interwork-shared.s diff --git a/COFF/PDB.cpp b/COFF/PDB.cpp index 56d5a3651143..d5c52a69be69 100644 --- a/COFF/PDB.cpp +++ b/COFF/PDB.cpp @@ -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 SectionTable) { + ArrayRef 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(&DI->PDB70.Signature)); // Should be the current time, but set 0 for reproducibilty. InfoBuilder.setSignature(0); InfoBuilder.setVersion(pdb::PdbRaw_ImplVer::PdbImplVC70); diff --git a/COFF/PDB.h b/COFF/PDB.h index 091e90fa1ef1..c9c37914299a 100644 --- a/COFF/PDB.h +++ b/COFF/PDB.h @@ -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 SectionTable); + llvm::ArrayRef SectionTable, + const llvm::codeview::DebugInfo *DI); } } diff --git a/COFF/Writer.cpp b/COFF/Writer.cpp index 3e69aebbb424..71217ebeb60a 100644 --- a/COFF/Writer.cpp +++ b/COFF/Writer.cpp @@ -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"); diff --git a/ELF/InputFiles.cpp b/ELF/InputFiles.cpp index 2a8659921463..f4128c5096cb 100644 --- a/ELF/InputFiles.cpp +++ b/ELF/InputFiles.cpp @@ -461,7 +461,7 @@ SymbolBody *elf::ObjectFile::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(Name, /*IsLocal=*/true, StOther, Type, this); return new (BAlloc) DefinedRegular(Name, /*IsLocal=*/true, StOther, Type, Value, Size, Sec, this); diff --git a/ELF/LTO.cpp b/ELF/LTO.cpp index a3d6a141a202..b342b6195f1d 100644 --- a/ELF/LTO.cpp +++ b/ELF/LTO.cpp @@ -96,12 +96,12 @@ BitcodeCompiler::BitcodeCompiler() : LTOObj(createLTO()) {} BitcodeCompiler::~BitcodeCompiler() = default; -static void undefine(Symbol *S) { - replaceBody(S, S->body()->getName(), /*IsLocal=*/false, - STV_DEFAULT, S->body()->Type, nullptr); +template static void undefine(Symbol *S) { + replaceBody>(S, S->body()->getName(), /*IsLocal=*/false, + STV_DEFAULT, S->body()->Type, nullptr); } -void BitcodeCompiler::add(BitcodeFile &F) { +template void BitcodeCompiler::add(BitcodeFile &F) { lto::InputFile &Obj = *F.Obj; unsigned SymNum = 0; std::vector 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(Sym); } checkError(LTOObj->add(std::move(F.Obj), Resols)); } @@ -157,3 +157,8 @@ std::vector BitcodeCompiler::compile() { } return Ret; } + +template void BitcodeCompiler::template add(BitcodeFile &); +template void BitcodeCompiler::template add(BitcodeFile &); +template void BitcodeCompiler::template add(BitcodeFile &); +template void BitcodeCompiler::template add(BitcodeFile &); diff --git a/ELF/LTO.h b/ELF/LTO.h index b3d734f2d381..3cb763650e1c 100644 --- a/ELF/LTO.h +++ b/ELF/LTO.h @@ -43,7 +43,7 @@ public: BitcodeCompiler(); ~BitcodeCompiler(); - void add(BitcodeFile &F); + template void add(BitcodeFile &F); std::vector compile(); private: diff --git a/ELF/SymbolTable.cpp b/ELF/SymbolTable.cpp index 79097e176e68..f08fa6229c1a 100644 --- a/ELF/SymbolTable.cpp +++ b/ELF/SymbolTable.cpp @@ -115,7 +115,7 @@ template void SymbolTable::addCombinedLTOObject() { // Compile bitcode files and replace bitcode symbols. LTO.reset(new BitcodeCompiler); for (BitcodeFile *F : BitcodeFiles) - LTO->add(*F); + LTO->add(*F); for (InputFile *File : LTO->compile()) { ObjectFile *Obj = cast>(File); @@ -256,7 +256,7 @@ Symbol *SymbolTable::addUndefined(StringRef Name, bool IsLocal, insert(Name, Type, getVisibility(StOther), CanOmitFromDynSym, File); if (WasInserted) { S->Binding = Binding; - replaceBody(S, Name, IsLocal, StOther, Type, File); + replaceBody>(S, Name, IsLocal, StOther, Type, File); return S; } if (Binding != STB_WEAK) { @@ -432,7 +432,7 @@ void SymbolTable::addShared(SharedFile *F, StringRef Name, if (S->VersionId == VER_NDX_LOCAL) S->VersionId = VER_NDX_GLOBAL; } - if (WasInserted || isa(S->body())) { + if (WasInserted || isa>(S->body())) { replaceBody>(S, F, Name, Sym, Verdef); if (!S->isWeak()) F->IsUsed = true; diff --git a/ELF/Symbols.cpp b/ELF/Symbols.cpp index a2133f411c20..f168d37bdf0a 100644 --- a/ELF/Symbols.cpp +++ b/ELF/Symbols.cpp @@ -173,6 +173,8 @@ template typename ELFT::uint SymbolBody::getThunkVA() const { return DR->ThunkData->getVA(); if (const auto *S = dyn_cast>(this)) return S->ThunkData->getVA(); + if (const auto *S = dyn_cast>(this)) + return S->ThunkData->getVA(); fatal("getThunkVA() not supported for Symbol class\n"); } @@ -232,8 +234,9 @@ template bool DefinedRegular::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 +Undefined::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() const; template uint64_t SymbolBody::template getSize() const; template uint64_t SymbolBody::template getSize() const; +template class elf::Undefined; +template class elf::Undefined; +template class elf::Undefined; +template class elf::Undefined; + template class elf::DefinedRegular; template class elf::DefinedRegular; template class elf::DefinedRegular; diff --git a/ELF/Symbols.h b/ELF/Symbols.h index c95241a5293e..cbf8fa81a138 100644 --- a/ELF/Symbols.h +++ b/ELF/Symbols.h @@ -236,7 +236,7 @@ public: const OutputSectionBase *Section; }; -class Undefined : public SymbolBody { +template class Undefined : public SymbolBody { public: Undefined(StringRefZ Name, bool IsLocal, uint8_t StOther, uint8_t Type, InputFile *F); @@ -245,6 +245,12 @@ public: 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 *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, DefinedSynthetic, - Undefined, SharedSymbol, LazyArchive, LazyObject> + Undefined, SharedSymbol, + LazyArchive, LazyObject> Body; SymbolBody *body() { return reinterpret_cast(Body.buffer); } diff --git a/ELF/Target.cpp b/ELF/Target.cpp index edae7c65c1b4..d82e654b9c4c 100644 --- a/ELF/Target.cpp +++ b/ELF/Target.cpp @@ -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 diff --git a/ELF/Thunks.cpp b/ELF/Thunks.cpp index 34b630ac2510..397a0ee66319 100644 --- a/ELF/Thunks.cpp +++ b/ELF/Thunks.cpp @@ -226,6 +226,8 @@ static void addThunkARM(uint32_t Reloc, SymbolBody &S, InputSection &IS) { Sym->ThunkData = T; else if (auto *Sym = dyn_cast>(&S)) Sym->ThunkData = T; + else if (auto *Sym = dyn_cast>(&S)) + Sym->ThunkData = T; else fatal("symbol not DefinedRegular or Shared"); } diff --git a/ELF/Writer.cpp b/ELF/Writer.cpp index e056384fbd44..154de8cf6d18 100644 --- a/ELF/Writer.cpp +++ b/ELF/Writer.cpp @@ -625,15 +625,12 @@ void PhdrEntry::add(OutputSectionBase *Sec) { } template -static Symbol *addOptionalSynthetic(StringRef Name, OutputSectionBase *Sec, - typename ELFT::uint Val, - uint8_t StOther = STV_HIDDEN) { - SymbolBody *S = Symtab::X->find(Name); - if (!S) - return nullptr; - if (!S->isUndefined() && !S->isShared()) - return S->symbol(); - return Symtab::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::X->find(Name)) + if (S->isUndefined() || S->isShared()) + Symtab::X->addSynthetic(Name, Sec, Val, StOther); } template @@ -1447,8 +1444,13 @@ template void Writer::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. diff --git a/test/COFF/pdb.test b/test/COFF/pdb.test index af174b7a2038..b20a58938920 100644 --- a/test/COFF/pdb.test +++ b/test/COFF/pdb.test @@ -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: diff --git a/test/ELF/arm-thumb-interwork-shared.s b/test/ELF/arm-thumb-interwork-shared.s new file mode 100644 index 000000000000..ffd055e5b621 --- /dev/null +++ b/test/ELF/arm-thumb-interwork-shared.s @@ -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 diff --git a/test/ELF/basic-mips.s b/test/ELF/basic-mips.s index dc640edae9f0..84a7663675fc 100644 --- a/test/ELF/basic-mips.s +++ b/test/ELF/basic-mips.s @@ -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: ] diff --git a/test/ELF/basic-ppc.s b/test/ELF/basic-ppc.s index c0f28bd48c41..e08c7a32eb7c 100644 --- a/test/ELF/basic-ppc.s +++ b/test/ELF/basic-ppc.s @@ -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: ] diff --git a/test/ELF/string-table.s b/test/ELF/string-table.s index c783445f8e31..92b8345976d8 100644 --- a/test/ELF/string-table.s +++ b/test/ELF/string-table.s @@ -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: }