Merge commit '11daa8ef1d85fdf815bb4ba83b548ca22ab7038c' into mainline

Author: asl

src/llvm/tools/lld/COFF/Chunks.cpp

@@ -11,6 +11,7 @@
 #include "InputFiles.h"
 #include "Symbols.h"
 #include "Writer.h"
+#include "SymbolTable.h"
 #include "lld/Common/ErrorHandler.h"
 #include "llvm/ADT/Twine.h"
 #include "llvm/BinaryFormat/COFF.h"
@@ -315,6 +316,32 @@ void SectionChunk::applyRelARM64(uint8_t *Off, uint16_t Type, OutputSection *OS,
   }
 }
 
+static void maybeReportRelocationToDiscarded(const SectionChunk *FromChunk,
+                                             Defined *Sym,
+                                             const coff_relocation &Rel) {
+  // Don't report these errors when the relocation comes from a debug info
+  // section or in mingw mode. MinGW mode object files (built by GCC) can
+  // have leftover sections with relocations against discarded comdat
+  // sections. Such sections are left as is, with relocations untouched.
+  if (FromChunk->isCodeView() || FromChunk->isDWARF() || Config->MinGW)
+    return;
+
+  // Get the name of the symbol. If it's null, it was discarded early, so we
+  // have to go back to the object file.
+  ObjFile *File = FromChunk->File;
+  StringRef Name;
+  if (Sym) {
+    Name = Sym->getName();
+  } else {
+    COFFSymbolRef COFFSym =
+        check(File->getCOFFObj()->getSymbol(Rel.SymbolTableIndex));
+    File->getCOFFObj()->getSymbolName(COFFSym, Name);
+  }
+
+  error("relocation against symbol in discarded section: " + Name +
+        getSymbolLocations(File, Rel.SymbolTableIndex));
+}
+
 void SectionChunk::writeTo(uint8_t *Buf) const {
   if (!hasData())
     return;
@@ -342,41 +369,23 @@ void SectionChunk::writeTo(uint8_t *Buf) const {
     // Use the potentially remapped Symbol instead of the one that the
     // relocation points to.
     auto *Sym = dyn_cast_or_null<Defined>(RelocTargets[I]);
-    if (!Sym) {
-      if (isCodeView() || isDWARF())
-        continue;
-      // Symbols in early discarded sections are represented using null pointers,
-      // so we need to retrieve the name from the object file.
-      COFFSymbolRef Sym =
-          check(File->getCOFFObj()->getSymbol(Rel.SymbolTableIndex));
-      StringRef Name;
-      File->getCOFFObj()->getSymbolName(Sym, Name);
-
-      // MinGW mode object files (built by GCC) can have leftover sections
-      // with relocations against discarded comdat sections. Such sections
-      // are left as is, with relocations untouched.
-      if (!Config->MinGW)
-        error("relocation against symbol in discarded section: " + Name);
-      continue;
-    }
+
     // Get the output section of the symbol for this relocation.  The output
     // section is needed to compute SECREL and SECTION relocations used in debug
     // info.
-    Chunk *C = Sym->getChunk();
+    Chunk *C = Sym ? Sym->getChunk() : nullptr;
     OutputSection *OS = C ? C->getOutputSection() : nullptr;
 
-    // Only absolute and __ImageBase symbols lack an output section. For any
-    // other symbol, this indicates that the chunk was discarded.  Normally
-    // relocations against discarded sections are an error.  However, debug info
-    // sections are not GC roots and can end up with these kinds of relocations.
-    // Skip these relocations.
-    if (!OS && !isa<DefinedAbsolute>(Sym) && !isa<DefinedSynthetic>(Sym)) {
-      if (isCodeView() || isDWARF())
-        continue;
-      error("relocation against symbol in discarded section: " +
-            Sym->getName());
+    // Skip the relocation if it refers to a discarded section, and diagnose it
+    // as an error if appropriate. If a symbol was discarded early, it may be
+    // null. If it was discarded late, the output section will be null, unless
+    // it was an absolute or synthetic symbol.
+    if (!Sym ||
+        (!OS && !isa<DefinedAbsolute>(Sym) && !isa<DefinedSynthetic>(Sym))) {
+      maybeReportRelocationToDiscarded(this, Sym, Rel);
       continue;
     }
+
     uint64_t S = Sym->getRVA();
 
     // Compute the RVA of the relocation for relative relocations.

src/llvm/tools/lld/COFF/ICF.cpp

@@ -262,8 +262,18 @@ void ICF::run(ArrayRef<Chunk *> Vec) {
 
   // Initially, we use hash values to partition sections.
   for_each(parallel::par, Chunks.begin(), Chunks.end(), [&](SectionChunk *SC) {
+    SC->Class[1] = xxHash64(SC->getContents());
+  });
+
+  // Combine the hashes of the sections referenced by each section into its
+  // hash.
+  for_each(parallel::par, Chunks.begin(), Chunks.end(), [&](SectionChunk *SC) {
+    uint32_t Hash = SC->Class[1];
+    for (Symbol *B : SC->symbols())
+      if (auto *Sym = dyn_cast_or_null<DefinedRegular>(B))
+        Hash ^= Sym->getChunk()->Class[1];
     // Set MSB to 1 to avoid collisions with non-hash classs.
-    SC->Class[0] = xxHash64(SC->getContents()) | (1 << 31);
+    SC->Class[0] = Hash | (1U << 31);
   });
 
   // From now on, sections in Chunks are ordered so that sections in

src/llvm/tools/lld/COFF/InputFiles.cpp

@@ -501,6 +501,10 @@ void ImportFile::parse() {
   ExternalName = ExtName;
 
   ImpSym = Symtab->addImportData(ImpName, this);
+  // If this was a duplicate, we logged an error but may continue;
+  // in this case, ImpSym is nullptr.
+  if (!ImpSym)
+    return;
 
   if (Hdr->getType() == llvm::COFF::IMPORT_CONST)
     static_cast<void>(Symtab->addImportData(Name, this));

src/llvm/tools/lld/COFF/InputFiles.h

@@ -15,6 +15,7 @@
 #include "llvm/ADT/ArrayRef.h"
 #include "llvm/ADT/DenseMap.h"
 #include "llvm/ADT/DenseSet.h"
+#include "llvm/DebugInfo/CodeView/TypeRecord.h"
 #include "llvm/LTO/LTO.h"
 #include "llvm/Object/Archive.h"
 #include "llvm/Object/COFF.h"
@@ -122,9 +123,12 @@ class ObjFile : public InputFile {
     return Symbols[SymbolIndex];
   }
 
-  // Returns the underying COFF file.
+  // Returns the underlying COFF file.
   COFFObjectFile *getCOFFObj() { return COFFObj.get(); }
 
+  // Whether the object was already merged into the final PDB or not
+  bool wasProcessedForPDB() const { return !!ModuleDBI; }
+
   static std::vector<ObjFile *> Instances;
 
   // Flags in the absolute @feat.00 symbol if it is present. These usually
@@ -147,6 +151,11 @@ class ObjFile : public InputFile {
 
   const coff_section *AddrsigSec = nullptr;
 
+  // When using Microsoft precompiled headers, this is the PCH's key.
+  // The same key is used by both the precompiled object, and objects using the
+  // precompiled object. Any difference indicates out-of-date objects.
+  llvm::Optional<llvm::codeview::EndPrecompRecord> EndPrecomp;
+
 private:
   void initializeChunks();
   void initializeSymbols();

src/llvm/tools/lld/COFF/LTO.cpp

@@ -60,6 +60,8 @@ static std::unique_ptr<lto::LTO> createLTO() {
   C.DisableVerify = true;
   C.DiagHandler = diagnosticHandler;
   C.OptLevel = Config->LTOO;
+  C.MAttrs = GetMAttrs();
+
   if (Config->SaveTemps)
     checkError(C.addSaveTemps(std::string(Config->OutputFile) + ".",
                               /*UseInputModulePath*/ true));

src/llvm/tools/lld/COFF/MinGW.cpp

@@ -84,6 +84,7 @@ AutoExporter::AutoExporter() {
       "libsupc++",
       "libobjc",
       "libgcj",
+      "libclang_rt.builtins",
       "libclang_rt.builtins-aarch64",
       "libclang_rt.builtins-arm",
       "libclang_rt.builtins-i386",