WIP: llvm-buildozer 3/3 [lld part]

[aganea]

Summary

Please see D86351 for description.

[aganea]

This is now part of D86351

COFF/Chunks.h

   size_t getSize() const override;
   void writeTo(uint8_t *buf) const override;
 
-  static MergeChunk *instances[Log2MaxSectionAlignment + 1];
+  static LLVM_THREAD_LOCAL MergeChunk *instances[Log2MaxSectionAlignment + 1];
   std::vector<SectionChunk *> sections;
 
 private:

COFF/Chunks.cpp

   }
 }
 
-MergeChunk *MergeChunk::instances[Log2MaxSectionAlignment + 1] = {};
+LLVM_THREAD_LOCAL MergeChunk *MergeChunk::instances[Log2MaxSectionAlignment + 1] = {};
 
 MergeChunk::MergeChunk(uint32_t alignment)
     : builder(StringTableBuilder::RAW, alignment) {

COFF/DebugTypes.cpp

   static Expected<TypeServerSource *>
   findFromFile(const ObjFile *dependentFile);
 
-  static std::map<std::string, std::pair<std::string, TypeServerSource *>>
+  static LLVM_THREAD_LOCAL std::map<std::string, std::pair<std::string, TypeServerSource *>>
       instances;
 
   // The interface to the PDB (if it was opened successfully)

 };
 } // namespace
 
-static std::vector<std::unique_ptr<TpiSource>> GC;
+static LLVM_THREAD_LOCAL std::vector<std::unique_ptr<TpiSource>> GC;
 
 TpiSource::TpiSource(TpiKind k, const ObjFile *f) : kind(k), file(f) {
   GC.push_back(std::unique_ptr<TpiSource>(this));

 } // namespace coff
 } // namespace lld
 
-std::map<std::string, std::pair<std::string, TypeServerSource *>>
+LLVM_THREAD_LOCAL std::map<std::string, std::pair<std::string, TypeServerSource *>>
     TypeServerSource::instances;
 
 // Make a PDB path assuming the PDB is in the same folder as the OBJ

COFF/Driver.cpp

 namespace lld {
 namespace coff {
 
-static Timer inputFileTimer("Input File Reading", Timer::root());
+static LLVM_THREAD_LOCAL Timer inputFileTimer("Input File Reading", Timer::root());
 
 Configuration *config;
 LinkerDriver *driver;

   return !s.empty() && s.drop_back().endswith("crtend");
 }
 
+/*
 // ErrorOr is not default constructible, so it cannot be used as the type
 // parameter of a future.
 // FIXME: We could open the file in createFutureForFile and avoid needing to

 #endif
   return std::async(strategy, [=]() {
     auto mbOrErr = MemoryBuffer::getFile(path,
-                                         /*FileSize*/ -1,
-                                         /*RequiresNullTerminator*/ false);
+                                         -1, // FileSize
+                                         false); // RequiresNullTerminator
     if (!mbOrErr)
       return MBErrPair{nullptr, mbOrErr.getError()};
     return MBErrPair{std::move(*mbOrErr), std::error_code()};
   });
-}
+}*/
 
 // Symbol names are mangled by prepending "_" on x86.
 static StringRef mangle(StringRef sym) {

 }
 
 void LinkerDriver::enqueuePath(StringRef path, bool wholeArchive, bool lazy) {
-  auto future =
-      std::make_shared<std::future<MBErrPair>>(createFutureForFile(path));
+  /*auto future =
+      std::make_shared<std::future<MBErrPair>>(createFutureForFile(path));*/
   std::string pathStr = path;
   enqueueTask([=]() {
-    auto mbOrErr = future->get();
-    if (mbOrErr.second) {
+    //auto mbOrErr = future->get();
+      auto mbOrErr = MemoryBuffer::getFile(pathStr,
+          /*FileSize*/ -1,
+          /*RequiresNullTerminator*/ false);
+      if (!mbOrErr) {
       std::string msg =
-          "could not open '" + pathStr + "': " + mbOrErr.second.message();
+          "could not open '" + pathStr + "': " + mbOrErr.getError().message();
       // Check if the filename is a typo for an option flag. OptTable thinks
       // that all args that are not known options and that start with / are
       // filenames, but e.g. `/nodefaultlibs` is more likely a typo for

       else
         error(msg + "; did you mean '" + nearest + "'");
     } else
-      driver->addBuffer(std::move(mbOrErr.first), wholeArchive, lazy);
+      driver->addBuffer(std::move(mbOrErr.get()), wholeArchive, lazy);
   });
 }
 

       c.getFullName(),
       "could not get the filename for the member defining symbol " +
       toCOFFString(sym));
-  auto future = std::make_shared<std::future<MBErrPair>>(
-      createFutureForFile(childName));
+  /*auto future = std::make_shared<std::future<MBErrPair>>(
+      createFutureForFile(childName));*/
   enqueueTask([=]() {
-    auto mbOrErr = future->get();
-    if (mbOrErr.second)
-      reportBufferError(errorCodeToError(mbOrErr.second), childName);
-    driver->addArchiveBuffer(takeBuffer(std::move(mbOrErr.first)),
+    //auto mbOrErr = future->get();
+    auto mbOrErr = MemoryBuffer::getFile(childName,
+                                         /*FileSize*/ -1,
+                                         /*RequiresNullTerminator*/ false);
+    if (!mbOrErr)
+      reportBufferError(errorCodeToError(mbOrErr.getError()), childName);
+    driver->addArchiveBuffer(takeBuffer(std::move(mbOrErr.get())),
                              toCOFFString(sym), parentName,
                              /*OffsetInArchive=*/0);
   });

     return;
   }
 
-  lld::threadsEnabled = args.hasFlag(OPT_threads, OPT_threads_no, true);
+  lld::threadsEnabled = args.hasFlag(OPT_threads, OPT_threads_no, false);
 
   if (args.hasArg(OPT_show_timing))
     config->showTiming = true;

COFF/ICF.cpp

 namespace lld {
 namespace coff {
 
-static Timer icfTimer("ICF", Timer::root());
+static LLVM_THREAD_LOCAL Timer icfTimer("ICF", Timer::root());
 
 class ICF {
 public:

COFF/InputFiles.h

 
   bool isResourceObjFile() const { return !resourceChunks.empty(); }
 
-  static std::vector<ObjFile *> instances;
+  static LLVM_THREAD_LOCAL std::vector<ObjFile *> instances;
 
   // Flags in the absolute @feat.00 symbol if it is present. These usually
   // indicate if an object was compiled with certain security features enabled

 
   static bool classof(const InputFile *f) { return f->kind() == ImportKind; }
 
-  static std::vector<ImportFile *> instances;
+  static LLVM_THREAD_LOCAL std::vector<ImportFile *> instances;
 
   Symbol *impSym = nullptr;
   Symbol *thunkSym = nullptr;

   static bool classof(const InputFile *f) { return f->kind() == BitcodeKind; }
   ArrayRef<Symbol *> getSymbols() { return symbols; }
   MachineTypes getMachineType() override;
-  static std::vector<BitcodeFile *> instances;
+  static LLVM_THREAD_LOCAL std::vector<BitcodeFile *> instances;
   std::unique_ptr<llvm::lto::InputFile> obj;
 
 private:

COFF/InputFiles.cpp

 namespace lld {
 namespace coff {
 
-std::vector<ObjFile *> ObjFile::instances;
-std::vector<ImportFile *> ImportFile::instances;
-std::vector<BitcodeFile *> BitcodeFile::instances;
+LLVM_THREAD_LOCAL std::vector<ObjFile *> ObjFile::instances;
+LLVM_THREAD_LOCAL std::vector<ImportFile *> ImportFile::instances;
+LLVM_THREAD_LOCAL std::vector<BitcodeFile *> BitcodeFile::instances;
 
 /// Checks that Source is compatible with being a weak alias to Target.
 /// If Source is Undefined and has no weak alias set, makes it a weak

COFF/MarkLive.cpp

 namespace lld {
 namespace coff {
 
-static Timer gctimer("GC", Timer::root());
+static LLVM_THREAD_LOCAL Timer gctimer("GC", Timer::root());
 
 // Set live bit on for each reachable chunk. Unmarked (unreachable)
 // COMDAT chunks will be ignored by Writer, so they will be excluded

COFF/PDB.cpp

 
 static ExitOnError exitOnErr;
 
-static Timer totalPdbLinkTimer("PDB Emission (Cumulative)", Timer::root());
+static LLVM_THREAD_LOCAL Timer totalPdbLinkTimer("PDB Emission (Cumulative)", Timer::root());
 
-static Timer addObjectsTimer("Add Objects", totalPdbLinkTimer);
-static Timer typeMergingTimer("Type Merging", addObjectsTimer);
-static Timer symbolMergingTimer("Symbol Merging", addObjectsTimer);
-static Timer globalsLayoutTimer("Globals Stream Layout", totalPdbLinkTimer);
-static Timer tpiStreamLayoutTimer("TPI Stream Layout", totalPdbLinkTimer);
-static Timer diskCommitTimer("Commit to Disk", totalPdbLinkTimer);
+static LLVM_THREAD_LOCAL Timer addObjectsTimer("Add Objects", totalPdbLinkTimer);
+static LLVM_THREAD_LOCAL Timer typeMergingTimer("Type Merging", addObjectsTimer);
+static LLVM_THREAD_LOCAL Timer symbolMergingTimer("Symbol Merging", addObjectsTimer);
+static LLVM_THREAD_LOCAL Timer globalsLayoutTimer("Globals Stream Layout", totalPdbLinkTimer);
+static LLVM_THREAD_LOCAL Timer tpiStreamLayoutTimer("TPI Stream Layout", totalPdbLinkTimer);
+static LLVM_THREAD_LOCAL Timer diskCommitTimer("Commit to Disk", totalPdbLinkTimer);
 
 namespace {
 class DebugSHandler;

COFF/SymbolTable.h

   std::unique_ptr<BitcodeCompiler> lto;
 };
 
-extern SymbolTable *symtab;
+extern LLVM_THREAD_LOCAL SymbolTable *symtab;
 
 std::vector<std::string> getSymbolLocations(ObjFile *file, uint32_t symIndex);
 

COFF/SymbolTable.cpp

 namespace lld {
 namespace coff {
 
-static Timer ltoTimer("LTO", Timer::root());
+static LLVM_THREAD_LOCAL Timer ltoTimer("LTO", Timer::root());
 
-SymbolTable *symtab;
+LLVM_THREAD_LOCAL SymbolTable *symtab;
 
 void SymbolTable::addFile(InputFile *file) {
   log("Reading " + toString(file));

COFF/Symbols.h

   // Section index relocations against absolute symbols resolve to
   // this 16 bit number, and it is the largest valid section index
   // plus one. This variable keeps it.
-  static uint16_t numOutputSections;
+  static LLVM_THREAD_LOCAL uint16_t numOutputSections;
 
 private:
   uint64_t va;

COFF/Symbols.cpp

   return COFFSymbolRef(reinterpret_cast<const coff_symbol32 *>(sym));
 }
 
-uint16_t DefinedAbsolute::numOutputSections;
+LLVM_THREAD_LOCAL uint16_t DefinedAbsolute::numOutputSections;
 
 static Chunk *makeImportThunk(DefinedImportData *s, uint16_t machine) {
   if (machine == AMD64)

COFF/Writer.cpp

 
 // Global vector of all output sections. After output sections are finalized,
 // this can be indexed by Chunk::getOutputSection.
-static std::vector<OutputSection *> outputSections;
+static LLVM_THREAD_LOCAL std::vector<OutputSection *> outputSections;
 
 OutputSection *Chunk::getOutputSection() const {
   return osidx == 0 ? nullptr : outputSections[osidx - 1];

 namespace lld {
 namespace coff {
 
-static Timer codeLayoutTimer("Code Layout", Timer::root());
-static Timer diskCommitTimer("Commit Output File", Timer::root());
+static LLVM_THREAD_LOCAL Timer codeLayoutTimer("Code Layout", Timer::root());
+static LLVM_THREAD_LOCAL Timer diskCommitTimer("Commit Output File", Timer::root());
 
 void writeResult() { Writer().run(); }
 

Common/ErrorHandler.cpp

 
   outs().flush();
   errs().flush();
-  _exit(val);
+  sys::Process::ExitCurrentProcess(val);
 }
 
 void lld::diagnosticHandler(const DiagnosticInfo &di) {

Common/Memory.cpp

 using namespace llvm;
 using namespace lld;
 
-BumpPtrAllocator lld::bAlloc;
-StringSaver lld::saver{bAlloc};
-std::vector<SpecificAllocBase *> lld::SpecificAllocBase::instances;
+LLVM_THREAD_LOCAL BumpPtrAllocator lld::bAlloc;
+LLVM_THREAD_LOCAL StringSaver lld::saver{bAlloc};
+LLVM_THREAD_LOCAL std::vector<SpecificAllocBase *> lld::SpecificAllocBase::instances;
 
 void lld::freeArena() {
   for (SpecificAllocBase *alloc : SpecificAllocBase::instances)

Common/Threads.cpp

 
 #include "lld/Common/Threads.h"
 
-bool lld::threadsEnabled = true;
+bool lld::threadsEnabled = false;

Common/Timer.cpp

 }
 
 Timer &Timer::root() {
-  static Timer rootTimer("Total Link Time");
+  static LLVM_THREAD_LOCAL Timer rootTimer("Total Link Time");
   return rootTimer;
 }
 

include/lld/Common/Memory.h

 namespace lld {
 
 // Use this arena if your object doesn't have a destructor.
-extern llvm::BumpPtrAllocator bAlloc;
-extern llvm::StringSaver saver;
+extern LLVM_THREAD_LOCAL llvm::BumpPtrAllocator bAlloc;
+extern LLVM_THREAD_LOCAL llvm::StringSaver saver;
 
 void freeArena();
 

   SpecificAllocBase() { instances.push_back(this); }
   virtual ~SpecificAllocBase() = default;
   virtual void reset() = 0;
-  static std::vector<SpecificAllocBase *> instances;
+  static LLVM_THREAD_LOCAL std::vector<SpecificAllocBase *> instances;
 };
 
 template <class T> struct SpecificAlloc : public SpecificAllocBase {