Vendor import of lld trunk r291012:vendor/lld/lld-trunk-r291015vendor/lld/lld-trunk-r291012

https://llvm.org/svn/llvm-project/lld/trunk@291012

17 files changed, 121 insertions, 76 deletions

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<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);
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<uint8_t> SectionTable);
+               llvm::ArrayRef<uint8_t> 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<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);
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<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 &);
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 <class ELFT> void add(BitcodeFile &F);
   std::vector<InputFile *> 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 <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;
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 <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>;
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 ELFT> 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<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); }
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<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");
 }
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 <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.
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: }