diff --git a/clang/include/clang/Tooling/DependencyScanning/DependencyScanningFilesystem.h b/clang/include/clang/Tooling/DependencyScanning/DependencyScanningFilesystem.h
--- a/clang/include/clang/Tooling/DependencyScanning/DependencyScanningFilesystem.h
+++ b/clang/include/clang/Tooling/DependencyScanning/DependencyScanningFilesystem.h
@@ -54,7 +54,12 @@
   static CachedFileSystemEntry createDirectoryEntry(llvm::vfs::Status &&Stat);
 
   /// \returns True if the entry is valid.
-  bool isValid() const { return !MaybeStat || MaybeStat->isStatusKnown(); }
+  bool isValid() const { return MaybeStat && MaybeStat->isStatusKnown(); }
+
+  std::error_code getErrorCode() const {
+    assert(!isValid() && "does not have an error code");
+    return MaybeStat.getError();
+  }
 
   /// \returns True if the current entry points to a directory.
   bool isDirectory() const { return MaybeStat && MaybeStat->isDirectory(); }
diff --git a/clang/lib/ASTMatchers/GtestMatchers.cpp b/clang/lib/ASTMatchers/GtestMatchers.cpp
--- a/clang/lib/ASTMatchers/GtestMatchers.cpp
+++ b/clang/lib/ASTMatchers/GtestMatchers.cpp
@@ -53,6 +53,7 @@
   case GtestCmp::Lt:
     return functionDecl(hasName("::testing::internal::CmpHelperLT"));
   }
+  llvm_unreachable("Unexpected GtestCmp!");
 }
 
 static llvm::StringRef getMacroTypeName(MacroType Macro) {
@@ -64,6 +65,7 @@
   case MacroType::On:
     return "ON";
   }
+  llvm_unreachable("Unexpected MacroType!");
 }
 
 static llvm::StringRef getComparisonTypeName(GtestCmp Cmp) {
@@ -81,6 +83,7 @@
   case GtestCmp::Lt:
     return "LT";
   }
+  llvm_unreachable("Unexpected GtestCmp!");
 }
 
 static std::string getMacroName(MacroType Macro, GtestCmp Cmp) {
@@ -170,6 +173,7 @@
             hasOverloadedOperatorName("()"), argumentCountIs(3),
             hasArgument(0, ignoringImplicit(MockCall))))));
   }
+  llvm_unreachable("Unexpected MockArgs!");
 }
 
 static internal::BindableMatcher<Stmt>
diff --git a/clang/lib/CodeGen/CodeGenAction.cpp b/clang/lib/CodeGen/CodeGenAction.cpp
--- a/clang/lib/CodeGen/CodeGenAction.cpp
+++ b/clang/lib/CodeGen/CodeGenAction.cpp
@@ -903,7 +903,9 @@
   case Backend_EmitMCNull:
     return CI.createNullOutputFile();
   case Backend_EmitObj:
-    return CI.createDefaultOutputFile(true, InFile, "o");
+    return CI.createDefaultOutputFile(true, InFile, "o",
+                                      /*RemoveFileOnSignal=*/true,
+                                      /*CreateMissingDirectories=*/true);
   }
 
   llvm_unreachable("Invalid action!");
diff --git a/clang/lib/Driver/Driver.cpp b/clang/lib/Driver/Driver.cpp
--- a/clang/lib/Driver/Driver.cpp
+++ b/clang/lib/Driver/Driver.cpp
@@ -295,7 +295,8 @@
   if (CCCIsCPP() || (PhaseArg = DAL.getLastArg(options::OPT_E)) ||
       (PhaseArg = DAL.getLastArg(options::OPT__SLASH_EP)) ||
       (PhaseArg = DAL.getLastArg(options::OPT_M, options::OPT_MM)) ||
-      (PhaseArg = DAL.getLastArg(options::OPT__SLASH_P))) {
+      (PhaseArg = DAL.getLastArg(options::OPT__SLASH_P)) ||
+      (PhaseArg = DAL.getLastArg(options::OPT_Eonly))) {
     FinalPhase = phases::Preprocess;
 
   // --precompile only runs up to precompilation.
diff --git a/clang/lib/Driver/ToolChains/Clang.cpp b/clang/lib/Driver/ToolChains/Clang.cpp
--- a/clang/lib/Driver/ToolChains/Clang.cpp
+++ b/clang/lib/Driver/ToolChains/Clang.cpp
@@ -41,6 +41,7 @@
 #include "llvm/Support/Compression.h"
 #include "llvm/Support/FileSystem.h"
 #include "llvm/Support/Host.h"
+#include "llvm/Support/InitLLVM.h"
 #include "llvm/Support/Path.h"
 #include "llvm/Support/Process.h"
 #include "llvm/Support/TargetParser.h"
@@ -4632,7 +4633,7 @@
   // We normally speed up the clang process a bit by skipping destructors at
   // exit, but when we're generating diagnostics we can rely on some of the
   // cleanup.
-  if (!C.isForDiagnostics())
+  if (!C.isForDiagnostics() && !llvm::InitLLVM::RunningInBuildozer())
     CmdArgs.push_back("-disable-free");
 
 #ifdef NDEBUG
diff --git a/clang/lib/Frontend/CompilerInstance.cpp b/clang/lib/Frontend/CompilerInstance.cpp
--- a/clang/lib/Frontend/CompilerInstance.cpp
+++ b/clang/lib/Frontend/CompilerInstance.cpp
@@ -728,6 +728,10 @@
         << OF.TempFilename << OF.Filename << EC.message();
 
     llvm::sys::fs::remove(OF.TempFilename);
+
+    // Don't leak file added by RemoveFileOnSignal() in
+    // CompilerInstance::createOutputFile()
+    llvm::sys::DontRemoveFileOnSignal(OF.TempFilename);
   }
   OutputFiles.clear();
   if (DeleteBuiltModules) {
diff --git a/clang/lib/Tooling/CommonOptionsParser.cpp b/clang/lib/Tooling/CommonOptionsParser.cpp
--- a/clang/lib/Tooling/CommonOptionsParser.cpp
+++ b/clang/lib/Tooling/CommonOptionsParser.cpp
@@ -86,21 +86,21 @@
 
   static cl::opt<std::string> BuildPath("p", cl::desc("Build path"),
                                         cl::Optional, cl::cat(Category),
-                                        cl::sub(*cl::AllSubCommands));
+                                        cl::allSub());
 
   static cl::list<std::string> SourcePaths(
       cl::Positional, cl::desc("<source0> [... <sourceN>]"), OccurrencesFlag,
-      cl::cat(Category), cl::sub(*cl::AllSubCommands));
+      cl::cat(Category), cl::allSub());
 
   static cl::list<std::string> ArgsAfter(
       "extra-arg",
       cl::desc("Additional argument to append to the compiler command line"),
-      cl::cat(Category), cl::sub(*cl::AllSubCommands));
+      cl::cat(Category), cl::allSub());
 
   static cl::list<std::string> ArgsBefore(
       "extra-arg-before",
       cl::desc("Additional argument to prepend to the compiler command line"),
-      cl::cat(Category), cl::sub(*cl::AllSubCommands));
+      cl::cat(Category), cl::allSub());
 
   cl::ResetAllOptionOccurrences();
 
diff --git a/clang/lib/Tooling/DependencyScanning/CMakeLists.txt b/clang/lib/Tooling/DependencyScanning/CMakeLists.txt
--- a/clang/lib/Tooling/DependencyScanning/CMakeLists.txt
+++ b/clang/lib/Tooling/DependencyScanning/CMakeLists.txt
@@ -1,4 +1,5 @@
 set(LLVM_LINK_COMPONENTS
+  BinaryFormat
   Core
   Support
   )
diff --git a/clang/lib/Tooling/DependencyScanning/DependencyScanningFilesystem.cpp b/clang/lib/Tooling/DependencyScanning/DependencyScanningFilesystem.cpp
--- a/clang/lib/Tooling/DependencyScanning/DependencyScanningFilesystem.cpp
+++ b/clang/lib/Tooling/DependencyScanning/DependencyScanningFilesystem.cpp
@@ -8,6 +8,7 @@
 
 #include "clang/Tooling/DependencyScanning/DependencyScanningFilesystem.h"
 #include "clang/Lex/DependencyDirectivesSourceMinimizer.h"
+#include "llvm/BinaryFormat/Magic.h"
 #include "llvm/Support/MemoryBuffer.h"
 #include "llvm/Support/Threading.h"
 
@@ -32,12 +33,15 @@
   if (!MaybeBuffer)
     return MaybeBuffer.getError();
 
+  const auto &Buffer = *MaybeBuffer;
+  llvm::file_magic M = llvm::identify_magic(Buffer->getBuffer());
+
   llvm::SmallString<1024> MinimizedFileContents;
   // Minimize the file down to directives that might affect the dependencies.
-  const auto &Buffer = *MaybeBuffer;
   SmallVector<minimize_source_to_dependency_directives::Token, 64> Tokens;
-  if (!Minimize || minimizeSourceToDependencyDirectives(
-                       Buffer->getBuffer(), MinimizedFileContents, Tokens)) {
+  if (!Minimize || M == llvm::file_magic::clang_pch ||
+      minimizeSourceToDependencyDirectives(Buffer->getBuffer(),
+                                           MinimizedFileContents, Tokens)) {
     // Use the original file unless requested otherwise, or
     // if the minimization failed.
     // FIXME: Propage the diagnostic if desired by the client.
@@ -204,6 +208,8 @@
       getOrCreateFileSystemEntry(Filename);
   if (!Result)
     return Result.getError();
+  if (!(*Result)->isValid())
+    return (*Result)->getErrorCode();
   return (*Result)->getStatus();
 }
 
diff --git a/clang/tools/clang-refactor/ClangRefactor.cpp b/clang/tools/clang-refactor/ClangRefactor.cpp
--- a/clang/tools/clang-refactor/ClangRefactor.cpp
+++ b/clang/tools/clang-refactor/ClangRefactor.cpp
@@ -38,12 +38,10 @@
 static cl::OptionCategory CommonRefactorOptions("Refactoring options");
 
 static cl::opt<bool> Verbose("v", cl::desc("Use verbose output"),
-                             cl::cat(cl::GeneralCategory),
-                             cl::sub(*cl::AllSubCommands));
+                             cl::cat(cl::GeneralCategory), cl::allSub());
 
 static cl::opt<bool> Inplace("i", cl::desc("Inplace edit <file>s"),
-                             cl::cat(cl::GeneralCategory),
-                             cl::sub(*cl::AllSubCommands));
+                             cl::cat(cl::GeneralCategory), cl::allSub());
 
 } // end namespace opts
 
diff --git a/clang/tools/driver/driver.cpp b/clang/tools/driver/driver.cpp
--- a/clang/tools/driver/driver.cpp
+++ b/clang/tools/driver/driver.cpp
@@ -33,6 +33,7 @@
 #include "llvm/Support/BuryPointer.h"
 #include "llvm/Support/CommandLine.h"
 #include "llvm/Support/CrashRecoveryContext.h"
+#include "llvm/Support/DynamicLibrary.h"
 #include "llvm/Support/ErrorHandling.h"
 #include "llvm/Support/FileSystem.h"
 #include "llvm/Support/Host.h"
@@ -50,6 +51,7 @@
 #include <memory>
 #include <set>
 #include <system_error>
+#include <windows.h>
 using namespace clang;
 using namespace clang::driver;
 using namespace llvm::opt;
@@ -348,6 +350,8 @@
   return 1;
 }
 
+int ClangDriverMain(SmallVectorImpl<const char *> &Args);
+
 int main(int Argc, const char **Argv) {
   noteBottomOfStack();
   llvm::InitLLVM X(Argc, Argv);
@@ -360,6 +364,18 @@
     return 1;
 
   llvm::InitializeAllTargets();
+  return ClangDriverMain(Args);
+}
+
+int ClangDriverMain(SmallVectorImpl<const char *> &Args) {
+  static LLVM_THREAD_LOCAL bool EnterPE = true;
+  if (EnterPE) {
+    llvm::sys::DynamicLibrary::AddSymbol("ClangDriverMain",
+                                         (void *)(intptr_t)&ClangDriverMain);
+    EnterPE = false;
+  } else {
+    llvm::cl::ResetAllOptionOccurrences();
+  }
   auto TargetAndMode = ToolChain::getTargetAndModeFromProgramName(Args[0]);
 
   llvm::BumpPtrAllocator A;
diff --git a/lld/COFF/Chunks.h b/lld/COFF/Chunks.h
--- a/lld/COFF/Chunks.h
+++ b/lld/COFF/Chunks.h
@@ -424,7 +424,7 @@
   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:
diff --git a/lld/COFF/Chunks.cpp b/lld/COFF/Chunks.cpp
--- a/lld/COFF/Chunks.cpp
+++ b/lld/COFF/Chunks.cpp
@@ -938,7 +938,8 @@
   }
 }
 
-MergeChunk *MergeChunk::instances[Log2MaxSectionAlignment + 1] = {};
+LLVM_THREAD_LOCAL MergeChunk
+    *MergeChunk::instances[Log2MaxSectionAlignment + 1] = {};
 
 MergeChunk::MergeChunk(uint32_t alignment)
     : builder(StringTableBuilder::RAW, alignment) {
diff --git a/lld/COFF/Config.h b/lld/COFF/Config.h
--- a/lld/COFF/Config.h
+++ b/lld/COFF/Config.h
@@ -275,7 +275,7 @@
   bool pseudoRelocs = false;
 };
 
-extern Configuration *config;
+extern LLVM_THREAD_LOCAL Configuration *config;
 
 } // namespace coff
 } // namespace lld
diff --git a/lld/COFF/DebugTypes.h b/lld/COFF/DebugTypes.h
--- a/lld/COFF/DebugTypes.h
+++ b/lld/COFF/DebugTypes.h
@@ -110,15 +110,15 @@
   }
 
   /// All sources of type information in the program.
-  static std::vector<TpiSource *> instances;
+  static LLVM_THREAD_LOCAL std::vector<TpiSource *> instances;
 
   /// Dependency type sources, such as type servers or PCH object files. These
   /// must be processed before objects that rely on them. Set by
   /// TpiSources::sortDependencies.
-  static ArrayRef<TpiSource *> dependencySources;
+  static LLVM_THREAD_LOCAL ArrayRef<TpiSource *> dependencySources;
 
   /// Object file sources. These must be processed after dependencySources.
-  static ArrayRef<TpiSource *> objectSources;
+  static LLVM_THREAD_LOCAL ArrayRef<TpiSource *> objectSources;
 
   /// Sorts the dependencies and reassigns TpiSource indices.
   static void sortDependencies();
diff --git a/lld/COFF/DebugTypes.cpp b/lld/COFF/DebugTypes.cpp
--- a/lld/COFF/DebugTypes.cpp
+++ b/lld/COFF/DebugTypes.cpp
@@ -160,9 +160,9 @@
 };
 } // namespace
 
-std::vector<TpiSource *> TpiSource::instances;
-ArrayRef<TpiSource *> TpiSource::dependencySources;
-ArrayRef<TpiSource *> TpiSource::objectSources;
+LLVM_THREAD_LOCAL std::vector<TpiSource *> TpiSource::instances;
+LLVM_THREAD_LOCAL ArrayRef<TpiSource *> TpiSource::dependencySources;
+LLVM_THREAD_LOCAL ArrayRef<TpiSource *> TpiSource::objectSources;
 
 TpiSource::TpiSource(TpiKind k, ObjFile *f)
     : kind(k), tpiSrcIdx(instances.size()), file(f) {
diff --git a/lld/COFF/Driver.h b/lld/COFF/Driver.h
--- a/lld/COFF/Driver.h
+++ b/lld/COFF/Driver.h
@@ -30,7 +30,7 @@
 namespace coff {
 
 class LinkerDriver;
-extern LinkerDriver *driver;
+extern LLVM_THREAD_LOCAL LinkerDriver *driver;
 
 using llvm::COFF::MachineTypes;
 using llvm::COFF::WindowsSubsystem;
diff --git a/lld/COFF/Driver.cpp b/lld/COFF/Driver.cpp
--- a/lld/COFF/Driver.cpp
+++ b/lld/COFF/Driver.cpp
@@ -59,10 +59,11 @@
 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;
+LLVM_THREAD_LOCAL Configuration *config;
+LLVM_THREAD_LOCAL LinkerDriver *driver;
 
 bool link(ArrayRef<const char *> args, bool canExitEarly, raw_ostream &stdoutOS,
           raw_ostream &stderrOS) {
@@ -144,7 +145,7 @@
 // FIXME: We could open the file in createFutureForFile and avoid needing to
 // return an error here, but for the moment that would cost us a file descriptor
 // (a limited resource on Windows) for the duration that the future is pending.
-using MBErrPair = std::pair<std::unique_ptr<MemoryBuffer>, std::error_code>;
+/*using MBErrPair = std::pair<std::unique_ptr<MemoryBuffer>, std::error_code>;
 
 // Create a std::future that opens and maps a file using the best strategy for
 // the host platform.
@@ -157,13 +158,14 @@
   auto strategy = std::launch::deferred;
 #endif
   return std::async(strategy, [=]() {
-    auto mbOrErr = MemoryBuffer::getFile(path, /*IsText=*/false,
-                                         /*RequiresNullTerminator=*/false);
+    auto mbOrErr = MemoryBuffer::getFile(path,
+                                         false, //IsText
+                                         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) {
@@ -247,14 +249,17 @@
 }
 
 void LinkerDriver::enqueuePath(StringRef path, bool wholeArchive, bool lazy) {
-  auto future = std::make_shared<std::future<MBErrPair>>(
-      createFutureForFile(std::string(path)));
+  /*auto future = std::make_shared<std::future<MBErrPair>>(
+      createFutureForFile(std::string(path)));*/
   std::string pathStr = std::string(path);
   enqueueTask([=]() {
-    auto mbOrErr = future->get();
-    if (mbOrErr.second) {
+    // auto mbOrErr = future->get();
+    auto mbOrErr = MemoryBuffer::getFile(pathStr,
+                                         false,  // IsText
+                                         false); // RequiresNullTerminator
+    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
@@ -266,7 +271,7 @@
       else
         error(msg + "; did you mean '" + nearest + "'");
     } else
-      driver->addBuffer(std::move(mbOrErr.first), wholeArchive, lazy);
+      driver->addBuffer(std::move(mbOrErr.get()), wholeArchive, lazy);
   });
 }
 
@@ -323,15 +328,16 @@
       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);
+    // auto mbOrErr = future->get();
+    auto mbOrErr = MemoryBuffer::getFile(childName, false, false);
+    if (!mbOrErr)
+      reportBufferError(errorCodeToError(mbOrErr.getError()), childName);
     // Pass empty string as archive name so that the original filename is
     // used as the buffer identifier.
-    driver->addArchiveBuffer(takeBuffer(std::move(mbOrErr.first)),
+    driver->addArchiveBuffer(takeBuffer(std::move(mbOrErr.get())),
                              toCOFFString(sym), "", /*OffsetInArchive=*/0);
   });
 }
diff --git a/lld/COFF/ICF.cpp b/lld/COFF/ICF.cpp
--- a/lld/COFF/ICF.cpp
+++ b/lld/COFF/ICF.cpp
@@ -36,7 +36,7 @@
 namespace lld {
 namespace coff {
 
-static Timer icfTimer("ICF", Timer::root());
+static LLVM_THREAD_LOCAL Timer icfTimer("ICF", Timer::root());
 
 class ICF {
 public:
diff --git a/lld/COFF/InputFiles.h b/lld/COFF/InputFiles.h
--- a/lld/COFF/InputFiles.h
+++ b/lld/COFF/InputFiles.h
@@ -173,7 +173,7 @@
 
   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
@@ -325,7 +325,7 @@
 
   static PDBInputFile *findFromRecordPath(StringRef path, ObjFile *fromFile);
 
-  static std::map<std::string, PDBInputFile *> instances;
+  static LLVM_THREAD_LOCAL std::map<std::string, PDBInputFile *> instances;
 
   // Record possible errors while opening the PDB file
   llvm::Optional<Error> loadErr;
@@ -346,7 +346,7 @@
 
   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;
@@ -384,7 +384,7 @@
   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:
diff --git a/lld/COFF/InputFiles.cpp b/lld/COFF/InputFiles.cpp
--- a/lld/COFF/InputFiles.cpp
+++ b/lld/COFF/InputFiles.cpp
@@ -69,10 +69,10 @@
       .str();
 }
 
-std::vector<ObjFile *> ObjFile::instances;
-std::map<std::string, PDBInputFile *> PDBInputFile::instances;
-std::vector<ImportFile *> ImportFile::instances;
-std::vector<BitcodeFile *> BitcodeFile::instances;
+LLVM_THREAD_LOCAL std::vector<ObjFile *> ObjFile::instances;
+LLVM_THREAD_LOCAL std::map<std::string, PDBInputFile *> PDBInputFile::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
diff --git a/lld/COFF/MarkLive.cpp b/lld/COFF/MarkLive.cpp
--- a/lld/COFF/MarkLive.cpp
+++ b/lld/COFF/MarkLive.cpp
@@ -15,7 +15,7 @@
 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
diff --git a/lld/COFF/PDB.h b/lld/COFF/PDB.h
--- a/lld/COFF/PDB.h
+++ b/lld/COFF/PDB.h
@@ -35,8 +35,8 @@
 llvm::Optional<std::pair<llvm::StringRef, uint32_t>>
 getFileLineCodeView(const SectionChunk *c, uint32_t addr);
 
-extern Timer loadGHashTimer;
-extern Timer mergeGHashTimer;
+extern LLVM_THREAD_LOCAL Timer loadGHashTimer;
+extern LLVM_THREAD_LOCAL Timer mergeGHashTimer;
 
 } // namespace coff
 } // namespace lld
diff --git a/lld/COFF/PDB.cpp b/lld/COFF/PDB.cpp
--- a/lld/COFF/PDB.cpp
+++ b/lld/COFF/PDB.cpp
@@ -66,15 +66,24 @@
 
 static ExitOnError exitOnErr;
 
-static Timer totalPdbLinkTimer("PDB Emission (Cumulative)", Timer::root());
-static Timer addObjectsTimer("Add Objects", totalPdbLinkTimer);
-Timer lld::coff::loadGHashTimer("Global Type Hashing", addObjectsTimer);
-Timer lld::coff::mergeGHashTimer("GHash Type Merging", addObjectsTimer);
-static Timer typeMergingTimer("Type Merging", addObjectsTimer);
-static Timer symbolMergingTimer("Symbol Merging", addObjectsTimer);
-static Timer publicsLayoutTimer("Publics Stream Layout", totalPdbLinkTimer);
-static Timer tpiStreamLayoutTimer("TPI Stream Layout", totalPdbLinkTimer);
-static Timer diskCommitTimer("Commit to Disk", totalPdbLinkTimer);
+static LLVM_THREAD_LOCAL Timer totalPdbLinkTimer("PDB Emission (Cumulative)",
+                                                 Timer::root());
+static LLVM_THREAD_LOCAL Timer addObjectsTimer("Add Objects",
+                                               totalPdbLinkTimer);
+LLVM_THREAD_LOCAL Timer lld::coff::loadGHashTimer("Global Type Hashing",
+                                                  addObjectsTimer);
+LLVM_THREAD_LOCAL Timer lld::coff::mergeGHashTimer("GHash Type Merging",
+                                                   addObjectsTimer);
+static LLVM_THREAD_LOCAL Timer typeMergingTimer("Type Merging",
+                                                addObjectsTimer);
+static LLVM_THREAD_LOCAL Timer symbolMergingTimer("Symbol Merging",
+                                                  addObjectsTimer);
+static LLVM_THREAD_LOCAL Timer publicsLayoutTimer("Publics 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;
diff --git a/lld/COFF/SymbolTable.h b/lld/COFF/SymbolTable.h
--- a/lld/COFF/SymbolTable.h
+++ b/lld/COFF/SymbolTable.h
@@ -130,7 +130,7 @@
   std::unique_ptr<BitcodeCompiler> lto;
 };
 
-extern SymbolTable *symtab;
+extern LLVM_THREAD_LOCAL SymbolTable *symtab;
 
 std::vector<std::string> getSymbolLocations(ObjFile *file, uint32_t symIndex);
 
diff --git a/lld/COFF/SymbolTable.cpp b/lld/COFF/SymbolTable.cpp
--- a/lld/COFF/SymbolTable.cpp
+++ b/lld/COFF/SymbolTable.cpp
@@ -28,9 +28,9 @@
 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));
diff --git a/lld/COFF/Symbols.h b/lld/COFF/Symbols.h
--- a/lld/COFF/Symbols.h
+++ b/lld/COFF/Symbols.h
@@ -257,7 +257,7 @@
   // 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;
diff --git a/lld/COFF/Symbols.cpp b/lld/COFF/Symbols.cpp
--- a/lld/COFF/Symbols.cpp
+++ b/lld/COFF/Symbols.cpp
@@ -100,7 +100,7 @@
   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)
diff --git a/lld/COFF/Writer.cpp b/lld/COFF/Writer.cpp
--- a/lld/COFF/Writer.cpp
+++ b/lld/COFF/Writer.cpp
@@ -82,7 +82,7 @@
 
 // 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];
@@ -307,8 +307,9 @@
 };
 } // anonymous namespace
 
-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 lld::coff::writeResult() { Writer().run(); }
 
diff --git a/lld/Common/Memory.cpp b/lld/Common/Memory.cpp
--- a/lld/Common/Memory.cpp
+++ b/lld/Common/Memory.cpp
@@ -11,9 +11,10 @@
 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)
diff --git a/lld/Common/Timer.cpp b/lld/Common/Timer.cpp
--- a/lld/Common/Timer.cpp
+++ b/lld/Common/Timer.cpp
@@ -32,7 +32,7 @@
 }
 
 Timer &Timer::root() {
-  static Timer rootTimer("Total Link Time");
+  static LLVM_THREAD_LOCAL Timer rootTimer("Total Link Time");
   return rootTimer;
 }
 
diff --git a/lld/include/lld/Common/Memory.h b/lld/include/lld/Common/Memory.h
--- a/lld/include/lld/Common/Memory.h
+++ b/lld/include/lld/Common/Memory.h
@@ -28,8 +28,8 @@
 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();
 
@@ -39,7 +39,7 @@
   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 {
diff --git a/llvm/include/llvm/ADT/iterator_range.h b/llvm/include/llvm/ADT/iterator_range.h
--- a/llvm/include/llvm/ADT/iterator_range.h
+++ b/llvm/include/llvm/ADT/iterator_range.h
@@ -18,6 +18,7 @@
 #ifndef LLVM_ADT_ITERATOR_RANGE_H
 #define LLVM_ADT_ITERATOR_RANGE_H
 
+#include <llvm/ADT/Optional.h>
 #include <utility>
 
 namespace llvm {
@@ -29,6 +30,8 @@
 template <typename IteratorT>
 class iterator_range {
   IteratorT begin_iterator, end_iterator;
+  size_t Length{};
+  bool LengthSet{false};
 
 public:
   //TODO: Add SFINAE to test that the Container's iterators match the range's
@@ -37,27 +40,45 @@
   iterator_range(Container &&c)
   //TODO: Consider ADL/non-member begin/end calls.
       : begin_iterator(c.begin()), end_iterator(c.end()) {}
-  iterator_range(IteratorT begin_iterator, IteratorT end_iterator)
+  iterator_range(IteratorT begin_iterator, IteratorT end_iterator,
+                 Optional<size_t> RangeLength = None)
       : begin_iterator(std::move(begin_iterator)),
-        end_iterator(std::move(end_iterator)) {}
+        end_iterator(std::move(end_iterator)) {
+    if (RangeLength) {
+      Length = *RangeLength;
+      LengthSet = true;
+    }
+  }
 
   IteratorT begin() const { return begin_iterator; }
   IteratorT end() const { return end_iterator; }
-  bool empty() const { return begin_iterator == end_iterator; }
+  size_t size() const {
+    assert(LengthSet && "Range length not set for this iterator! Use iteration "
+                        "instead to determine the size!");
+    return Length;
+  }
+  bool empty() const {
+    if (LengthSet)
+      return !Length;
+    return begin_iterator == end_iterator;
+  }
 };
 
 /// Convenience function for iterating over sub-ranges.
 ///
 /// This provides a bit of syntactic sugar to make using sub-ranges
 /// in for loops a bit easier. Analogous to std::make_pair().
-template <class T> iterator_range<T> make_range(T x, T y) {
-  return iterator_range<T>(std::move(x), std::move(y));
+template <class T>
+iterator_range<T> make_range(T x, T y, Optional<size_t> RangeLength = None) {
+  return iterator_range<T>(std::move(x), std::move(y), RangeLength);
 }
 
-template <typename T> iterator_range<T> make_range(std::pair<T, T> p) {
-  return iterator_range<T>(std::move(p.first), std::move(p.second));
+template <typename T>
+iterator_range<T> make_range(std::pair<T, T> p,
+                             Optional<size_t> RangeLength = None) {
+  return iterator_range<T>(std::move(p.first), std::move(p.second),
+                           RangeLength);
 }
-
 }
 
 #endif
diff --git a/llvm/include/llvm/Analysis/LoopAccessAnalysis.h b/llvm/include/llvm/Analysis/LoopAccessAnalysis.h
--- a/llvm/include/llvm/Analysis/LoopAccessAnalysis.h
+++ b/llvm/include/llvm/Analysis/LoopAccessAnalysis.h
@@ -39,15 +39,15 @@
   static const unsigned MaxVectorWidth;
 
   /// VF as overridden by the user.
-  static unsigned VectorizationFactor;
+  static LLVM_THREAD_LOCAL unsigned VectorizationFactor;
   /// Interleave factor as overridden by the user.
-  static unsigned VectorizationInterleave;
+  static LLVM_THREAD_LOCAL unsigned VectorizationInterleave;
   /// True if force-vector-interleave was specified by the user.
   static bool isInterleaveForced();
 
   /// \When performing memory disambiguation checks at runtime do not
   /// make more than this number of comparisons.
-  static unsigned RuntimeMemoryCheckThreshold;
+  static LLVM_THREAD_LOCAL unsigned RuntimeMemoryCheckThreshold;
 };
 
 /// Checks memory dependences among accesses to the same underlying
diff --git a/llvm/include/llvm/Analysis/ObjCARCAnalysisUtils.h b/llvm/include/llvm/Analysis/ObjCARCAnalysisUtils.h
--- a/llvm/include/llvm/Analysis/ObjCARCAnalysisUtils.h
+++ b/llvm/include/llvm/Analysis/ObjCARCAnalysisUtils.h
@@ -36,7 +36,7 @@
 namespace objcarc {
 
 /// A handy option to enable/disable all ARC Optimizations.
-extern bool EnableARCOpts;
+extern LLVM_THREAD_LOCAL bool EnableARCOpts;
 
 /// Test if the given module looks interesting to run ARC optimization
 /// on.
diff --git a/llvm/include/llvm/Analysis/RegionInfo.h b/llvm/include/llvm/Analysis/RegionInfo.h
--- a/llvm/include/llvm/Analysis/RegionInfo.h
+++ b/llvm/include/llvm/Analysis/RegionInfo.h
@@ -799,8 +799,8 @@
   RegionInfoBase(const RegionInfoBase &) = delete;
   RegionInfoBase &operator=(const RegionInfoBase &) = delete;
 
-  static bool VerifyRegionInfo;
-  static typename RegionT::PrintStyle printStyle;
+  static LLVM_THREAD_LOCAL bool VerifyRegionInfo;
+  static LLVM_THREAD_LOCAL typename RegionT::PrintStyle printStyle;
 
   void print(raw_ostream &OS) const;
 #if !defined(NDEBUG) || defined(LLVM_ENABLE_DUMP)
diff --git a/llvm/include/llvm/Analysis/RegionInfoImpl.h b/llvm/include/llvm/Analysis/RegionInfoImpl.h
--- a/llvm/include/llvm/Analysis/RegionInfoImpl.h
+++ b/llvm/include/llvm/Analysis/RegionInfoImpl.h
@@ -770,15 +770,16 @@
 
 #ifdef EXPENSIVE_CHECKS
 template <class Tr>
-bool RegionInfoBase<Tr>::VerifyRegionInfo = true;
+LLVM_THREAD_LOCAL bool RegionInfoBase<Tr>::VerifyRegionInfo = true;
 #else
 template <class Tr>
-bool RegionInfoBase<Tr>::VerifyRegionInfo = false;
+LLVM_THREAD_LOCAL bool RegionInfoBase<Tr>::VerifyRegionInfo = false;
 #endif
 
 template <class Tr>
-typename Tr::RegionT::PrintStyle RegionInfoBase<Tr>::printStyle =
-    RegionBase<Tr>::PrintNone;
+LLVM_THREAD_LOCAL
+    typename Tr::RegionT::PrintStyle RegionInfoBase<Tr>::printStyle =
+        RegionBase<Tr>::PrintNone;
 
 template <class Tr>
 void RegionInfoBase<Tr>::print(raw_ostream &OS) const {
diff --git a/llvm/include/llvm/BinaryFormat/Magic.h b/llvm/include/llvm/BinaryFormat/Magic.h
--- a/llvm/include/llvm/BinaryFormat/Magic.h
+++ b/llvm/include/llvm/BinaryFormat/Magic.h
@@ -50,6 +50,7 @@
     wasm_object,         ///< WebAssembly Object file
     pdb,                 ///< Windows PDB debug info file
     tapi_file,           ///< Text-based Dynamic Library Stub file
+    clang_pch,           ///< Clang PCH precompiled headers file
   };
 
   bool is_object() const { return V != unknown; }
diff --git a/llvm/include/llvm/Pass.h b/llvm/include/llvm/Pass.h
--- a/llvm/include/llvm/Pass.h
+++ b/llvm/include/llvm/Pass.h
@@ -28,6 +28,7 @@
 #ifndef LLVM_PASS_H
 #define LLVM_PASS_H
 
+#include "llvm/Support/Compiler.h"
 #include <string>
 
 namespace llvm {
@@ -322,13 +323,13 @@
 /// If the user specifies the -time-passes argument on an LLVM tool command line
 /// then the value of this boolean will be true, otherwise false.
 /// This is the storage for the -time-passes option.
-extern bool TimePassesIsEnabled;
+extern LLVM_THREAD_LOCAL bool TimePassesIsEnabled;
 /// If TimePassesPerRun is true, there would be one line of report for
 /// each pass invocation.
 /// If TimePassesPerRun is false, there would be only one line of
 /// report for each pass (even there are more than one pass objects).
 /// (For new pass manager only)
-extern bool TimePassesPerRun;
+extern LLVM_THREAD_LOCAL bool TimePassesPerRun;
 
 } // end namespace llvm
 
diff --git a/llvm/include/llvm/Support/CLData.h b/llvm/include/llvm/Support/CLData.h
new file mode 100644
--- /dev/null
+++ b/llvm/include/llvm/Support/CLData.h
@@ -0,0 +1,47 @@
+//===- llvm/Support/CLData.h - Command line data storage --------*- C++ -*-===//
+//
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
+//
+//===----------------------------------------------------------------------===//
+//
+// This is simply a wrapper over a data type, which allows the user to switch,
+// in certain cases, from global state to thread-local state.
+//
+//===----------------------------------------------------------------------===//
+
+#ifndef LLVM_SUPPORT_CLDATA_H
+#define LLVM_SUPPORT_CLDATA_H
+
+namespace llvm {
+
+/// cl Namespace - This namespace contains all of the command line option
+/// processing machinery.  It is intentionally a short name to make qualified
+/// usage concise.
+namespace cl {
+
+//===----------------------------------------------------------------------===//
+// data - A simple data wrapper to be used along with cl::location
+//
+template <class DataType> class data {
+public:
+  data() = default;
+  data(const DataType &D) { Val = D; }
+  template <class... Mods>
+  explicit data(Mods &&... Ms) : Val(std::forward<Mods>(Ms)...) {}
+  operator DataType() { return Val; }
+  data &operator=(const DataType &D) {
+    Val = D;
+    return *this;
+  }
+  DataType &operator*() { return Val; }
+  DataType *operator->() { return &Val; }
+  DataType Val;
+};
+
+} // end namespace cl
+
+} // end namespace llvm
+
+#endif // LLVM_SUPPORT_COMMANDLINE_H
diff --git a/llvm/include/llvm/Support/CommandLine.h b/llvm/include/llvm/Support/CommandLine.h
--- a/llvm/include/llvm/Support/CommandLine.h
+++ b/llvm/include/llvm/Support/CommandLine.h
@@ -20,6 +20,7 @@
 #define LLVM_SUPPORT_COMMANDLINE_H
 
 #include "llvm/ADT/ArrayRef.h"
+#include "llvm/ADT/DenseMap.h"
 #include "llvm/ADT/None.h"
 #include "llvm/ADT/Optional.h"
 #include "llvm/ADT/STLExtras.h"
@@ -31,6 +32,7 @@
 #include "llvm/ADT/iterator_range.h"
 #include "llvm/Support/ErrorHandling.h"
 #include "llvm/Support/ManagedStatic.h"
+#include "llvm/Support/Process.h"
 #include "llvm/Support/raw_ostream.h"
 #include <cassert>
 #include <climits>
@@ -238,10 +240,10 @@
 };
 
 // A special subcommand representing no subcommand
-extern ManagedStatic<SubCommand> TopLevelSubCommand;
+// extern ManagedStatic<SubCommand> TopLevelSubCommand;
 
 // A special subcommand that can be used to put an option into all subcommands.
-extern ManagedStatic<SubCommand> AllSubCommands;
+// extern ManagedStatic<SubCommand> AllSubCommands;
 
 //===----------------------------------------------------------------------===//
 // Option Base class
@@ -315,11 +317,7 @@
     return getNumOccurrencesFlag() == cl::ConsumeAfter;
   }
 
-  bool isInAllSubCommands() const {
-    return any_of(Subs, [](const SubCommand *SC) {
-      return SC == &*AllSubCommands;
-    });
-  }
+  bool isInAllSubCommands() const;
 
   //-------------------------------------------------------------------------===
   // Accessor functions set by OptionModifiers
@@ -403,6 +401,10 @@
 
   inline int getNumOccurrences() const { return NumOccurrences; }
   void reset();
+
+  virtual unsigned getSize() const = 0;
+  virtual void duplicateInto(Option *O) = 0;
+  virtual void postRemap(DenseMap<Option *, Option *> &RemapOpt) {}
 };
 
 //===----------------------------------------------------------------------===//
@@ -453,14 +455,17 @@
 
   LocationClass(Ty &L) : Loc(L) {}
 
-  template <class Opt> void apply(Opt &O) const { O.setLocation(O, Loc); }
+  template <class Opt> void apply(Opt &O) const {
+    size_t TLsOffset = sys::Process::GetOffsetInTLS(&Loc);
+    O.setLocation(O, Loc, TLsOffset);
+  }
 };
 
 template <class Ty> LocationClass<Ty> location(Ty &L) {
   return LocationClass<Ty>(L);
 }
 
-// cat - Specifiy the Option category for the command line argument to belong
+// cat - Specify the Option category for the command line argument to belong
 // to.
 struct cat {
   OptionCategory &Category;
@@ -515,6 +520,14 @@
   return cb<result_type, arg_type>(CB);
 }
 
+struct allSub : public sub {
+  allSub();
+};
+
+struct topLevel : public sub {
+  topLevel();
+};
+
 //===----------------------------------------------------------------------===//
 // OptionValue class
 
@@ -1325,6 +1338,7 @@
 class opt_storage {
   DataType *Location = nullptr; // Where to store the object...
   OptionValue<DataType> Default;
+  unsigned TLSOffset{};
 
   void check_location() const {
     assert(Location && "cl::location(...) not specified for a command "
@@ -1332,14 +1346,20 @@
                        "or cl::init specified before cl::location()!!");
   }
 
+protected:
+  void remapLocationToTLS() {
+    Location = (DataType *)sys::Process::RemapIntoTLS(Location, TLSOffset);
+  }
+
 public:
   opt_storage() = default;
 
-  bool setLocation(Option &O, DataType &L) {
+  bool setLocation(Option &O, DataType &L, size_t Off) {
     if (Location)
       return O.error("cl::location(x) specified more than once!");
     Location = &L;
     Default = L;
+    TLSOffset = Off;
     return false;
   }
 
@@ -1383,6 +1403,9 @@
   const DataType &getValue() const { return *this; }
 
   const OptionValue<DataType> &getDefault() const { return Default; }
+
+protected:
+  void remapLocationToTLS() {}
 };
 
 // Define a partial specialization to handle things we cannot inherit from.  In
@@ -1412,6 +1435,9 @@
 
   // If the datatype is a pointer, support -> on it.
   DataType operator->() const { return Value; }
+
+protected:
+  void remapLocationToTLS() {}
 };
 
 //===----------------------------------------------------------------------===//
@@ -1424,6 +1450,15 @@
                                std::is_class<DataType>::value> {
   ParserClass Parser;
 
+  unsigned getSize() const override { return sizeof(*this); }
+
+  void duplicateInto(Option *O) override {
+    new ((void *)O) opt<DataType, ExternalStorage, ParserClass>(*this);
+
+    if (ExternalStorage)
+      ((opt<DataType, ExternalStorage, ParserClass> *)O)->remapLocationToTLS();
+  }
+
   bool handleOccurrence(unsigned pos, StringRef ArgName,
                         StringRef Arg) override {
     typename ParserClass::parser_data_type Val =
@@ -1481,8 +1516,8 @@
 
 public:
   // Command line options should not be copyable
-  opt(const opt &) = delete;
-  opt &operator=(const opt &) = delete;
+  // opt(const opt &) = delete;
+  // opt &operator=(const opt &) = delete;
 
   // setInitialValue - Used by the cl::init modifier...
   void setInitialValue(const DataType &V) { this->setValue(V, true); }
@@ -1527,12 +1562,15 @@
 template <class DataType, class StorageClass> class list_storage {
   StorageClass *Location = nullptr; // Where to store the object...
 
+protected:
+  void remapLocationToTLS() {}
+
 public:
   list_storage() = default;
 
   void clear() {}
 
-  bool setLocation(Option &O, StorageClass &L) {
+  bool setLocation(Option &O, StorageClass &L, size_t Off) {
     if (Location)
       return O.error("cl::location(x) specified more than once!");
     Location = &L;
@@ -1544,6 +1582,11 @@
                             "line option with external storage!");
     Location->push_back(V);
   }
+
+  using iterator = typename StorageClass::iterator;
+
+  iterator begin() const { return Location->begin(); }
+  iterator end() const { return Location->end(); }
 };
 
 // Define how to hold a class type object, such as a string.
@@ -1557,6 +1600,9 @@
 template <class DataType> class list_storage<DataType, bool> {
   std::vector<DataType> Storage;
 
+protected:
+  void remapLocationToTLS() {}
+
 public:
   using iterator = typename std::vector<DataType>::iterator;
 
@@ -1614,6 +1660,8 @@
   reference front() { return Storage.front(); }
   const_reference front() const { return Storage.front(); }
 
+  const DataType *data() const { return Storage.data(); }
+
   operator std::vector<DataType> &() { return Storage; }
   operator ArrayRef<DataType>() const { return Storage; }
   std::vector<DataType> *operator&() { return &Storage; }
@@ -1631,6 +1679,19 @@
   std::vector<unsigned> Positions;
   ParserClass Parser;
 
+  unsigned getSize() const override { return sizeof(*this); }
+
+  void duplicateInto(Option *O) override {
+    new ((void *)O) list<DataType, StorageClass, ParserClass>(*this);
+
+    if (!std::is_base_of<StorageClass, bool>::value) {
+      ((list<DataType, StorageClass, ParserClass> *)O)->remapLocationToTLS();
+      /*for (const DataType &D : *this) {
+        llvm::sys::Process::RemapIntoTLS((void**)&D);
+      }*/
+    }
+  }
+
   enum ValueExpected getValueExpectedFlagDefault() const override {
     return Parser.getValueExpectedFlagDefault();
   }
@@ -1677,8 +1738,8 @@
 
 public:
   // Command line options should not be copyable
-  list(const list &) = delete;
-  list &operator=(const list &) = delete;
+  // list(const list &) = delete;
+  // list &operator=(const list &) = delete;
 
   ParserClass &getParser() { return Parser; }
 
@@ -1725,6 +1786,7 @@
 //
 template <class DataType, class StorageClass> class bits_storage {
   unsigned *Location = nullptr; // Where to store the bits...
+  size_t TLSOffset{};
 
   template <class T> static unsigned Bit(const T &V) {
     unsigned BitPos = reinterpret_cast<unsigned>(V);
@@ -1736,10 +1798,11 @@
 public:
   bits_storage() = default;
 
-  bool setLocation(Option &O, unsigned &L) {
+  bool setLocation(Option &O, unsigned &L, size_t Off) {
     if (Location)
       return O.error("cl::location(x) specified more than once!");
     Location = &L;
+    TLSOffset = Off;
     return false;
   }
 
@@ -1749,7 +1812,9 @@
     *Location |= Bit(V);
   }
 
-  unsigned getBits() { return *Location; }
+  unsigned getBits() const { return *Location; }
+
+  unsigned *getBitsPtr() const { return Location; }
 
   template <class T> bool isSet(const T &V) {
     return (*Location & Bit(V)) != 0;
@@ -1772,7 +1837,9 @@
 public:
   template <class T> void addValue(const T &V) { Bits |= Bit(V); }
 
-  unsigned getBits() { return Bits; }
+  unsigned getBits() const { return Bits; }
+
+  unsigned *getBitsPtr() const { return &Bits; }
 
   template <class T> bool isSet(const T &V) { return (Bits & Bit(V)) != 0; }
 };
@@ -1786,6 +1853,12 @@
   std::vector<unsigned> Positions;
   ParserClass Parser;
 
+  unsigned getSize() const override { return sizeof(*this); }
+
+  void duplicateInto(Option *O) override {
+    new ((void *)O) bits<DataType, Storage, ParserClass>(*this);
+  }
+
   enum ValueExpected getValueExpectedFlagDefault() const override {
     return Parser.getValueExpectedFlagDefault();
   }
@@ -1829,8 +1902,8 @@
 
 public:
   // Command line options should not be copyable
-  bits(const bits &) = delete;
-  bits &operator=(const bits &) = delete;
+  // bits(const bits &) = delete;
+  // bits &operator=(const bits &) = delete;
 
   ParserClass &getParser() { return Parser; }
 
@@ -1862,6 +1935,14 @@
 class alias : public Option {
   Option *AliasFor;
 
+  unsigned getSize() const override { return sizeof(*this); }
+
+  void duplicateInto(Option *O) override { new ((void *)O) alias(*this); }
+
+  void postRemap(DenseMap<Option *, Option *> &RemapOpt) override {
+    AliasFor = RemapOpt[AliasFor];
+  }
+
   bool handleOccurrence(unsigned pos, StringRef /*ArgName*/,
                         StringRef Arg) override {
     return AliasFor->handleOccurrence(pos, AliasFor->ArgStr, Arg);
@@ -1900,8 +1981,8 @@
 
 public:
   // Command line options should not be copyable
-  alias(const alias &) = delete;
-  alias &operator=(const alias &) = delete;
+  // alias(const alias &) = delete;
+  // alias &operator=(const alias &) = delete;
 
   void setAliasFor(Option &O) {
     if (AliasFor)
@@ -1976,7 +2057,7 @@
 /// Hopefully this API can be deprecated soon. Any situation where options need
 /// to be modified by tools or libraries should be handled by sane APIs rather
 /// than just handing around a global list.
-StringMap<Option *> &getRegisteredOptions(SubCommand &Sub = *TopLevelSubCommand);
+StringMap<Option *> &getRegisteredOptions();
 
 /// Use this to get all registered SubCommands from the provided parser.
 ///
@@ -2000,6 +2081,8 @@
 iterator_range<typename SmallPtrSet<SubCommand *, 4>::iterator>
 getRegisteredSubcommands();
 
+bool isTopLevel(SubCommand *SC);
+
 //===----------------------------------------------------------------------===//
 // Standalone command line processing utilities.
 //
@@ -2123,8 +2206,7 @@
 /// Some tools (like clang-format) like to be able to hide all options that are
 /// not specific to the tool. This function allows a tool to specify a single
 /// option category to display in the -help output.
-void HideUnrelatedOptions(cl::OptionCategory &Category,
-                          SubCommand &Sub = *TopLevelSubCommand);
+void HideUnrelatedOptions(cl::OptionCategory &Category);
 
 /// Mark all options not part of the categories as cl::ReallyHidden.
 ///
@@ -2133,8 +2215,7 @@
 /// Some tools (like clang-format) like to be able to hide all options that are
 /// not specific to the tool. This function allows a tool to specify a single
 /// option category to display in the -help output.
-void HideUnrelatedOptions(ArrayRef<const cl::OptionCategory *> Categories,
-                          SubCommand &Sub = *TopLevelSubCommand);
+void HideUnrelatedOptions(ArrayRef<const cl::OptionCategory *> Categories);
 
 /// Reset all command line options to a state that looks as if they have
 /// never appeared on the command line.  This is useful for being able to parse
diff --git a/llvm/include/llvm/Support/Debug.h b/llvm/include/llvm/Support/Debug.h
--- a/llvm/include/llvm/Support/Debug.h
+++ b/llvm/include/llvm/Support/Debug.h
@@ -28,6 +28,8 @@
 #ifndef LLVM_SUPPORT_DEBUG_H
 #define LLVM_SUPPORT_DEBUG_H
 
+#include "llvm/Support/Compiler.h"
+
 namespace llvm {
 
 class raw_ostream;
@@ -76,7 +78,7 @@
 /// is specified.  This should probably not be referenced directly, instead, use
 /// the DEBUG macro below.
 ///
-extern bool DebugFlag;
+extern LLVM_THREAD_LOCAL bool DebugFlag;
 
 /// \name Verification flags.
 ///
@@ -87,15 +89,15 @@
 
 /// Enables verification of dominator trees.
 ///
-extern bool VerifyDomInfo;
+extern LLVM_THREAD_LOCAL bool VerifyDomInfo;
 
 /// Enables verification of loop info.
 ///
-extern bool VerifyLoopInfo;
+extern LLVM_THREAD_LOCAL bool VerifyLoopInfo;
 
 /// Enables verification of MemorySSA.
 ///
-extern bool VerifyMemorySSA;
+extern LLVM_THREAD_LOCAL bool VerifyMemorySSA;
 
 ///\}
 
diff --git a/llvm/include/llvm/Support/DebugCounter.h b/llvm/include/llvm/Support/DebugCounter.h
--- a/llvm/include/llvm/Support/DebugCounter.h
+++ b/llvm/include/llvm/Support/DebugCounter.h
@@ -60,9 +60,6 @@
   /// Returns a reference to the singleton instance.
   static DebugCounter &instance();
 
-  // Used by the command line option parser to push a new value it parsed.
-  void push_back(const std::string &);
-
   // Register a counter with the specified name.
   //
   // FIXME: Currently, counter registration is required to happen before command
@@ -137,10 +134,7 @@
 
   // Iterate through the registered counters
   typedef UniqueVector<std::string> CounterVector;
-  CounterVector::const_iterator begin() const {
-    return RegisteredCounters.begin();
-  }
-  CounterVector::const_iterator end() const { return RegisteredCounters.end(); }
+  const CounterVector &getCounterVector() const { return RegisteredCounters; }
 
   // Force-enables counting all DebugCounters.
   //
@@ -179,6 +173,28 @@
   // Whether we should do DebugCounting at all. DebugCounters aren't
   // thread-safe, so this should always be false in multithreaded scenarios.
   bool Enabled = false;
+
+public:
+  // Used by the command line option parser to push a new value it parsed.
+  void push_back(const std::string &);
+
+  struct iterator {
+    DebugCounter *This;
+    DenseMap<unsigned, CounterInfo>::iterator It;
+
+    bool operator!=(const iterator &RHS) const { return It != RHS.It; }
+
+    iterator &operator++() /*preincrement*/ {
+      ++It;
+      return *this;
+    }
+
+    const std::string &operator*() const {
+      return This->RegisteredCounters[It->first];
+    }
+  };
+  iterator begin() { return {this, Counters.begin()}; }
+  iterator end() { return {this, Counters.end()}; }
 };
 
 #define DEBUG_COUNTER(VARNAME, COUNTERNAME, DESC)                              \
diff --git a/llvm/include/llvm/Support/Error.h b/llvm/include/llvm/Support/Error.h
--- a/llvm/include/llvm/Support/Error.h
+++ b/llvm/include/llvm/Support/Error.h
@@ -1336,13 +1336,7 @@
   }
 
 private:
-  void checkError(Error Err) const {
-    if (Err) {
-      int ExitCode = GetExitCode(Err);
-      logAllUnhandledErrors(std::move(Err), errs(), Banner);
-      exit(ExitCode);
-    }
-  }
+  void checkError(Error Err) const;
 
   std::string Banner;
   std::function<int(const Error &)> GetExitCode;
diff --git a/llvm/include/llvm/Support/InitLLVM.h b/llvm/include/llvm/Support/InitLLVM.h
--- a/llvm/include/llvm/Support/InitLLVM.h
+++ b/llvm/include/llvm/Support/InitLLVM.h
@@ -42,6 +42,17 @@
 
   ~InitLLVM();
 
+  // This is necessary to properly initialize the CRT for Clang/LLVM EXE loaded
+  // as DLLs inside Buildozer.
+  static void InitFromBuildozer(void *InitEvent, void *ExitEvent);
+
+  static void SetCurrentModuleBackdoor(void *ModuleHandle);
+
+  // Don't register crash handlers, it is assumed someone else does it.
+  static void SkipInitLLVM();
+
+  static bool RunningInBuildozer();
+
 private:
   BumpPtrAllocator Alloc;
   SmallVector<const char *, 0> Args;
diff --git a/llvm/include/llvm/Support/Process.h b/llvm/include/llvm/Support/Process.h
--- a/llvm/include/llvm/Support/Process.h
+++ b/llvm/include/llvm/Support/Process.h
@@ -220,6 +220,13 @@
 private:
   LLVM_ATTRIBUTE_NORETURN
   static void ExitNoCleanup(int RetCode);
+
+public:
+  static bool IsInTLS(const void *Data);
+
+  static unsigned GetOffsetInTLS(const void *Data);
+
+  static void *RemapIntoTLS(void *Data, unsigned TLSOffset);
 };
 
 }
diff --git a/llvm/include/llvm/Support/TargetRegistry.h b/llvm/include/llvm/Support/TargetRegistry.h
--- a/llvm/include/llvm/Support/TargetRegistry.h
+++ b/llvm/include/llvm/Support/TargetRegistry.h
@@ -701,8 +701,8 @@
   /// by architecture is done.
   /// \param Error - On failure, an error string describing why no target was
   /// found.
-  static const Target *lookupTarget(const std::string &ArchName,
-                                    Triple &TheTriple, std::string &Error);
+  static const Target *lookupTarget(StringRef ArchName, Triple &TheTriple,
+                                    std::string &Error);
 
   /// @}
   /// @name Target Registration
diff --git a/llvm/include/llvm/Support/circular_raw_ostream.h b/llvm/include/llvm/Support/circular_raw_ostream.h
--- a/llvm/include/llvm/Support/circular_raw_ostream.h
+++ b/llvm/include/llvm/Support/circular_raw_ostream.h
@@ -106,9 +106,9 @@
     ///
     circular_raw_ostream(raw_ostream &Stream, const char *Header,
                          size_t BuffSize = 0, bool Owns = REFERENCE_ONLY)
-        : raw_ostream(/*unbuffered*/ true), TheStream(nullptr),
-          OwnsStream(Owns), BufferSize(BuffSize), BufferArray(nullptr),
-          Filled(false), Banner(Header) {
+        : raw_ostream(/*unbuffered*/ true, OStreamKind::OK_CircularStream),
+          TheStream(nullptr), OwnsStream(Owns), BufferSize(BuffSize),
+          BufferArray(nullptr), Filled(false), Banner(Header) {
       if (BufferSize != 0)
         BufferArray = new char[BufferSize];
       Cur = BufferArray;
@@ -122,6 +122,10 @@
       delete[] BufferArray;
     }
 
+    static bool classof(const raw_ostream *s) {
+      return s->get_kind() == OStreamKind::OK_CircularStream;
+    }
+
     bool is_displayed() const override {
       return TheStream->is_displayed();
     }
diff --git a/llvm/include/llvm/Support/raw_os_ostream.h b/llvm/include/llvm/Support/raw_os_ostream.h
--- a/llvm/include/llvm/Support/raw_os_ostream.h
+++ b/llvm/include/llvm/Support/raw_os_ostream.h
@@ -32,8 +32,13 @@
   uint64_t current_pos() const override;
 
 public:
-  raw_os_ostream(std::ostream &O) : OS(O) {}
+  raw_os_ostream(std::ostream &O)
+      : raw_ostream(false, OStreamKind::OK_OSOStream), OS(O) {}
   ~raw_os_ostream() override;
+
+  static bool classof(const raw_ostream *s) {
+    return s->get_kind() == OStreamKind::OK_OSOStream;
+  }
 };
 
 } // end llvm namespace
diff --git a/llvm/include/llvm/Support/raw_ostream.h b/llvm/include/llvm/Support/raw_ostream.h
--- a/llvm/include/llvm/Support/raw_ostream.h
+++ b/llvm/include/llvm/Support/raw_ostream.h
@@ -53,6 +53,14 @@
   enum class OStreamKind {
     OK_OStream,
     OK_FDStream,
+    OK_PWriteStream,
+    OK_FDOStream,
+    OK_StrStream,
+    OK_SVecStream,
+    OK_NullStream,
+    OK_OSOStream,
+    OK_SHA1OStream,
+    OK_CircularStream
   };
 
 private:
@@ -325,6 +333,16 @@
   /// stream. Specifying a nullptr unties the stream.
   void tie(raw_ostream *TieTo) { TiedStream = TieTo; }
 
+  virtual void close() {}
+
+  virtual bool has_error() const { return false; }
+
+  virtual void clear_error() {}
+
+  virtual bool supportsSeeking() const { return false; }
+
+  virtual std::error_code error() const { return std::error_code(); }
+
   //===--------------------------------------------------------------------===//
   // Subclass Interface
   //===--------------------------------------------------------------------===//
@@ -409,7 +427,7 @@
 
 public:
   explicit raw_pwrite_stream(bool Unbuffered = false,
-                             OStreamKind K = OStreamKind::OK_OStream)
+                             OStreamKind K = OStreamKind::OK_PWriteStream)
       : raw_ostream(Unbuffered, K) {}
   void pwrite(const char *Ptr, size_t Size, uint64_t Offset) {
 #ifndef NDEBUG
@@ -421,6 +439,10 @@
 #endif
     pwrite_impl(Ptr, Size, Offset);
   }
+
+  static bool classof(const raw_ostream *s) {
+    return s->get_kind() == OStreamKind::OK_PWriteStream;
+  }
 };
 
 //===----------------------------------------------------------------------===//
@@ -493,15 +515,19 @@
   /// this closes the file when the stream is destroyed. If FD is for stdout or
   /// stderr, it will not be closed.
   raw_fd_ostream(int fd, bool shouldClose, bool unbuffered = false,
-                 OStreamKind K = OStreamKind::OK_OStream);
+                 OStreamKind K = OStreamKind::OK_FDOStream);
 
   ~raw_fd_ostream() override;
 
+  static bool classof(const raw_ostream *s) {
+    return s->get_kind() == OStreamKind::OK_FDOStream;
+  }
+
   /// Manually flush the stream and close the file. Note that this does not call
   /// fsync.
-  void close();
+  void close() override;
 
-  bool supportsSeeking() const { return SupportsSeeking; }
+  bool supportsSeeking() const override { return SupportsSeeking; }
 
   /// Flushes the stream and repositions the underlying file descriptor position
   /// to the offset specified from the beginning of the file.
@@ -511,13 +537,13 @@
 
   bool has_colors() const override;
 
-  std::error_code error() const { return EC; }
+  std::error_code error() const override { return EC; }
 
   /// Return the value of the flag in this raw_fd_ostream indicating whether an
   /// output error has been encountered.
   /// This doesn't implicitly flush any pending output.  Also, it doesn't
   /// guarantee to detect all errors unless the stream has been closed.
-  bool has_error() const { return bool(EC); }
+  bool has_error() const override { return bool(EC); }
 
   /// Set the flag read by has_error() to false. If the error flag is set at the
   /// time when this raw_ostream's destructor is called, report_fatal_error is
@@ -528,7 +554,7 @@
   ///    Unless explicitly silenced."
   ///      - from The Zen of Python, by Tim Peters
   ///
-  void clear_error() { EC = std::error_code(); }
+  void clear_error() override { EC = std::error_code(); }
 
   /// Locks the underlying file.
   ///
@@ -565,14 +591,14 @@
 
 /// This returns a reference to a raw_fd_ostream for standard output. Use it
 /// like: outs() << "foo" << "bar";
-raw_fd_ostream &outs();
+raw_ostream &outs();
 
 /// This returns a reference to a raw_ostream for standard error.
 /// Use it like: errs() << "foo" << "bar";
 /// By default, the stream is tied to stdout to ensure stdout is flushed before
 /// stderr is written, to ensure the error messages are written in their
 /// expected place.
-raw_fd_ostream &errs();
+raw_ostream &errs();
 
 /// This returns a reference to a raw_ostream which simply discards output.
 raw_ostream &nulls();
@@ -602,7 +628,9 @@
   ssize_t read(char *Ptr, size_t Size);
 
   /// Check if \p OS is a pointer of type raw_fd_stream*.
-  static bool classof(const raw_ostream *OS);
+  static bool classof(const raw_ostream *s) {
+    return s->get_kind() == OStreamKind::OK_FDStream;
+  }
 };
 
 //===----------------------------------------------------------------------===//
@@ -622,11 +650,16 @@
   uint64_t current_pos() const override { return OS.size(); }
 
 public:
-  explicit raw_string_ostream(std::string &O) : OS(O) {
+  explicit raw_string_ostream(std::string &O)
+      : raw_ostream(false, OStreamKind::OK_StrStream), OS(O) {
     SetUnbuffered();
   }
   ~raw_string_ostream() override;
 
+  static bool classof(const raw_ostream *s) {
+    return s->get_kind() == OStreamKind::OK_StrStream;
+  }
+
   /// Flushes the stream contents to the target string and returns  the string's
   /// reference.
   std::string& str() {
@@ -660,12 +693,17 @@
   ///
   /// \param O The vector to write to; this should generally have at least 128
   /// bytes free to avoid any extraneous memory overhead.
-  explicit raw_svector_ostream(SmallVectorImpl<char> &O) : OS(O) {
+  explicit raw_svector_ostream(SmallVectorImpl<char> &O)
+      : raw_pwrite_stream(false, OStreamKind::OK_SVecStream), OS(O) {
     SetUnbuffered();
   }
 
   ~raw_svector_ostream() override = default;
 
+  static bool classof(const raw_ostream *s) {
+    return s->get_kind() == OStreamKind::OK_SVecStream;
+  }
+
   void flush() = delete;
 
   /// Return a StringRef for the vector contents.
@@ -687,8 +725,13 @@
   uint64_t current_pos() const override;
 
 public:
-  explicit raw_null_ostream() = default;
+  explicit raw_null_ostream()
+      : raw_pwrite_stream(false, OStreamKind::OK_NullStream) {}
   ~raw_null_ostream() override;
+
+  static bool classof(const raw_ostream *s) {
+    return s->get_kind() == OStreamKind::OK_NullStream;
+  }
 };
 
 class buffer_ostream : public raw_svector_ostream {
diff --git a/llvm/include/llvm/Support/raw_sha1_ostream.h b/llvm/include/llvm/Support/raw_sha1_ostream.h
--- a/llvm/include/llvm/Support/raw_sha1_ostream.h
+++ b/llvm/include/llvm/Support/raw_sha1_ostream.h
@@ -29,6 +29,12 @@
   }
 
 public:
+  raw_sha1_ostream() : raw_ostream(false, OStreamKind::OK_SHA1OStream) {}
+
+  static bool classof(const raw_ostream *s) {
+    return s->get_kind() == OStreamKind::OK_SHA1OStream;
+  }
+
   /// Return the current SHA1 hash for the content of the stream
   StringRef sha1() {
     flush();
diff --git a/llvm/include/llvm/TableGen/TableGenBackend.h b/llvm/include/llvm/TableGen/TableGenBackend.h
--- a/llvm/include/llvm/TableGen/TableGenBackend.h
+++ b/llvm/include/llvm/TableGen/TableGenBackend.h
@@ -22,8 +22,6 @@
 /// raw_ostream.
 void emitSourceFileHeader(StringRef Desc, raw_ostream &OS);
 
-extern bool TimeRegions;
-
 } // End llvm namespace
 
 #endif
diff --git a/llvm/include/llvm/Transforms/IPO/Attributor.h b/llvm/include/llvm/Transforms/IPO/Attributor.h
--- a/llvm/include/llvm/Transforms/IPO/Attributor.h
+++ b/llvm/include/llvm/Transforms/IPO/Attributor.h
@@ -142,7 +142,7 @@
 
 /// The value passed to the line option that defines the maximal initialization
 /// chain length.
-extern unsigned MaxInitializationChainLength;
+extern LLVM_THREAD_LOCAL unsigned MaxInitializationChainLength;
 
 ///{
 enum class ChangeStatus {
@@ -3637,7 +3637,7 @@
 
   /// Maximum number of potential values to be tracked.
   /// This is set by -attributor-max-potential-values command line option
-  static unsigned MaxPotentialValues;
+  static LLVM_THREAD_LOCAL unsigned MaxPotentialValues;
 
   /// Return empty set as the best state of potential values.
   static PotentialValuesState getBestState() {
diff --git a/llvm/include/llvm/Transforms/Scalar/LoopIdiomRecognize.h b/llvm/include/llvm/Transforms/Scalar/LoopIdiomRecognize.h
--- a/llvm/include/llvm/Transforms/Scalar/LoopIdiomRecognize.h
+++ b/llvm/include/llvm/Transforms/Scalar/LoopIdiomRecognize.h
@@ -27,13 +27,13 @@
 /// passes.
 struct DisableLIRP {
   /// When true, the entire pass is disabled.
-  static bool All;
+  static LLVM_THREAD_LOCAL bool All;
 
   /// When true, Memset is disabled.
-  static bool Memset;
+  static LLVM_THREAD_LOCAL bool Memset;
 
   /// When true, Memcpy is disabled.
-  static bool Memcpy;
+  static LLVM_THREAD_LOCAL bool Memcpy;
 };
 
 /// Performs Loop Idiom Recognize Pass.
diff --git a/llvm/lib/Analysis/LoopAccessAnalysis.cpp b/llvm/lib/Analysis/LoopAccessAnalysis.cpp
--- a/llvm/lib/Analysis/LoopAccessAnalysis.cpp
+++ b/llvm/lib/Analysis/LoopAccessAnalysis.cpp
@@ -73,7 +73,7 @@
 VectorizationFactor("force-vector-width", cl::Hidden,
                     cl::desc("Sets the SIMD width. Zero is autoselect."),
                     cl::location(VectorizerParams::VectorizationFactor));
-unsigned VectorizerParams::VectorizationFactor;
+LLVM_THREAD_LOCAL unsigned VectorizerParams::VectorizationFactor;
 
 static cl::opt<unsigned, true>
 VectorizationInterleave("force-vector-interleave", cl::Hidden,
@@ -81,14 +81,14 @@
                                  "Zero is autoselect."),
                         cl::location(
                             VectorizerParams::VectorizationInterleave));
-unsigned VectorizerParams::VectorizationInterleave;
+LLVM_THREAD_LOCAL unsigned VectorizerParams::VectorizationInterleave;
 
 static cl::opt<unsigned, true> RuntimeMemoryCheckThreshold(
     "runtime-memory-check-threshold", cl::Hidden,
     cl::desc("When performing memory disambiguation checks at runtime do not "
              "generate more than this number of comparisons (default = 8)."),
     cl::location(VectorizerParams::RuntimeMemoryCheckThreshold), cl::init(8));
-unsigned VectorizerParams::RuntimeMemoryCheckThreshold;
+LLVM_THREAD_LOCAL unsigned VectorizerParams::RuntimeMemoryCheckThreshold;
 
 /// The maximum iterations used to merge memory checks
 static cl::opt<unsigned> MemoryCheckMergeThreshold(
diff --git a/llvm/lib/Analysis/LoopInfo.cpp b/llvm/lib/Analysis/LoopInfo.cpp
--- a/llvm/lib/Analysis/LoopInfo.cpp
+++ b/llvm/lib/Analysis/LoopInfo.cpp
@@ -49,9 +49,9 @@
 
 // Always verify loopinfo if expensive checking is enabled.
 #ifdef EXPENSIVE_CHECKS
-bool llvm::VerifyLoopInfo = true;
+LLVM_THREAD_LOCAL bool llvm::VerifyLoopInfo = true;
 #else
-bool llvm::VerifyLoopInfo = false;
+LLVM_THREAD_LOCAL bool llvm::VerifyLoopInfo = false;
 #endif
 static cl::opt<bool, true>
     VerifyLoopInfoX("verify-loop-info", cl::location(VerifyLoopInfo),
diff --git a/llvm/lib/Analysis/MemorySSA.cpp b/llvm/lib/Analysis/MemorySSA.cpp
--- a/llvm/lib/Analysis/MemorySSA.cpp
+++ b/llvm/lib/Analysis/MemorySSA.cpp
@@ -86,9 +86,9 @@
 
 // Always verify MemorySSA if expensive checking is enabled.
 #ifdef EXPENSIVE_CHECKS
-bool llvm::VerifyMemorySSA = true;
+LLVM_THREAD_LOCAL bool llvm::VerifyMemorySSA = true;
 #else
-bool llvm::VerifyMemorySSA = false;
+LLVM_THREAD_LOCAL bool llvm::VerifyMemorySSA = false;
 #endif
 /// Enables memory ssa as a dependency for loop passes in legacy pass manager.
 cl::opt<bool> llvm::EnableMSSALoopDependency(
diff --git a/llvm/lib/Analysis/ModuleSummaryAnalysis.cpp b/llvm/lib/Analysis/ModuleSummaryAnalysis.cpp
--- a/llvm/lib/Analysis/ModuleSummaryAnalysis.cpp
+++ b/llvm/lib/Analysis/ModuleSummaryAnalysis.cpp
@@ -62,8 +62,8 @@
 
 // Option to force edges cold which will block importing when the
 // -import-cold-multiplier is set to 0. Useful for debugging.
-FunctionSummary::ForceSummaryHotnessType ForceSummaryEdgesCold =
-    FunctionSummary::FSHT_None;
+LLVM_THREAD_LOCAL FunctionSummary::ForceSummaryHotnessType
+    ForceSummaryEdgesCold = FunctionSummary::FSHT_None;
 cl::opt<FunctionSummary::ForceSummaryHotnessType, true> FSEC(
     "force-summary-edges-cold", cl::Hidden, cl::location(ForceSummaryEdgesCold),
     cl::desc("Force all edges in the function summary to cold"),
diff --git a/llvm/lib/Analysis/ObjCARCAnalysisUtils.cpp b/llvm/lib/Analysis/ObjCARCAnalysisUtils.cpp
--- a/llvm/lib/Analysis/ObjCARCAnalysisUtils.cpp
+++ b/llvm/lib/Analysis/ObjCARCAnalysisUtils.cpp
@@ -20,7 +20,7 @@
 using namespace llvm::objcarc;
 
 /// A handy option to enable/disable all ARC Optimizations.
-bool llvm::objcarc::EnableARCOpts;
+LLVM_THREAD_LOCAL bool llvm::objcarc::EnableARCOpts;
 static cl::opt<bool, true> EnableARCOptimizations(
     "enable-objc-arc-opts", cl::desc("enable/disable all ARC Optimizations"),
     cl::location(EnableARCOpts), cl::init(true), cl::Hidden);
diff --git a/llvm/lib/BinaryFormat/Magic.cpp b/llvm/lib/BinaryFormat/Magic.cpp
--- a/llvm/lib/BinaryFormat/Magic.cpp
+++ b/llvm/lib/BinaryFormat/Magic.cpp
@@ -216,6 +216,11 @@
       return file_magic::tapi_file;
     break;
 
+  case 'C':
+    if (startswith(Magic, "CPCH"))
+      return file_magic::clang_pch;
+    break;
+
   default:
     break;
   }
diff --git a/llvm/lib/Bitcode/Writer/BitcodeWriter.cpp b/llvm/lib/Bitcode/Writer/BitcodeWriter.cpp
--- a/llvm/lib/Bitcode/Writer/BitcodeWriter.cpp
+++ b/llvm/lib/Bitcode/Writer/BitcodeWriter.cpp
@@ -94,7 +94,8 @@
     "write-relbf-to-summary", cl::Hidden, cl::init(false),
     cl::desc("Write relative block frequency to function summary "));
 
-extern FunctionSummary::ForceSummaryHotnessType ForceSummaryEdgesCold;
+extern LLVM_THREAD_LOCAL FunctionSummary::ForceSummaryHotnessType
+    ForceSummaryEdgesCold;
 
 namespace {
 
diff --git a/llvm/lib/CodeGen/MachineDominators.cpp b/llvm/lib/CodeGen/MachineDominators.cpp
--- a/llvm/lib/CodeGen/MachineDominators.cpp
+++ b/llvm/lib/CodeGen/MachineDominators.cpp
@@ -22,9 +22,9 @@
 namespace llvm {
 // Always verify dominfo if expensive checking is enabled.
 #ifdef EXPENSIVE_CHECKS
-bool VerifyMachineDomInfo = true;
+LLVM_THREAD_LOCAL bool VerifyMachineDomInfo = true;
 #else
-bool VerifyMachineDomInfo = false;
+LLVM_THREAD_LOCAL bool VerifyMachineDomInfo = false;
 #endif
 } // namespace llvm
 
diff --git a/llvm/lib/CodeGen/RegAllocBase.h b/llvm/lib/CodeGen/RegAllocBase.h
--- a/llvm/lib/CodeGen/RegAllocBase.h
+++ b/llvm/lib/CodeGen/RegAllocBase.h
@@ -113,7 +113,7 @@
 
 public:
   /// VerifyEnabled - True when -verify-regalloc is given.
-  static bool VerifyEnabled;
+  LLVM_THREAD_LOCAL static bool VerifyEnabled;
 
 private:
   void seedLiveRegs();
diff --git a/llvm/lib/CodeGen/RegAllocBase.cpp b/llvm/lib/CodeGen/RegAllocBase.cpp
--- a/llvm/lib/CodeGen/RegAllocBase.cpp
+++ b/llvm/lib/CodeGen/RegAllocBase.cpp
@@ -45,7 +45,7 @@
 
 const char RegAllocBase::TimerGroupName[] = "regalloc";
 const char RegAllocBase::TimerGroupDescription[] = "Register Allocation";
-bool RegAllocBase::VerifyEnabled = false;
+LLVM_THREAD_LOCAL bool RegAllocBase::VerifyEnabled = false;
 
 //===----------------------------------------------------------------------===//
 //                         RegAllocBase Implementation
diff --git a/llvm/lib/CodeGen/SelectionDAG/SelectionDAGBuilder.cpp b/llvm/lib/CodeGen/SelectionDAG/SelectionDAGBuilder.cpp
--- a/llvm/lib/CodeGen/SelectionDAG/SelectionDAGBuilder.cpp
+++ b/llvm/lib/CodeGen/SelectionDAG/SelectionDAGBuilder.cpp
@@ -115,7 +115,7 @@
 
 /// LimitFloatPrecision - Generate low-precision inline sequences for
 /// some float libcalls (6, 8 or 12 bits).
-static unsigned LimitFloatPrecision;
+static LLVM_THREAD_LOCAL unsigned LimitFloatPrecision;
 
 static cl::opt<bool>
     InsertAssertAlign("insert-assert-align", cl::init(true),
diff --git a/llvm/lib/ExecutionEngine/Interpreter/Execution.cpp b/llvm/lib/ExecutionEngine/Interpreter/Execution.cpp
--- a/llvm/lib/ExecutionEngine/Interpreter/Execution.cpp
+++ b/llvm/lib/ExecutionEngine/Interpreter/Execution.cpp
@@ -22,6 +22,7 @@
 #include "llvm/Support/Debug.h"
 #include "llvm/Support/ErrorHandling.h"
 #include "llvm/Support/MathExtras.h"
+#include "llvm/Support/Process.h"
 #include "llvm/Support/raw_ostream.h"
 #include <algorithm>
 #include <cmath>
@@ -878,7 +879,7 @@
   // the stack before interpreting atexit handlers.
   ECStack.clear();
   runAtExitHandlers();
-  exit(GV.IntVal.zextOrTrunc(32).getZExtValue());
+  sys::Process::Exit(GV.IntVal.zextOrTrunc(32).getZExtValue());
 }
 
 /// Pop the last stack frame off of ECStack and then copy the result
diff --git a/llvm/lib/ExecutionEngine/TargetSelect.cpp b/llvm/lib/ExecutionEngine/TargetSelect.cpp
--- a/llvm/lib/ExecutionEngine/TargetSelect.cpp
+++ b/llvm/lib/ExecutionEngine/TargetSelect.cpp
@@ -44,35 +44,17 @@
   if (TheTriple.getTriple().empty())
     TheTriple.setTriple(sys::getProcessTriple());
 
-  // Adjust the triple to match what the user requested.
-  const Target *TheTarget = nullptr;
-  if (!MArch.empty()) {
-    auto I = find_if(TargetRegistry::targets(),
-                     [&](const Target &T) { return MArch == T.getName(); });
-
-    if (I == TargetRegistry::targets().end()) {
-      if (ErrorStr)
-        *ErrorStr = "No available targets are compatible with this -march, "
-                    "see -version for the available targets.\n";
-      return nullptr;
-    }
-
-    TheTarget = &*I;
-
-    // Adjust the triple to match (if known), otherwise stick with the
-    // requested/host triple.
-    Triple::ArchType Type = Triple::getArchTypeForLLVMName(MArch);
-    if (Type != Triple::UnknownArch)
-      TheTriple.setArch(Type);
-  } else {
-    std::string Error;
-    TheTarget = TargetRegistry::lookupTarget(TheTriple.getTriple(), Error);
-    if (!TheTarget) {
-      if (ErrorStr)
-        *ErrorStr = Error;
-      return nullptr;
-    }
-  }
+  std::string Error;
+  const Target *TheTarget =
+      TargetRegistry::lookupTarget(MArch, TheTriple, Error);
+  if (!MArch.empty() && !TheTarget)
+    Error = "No available targets are compatible with -march=" + MArch.str() +
+            ", "
+            "see -version for the available targets.\n";
+  if (ErrorStr)
+    *ErrorStr = Error;
+  if (!TheTarget)
+    return nullptr;
 
   // Package up features to be passed to target/subtarget
   std::string FeaturesStr;
diff --git a/llvm/lib/IR/DiagnosticHandler.cpp b/llvm/lib/IR/DiagnosticHandler.cpp
--- a/llvm/lib/IR/DiagnosticHandler.cpp
+++ b/llvm/lib/IR/DiagnosticHandler.cpp
@@ -37,9 +37,9 @@
   }
 };
 
-static PassRemarksOpt PassRemarksPassedOptLoc;
-static PassRemarksOpt PassRemarksMissedOptLoc;
-static PassRemarksOpt PassRemarksAnalysisOptLoc;
+static LLVM_THREAD_LOCAL PassRemarksOpt PassRemarksPassedOptLoc;
+static LLVM_THREAD_LOCAL PassRemarksOpt PassRemarksMissedOptLoc;
+static LLVM_THREAD_LOCAL PassRemarksOpt PassRemarksAnalysisOptLoc;
 
 // -pass-remarks
 //    Command line flag to enable emitOptimizationRemark()
diff --git a/llvm/lib/IR/Dominators.cpp b/llvm/lib/IR/Dominators.cpp
--- a/llvm/lib/IR/Dominators.cpp
+++ b/llvm/lib/IR/Dominators.cpp
@@ -29,7 +29,7 @@
 #include <algorithm>
 using namespace llvm;
 
-bool llvm::VerifyDomInfo = false;
+LLVM_THREAD_LOCAL bool llvm::VerifyDomInfo = false;
 static cl::opt<bool, true>
     VerifyDomInfoX("verify-dom-info", cl::location(VerifyDomInfo), cl::Hidden,
                    cl::desc("Verify dominator info (time consuming)"));
diff --git a/llvm/lib/IR/LLVMContext.cpp b/llvm/lib/IR/LLVMContext.cpp
--- a/llvm/lib/IR/LLVMContext.cpp
+++ b/llvm/lib/IR/LLVMContext.cpp
@@ -25,6 +25,7 @@
 #include "llvm/Remarks/RemarkStreamer.h"
 #include "llvm/Support/Casting.h"
 #include "llvm/Support/ErrorHandling.h"
+#include "llvm/Support/Process.h"
 #include "llvm/Support/raw_ostream.h"
 #include <cassert>
 #include <cstdlib>
@@ -245,7 +246,7 @@
   DI.print(DP);
   errs() << "\n";
   if (DI.getSeverity() == DS_Error)
-    exit(1);
+    sys::Process::Exit(1);
 }
 
 void LLVMContext::emitError(unsigned LocCookie, const Twine &ErrorStr) {
diff --git a/llvm/lib/IR/PassTimingInfo.cpp b/llvm/lib/IR/PassTimingInfo.cpp
--- a/llvm/lib/IR/PassTimingInfo.cpp
+++ b/llvm/lib/IR/PassTimingInfo.cpp
@@ -34,8 +34,8 @@
 
 namespace llvm {
 
-bool TimePassesIsEnabled = false;
-bool TimePassesPerRun = false;
+LLVM_THREAD_LOCAL bool TimePassesIsEnabled = false;
+LLVM_THREAD_LOCAL bool TimePassesPerRun = false;
 
 static cl::opt<bool, true> EnableTiming(
     "time-passes", cl::location(TimePassesIsEnabled), cl::Hidden,
diff --git a/llvm/lib/IRReader/IRReader.cpp b/llvm/lib/IRReader/IRReader.cpp
--- a/llvm/lib/IRReader/IRReader.cpp
+++ b/llvm/lib/IRReader/IRReader.cpp
@@ -21,7 +21,7 @@
 using namespace llvm;
 
 namespace llvm {
-  extern bool TimePassesIsEnabled;
+extern LLVM_THREAD_LOCAL bool TimePassesIsEnabled;
 }
 
 const char TimeIRParsingGroupName[] = "irparse";
diff --git a/llvm/lib/LTO/LTOBackend.cpp b/llvm/lib/LTO/LTOBackend.cpp
--- a/llvm/lib/LTO/LTOBackend.cpp
+++ b/llvm/lib/LTO/LTOBackend.cpp
@@ -35,6 +35,7 @@
 #include "llvm/Support/FileSystem.h"
 #include "llvm/Support/MemoryBuffer.h"
 #include "llvm/Support/Path.h"
+#include "llvm/Support/Process.h"
 #include "llvm/Support/Program.h"
 #include "llvm/Support/SmallVectorMemoryBuffer.h"
 #include "llvm/Support/TargetRegistry.h"
@@ -77,7 +78,7 @@
 LLVM_ATTRIBUTE_NORETURN static void reportOpenError(StringRef Path, Twine Msg) {
   errs() << "failed to open " << Path << ": " << Msg << '\n';
   errs().flush();
-  exit(1);
+  sys::Process::Exit(1);
 }
 
 Error Config::addSaveTemps(std::string OutputFileName,
diff --git a/llvm/lib/MC/MCContext.cpp b/llvm/lib/MC/MCContext.cpp
--- a/llvm/lib/MC/MCContext.cpp
+++ b/llvm/lib/MC/MCContext.cpp
@@ -41,6 +41,7 @@
 #include "llvm/Support/ErrorHandling.h"
 #include "llvm/Support/MemoryBuffer.h"
 #include "llvm/Support/Path.h"
+#include "llvm/Support/Process.h"
 #include "llvm/Support/Signals.h"
 #include "llvm/Support/SourceMgr.h"
 #include "llvm/Support/raw_ostream.h"
@@ -971,5 +972,5 @@
   // to make sure any special cleanups get done, in particular that we remove
   // files registered with RemoveFileOnSignal.
   sys::RunInterruptHandlers();
-  exit(1);
+  sys::Process::Exit(1);
 }
diff --git a/llvm/lib/Object/Binary.cpp b/llvm/lib/Object/Binary.cpp
--- a/llvm/lib/Object/Binary.cpp
+++ b/llvm/lib/Object/Binary.cpp
@@ -84,6 +84,7 @@
     return errorCodeToError(object_error::invalid_file_type);
   case file_magic::unknown:
   case file_magic::coff_cl_gl_object:
+  case file_magic::clang_pch:
     // Unrecognized object file format.
     return errorCodeToError(object_error::invalid_file_type);
   case file_magic::minidump:
diff --git a/llvm/lib/Object/ObjectFile.cpp b/llvm/lib/Object/ObjectFile.cpp
--- a/llvm/lib/Object/ObjectFile.cpp
+++ b/llvm/lib/Object/ObjectFile.cpp
@@ -145,6 +145,7 @@
   case file_magic::windows_resource:
   case file_magic::pdb:
   case file_magic::minidump:
+  case file_magic::clang_pch:
     return errorCodeToError(object_error::invalid_file_type);
   case file_magic::tapi_file:
     return errorCodeToError(object_error::invalid_file_type);
diff --git a/llvm/lib/Support/CMakeLists.txt b/llvm/lib/Support/CMakeLists.txt
--- a/llvm/lib/Support/CMakeLists.txt
+++ b/llvm/lib/Support/CMakeLists.txt
@@ -7,7 +7,8 @@
 if( MSVC OR MINGW )
   # libuuid required for FOLDERID_Profile usage in lib/Support/Windows/Path.inc.
   # advapi32 required for CryptAcquireContextW in lib/Support/Windows/Path.inc.
-  set(system_libs ${system_libs} psapi shell32 ole32 uuid advapi32)
+  # dbghelp for llvm::sys::Process::IsInTLS in CommandLine.h
+  set(system_libs ${system_libs} psapi shell32 ole32 uuid advapi32 dbghelp)
 elseif( CMAKE_HOST_UNIX )
   if( HAVE_LIBRT )
     set(system_libs ${system_libs} rt)
@@ -53,6 +54,9 @@
   set(system_libs ${system_libs} ${Z3_LIBRARIES})
 endif()
 
+# Hack
+# set(system_libs ${system_libs} "-INCLUDE:malloc")
+
 # Override the C runtime allocator on Windows and embed it into LLVM tools & libraries
 if(LLVM_INTEGRATED_CRT_ALLOC)
   if (CMAKE_BUILD_TYPE AND NOT ${LLVM_USE_CRT_${uppercase_CMAKE_BUILD_TYPE}} MATCHES "^(MT|MTd)$")
diff --git a/llvm/lib/Support/CommandLine.cpp b/llvm/lib/Support/CommandLine.cpp
--- a/llvm/lib/Support/CommandLine.cpp
+++ b/llvm/lib/Support/CommandLine.cpp
@@ -34,6 +34,7 @@
 #include "llvm/Support/ErrorHandling.h"
 #include "llvm/Support/FileSystem.h"
 #include "llvm/Support/Host.h"
+#include "llvm/Support/InitLLVM.h"
 #include "llvm/Support/ManagedStatic.h"
 #include "llvm/Support/MemoryBuffer.h"
 #include "llvm/Support/Path.h"
@@ -165,10 +166,12 @@
   SmallPtrSet<SubCommand *, 4> RegisteredSubCommands;
 
   CommandLineParser() : ActiveSubCommand(nullptr) {
-    registerSubCommand(&*TopLevelSubCommand);
-    registerSubCommand(&*AllSubCommands);
+    registerSubCommand(&TopLevelSubCommand);
+    registerSubCommand(&AllSubCommands);
   }
 
+  CommandLineParser(const CommandLineParser &Other);
+
   void ResetAllOptionOccurrences();
 
   bool ParseCommandLineOptions(int argc, const char *const *argv,
@@ -186,7 +189,7 @@
 
     // If we're adding this to all sub-commands, add it to the ones that have
     // already been registered.
-    if (SC == &*AllSubCommands) {
+    if (SC == &AllSubCommands) {
       for (auto *Sub : RegisteredSubCommands) {
         if (SC == Sub)
           continue;
@@ -197,7 +200,7 @@
 
   void addLiteralOption(Option &Opt, StringRef Name) {
     if (Opt.Subs.empty())
-      addLiteralOption(Opt, &*TopLevelSubCommand, Name);
+      addLiteralOption(Opt, &TopLevelSubCommand, Name);
     else {
       for (auto *SC : Opt.Subs)
         addLiteralOption(Opt, SC, Name);
@@ -242,7 +245,7 @@
 
     // If we're adding this to all sub-commands, add it to the ones that have
     // already been registered.
-    if (SC == &*AllSubCommands) {
+    if (SC == &AllSubCommands) {
       for (auto *Sub : RegisteredSubCommands) {
         if (SC == Sub)
           continue;
@@ -258,7 +261,7 @@
     }
 
     if (O->Subs.empty()) {
-      addOption(O, &*TopLevelSubCommand);
+      addOption(O, &TopLevelSubCommand);
     } else {
       for (auto *SC : O->Subs)
         addOption(O, SC);
@@ -300,7 +303,7 @@
 
   void removeOption(Option *O) {
     if (O->Subs.empty())
-      removeOption(O, &*TopLevelSubCommand);
+      removeOption(O, &TopLevelSubCommand);
     else {
       if (O->isInAllSubCommands()) {
         for (auto *SC : RegisteredSubCommands)
@@ -339,7 +342,7 @@
 
   void updateArgStr(Option *O, StringRef NewName) {
     if (O->Subs.empty())
-      updateArgStr(O, NewName, &*TopLevelSubCommand);
+      updateArgStr(O, NewName, &TopLevelSubCommand);
     else {
       if (O->isInAllSubCommands()) {
         for (auto *SC : RegisteredSubCommands)
@@ -374,8 +377,8 @@
 
     // For all options that have been registered for all subcommands, add the
     // option to this subcommand now.
-    if (sub != &*AllSubCommands) {
-      for (auto &E : AllSubCommands->OptionsMap) {
+    if (sub != &AllSubCommands) {
+      for (auto &E : AllSubCommands.OptionsMap) {
         Option *O = E.second;
         if ((O->isPositional() || O->isSink() || O->isConsumeAfter()) ||
             O->hasArgStr())
@@ -407,14 +410,21 @@
     ResetAllOptionOccurrences();
     RegisteredSubCommands.clear();
 
-    TopLevelSubCommand->reset();
-    AllSubCommands->reset();
-    registerSubCommand(&*TopLevelSubCommand);
-    registerSubCommand(&*AllSubCommands);
+    TopLevelSubCommand.reset();
+    AllSubCommands.reset();
+    registerSubCommand(&TopLevelSubCommand);
+    registerSubCommand(&AllSubCommands);
 
     DefaultOptions.clear();
   }
 
+  // A special subcommand representing no subcommand.
+  SubCommand TopLevelSubCommand;
+
+  // A special subcommand that can be used to put an option into all
+  // subcommands.
+  SubCommand AllSubCommands;
+
 private:
   SubCommand *ActiveSubCommand;
 
@@ -431,26 +441,42 @@
 
 } // namespace
 
-static ManagedStatic<CommandLineParser> GlobalParser;
+// This shouldn't be used directly. It is only here to provide a intialized copy
+// of all the TLS variables. Use GetParser() instead.
+static ManagedStatic<CommandLineParser> StaticParser;
+
+static CommandLineParser *GetParser() {
+  if (InitLLVM::RunningInBuildozer()) {
+    static LLVM_THREAD_LOCAL CommandLineParser Local(*StaticParser);
+    return &Local;
+  }
+  return &*StaticParser;
+}
 
 void cl::AddLiteralOption(Option &O, StringRef Name) {
-  GlobalParser->addLiteralOption(O, Name);
+  GetParser()->addLiteralOption(O, Name);
 }
 
 extrahelp::extrahelp(StringRef Help) : morehelp(Help) {
-  GlobalParser->MoreHelp.push_back(Help);
+  GetParser()->MoreHelp.push_back(Help);
 }
 
 void Option::addArgument() {
-  GlobalParser->addOption(this);
+  GetParser()->addOption(this);
   FullyInitialized = true;
 }
 
-void Option::removeArgument() { GlobalParser->removeOption(this); }
+void Option::removeArgument() { GetParser()->removeOption(this); }
+
+bool Option::isInAllSubCommands() const {
+  return any_of(Subs, [](const SubCommand *SC) {
+    return SC == &(GetParser()->AllSubCommands);
+  });
+}
 
 void Option::setArgStr(StringRef S) {
   if (FullyInitialized)
-    GlobalParser->updateArgStr(this, S);
+    GetParser()->updateArgStr(this, S);
   assert((S.empty() || S[0] != '-') && "Option can't start with '-");
   ArgStr = S;
   if (ArgStr.size() == 1)
@@ -475,29 +501,15 @@
     removeArgument();
 }
 
-// Initialise the general option category.
+// Initialize the general option category.
 OptionCategory llvm::cl::GeneralCategory("General options");
 
-void OptionCategory::registerCategory() {
-  GlobalParser->registerCategory(this);
-}
+void OptionCategory::registerCategory() { GetParser()->registerCategory(this); }
 
-// A special subcommand representing no subcommand. It is particularly important
-// that this ManagedStatic uses constant initailization and not dynamic
-// initialization because it is referenced from cl::opt constructors, which run
-// dynamically in an arbitrary order.
-LLVM_REQUIRE_CONSTANT_INITIALIZATION
-ManagedStatic<SubCommand> llvm::cl::TopLevelSubCommand;
-
-// A special subcommand that can be used to put an option into all subcommands.
-ManagedStatic<SubCommand> llvm::cl::AllSubCommands;
-
-void SubCommand::registerSubCommand() {
-  GlobalParser->registerSubCommand(this);
-}
+void SubCommand::registerSubCommand() { GetParser()->registerSubCommand(this); }
 
 void SubCommand::unregisterSubCommand() {
-  GlobalParser->unregisterSubCommand(this);
+  GetParser()->unregisterSubCommand(this);
 }
 
 void SubCommand::reset() {
@@ -509,13 +521,110 @@
 }
 
 SubCommand::operator bool() const {
-  return (GlobalParser->getActiveSubCommand() == this);
+  return (GetParser()->getActiveSubCommand() == this);
 }
 
 //===----------------------------------------------------------------------===//
 // Basic, shared command line option processing machinery.
 //
 
+// Duplicate into a self-contained Parser
+CommandLineParser::CommandLineParser(const CommandLineParser &Other) {
+  RegisteredOptionCategories = Other.RegisteredOptionCategories;
+
+  auto computeSize = [&Other]() -> unsigned {
+    DenseSet<Option *> Opt;
+
+    for (Option *O : Other.DefaultOptions)
+      Opt.insert(O);
+    for (SubCommand *C : Other.RegisteredSubCommands) {
+      for (Option *O : C->PositionalOpts)
+        Opt.insert(O);
+      for (Option *O : C->SinkOpts)
+        Opt.insert(O);
+      for (auto &P : C->OptionsMap)
+        Opt.insert(P.getValue());
+    }
+
+    unsigned Size{};
+    for (Option *O : Opt)
+      Size += O->getSize();
+    return Size;
+  };
+
+  static unsigned TotalOptionsSize = computeSize();
+  static LLVM_THREAD_LOCAL std::unique_ptr<char[]> OptStorage(
+      new char[TotalOptionsSize]);
+
+  // Now remap all point from the source
+
+  DenseMap<Option *, Option *> RemapOpt;
+  char *Next = OptStorage.get();
+
+  DenseMap<SubCommand *, SubCommand *> RemapCommands;
+
+  auto FindNewO = [&](Option *O) -> Option * {
+    auto R = RemapOpt.insert({O, (Option *)Next});
+    if (!R.second)
+      return R.first->second;
+    // Ensure external location are in .tls storage, to accommodate for
+    // Buildozer launching several thread of the Clang driver
+    // O->checkLocation();
+    Option *NewO = (Option *)Next;
+    unsigned Size = O->getSize();
+    O->duplicateInto(NewO);
+
+    NewO->Subs.clear();
+    for (auto S : O->Subs) {
+      SubCommand *NewS = RemapCommands[S];
+      assert(NewS);
+      NewO->Subs.insert(NewS);
+    }
+
+    Next += Size;
+    return NewO;
+  };
+
+  registerSubCommand(&TopLevelSubCommand);
+  registerSubCommand(&AllSubCommands);
+
+  for (SubCommand *C : Other.RegisteredSubCommands) {
+    if (C == &Other.TopLevelSubCommand) {
+      RemapCommands[C] = &TopLevelSubCommand;
+      continue;
+    }
+    if (C == &Other.AllSubCommands) {
+      RemapCommands[C] = &AllSubCommands;
+      continue;
+    }
+    assert(false);
+  }
+
+  for (Option *O : Other.DefaultOptions) {
+    Option *NewO = FindNewO(O);
+    DefaultOptions.push_back(NewO);
+  }
+
+  for (SubCommand *C : Other.RegisteredSubCommands) {
+    SubCommand *ThisC = RemapCommands[C];
+    for (Option *O : C->PositionalOpts) {
+      Option *NewO = FindNewO(O);
+      ThisC->PositionalOpts.push_back(NewO);
+    }
+    for (Option *O : C->SinkOpts) {
+      Option *NewO = FindNewO(O);
+      ThisC->SinkOpts.push_back(NewO);
+    }
+    for (auto &P : C->OptionsMap) {
+      Option *NewO = FindNewO(P.getValue());
+      ThisC->OptionsMap[P.getKey()] = NewO;
+    }
+  }
+
+  for (auto &Pair : RemapOpt)
+    Pair.second->postRemap(RemapOpt);
+}
+
 /// LookupOption - Lookup the option specified by the specified option on the
 /// command line.  If there is a value specified (after an equal sign) return
 /// that as well.  This assumes that leading dashes have already been stripped.
@@ -524,7 +633,7 @@
   // Reject all dashes.
   if (Arg.empty())
     return nullptr;
-  assert(&Sub != &*AllSubCommands);
+  assert(&Sub != &AllSubCommands);
 
   size_t EqualPos = Arg.find('=');
 
@@ -552,9 +661,9 @@
 
 SubCommand *CommandLineParser::LookupSubCommand(StringRef Name) {
   if (Name.empty())
-    return &*TopLevelSubCommand;
+    return &TopLevelSubCommand;
   for (auto *S : RegisteredSubCommands) {
-    if (S == &*AllSubCommands)
+    if (S == &AllSubCommands)
       continue;
     if (S->getName().empty())
       continue;
@@ -562,7 +671,7 @@
     if (StringRef(S->getName()) == StringRef(Name))
       return S;
   }
-  return &*TopLevelSubCommand;
+  return &TopLevelSubCommand;
 }
 
 /// LookupNearestOption - Lookup the closest match to the option specified by
@@ -1315,8 +1424,8 @@
   int NewArgc = static_cast<int>(NewArgv.size());
 
   // Parse all options.
-  return GlobalParser->ParseCommandLineOptions(NewArgc, &NewArgv[0], Overview,
-                                               Errs, LongOptionsUseDoubleDash);
+  return GetParser()->ParseCommandLineOptions(NewArgc, &NewArgv[0], Overview,
+                                              Errs, LongOptionsUseDoubleDash);
 }
 
 void CommandLineParser::ResetAllOptionOccurrences() {
@@ -1362,15 +1471,15 @@
   bool HasUnlimitedPositionals = false;
 
   int FirstArg = 1;
-  SubCommand *ChosenSubCommand = &*TopLevelSubCommand;
+  SubCommand *ChosenSubCommand = &TopLevelSubCommand;
   if (argc >= 2 && argv[FirstArg][0] != '-') {
     // If the first argument specifies a valid subcommand, start processing
     // options from the second argument.
     ChosenSubCommand = LookupSubCommand(StringRef(argv[FirstArg]));
-    if (ChosenSubCommand != &*TopLevelSubCommand)
+    if (ChosenSubCommand != &TopLevelSubCommand)
       FirstArg = 2;
   }
-  GlobalParser->ActiveSubCommand = ChosenSubCommand;
+  GetParser()->ActiveSubCommand = ChosenSubCommand;
 
   assert(ChosenSubCommand);
   auto &ConsumeAfterOpt = ChosenSubCommand->ConsumeAfterOpt;
@@ -1661,7 +1770,7 @@
   // If we had an error processing our arguments, don't let the program execute
   if (ErrorParsing) {
     if (!IgnoreErrors)
-      exit(1);
+      sys::Process::Exit(1);
     return false;
   }
   return true;
@@ -1677,7 +1786,7 @@
   if (ArgName.empty())
     Errs << HelpStr; // Be nice for positional arguments
   else
-    Errs << GlobalParser->ProgramName << ": for the " << PrintArg(ArgName, 0);
+    Errs << GetParser()->ProgramName << ": for the " << PrintArg(ArgName, 0);
 
   Errs << " option: " << Message << "\n";
   return true;
@@ -2194,11 +2303,11 @@
     printHelp();
 
     // Halt the program since help information was printed
-    exit(0);
+    sys::Process::Exit(0);
   }
 
   void printHelp() {
-    SubCommand *Sub = GlobalParser->getActiveSubCommand();
+    SubCommand *Sub = GetParser()->getActiveSubCommand();
     auto &OptionsMap = Sub->OptionsMap;
     auto &PositionalOpts = Sub->PositionalOpts;
     auto &ConsumeAfterOpt = Sub->ConsumeAfterOpt;
@@ -2207,13 +2316,13 @@
     sortOpts(OptionsMap, Opts, ShowHidden);
 
     StrSubCommandPairVector Subs;
-    sortSubCommands(GlobalParser->RegisteredSubCommands, Subs);
+    sortSubCommands(GetParser()->RegisteredSubCommands, Subs);
 
-    if (!GlobalParser->ProgramOverview.empty())
-      outs() << "OVERVIEW: " << GlobalParser->ProgramOverview << "\n";
+    if (!GetParser()->ProgramOverview.empty())
+      outs() << "OVERVIEW: " << GetParser()->ProgramOverview << "\n";
 
-    if (Sub == &*TopLevelSubCommand) {
-      outs() << "USAGE: " << GlobalParser->ProgramName;
+    if (Sub == &GetParser()->TopLevelSubCommand) {
+      outs() << "USAGE: " << GetParser()->ProgramName;
       if (Subs.size() > 2)
         outs() << " [subcommand]";
       outs() << " [options]";
@@ -2222,7 +2331,7 @@
         outs() << "SUBCOMMAND '" << Sub->getName()
                << "': " << Sub->getDescription() << "\n\n";
       }
-      outs() << "USAGE: " << GlobalParser->ProgramName << " " << Sub->getName()
+      outs() << "USAGE: " << GetParser()->ProgramName << " " << Sub->getName()
              << " [options]";
     }
 
@@ -2236,7 +2345,7 @@
     if (ConsumeAfterOpt)
       outs() << " " << ConsumeAfterOpt->HelpStr;
 
-    if (Sub == &*TopLevelSubCommand && !Subs.empty()) {
+    if (Sub == &GetParser()->TopLevelSubCommand && !Subs.empty()) {
       // Compute the maximum subcommand length...
       size_t MaxSubLen = 0;
       for (size_t i = 0, e = Subs.size(); i != e; ++i)
@@ -2246,7 +2355,7 @@
       outs() << "SUBCOMMANDS:\n\n";
       printSubCommands(Subs, MaxSubLen);
       outs() << "\n";
-      outs() << "  Type \"" << GlobalParser->ProgramName
+      outs() << "  Type \"" << GetParser()->ProgramName
              << " <subcommand> --help\" to get more help on a specific "
                 "subcommand";
     }
@@ -2262,9 +2371,9 @@
     printOptions(Opts, MaxArgLen);
 
     // Print any extra help the user has declared.
-    for (const auto &I : GlobalParser->MoreHelp)
+    for (const auto &I : GetParser()->MoreHelp)
       outs() << I;
-    GlobalParser->MoreHelp.clear();
+    GetParser()->MoreHelp.clear();
   }
 };
 
@@ -2291,8 +2400,8 @@
 
     // Collect registered option categories into vector in preparation for
     // sorting.
-    for (auto I = GlobalParser->RegisteredOptionCategories.begin(),
-              E = GlobalParser->RegisteredOptionCategories.end();
+    for (auto I = GetParser()->RegisteredOptionCategories.begin(),
+              E = GetParser()->RegisteredOptionCategories.end();
          I != E; ++I) {
       SortedCategories.push_back(*I);
     }
@@ -2376,17 +2485,17 @@
 
 // Declare the four HelpPrinter instances that are used to print out help, or
 // help-hidden as an uncategorized list or in categories.
-static HelpPrinter UncategorizedNormalPrinter(false);
-static HelpPrinter UncategorizedHiddenPrinter(true);
-static CategorizedHelpPrinter CategorizedNormalPrinter(false);
-static CategorizedHelpPrinter CategorizedHiddenPrinter(true);
+static LLVM_THREAD_LOCAL HelpPrinter UncategorizedNormalPrinter(false);
+static LLVM_THREAD_LOCAL HelpPrinter UncategorizedHiddenPrinter(true);
+static LLVM_THREAD_LOCAL CategorizedHelpPrinter CategorizedNormalPrinter(false);
+static LLVM_THREAD_LOCAL CategorizedHelpPrinter CategorizedHiddenPrinter(true);
 
 // Declare HelpPrinter wrappers that will decide whether or not to invoke
 // a categorizing help printer
-static HelpPrinterWrapper WrappedNormalPrinter(UncategorizedNormalPrinter,
-                                               CategorizedNormalPrinter);
-static HelpPrinterWrapper WrappedHiddenPrinter(UncategorizedHiddenPrinter,
-                                               CategorizedHiddenPrinter);
+static LLVM_THREAD_LOCAL HelpPrinterWrapper
+    WrappedNormalPrinter(UncategorizedNormalPrinter, CategorizedNormalPrinter);
+static LLVM_THREAD_LOCAL HelpPrinterWrapper
+    WrappedHiddenPrinter(UncategorizedHiddenPrinter, CategorizedHiddenPrinter);
 
 // Define a category for generic options that all tools should have.
 static cl::OptionCategory GenericCategory("Generic Options");
@@ -2398,13 +2507,12 @@
     "help-list",
     cl::desc("Display list of available options (--help-list-hidden for more)"),
     cl::location(UncategorizedNormalPrinter), cl::Hidden, cl::ValueDisallowed,
-    cl::cat(GenericCategory), cl::sub(*AllSubCommands));
+    cl::cat(GenericCategory), cl::allSub());
 
 static cl::opt<HelpPrinter, true, parser<bool>>
     HLHOp("help-list-hidden", cl::desc("Display list of all available options"),
           cl::location(UncategorizedHiddenPrinter), cl::Hidden,
-          cl::ValueDisallowed, cl::cat(GenericCategory),
-          cl::sub(*AllSubCommands));
+          cl::ValueDisallowed, cl::cat(GenericCategory), cl::allSub());
 
 // Define uncategorized/categorized help printers. These printers change their
 // behaviour at runtime depending on whether one or more Option categories have
@@ -2412,7 +2520,7 @@
 static cl::opt<HelpPrinterWrapper, true, parser<bool>>
     HOp("help", cl::desc("Display available options (--help-hidden for more)"),
         cl::location(WrappedNormalPrinter), cl::ValueDisallowed,
-        cl::cat(GenericCategory), cl::sub(*AllSubCommands));
+        cl::cat(GenericCategory), cl::allSub());
 
 static cl::alias HOpA("h", cl::desc("Alias for --help"), cl::aliasopt(HOp),
                       cl::DefaultOption);
@@ -2420,18 +2528,17 @@
 static cl::opt<HelpPrinterWrapper, true, parser<bool>>
     HHOp("help-hidden", cl::desc("Display all available options"),
          cl::location(WrappedHiddenPrinter), cl::Hidden, cl::ValueDisallowed,
-         cl::cat(GenericCategory), cl::sub(*AllSubCommands));
+         cl::cat(GenericCategory), cl::allSub());
 
 static cl::opt<bool> PrintOptions(
     "print-options",
     cl::desc("Print non-default options after command line parsing"),
-    cl::Hidden, cl::init(false), cl::cat(GenericCategory),
-    cl::sub(*AllSubCommands));
+    cl::Hidden, cl::init(false), cl::cat(GenericCategory), cl::allSub());
 
 static cl::opt<bool> PrintAllOptions(
     "print-all-options",
     cl::desc("Print all option values after command line parsing"), cl::Hidden,
-    cl::init(false), cl::cat(GenericCategory), cl::sub(*AllSubCommands));
+    cl::init(false), cl::cat(GenericCategory), cl::allSub());
 
 void HelpPrinterWrapper::operator=(bool Value) {
   if (!Value)
@@ -2440,7 +2547,7 @@
   // Decide which printer to invoke. If more than one option category is
   // registered then it is useful to show the categorized help instead of
   // uncategorized help.
-  if (GlobalParser->RegisteredOptionCategories.size() > 1) {
+  if (GetParser()->RegisteredOptionCategories.size() > 1) {
     // unhide --help-list option so user can have uncategorized output if they
     // want it.
     HLOp.setHiddenFlag(NotHidden);
@@ -2451,7 +2558,7 @@
 }
 
 // Print the value of each option.
-void cl::PrintOptionValues() { GlobalParser->printOptionValues(); }
+void cl::PrintOptionValues() { GetParser()->printOptionValues(); }
 
 void CommandLineParser::printOptionValues() {
   if (!PrintOptions && !PrintAllOptions)
@@ -2534,7 +2641,7 @@
 
     if (OverrideVersionPrinter != nullptr) {
       OverrideVersionPrinter(outs());
-      exit(0);
+      sys::Process::Exit(0);
     }
     print();
 
@@ -2546,13 +2653,13 @@
         I(outs());
     }
 
-    exit(0);
+    sys::Process::Exit(0);
   }
 };
 } // End anonymous namespace
 
 // Define the --version option that prints out the LLVM version for the tool
-static VersionPrinter VersionPrinterInstance;
+static LLVM_THREAD_LOCAL VersionPrinter VersionPrinterInstance;
 
 static cl::opt<VersionPrinter, true, parser<bool>>
     VersOp("version", cl::desc("Display the version of this program"),
@@ -2583,8 +2690,9 @@
   ExtraVersionPrinters->push_back(func);
 }
 
-StringMap<Option *> &cl::getRegisteredOptions(SubCommand &Sub) {
-  auto &Subs = GlobalParser->RegisteredSubCommands;
+StringMap<Option *> &cl::getRegisteredOptions() {
+  SubCommand &Sub = GetParser()->TopLevelSubCommand;
+  auto &Subs = GetParser()->RegisteredSubCommands;
   (void)Subs;
   assert(is_contained(Subs, &Sub));
   return Sub.OptionsMap;
@@ -2592,10 +2700,15 @@
 
 iterator_range<typename SmallPtrSet<SubCommand *, 4>::iterator>
 cl::getRegisteredSubcommands() {
-  return GlobalParser->getRegisteredSubcommands();
+  return GetParser()->getRegisteredSubcommands();
+}
+
+bool cl::isTopLevel(SubCommand *SC) {
+  return &(GetParser()->TopLevelSubCommand) == SC;
 }
 
-void cl::HideUnrelatedOptions(cl::OptionCategory &Category, SubCommand &Sub) {
+void cl::HideUnrelatedOptions(cl::OptionCategory &Category) {
+  SubCommand &Sub = GetParser()->TopLevelSubCommand;
   for (auto &I : Sub.OptionsMap) {
     for (auto &Cat : I.second->Categories) {
       if (Cat != &Category &&
@@ -2605,8 +2718,8 @@
   }
 }
 
-void cl::HideUnrelatedOptions(ArrayRef<const cl::OptionCategory *> Categories,
-                              SubCommand &Sub) {
+void cl::HideUnrelatedOptions(ArrayRef<const cl::OptionCategory *> Categories) {
+  SubCommand &Sub = GetParser()->TopLevelSubCommand;
   for (auto &I : Sub.OptionsMap) {
     for (auto &Cat : I.second->Categories) {
       if (!is_contained(Categories, Cat) && Cat != &GenericCategory)
@@ -2615,9 +2728,9 @@
   }
 }
 
-void cl::ResetCommandLineParser() { GlobalParser->reset(); }
+void cl::ResetCommandLineParser() { GetParser()->reset(); }
 void cl::ResetAllOptionOccurrences() {
-  GlobalParser->ResetAllOptionOccurrences();
+  GetParser()->ResetAllOptionOccurrences();
 }
 
 void LLVMParseCommandLineOptions(int argc, const char *const *argv,
@@ -2625,3 +2738,7 @@
   llvm::cl::ParseCommandLineOptions(argc, argv, StringRef(Overview),
                                     &llvm::nulls());
 }
+
+cl::allSub::allSub() : sub(GetParser()->AllSubCommands) {}
+
+cl::topLevel::topLevel() : sub(GetParser()->TopLevelSubCommand) {}
\ No newline at end of file
diff --git a/llvm/lib/Support/Debug.cpp b/llvm/lib/Support/Debug.cpp
--- a/llvm/lib/Support/Debug.cpp
+++ b/llvm/lib/Support/Debug.cpp
@@ -40,7 +40,7 @@
 // built without NDEBUG can depend on via the llvm/Support/Debug.h header.
 namespace llvm {
 /// Exported boolean set by the -debug option.
-bool DebugFlag = false;
+LLVM_THREAD_LOCAL bool DebugFlag = false;
 
 static ManagedStatic<std::vector<std::string>> CurrentDebugType;
 
@@ -111,7 +111,7 @@
 
 } // namespace
 
-static DebugOnlyOpt DebugOnlyOptLoc;
+static LLVM_THREAD_LOCAL DebugOnlyOpt DebugOnlyOptLoc;
 
 static cl::opt<DebugOnlyOpt, true, cl::parser<std::string> >
 DebugOnly("debug-only", cl::desc("Enable a specific type of debug output (comma separated list of types)"),
diff --git a/llvm/lib/Support/DebugCounter.cpp b/llvm/lib/Support/DebugCounter.cpp
--- a/llvm/lib/Support/DebugCounter.cpp
+++ b/llvm/lib/Support/DebugCounter.cpp
@@ -1,6 +1,7 @@
 #include "llvm/Support/DebugCounter.h"
 #include "llvm/Support/CommandLine.h"
 #include "llvm/Support/Format.h"
+#include "llvm/Support/InitLLVM.h"
 #include "llvm/Support/ManagedStatic.h"
 
 using namespace llvm;
@@ -31,7 +32,7 @@
     // width, so we do the same.
     Option::printHelpStr(HelpStr, GlobalWidth, ArgStr.size() + 6);
     const auto &CounterInstance = DebugCounter::instance();
-    for (const auto &Name : CounterInstance) {
+    for (const auto &Name : CounterInstance.getCounterVector()) {
       const auto Info =
           CounterInstance.getCounterInfo(CounterInstance.getCounterId(Name));
       size_t NumSpaces = GlobalWidth - Info.first.size() - 8;
@@ -60,7 +61,13 @@
     print(dbgs());
 }
 
-DebugCounter &DebugCounter::instance() { return *DC; }
+DebugCounter &DebugCounter::instance() {
+  if (InitLLVM::RunningInBuildozer()) {
+    static LLVM_THREAD_LOCAL DebugCounter Local;
+    return Local;
+  }
+  return *DC;
+}
 
 // This is called by the command line parser when it sees a value for the
 // debug-counter option defined above.
diff --git a/llvm/lib/Support/Error.cpp b/llvm/lib/Support/Error.cpp
--- a/llvm/lib/Support/Error.cpp
+++ b/llvm/lib/Support/Error.cpp
@@ -10,6 +10,7 @@
 #include "llvm/ADT/Twine.h"
 #include "llvm/Support/ErrorHandling.h"
 #include "llvm/Support/ManagedStatic.h"
+#include "llvm/Support/Process.h"
 #include <system_error>
 
 using namespace llvm;
@@ -172,3 +173,11 @@
 LLVMErrorRef LLVMCreateStringError(const char *ErrMsg) {
   return wrap(make_error<StringError>(ErrMsg, inconvertibleErrorCode()));
 }
+
+void ExitOnError::checkError(Error Err) const {
+  if (Err) {
+    int ExitCode = GetExitCode(Err);
+    logAllUnhandledErrors(std::move(Err), errs(), Banner);
+    sys::Process::Exit(ExitCode);
+  }
+}
\ No newline at end of file
diff --git a/llvm/lib/Support/ErrorHandling.cpp b/llvm/lib/Support/ErrorHandling.cpp
--- a/llvm/lib/Support/ErrorHandling.cpp
+++ b/llvm/lib/Support/ErrorHandling.cpp
@@ -39,11 +39,11 @@
 
 using namespace llvm;
 
-static fatal_error_handler_t ErrorHandler = nullptr;
-static void *ErrorHandlerUserData = nullptr;
+static LLVM_THREAD_LOCAL fatal_error_handler_t ErrorHandler = nullptr;
+static LLVM_THREAD_LOCAL void *ErrorHandlerUserData = nullptr;
 
-static fatal_error_handler_t BadAllocErrorHandler = nullptr;
-static void *BadAllocErrorHandlerUserData = nullptr;
+static LLVM_THREAD_LOCAL fatal_error_handler_t BadAllocErrorHandler = nullptr;
+static LLVM_THREAD_LOCAL void *BadAllocErrorHandlerUserData = nullptr;
 
 #if LLVM_ENABLE_THREADS == 1
 // Mutexes to synchronize installing error handlers and calling error handlers.
@@ -57,14 +57,14 @@
 // STL and hide all of its symbols with 'opt -internalize'. To reduce size, it
 // cuts out the threading portions of the hermetic copy of libc++ that it
 // builds. We can remove these ifdefs if that script goes away.
-static std::mutex ErrorHandlerMutex;
-static std::mutex BadAllocErrorHandlerMutex;
+// static std::mutex ErrorHandlerMutex;
+// static std::mutex BadAllocErrorHandlerMutex;
 #endif
 
 void llvm::install_fatal_error_handler(fatal_error_handler_t handler,
                                        void *user_data) {
 #if LLVM_ENABLE_THREADS == 1
-  std::lock_guard<std::mutex> Lock(ErrorHandlerMutex);
+  // std::lock_guard<std::mutex> Lock(ErrorHandlerMutex);
 #endif
   assert(!ErrorHandler && "Error handler already registered!\n");
   ErrorHandler = handler;
@@ -73,7 +73,7 @@
 
 void llvm::remove_fatal_error_handler() {
 #if LLVM_ENABLE_THREADS == 1
-  std::lock_guard<std::mutex> Lock(ErrorHandlerMutex);
+  // std::lock_guard<std::mutex> Lock(ErrorHandlerMutex);
 #endif
   ErrorHandler = nullptr;
   ErrorHandlerUserData = nullptr;
@@ -98,7 +98,7 @@
     // Only acquire the mutex while reading the handler, so as not to invoke a
     // user-supplied callback under a lock.
 #if LLVM_ENABLE_THREADS == 1
-    std::lock_guard<std::mutex> Lock(ErrorHandlerMutex);
+    // std::lock_guard<std::mutex> Lock(ErrorHandlerMutex);
 #endif
     handler = ErrorHandler;
     handlerData = ErrorHandlerUserData;
@@ -129,7 +129,7 @@
 void llvm::install_bad_alloc_error_handler(fatal_error_handler_t handler,
                                            void *user_data) {
 #if LLVM_ENABLE_THREADS == 1
-  std::lock_guard<std::mutex> Lock(BadAllocErrorHandlerMutex);
+  // std::lock_guard<std::mutex> Lock(BadAllocErrorHandlerMutex);
 #endif
   assert(!ErrorHandler && "Bad alloc error handler already registered!\n");
   BadAllocErrorHandler = handler;
@@ -138,7 +138,7 @@
 
 void llvm::remove_bad_alloc_error_handler() {
 #if LLVM_ENABLE_THREADS == 1
-  std::lock_guard<std::mutex> Lock(BadAllocErrorHandlerMutex);
+  // std::lock_guard<std::mutex> Lock(BadAllocErrorHandlerMutex);
 #endif
   BadAllocErrorHandler = nullptr;
   BadAllocErrorHandlerUserData = nullptr;
@@ -151,7 +151,7 @@
     // Only acquire the mutex while reading the handler, so as not to invoke a
     // user-supplied callback under a lock.
 #if LLVM_ENABLE_THREADS == 1
-    std::lock_guard<std::mutex> Lock(BadAllocErrorHandlerMutex);
+    // std::lock_guard<std::mutex> Lock(BadAllocErrorHandlerMutex);
 #endif
     Handler = BadAllocErrorHandler;
     HandlerData = BadAllocErrorHandlerUserData;
diff --git a/llvm/lib/Support/InitLLVM.cpp b/llvm/lib/Support/InitLLVM.cpp
--- a/llvm/lib/Support/InitLLVM.cpp
+++ b/llvm/lib/Support/InitLLVM.cpp
@@ -16,13 +16,32 @@
 
 #ifdef _WIN32
 #include "llvm/Support/Windows/WindowsSupport.h"
+#include <process.h>
 #endif
 
 using namespace llvm;
 using namespace llvm::sys;
 
+// Needed to initialize LLVM under-the-hood from Buildozer
+static LLVM_THREAD_LOCAL void *CRTInitEvent{};
+static LLVM_THREAD_LOCAL void *CRTExitEvent{};
+static bool ShouldSkipInitLLVM{};
+LLVM_THREAD_LOCAL HANDLE CurrentHandle{};
+
 InitLLVM::InitLLVM(int &Argc, const char **&Argv,
                    bool InstallPipeSignalExitHandler) {
+  if (CRTInitEvent) {
+#ifdef _WIN32
+    SetEvent((HANDLE)CRTInitEvent);
+    WaitForSingleObject(CRTExitEvent, INFINITE);
+    llvm_shutdown(); // clean up allocations
+    _cexit();
+    sys::Process::Exit(0);
+#endif
+  }
+  if (ShouldSkipInitLLVM)
+    return;
+
   if (InstallPipeSignalExitHandler)
     // The pipe signal handler must be installed before any other handlers are
     // registered. This is because the Unix \ref RegisterHandlers function does
@@ -60,4 +79,44 @@
 #endif
 }
 
-InitLLVM::~InitLLVM() { llvm_shutdown(); }
+InitLLVM::~InitLLVM() {
+  if (ShouldSkipInitLLVM)
+    return;
+  llvm_shutdown();
+}
+
+#ifdef __clang__
+__attribute__((used))
+#endif
+void InitLLVM::InitFromBuildozer(void* InitEvent,
+    void* ExitEvent) {
+  CRTInitEvent = InitEvent;
+  CRTExitEvent = ExitEvent;
+}
+#if defined(_MSC_VER) && !defined(__clang__)
+#pragma comment(linker, "/INCLUDE:?InitFromBuildozer@InitLLVM@llvm@@SAXPEAX0@Z")
+#endif
+
+#ifdef __clang__
+__attribute__((used))
+#endif
+void
+InitLLVM::SetCurrentModuleBackdoor(void *ModuleHandle) {
+  CurrentHandle = ModuleHandle;
+}
+#if defined(_MSC_VER) && !defined(__clang__)
+#pragma comment(linker,                                                        \
+                "/INCLUDE:?SetCurrentModuleBackdoor@InitLLVM@llvm@@SAXPEAX@Z")
+#endif
+
+#ifdef __clang__
+__attribute__((used))
+#endif
+void InitLLVM::SkipInitLLVM() {
+  ShouldSkipInitLLVM = true;
+}
+#if defined(_MSC_VER) && !defined(__clang__)
+#pragma comment(linker, "/INCLUDE:?SkipInitLLVM@InitLLVM@llvm@@SAXXZ")
+#endif
+
+bool InitLLVM::RunningInBuildozer() { return ShouldSkipInitLLVM; }
diff --git a/llvm/lib/Support/Process.cpp b/llvm/lib/Support/Process.cpp
--- a/llvm/lib/Support/Process.cpp
+++ b/llvm/lib/Support/Process.cpp
@@ -17,6 +17,7 @@
 #include "llvm/Config/llvm-config.h"
 #include "llvm/Support/CrashRecoveryContext.h"
 #include "llvm/Support/FileSystem.h"
+#include "llvm/Support/InitLLVM.h"
 #include "llvm/Support/Path.h"
 #include "llvm/Support/Program.h"
 
@@ -97,6 +98,10 @@
   if (CrashRecoveryContext *CRC = CrashRecoveryContext::GetCurrent())
     CRC->HandleExit(RetCode);
 
+  if (InitLLVM::RunningInBuildozer())
+    assert(CrashRecoveryContext::GetCurrent());
+  // RaiseException(0xE0000000 | code, 0, 0, NULL);
+
   if (NoCleanup)
     ExitNoCleanup(RetCode);
   else
diff --git a/llvm/lib/Support/Signals.cpp b/llvm/lib/Support/Signals.cpp
--- a/llvm/lib/Support/Signals.cpp
+++ b/llvm/lib/Support/Signals.cpp
@@ -38,12 +38,12 @@
 using namespace llvm;
 
 // Use explicit storage to avoid accessing cl::opt in a signal handler.
-static bool DisableSymbolicationFlag = false;
+static LLVM_THREAD_LOCAL bool DisableSymbolicationFlag = false;
 static cl::opt<bool, true>
     DisableSymbolication("disable-symbolication",
                          cl::desc("Disable symbolizing crash backtraces."),
                          cl::location(DisableSymbolicationFlag), cl::Hidden);
-static std::string CrashDiagnosticsDirectory;
+static LLVM_THREAD_LOCAL std::string CrashDiagnosticsDirectory;
 static cl::opt<std::string, true>
     CrashDiagnosticsDir("crash-diagnostics-dir", cl::value_desc("directory"),
                         cl::desc("Directory for crash diagnostic files."),
diff --git a/llvm/lib/Support/TargetRegistry.cpp b/llvm/lib/Support/TargetRegistry.cpp
--- a/llvm/lib/Support/TargetRegistry.cpp
+++ b/llvm/lib/Support/TargetRegistry.cpp
@@ -9,19 +9,21 @@
 #include "llvm/Support/TargetRegistry.h"
 #include "llvm/ADT/STLExtras.h"
 #include "llvm/ADT/StringRef.h"
+#include "llvm/Support/RWMutex.h"
 #include "llvm/Support/raw_ostream.h"
 #include <cassert>
 #include <vector>
 using namespace llvm;
 
-// Clients are responsible for avoid race conditions in registration.
-static Target *FirstTarget = nullptr;
+static Target *FirstTarget{};
+static unsigned TargetsCount{};
+static sys::SmartRWMutex<true> TargetsMutex;
 
 iterator_range<TargetRegistry::iterator> TargetRegistry::targets() {
-  return make_range(iterator(FirstTarget), iterator());
+  return make_range(iterator(FirstTarget), iterator(), TargetsCount);
 }
 
-const Target *TargetRegistry::lookupTarget(const std::string &ArchName,
+const Target *TargetRegistry::lookupTarget(StringRef ArchName,
                                            Triple &TheTriple,
                                            std::string &Error) {
   // Allocate target machine.  First, check whether the user has explicitly
@@ -29,11 +31,12 @@
   // name, because it might be a backend that has no mapping to a target triple.
   const Target *TheTarget = nullptr;
   if (!ArchName.empty()) {
+    sys::SmartScopedReader<true> Lock(TargetsMutex);
     auto I = find_if(targets(),
                      [&](const Target &T) { return ArchName == T.getName(); });
 
     if (I == targets().end()) {
-      Error = "error: invalid target '" + ArchName + "'.\n";
+      Error = "error: invalid target '" + ArchName.str() + "'.\n";
       return nullptr;
     }
 
@@ -61,6 +64,7 @@
 
 const Target *TargetRegistry::lookupTarget(const std::string &TT,
                                            std::string &Error) {
+  sys::SmartScopedReader<true> Lock(TargetsMutex);
   // Provide special warning when no targets are initialized.
   if (targets().begin() == targets().end()) {
     Error = "Unable to find target for this triple (no targets are registered)";
@@ -93,6 +97,8 @@
   assert(Name && ShortDesc && ArchMatchFn &&
          "Missing required target information!");
 
+  sys::SmartScopedWriter<true> Lock(TargetsMutex);
+
   // Check if this target has already been initialized, we allow this as a
   // convenience to some clients.
   if (T.Name)
@@ -101,6 +107,7 @@
   // Add to the list of targets.
   T.Next = FirstTarget;
   FirstTarget = &T;
+  ++TargetsCount;
 
   T.Name = Name;
   T.ShortDesc = ShortDesc;
@@ -117,9 +124,14 @@
 void TargetRegistry::printRegisteredTargetsForVersion(raw_ostream &OS) {
   std::vector<std::pair<StringRef, const Target*> > Targets;
   size_t Width = 0;
-  for (const auto &T : TargetRegistry::targets()) {
-    Targets.push_back(std::make_pair(T.getName(), &T));
-    Width = std::max(Width, Targets.back().first.size());
+  {
+    sys::SmartScopedReader<true> Lock(TargetsMutex);
+    auto Range = TargetRegistry::targets();
+    Targets.reserve(Range.size());
+    for (const auto &T : Range) {
+      Targets.push_back(std::make_pair(T.getName(), &T));
+      Width = std::max(Width, Targets.back().first.size());
+    }
   }
   array_pod_sort(Targets.begin(), Targets.end(), TargetArraySortFn);
 
diff --git a/llvm/lib/Support/Timer.cpp b/llvm/lib/Support/Timer.cpp
--- a/llvm/lib/Support/Timer.cpp
+++ b/llvm/lib/Support/Timer.cpp
@@ -17,6 +17,7 @@
 #include "llvm/Support/CommandLine.h"
 #include "llvm/Support/FileSystem.h"
 #include "llvm/Support/Format.h"
+#include "llvm/Support/InitLLVM.h"
 #include "llvm/Support/ManagedStatic.h"
 #include "llvm/Support/Mutex.h"
 #include "llvm/Support/Process.h"
@@ -44,6 +45,10 @@
 // it is needed and never destroying it.
 static ManagedStatic<std::string> LibSupportInfoOutputFilename;
 static std::string &getLibSupportInfoOutputFilename() {
+  if (InitLLVM::RunningInBuildozer()) {
+    static LLVM_THREAD_LOCAL std::string Local;
+    return Local;
+  }
   return *LibSupportInfoOutputFilename;
 }
 
diff --git a/llvm/lib/Support/ToolOutputFile.cpp b/llvm/lib/Support/ToolOutputFile.cpp
--- a/llvm/lib/Support/ToolOutputFile.cpp
+++ b/llvm/lib/Support/ToolOutputFile.cpp
@@ -12,6 +12,7 @@
 
 #include "llvm/Support/ToolOutputFile.h"
 #include "llvm/ADT/Triple.h"
+#include "llvm/Support/Casting.h"
 #include "llvm/Support/FileSystem.h"
 #include "llvm/Support/Signals.h"
 using namespace llvm;
@@ -42,7 +43,7 @@
                                sys::fs::OpenFlags Flags)
     : Installer(Filename) {
   if (isStdout(Filename)) {
-    OS = &outs();
+    OS = llvm::dyn_cast<raw_fd_ostream>(&outs());
     EC = std::error_code();
     return;
   }
diff --git a/llvm/lib/Support/Windows/Memory.inc b/llvm/lib/Support/Windows/Memory.inc
--- a/llvm/lib/Support/Windows/Memory.inc
+++ b/llvm/lib/Support/Windows/Memory.inc
@@ -194,3 +194,54 @@
 
 } // namespace sys
 } // namespace llvm
+
+#ifndef _DLL
+#define ENABLE_PRELOAD 1
+#include "F:\aganea\git\rpmalloc\rpmalloc\rpmalloc.c"
+
+typedef void *(__thiscall *MALLOC)(size_t);
+typedef void(__thiscall *FREE)(void *);
+typedef void *(__thiscall *CALLOC)(size_t, size_t);
+typedef void *(__thiscall *REALLOC)(void *, size_t);
+
+static uintptr_t AllocatorsTable[4]{
+    reinterpret_cast<uintptr_t>(&rpmalloc),
+    reinterpret_cast<uintptr_t>(&rpfree),
+    reinterpret_cast<uintptr_t>(&rpcalloc),
+    reinterpret_cast<uintptr_t>(&rprealloc),
+};
+
+#ifdef __clang__
+__attribute__((used))
+#endif
+void HookAllocators(uintptr_t *Table) {
+  memcpy(AllocatorsTable, Table, sizeof(AllocatorsTable));
+}
+#if defined(_MSC_VER) && !defined(__clang__)
+#pragma comment(linker, "/INCLUDE:?HookAllocators@@YAXPEA_K@Z")
+#endif
+
+extern "C" {
+_ACRTIMP _CRTRESTRICT void *malloc(size_t size) {
+  return reinterpret_cast<MALLOC>(AllocatorsTable[0])(size);
+}
+
+_ACRTIMP void free(void *p) { reinterpret_cast<FREE>(AllocatorsTable[1])(p); }
+
+_ACRTIMP _CRTRESTRICT void *calloc(size_t n, size_t elem_size) {
+  return reinterpret_cast<CALLOC>(AllocatorsTable[2])(n, elem_size);
+}
+_ACRTIMP _CRTRESTRICT void *realloc(void *ptr, size_t size) {
+  return reinterpret_cast<REALLOC>(AllocatorsTable[3])(ptr, size);
+}
+}
+
+// Bypass CRT debug allocator
+#ifdef _DEBUG
+void *operator new(decltype(sizeof(0)) n) noexcept(false) { return malloc(n); }
+void __CRTDECL operator delete(void *const block) noexcept { free(block); }
+
+void *operator new[](std::size_t s) throw(std::bad_alloc) { return malloc(s); }
+void operator delete[](void *p) throw() { free(p); }
+#endif
+#endif // _DLL
diff --git a/llvm/lib/Support/Windows/Path.inc b/llvm/lib/Support/Windows/Path.inc
--- a/llvm/lib/Support/Windows/Path.inc
+++ b/llvm/lib/Support/Windows/Path.inc
@@ -58,6 +58,71 @@
   }
 }
 
+// The Set/GetCurrentDirectoryW APIs store internally a state per-process. When working with llvm-buildozer we need a state per-thread (or per-context)
+static LLVM_THREAD_LOCAL wchar_t CurrentDirectory[MAX_PATH * 2]{};
+static LLVM_THREAD_LOCAL unsigned CurrentDirectoryLen{};
+
+static unsigned InternalGetCurrentDirectory(unsigned len, wchar_t* data) {
+    if (!CurrentDirectoryLen)
+        return ::GetCurrentDirectoryW(len, data);
+
+    unsigned RealLen = CurrentDirectoryLen - 1; // to never reach zero
+    if (len == 0 || data == nullptr)
+        return RealLen;
+    if (len < RealLen)
+        return RealLen + 1;
+    wmemcpy_s(data, len, CurrentDirectory, RealLen);
+    data[RealLen] = 0;
+    return RealLen;
+}
+static bool InternalSetCurrentDirectory(const wchar_t* data) {
+    if (!CurrentDirectoryLen)
+        return !!::SetCurrentDirectoryW(data);
+
+    wcscpy_s(CurrentDirectory, MAX_PATH, data);
+    CurrentDirectoryLen = wcslen(CurrentDirectory) + 1; // +1 to never reach zero
+    CurrentDirectory[CurrentDirectoryLen - 1] = 0;
+    return true;
+}
+
+#ifdef __clang__
+__attribute__((used))
+#endif
+void SetCurrentDirectoryBackdoor(const wchar_t* data) {
+    wcscpy_s(CurrentDirectory, MAX_PATH, data);
+    unsigned Len = wcslen(CurrentDirectory);
+    if (CurrentDirectory[Len - 1] == L'\\') {
+        CurrentDirectory[Len - 1] = 0;
+        --Len;
+    }
+    CurrentDirectoryLen = Len + 1; // +1 to never reach zero
+}
+#if defined(_MSC_VER) && !defined(__clang__)
+#pragma comment(linker, "/INCLUDE:?SetCurrentDirectoryBackdoor@@YAXPEB_W@Z")
+#endif
+
+static bool IsAbsoluteInternal(const wchar_t* data) {
+    if (!data || !data[0])
+        return false;
+    return (iswalpha(data[0]) && data[1] == L':') ||
+        (data[0] == L'\\' && data[0] == data[1]);
+}
+
+const wchar_t* PathAbsolutize(const wchar_t* data) {
+    if (!CurrentDirectoryLen || IsAbsoluteInternal(data))
+        return data;
+
+    CurrentDirectory[CurrentDirectoryLen - 1] = 0;
+    wchar_t* FullPath = CurrentDirectory + (CurrentDirectoryLen - 1);
+
+    if (data[0] != L'\\')
+        wcscat_s(FullPath, (MAX_PATH * 2) - CurrentDirectoryLen, L"\\");
+    wcscat_s(FullPath, (MAX_PATH * 2) - CurrentDirectoryLen, data);
+    // add an extra zero for remove_directories()
+    FullPath[wcslen(FullPath) + 1] = 0;
+    return CurrentDirectory;
+}
+
 namespace llvm {
 namespace sys  {
 namespace windows {
@@ -82,7 +147,7 @@
   if (IsAbsolute)
     CurPathLen = 0; // No contribution from current_path needed.
   else {
-    CurPathLen = ::GetCurrentDirectoryW(
+    CurPathLen = InternalGetCurrentDirectory(
         0, NULL); // Returns the size including the null terminator.
     if (CurPathLen == 0)
       return mapWindowsError(::GetLastError());
@@ -124,8 +189,13 @@
 const file_t kInvalidFile = INVALID_HANDLE_VALUE;
 
 std::string getMainExecutable(const char *argv0, void *MainExecAddr) {
+    HMODULE hm;
+    GetModuleHandleEx(GET_MODULE_HANDLE_EX_FLAG_FROM_ADDRESS |
+        GET_MODULE_HANDLE_EX_FLAG_UNCHANGED_REFCOUNT,
+        (LPCWSTR)&getMainExecutable, &hm);
+
   SmallVector<wchar_t, MAX_PATH> PathName;
-  DWORD Size = ::GetModuleFileNameW(NULL, PathName.data(), PathName.capacity());
+  DWORD Size = ::GetModuleFileNameW(hm, PathName.data(), PathName.capacity());
 
   // A zero return value indicates a failure other than insufficient space.
   if (Size == 0)
@@ -194,7 +264,7 @@
 
   do {
     cur_path.reserve(len);
-    len = ::GetCurrentDirectoryW(cur_path.capacity(), cur_path.data());
+    len = InternalGetCurrentDirectory(cur_path.capacity(), cur_path.data());
 
     // A zero return value indicates a failure other than insufficient space.
     if (len == 0)
@@ -216,7 +286,7 @@
   if (std::error_code ec = widenPath(path, wide_path))
     return ec;
 
-  if (!::SetCurrentDirectoryW(wide_path.begin()))
+  if (!InternalSetCurrentDirectory(wide_path.begin()))
     return mapWindowsError(::GetLastError());
 
   return std::error_code();
@@ -231,7 +301,7 @@
   if (std::error_code ec = widenPath(path, path_utf16, MAX_PATH - 12))
     return ec;
 
-  if (!::CreateDirectoryW(path_utf16.begin(), NULL)) {
+  if (!::CreateDirectoryW(PathAbsolutize(path_utf16.begin()), NULL)) {
     DWORD LastError = ::GetLastError();
     if (LastError != ERROR_ALREADY_EXISTS || !IgnoreExisting)
       return mapWindowsError(LastError);
@@ -250,7 +320,7 @@
   if (std::error_code ec = widenPath(to, wide_to))
     return ec;
 
-  if (!::CreateHardLinkW(wide_from.begin(), wide_to.begin(), NULL))
+  if (!::CreateHardLinkW(PathAbsolutize(wide_from.begin()), PathAbsolutize(wide_to.begin()), NULL))
     return mapWindowsError(::GetLastError());
 
   return std::error_code();
@@ -277,7 +347,7 @@
   // FILE_FLAG_BACKUP_SEMANTICS (which allows us to open directories), and
   // FILE_FLAG_OPEN_REPARSE_POINT (don't follow symlinks).
   ScopedFileHandle h(::CreateFileW(
-      c_str(path_utf16), DELETE,
+      PathAbsolutize(c_str(path_utf16)), DELETE,
       FILE_SHARE_READ | FILE_SHARE_WRITE | FILE_SHARE_DELETE, NULL,
       OPEN_EXISTING,
       FILE_ATTRIBUTE_NORMAL | FILE_FLAG_BACKUP_SEMANTICS |
@@ -299,7 +369,7 @@
   while (true) {
     VolumePath.resize(Len);
     BOOL Success =
-        ::GetVolumePathNameW(Path.data(), VolumePath.data(), VolumePath.size());
+        ::GetVolumePathNameW(PathAbsolutize(Path.data()), VolumePath.data(), VolumePath.size());
 
     if (Success)
       break;
@@ -444,14 +514,17 @@
   if (auto EC = widenPath(To, ToWide))
     return EC;
 
+  const wchar_t* AbsToWide = PathAbsolutize(ToWide.begin());
+  unsigned AbsToWideLen = wcslen(AbsToWide);
+
   std::vector<char> RenameInfoBuf(sizeof(FILE_RENAME_INFO) - sizeof(wchar_t) +
-                                  (ToWide.size() * sizeof(wchar_t)));
+                                  (AbsToWideLen * sizeof(wchar_t)));
   FILE_RENAME_INFO &RenameInfo =
       *reinterpret_cast<FILE_RENAME_INFO *>(RenameInfoBuf.data());
   RenameInfo.ReplaceIfExists = ReplaceIfExists;
   RenameInfo.RootDirectory = 0;
-  RenameInfo.FileNameLength = ToWide.size() * sizeof(wchar_t);
-  std::copy(ToWide.begin(), ToWide.end(), &RenameInfo.FileName[0]);
+  RenameInfo.FileNameLength = AbsToWideLen * sizeof(wchar_t);
+  std::copy(AbsToWide, AbsToWide + AbsToWideLen, &RenameInfo.FileName[0]);
 
   SetLastError(ERROR_SUCCESS);
   if (!SetFileInformationByHandle(FromHandle, FileRenameInfo, &RenameInfo,
@@ -483,7 +556,7 @@
       SmallVector<wchar_t, MAX_PATH> WideFrom;
       if (std::error_code EC2 = realPathFromHandle(FromHandle, WideFrom))
         return EC2;
-      if (::MoveFileExW(WideFrom.begin(), WideTo.begin(),
+      if (::MoveFileExW(PathAbsolutize(WideFrom.begin()), PathAbsolutize(WideTo.begin()),
                         MOVEFILE_REPLACE_EXISTING))
         return std::error_code();
       return mapWindowsError(GetLastError());
@@ -499,7 +572,7 @@
     // to arrange for the destination file to be deleted when the other process
     // closes it.
     ScopedFileHandle ToHandle(
-        ::CreateFileW(WideTo.begin(), GENERIC_READ | DELETE,
+        ::CreateFileW(PathAbsolutize(WideTo.begin()), GENERIC_READ | DELETE,
                       FILE_SHARE_READ | FILE_SHARE_WRITE | FILE_SHARE_DELETE,
                       NULL, OPEN_EXISTING,
                       FILE_ATTRIBUTE_NORMAL | FILE_FLAG_DELETE_ON_CLOSE, NULL));
@@ -527,7 +600,7 @@
           // might have caused the permission denied error. If that was the
           // case, we don't need to move it ourselves.
           ScopedFileHandle ToHandle2(::CreateFileW(
-              WideTo.begin(), 0,
+              PathAbsolutize(WideTo.begin()), 0,
               FILE_SHARE_READ | FILE_SHARE_WRITE | FILE_SHARE_DELETE, NULL,
               OPEN_EXISTING, FILE_ATTRIBUTE_NORMAL, NULL));
           if (!ToHandle2) {
@@ -577,7 +650,7 @@
     if (Retry != 0)
       ::Sleep(10);
     FromHandle =
-        ::CreateFileW(WideFrom.begin(), GENERIC_READ | DELETE,
+        ::CreateFileW(PathAbsolutize(WideFrom.begin()), GENERIC_READ | DELETE,
                       FILE_SHARE_READ | FILE_SHARE_WRITE | FILE_SHARE_DELETE,
                       NULL, OPEN_EXISTING, FILE_ATTRIBUTE_NORMAL, NULL);
     if (FromHandle)
@@ -609,7 +682,7 @@
   if (std::error_code EC = widenPath(Path, PathUtf16))
     return EC;
 
-  DWORD Attributes = ::GetFileAttributesW(PathUtf16.begin());
+  DWORD Attributes = ::GetFileAttributesW(PathAbsolutize(PathUtf16.begin()));
 
   if (Attributes == INVALID_FILE_ATTRIBUTES) {
     // See if the file didn't actually exist.
@@ -753,7 +826,7 @@
   if (std::error_code ec = widenPath(path8, path_utf16))
     return ec;
 
-  DWORD attr = ::GetFileAttributesW(path_utf16.begin());
+  DWORD attr = ::GetFileAttributesW(PathAbsolutize(path_utf16.begin()));
   if (attr == INVALID_FILE_ATTRIBUTES)
     return getStatus(INVALID_HANDLE_VALUE, result);
 
@@ -763,7 +836,7 @@
     Flags |= FILE_FLAG_OPEN_REPARSE_POINT;
 
   ScopedFileHandle h(
-      ::CreateFileW(path_utf16.begin(), 0, // Attributes only.
+      ::CreateFileW(PathAbsolutize(path_utf16.begin()), 0, // Attributes only.
                     FILE_SHARE_DELETE | FILE_SHARE_READ | FILE_SHARE_WRITE,
                     NULL, OPEN_EXISTING, Flags, 0));
   if (!h)
@@ -790,7 +863,7 @@
   if (std::error_code EC = widenPath(Path, PathUTF16))
     return EC;
 
-  DWORD Attributes = ::GetFileAttributesW(PathUTF16.begin());
+  DWORD Attributes = ::GetFileAttributesW(PathAbsolutize(PathUTF16.begin()));
   if (Attributes == INVALID_FILE_ATTRIBUTES)
     return mapWindowsError(GetLastError());
 
@@ -810,7 +883,7 @@
     Attributes &= ~FILE_ATTRIBUTE_NORMAL;
   }
 
-  if (!::SetFileAttributesW(PathUTF16.begin(), Attributes))
+  if (!::SetFileAttributesW(PathAbsolutize(PathUTF16.begin()), Attributes))
     return mapWindowsError(GetLastError());
 
   return std::error_code();
@@ -984,7 +1057,7 @@
   //  Get the first directory entry.
   WIN32_FIND_DATAW FirstFind;
   ScopedFindHandle FindHandle(::FindFirstFileExW(
-      c_str(PathUTF16), FindExInfoBasic, &FirstFind, FindExSearchNameMatch,
+      PathAbsolutize(c_str(PathUTF16)), FindExInfoBasic, &FirstFind, FindExSearchNameMatch,
       NULL, FIND_FIRST_EX_LARGE_FETCH));
   if (!FindHandle)
     return mapWindowsError(::GetLastError());
@@ -1137,7 +1210,7 @@
   SA.bInheritHandle = Inherit;
 
   HANDLE H =
-      ::CreateFileW(PathUTF16.begin(), Access,
+      ::CreateFileW(PathAbsolutize(PathUTF16.begin()), Access,
                     FILE_SHARE_READ | FILE_SHARE_WRITE | FILE_SHARE_DELETE, &SA,
                     Disp, Flags, NULL);
   if (H == INVALID_HANDLE_VALUE) {
@@ -1339,7 +1412,7 @@
 
   SHFILEOPSTRUCTW shfos = {};
   shfos.wFunc = FO_DELETE;
-  shfos.pFrom = Path16.data();
+  shfos.pFrom = PathAbsolutize(Path16.data());
   shfos.fFlags = FOF_NO_UI;
 
   int result = ::SHFileOperationW(&shfos);
diff --git a/llvm/lib/Support/Windows/Process.inc b/llvm/lib/Support/Windows/Process.inc
--- a/llvm/lib/Support/Windows/Process.inc
+++ b/llvm/lib/Support/Windows/Process.inc
@@ -25,6 +25,8 @@
 #include <io.h>
 #include <psapi.h>
 #include <shellapi.h>
+#include <winternl.h>
+#include <dbghelp.h>
 
 #if !defined(__MINGW32__)
  #pragma comment(lib, "psapi.lib")
@@ -36,6 +38,8 @@
 //===          and must not be UNIX code
 //===----------------------------------------------------------------------===//
 
+const wchar_t* PathAbsolutize(const wchar_t* data);
+
 #ifdef __MINGW32__
 // This ban should be lifted when MinGW 1.0+ has defined this value.
 #  define _HEAPOK (-2)
@@ -174,7 +178,7 @@
   // directory portion of the file path.  For example, it doesn't handle
   // "*\foo.c" nor "s?c\bar.cpp".
   WIN32_FIND_DATAW FileData;
-  HANDLE FindHandle = FindFirstFileW(ArgW.data(), &FileData);
+  HANDLE FindHandle = FindFirstFileW(PathAbsolutize(ArgW.data()), &FileData);
   if (FindHandle == INVALID_HANDLE_VALUE) {
     Args.push_back(Arg.data());
     return EC;
@@ -509,3 +513,72 @@
   TerminateProcess(GetCurrentProcess(), RetCode);
   llvm_unreachable("TerminateProcess doesn't return");
 }
+
+extern LLVM_THREAD_LOCAL HANDLE CurrentHandle; // in InitLLVM.cpp
+
+bool sys::Process::IsInTLS(const void *Data) {
+  DWORD Size = 0;
+  PIMAGE_TLS_DIRECTORY64 TLS =
+      (PIMAGE_TLS_DIRECTORY64)ImageDirectoryEntryToData(
+          CurrentHandle, TRUE, IMAGE_DIRECTORY_ENTRY_TLS, &Size);
+  if (!TLS)
+    return false;
+
+  PTEB TEB = NtCurrentTeb();
+
+  uint64_t **ProcessTLS =
+      (uint64_t **)TEB->Reserved1[11]; // ThreadLocalStoragePointer
+
+  char *ThreadTLS =
+      (char *)*(ProcessTLS + *(unsigned int *)TLS->AddressOfIndex);
+  unsigned TLSLen = TLS->EndAddressOfRawData - TLS->StartAddressOfRawData;
+
+  return Data >= ThreadTLS && Data < (ThreadTLS + TLSLen);
+}
+
+unsigned sys::Process::GetOffsetInTLS(const void *Data) {
+  DWORD Size = 0;
+  PIMAGE_TLS_DIRECTORY64 TLS =
+      (PIMAGE_TLS_DIRECTORY64)ImageDirectoryEntryToData(
+          CurrentHandle, TRUE, IMAGE_DIRECTORY_ENTRY_TLS, &Size);
+  if (!TLS)
+    return 0;
+
+  PTEB TEB = NtCurrentTeb();
+
+  uint64_t **ProcessTLS =
+      (uint64_t **)TEB->Reserved1[11]; // ThreadLocalStoragePointer
+
+  char *ThreadTLS =
+      (char *)*(ProcessTLS + *(unsigned int *)TLS->AddressOfIndex);
+  unsigned TLSLen = TLS->EndAddressOfRawData - TLS->StartAddressOfRawData;
+
+  if (Data >= ThreadTLS && Data < (ThreadTLS + TLSLen))
+    return ((const char *)Data - ThreadTLS) + 1;
+  return 0;
+}
+
+void *sys::Process::RemapIntoTLS(void *Data, unsigned TLSOffset) {
+  if (!TLSOffset)
+    return Data;
+
+  DWORD Size = 0;
+  PIMAGE_TLS_DIRECTORY64 TLS =
+      (PIMAGE_TLS_DIRECTORY64)ImageDirectoryEntryToData(
+          CurrentHandle, TRUE, IMAGE_DIRECTORY_ENTRY_TLS, &Size);
+  if (!TLS)
+    return Data;
+
+  PTEB TEB = NtCurrentTeb();
+
+  uint64_t **ProcessTLS =
+      (uint64_t **)TEB->Reserved1[11]; // ThreadLocalStoragePointer
+
+  char *ThreadTLS =
+      (char *)*(ProcessTLS + *(unsigned int *)TLS->AddressOfIndex);
+  unsigned TLSLen = TLS->EndAddressOfRawData - TLS->StartAddressOfRawData;
+  assert(TLSOffset <= TLSLen);
+  (void)TLSLen;
+
+  return ThreadTLS + (TLSOffset - 1);
+}
diff --git a/llvm/lib/Support/Windows/Program.inc b/llvm/lib/Support/Windows/Program.inc
--- a/llvm/lib/Support/Windows/Program.inc
+++ b/llvm/lib/Support/Windows/Program.inc
@@ -30,6 +30,8 @@
 //===          and must not be UNIX code
 //===----------------------------------------------------------------------===//
 
+const wchar_t* PathAbsolutize(const wchar_t* data);
+
 namespace llvm {
 
 ProcessInfo::ProcessInfo() : Pid(0), Process(0), ReturnCode(0) {}
@@ -81,7 +83,7 @@
               windows::UTF8ToUTF16(Twine(Name + Ext).str(), U16NameExt))
         return EC;
 
-      Len = ::SearchPathW(Path, c_str(U16NameExt), nullptr,
+      Len = ::SearchPathW(Path ? PathAbsolutize(Path) : nullptr, c_str(U16NameExt), nullptr,
                           U16Result.capacity(), U16Result.data(), nullptr);
     } while (Len > U16Result.capacity());
 
@@ -156,7 +158,7 @@
     if (sys::windows::widenPath(fname, fnameUnicode))
       return INVALID_HANDLE_VALUE;
   }
-  h = CreateFileW(fnameUnicode.data(), fd ? GENERIC_WRITE : GENERIC_READ,
+  h = CreateFileW(PathAbsolutize(fnameUnicode.data()), fd ? GENERIC_WRITE : GENERIC_READ,
                   FILE_SHARE_READ, &sa, fd == 0 ? OPEN_EXISTING : CREATE_ALWAYS,
                   FILE_ATTRIBUTE_NORMAL, NULL);
   if (h == INVALID_HANDLE_VALUE) {
diff --git a/llvm/lib/Support/raw_ostream.cpp b/llvm/lib/Support/raw_ostream.cpp
--- a/llvm/lib/Support/raw_ostream.cpp
+++ b/llvm/lib/Support/raw_ostream.cpp
@@ -19,6 +19,7 @@
 #include "llvm/Support/FileSystem.h"
 #include "llvm/Support/Format.h"
 #include "llvm/Support/FormatVariadic.h"
+#include "llvm/Support/InitLLVM.h"
 #include "llvm/Support/MathExtras.h"
 #include "llvm/Support/NativeFormatting.h"
 #include "llvm/Support/Process.h"
@@ -881,7 +882,40 @@
 //  outs(), errs(), nulls()
 //===----------------------------------------------------------------------===//
 
-raw_fd_ostream &llvm::outs() {
+struct LocalStd {
+  bool Initialized;
+  std::string Str;
+  raw_string_ostream S{Str};
+};
+static LLVM_THREAD_LOCAL char LocalStream[2][sizeof(LocalStd)]{};
+
+#define RETURN_LOCAL_STREAM(I)                                                 \
+  if (InitLLVM::RunningInBuildozer()) {                                        \
+    LocalStd &S = (LocalStd &)LocalStream[I];                                  \
+    if (!S.Initialized) {                                                      \
+      new (LocalStream[I]) LocalStd;                                           \
+      S.Initialized = true;                                                    \
+    }                                                                          \
+    return S.S;                                                                \
+  }
+
+#ifdef __clang__
+__attribute__((used))
+#endif
+void CaptureLocalOutput(llvm::StringRef& StdErr,
+    llvm::StringRef& StdOut) {
+  auto &Outs = (raw_string_ostream &)llvm::outs();
+  StdOut = Outs.str();
+  auto &Err = (raw_string_ostream &)llvm::errs();
+  StdErr = Err.str();
+}
+#if defined(_MSC_VER) && !defined(__clang__)
+#pragma comment(linker,                                                        \
+                "/INCLUDE:?CaptureLocalOutput@@YAXAEAVStringRef@llvm@@0@Z")
+#endif
+
+raw_ostream &llvm::outs() {
+  RETURN_LOCAL_STREAM(0)
   // Set buffer settings to model stdout behavior.
   std::error_code EC;
   static raw_fd_ostream S("-", EC, sys::fs::OF_None);
@@ -889,7 +923,8 @@
   return S;
 }
 
-raw_fd_ostream &llvm::errs() {
+raw_ostream &llvm::errs() {
+  RETURN_LOCAL_STREAM(1)
   // Set standard error to be unbuffered and tied to outs() by default.
   static raw_fd_ostream S(STDERR_FILENO, false, true);
   return S;
@@ -928,10 +963,6 @@
   return Ret;
 }
 
-bool raw_fd_stream::classof(const raw_ostream *OS) {
-  return OS->get_kind() == OStreamKind::OK_FDStream;
-}
-
 //===----------------------------------------------------------------------===//
 //  raw_string_ostream
 //===----------------------------------------------------------------------===//
diff --git a/llvm/lib/TableGen/Error.cpp b/llvm/lib/TableGen/Error.cpp
--- a/llvm/lib/TableGen/Error.cpp
+++ b/llvm/lib/TableGen/Error.cpp
@@ -11,11 +11,12 @@
 //
 //===----------------------------------------------------------------------===//
 
+#include "llvm/TableGen/Error.h"
 #include "llvm/ADT/Twine.h"
-#include "llvm/Support/raw_ostream.h"
+#include "llvm/Support/Process.h"
 #include "llvm/Support/Signals.h"
 #include "llvm/Support/WithColor.h"
-#include "llvm/TableGen/Error.h"
+#include "llvm/Support/raw_ostream.h"
 #include "llvm/TableGen/Record.h"
 #include <cstdlib>
 
@@ -56,14 +57,14 @@
   PrintNote(Msg);
   // The following call runs the file cleanup handlers.
   sys::RunInterruptHandlers();
-  std::exit(1);
+  sys::Process::Exit(1);
 }
 
 void PrintFatalNote(ArrayRef<SMLoc> NoteLoc, const Twine &Msg) {
   PrintNote(NoteLoc, Msg);
   // The following call runs the file cleanup handlers.
   sys::RunInterruptHandlers();
-  std::exit(1);
+  sys::Process::Exit(1);
 }
 
 // This method takes a Record and uses the source location
@@ -72,7 +73,7 @@
   PrintNote(Rec->getLoc(), Msg);
   // The following call runs the file cleanup handlers.
   sys::RunInterruptHandlers();
-  std::exit(1);
+  sys::Process::Exit(1);
 }
 
 // This method takes a RecordVal and uses the source location
@@ -81,7 +82,7 @@
   PrintNote(RecVal->getLoc(), Msg);
   // The following call runs the file cleanup handlers.
   sys::RunInterruptHandlers();
-  std::exit(1);
+  sys::Process::Exit(1);
 }
 
 // Functions to print warnings.
@@ -126,14 +127,14 @@
   PrintError(Msg);
   // The following call runs the file cleanup handlers.
   sys::RunInterruptHandlers();
-  std::exit(1);
+  sys::Process::Exit(1);
 }
 
 void PrintFatalError(ArrayRef<SMLoc> ErrorLoc, const Twine &Msg) {
   PrintError(ErrorLoc, Msg);
   // The following call runs the file cleanup handlers.
   sys::RunInterruptHandlers();
-  std::exit(1);
+  sys::Process::Exit(1);
 }
 
 // This method takes a Record and uses the source location
@@ -142,7 +143,7 @@
   PrintError(Rec->getLoc(), Msg);
   // The following call runs the file cleanup handlers.
   sys::RunInterruptHandlers();
-  std::exit(1);
+  sys::Process::Exit(1);
 }
 
 // This method takes a RecordVal and uses the source location
@@ -151,7 +152,7 @@
   PrintError(RecVal->getLoc(), Msg);
   // The following call runs the file cleanup handlers.
   sys::RunInterruptHandlers();
-  std::exit(1);
+  sys::Process::Exit(1);
 }
 
 // Check an assertion: Obtain the condition value and be sure it is true.
diff --git a/llvm/lib/Target/AMDGPU/AMDGPULowerIntrinsics.cpp b/llvm/lib/Target/AMDGPU/AMDGPULowerIntrinsics.cpp
--- a/llvm/lib/Target/AMDGPU/AMDGPULowerIntrinsics.cpp
+++ b/llvm/lib/Target/AMDGPU/AMDGPULowerIntrinsics.cpp
@@ -26,7 +26,7 @@
 
 namespace {
 
-static int MaxStaticSize;
+static LLVM_THREAD_LOCAL int MaxStaticSize;
 
 static cl::opt<int, true> MemIntrinsicExpandSizeThresholdOpt(
   "amdgpu-mem-intrinsic-expand-size",
diff --git a/llvm/lib/Target/AMDGPU/AMDGPUTargetMachine.h b/llvm/lib/Target/AMDGPU/AMDGPUTargetMachine.h
--- a/llvm/lib/Target/AMDGPU/AMDGPUTargetMachine.h
+++ b/llvm/lib/Target/AMDGPU/AMDGPUTargetMachine.h
@@ -32,10 +32,10 @@
   StringRef getFeatureString(const Function &F) const;
 
 public:
-  static bool EnableLateStructurizeCFG;
-  static bool EnableFunctionCalls;
-  static bool EnableFixedFunctionABI;
-  static bool EnableLowerModuleLDS;
+  static LLVM_THREAD_LOCAL bool EnableLateStructurizeCFG;
+  static LLVM_THREAD_LOCAL bool EnableFunctionCalls;
+  static LLVM_THREAD_LOCAL bool EnableFixedFunctionABI;
+  static LLVM_THREAD_LOCAL bool EnableLowerModuleLDS;
 
   AMDGPUTargetMachine(const Target &T, const Triple &TT, StringRef CPU,
                       StringRef FS, TargetOptions Options,
diff --git a/llvm/lib/Target/AMDGPU/AMDGPUTargetMachine.cpp b/llvm/lib/Target/AMDGPU/AMDGPUTargetMachine.cpp
--- a/llvm/lib/Target/AMDGPU/AMDGPUTargetMachine.cpp
+++ b/llvm/lib/Target/AMDGPU/AMDGPUTargetMachine.cpp
@@ -389,10 +389,10 @@
   }
 }
 
-bool AMDGPUTargetMachine::EnableLateStructurizeCFG = false;
-bool AMDGPUTargetMachine::EnableFunctionCalls = false;
-bool AMDGPUTargetMachine::EnableFixedFunctionABI = false;
-bool AMDGPUTargetMachine::EnableLowerModuleLDS = true;
+LLVM_THREAD_LOCAL bool AMDGPUTargetMachine::EnableLateStructurizeCFG = false;
+LLVM_THREAD_LOCAL bool AMDGPUTargetMachine::EnableFunctionCalls = false;
+LLVM_THREAD_LOCAL bool AMDGPUTargetMachine::EnableFixedFunctionABI = false;
+LLVM_THREAD_LOCAL bool AMDGPUTargetMachine::EnableLowerModuleLDS = true;
 
 AMDGPUTargetMachine::~AMDGPUTargetMachine() = default;
 
diff --git a/llvm/lib/Target/AMDGPU/SIPreEmitPeephole.cpp b/llvm/lib/Target/AMDGPU/SIPreEmitPeephole.cpp
--- a/llvm/lib/Target/AMDGPU/SIPreEmitPeephole.cpp
+++ b/llvm/lib/Target/AMDGPU/SIPreEmitPeephole.cpp
@@ -20,7 +20,7 @@
 
 #define DEBUG_TYPE "si-pre-emit-peephole"
 
-static unsigned SkipThreshold;
+static LLVM_THREAD_LOCAL unsigned SkipThreshold;
 
 static cl::opt<unsigned, true> SkipThresholdFlag(
     "amdgpu-skip-threshold", cl::Hidden,
diff --git a/llvm/lib/Target/RISCV/MCTargetDesc/RISCVBaseInfo.cpp b/llvm/lib/Target/RISCV/MCTargetDesc/RISCVBaseInfo.cpp
--- a/llvm/lib/Target/RISCV/MCTargetDesc/RISCVBaseInfo.cpp
+++ b/llvm/lib/Target/RISCV/MCTargetDesc/RISCVBaseInfo.cpp
@@ -135,6 +135,7 @@
   case RISCVII::VLMUL::LMUL_F8:
     return std::make_pair(1 << (8 - static_cast<unsigned>(VLMUL)), true);
   }
+  llvm_unreachable("Unexpected LMUL value!");
 }
 
 void RISCVVType::printVType(unsigned VType, raw_ostream &OS) {
diff --git a/llvm/lib/Target/TargetMachineC.cpp b/llvm/lib/Target/TargetMachineC.cpp
--- a/llvm/lib/Target/TargetMachineC.cpp
+++ b/llvm/lib/Target/TargetMachineC.cpp
@@ -45,7 +45,7 @@
 }
 
 LLVMTargetRef LLVMGetFirstTarget() {
-  if (TargetRegistry::targets().begin() == TargetRegistry::targets().end()) {
+  if (TargetRegistry::targets().empty()) {
     return nullptr;
   }
 
diff --git a/llvm/lib/Target/X86/MCTargetDesc/X86AsmBackend.cpp b/llvm/lib/Target/X86/MCTargetDesc/X86AsmBackend.cpp
--- a/llvm/lib/Target/X86/MCTargetDesc/X86AsmBackend.cpp
+++ b/llvm/lib/Target/X86/MCTargetDesc/X86AsmBackend.cpp
@@ -73,7 +73,7 @@
   void addKind(X86::AlignBranchBoundaryKind Value) { AlignBranchKind |= Value; }
 };
 
-X86AlignBranchKind X86AlignBranchKindLoc;
+LLVM_THREAD_LOCAL X86AlignBranchKind X86AlignBranchKindLoc;
 
 cl::opt<unsigned> X86AlignBranchBoundary(
     "x86-align-branch-boundary", cl::init(0),
diff --git a/llvm/lib/ToolDrivers/llvm-lib/LibDriver.cpp b/llvm/lib/ToolDrivers/llvm-lib/LibDriver.cpp
--- a/llvm/lib/ToolDrivers/llvm-lib/LibDriver.cpp
+++ b/llvm/lib/ToolDrivers/llvm-lib/LibDriver.cpp
@@ -103,7 +103,7 @@
     return;
   handleAllErrors(std::move(E), [&](const llvm::ErrorInfoBase &EIB) {
     llvm::errs() << "error opening '" << File << "': " << EIB.message() << '\n';
-    exit(1);
+    sys::Process::Exit(1);
   });
 }
 
diff --git a/llvm/lib/Transforms/IPO/Attributor.cpp b/llvm/lib/Transforms/IPO/Attributor.cpp
--- a/llvm/lib/Transforms/IPO/Attributor.cpp
+++ b/llvm/lib/Transforms/IPO/Attributor.cpp
@@ -85,7 +85,7 @@
     cl::desc(
         "Maximal number of chained initializations (to avoid stack overflows)"),
     cl::location(MaxInitializationChainLength), cl::init(1024));
-unsigned llvm::MaxInitializationChainLength;
+LLVM_THREAD_LOCAL unsigned llvm::MaxInitializationChainLength;
 
 static cl::opt<bool> VerifyMaxFixpointIterations(
     "attributor-max-iterations-verify", cl::Hidden,
diff --git a/llvm/lib/Transforms/IPO/AttributorAttributes.cpp b/llvm/lib/Transforms/IPO/AttributorAttributes.cpp
--- a/llvm/lib/Transforms/IPO/AttributorAttributes.cpp
+++ b/llvm/lib/Transforms/IPO/AttributorAttributes.cpp
@@ -48,7 +48,8 @@
                                        cl::Hidden);
 
 template <>
-unsigned llvm::PotentialConstantIntValuesState::MaxPotentialValues = 0;
+LLVM_THREAD_LOCAL unsigned
+    llvm::PotentialConstantIntValuesState::MaxPotentialValues = 0;
 
 static cl::opt<unsigned, true> MaxPotentialValues(
     "attributor-max-potential-values", cl::Hidden,
diff --git a/llvm/lib/Transforms/Instrumentation/ControlHeightReduction.cpp b/llvm/lib/Transforms/Instrumentation/ControlHeightReduction.cpp
--- a/llvm/lib/Transforms/Instrumentation/ControlHeightReduction.cpp
+++ b/llvm/lib/Transforms/Instrumentation/ControlHeightReduction.cpp
@@ -32,6 +32,7 @@
 #include "llvm/Support/BranchProbability.h"
 #include "llvm/Support/CommandLine.h"
 #include "llvm/Support/MemoryBuffer.h"
+#include "llvm/Support/Process.h"
 #include "llvm/Transforms/Utils.h"
 #include "llvm/Transforms/Utils/BasicBlockUtils.h"
 #include "llvm/Transforms/Utils/Cloning.h"
@@ -73,7 +74,7 @@
     auto FileOrErr = MemoryBuffer::getFile(CHRModuleList);
     if (!FileOrErr) {
       errs() << "Error: Couldn't read the chr-module-list file " << CHRModuleList << "\n";
-      std::exit(1);
+      sys::Process::Exit(1);
     }
     StringRef Buf = FileOrErr->get()->getBuffer();
     SmallVector<StringRef, 0> Lines;
@@ -88,7 +89,7 @@
     auto FileOrErr = MemoryBuffer::getFile(CHRFunctionList);
     if (!FileOrErr) {
       errs() << "Error: Couldn't read the chr-function-list file " << CHRFunctionList << "\n";
-      std::exit(1);
+      sys::Process::Exit(1);
     }
     StringRef Buf = FileOrErr->get()->getBuffer();
     SmallVector<StringRef, 0> Lines;
diff --git a/llvm/lib/Transforms/Instrumentation/GCOVProfiling.cpp b/llvm/lib/Transforms/Instrumentation/GCOVProfiling.cpp
--- a/llvm/lib/Transforms/Instrumentation/GCOVProfiling.cpp
+++ b/llvm/lib/Transforms/Instrumentation/GCOVProfiling.cpp
@@ -845,7 +845,8 @@
       DISubprogram *SP = F.getSubprogram();
       unsigned EndLine;
       if (!SP) continue;
-      if (!functionHasLines(F, EndLine) || !isFunctionInstrumented(F))
+      if (SP->isArtificial() || !functionHasLines(F, EndLine) ||
+          !isFunctionInstrumented(F))
         continue;
       // TODO: Functions using scope-based EH are currently not supported.
       if (isUsingScopeBasedEH(F)) continue;
diff --git a/llvm/lib/Transforms/Scalar/LoopIdiomRecognize.cpp b/llvm/lib/Transforms/Scalar/LoopIdiomRecognize.cpp
--- a/llvm/lib/Transforms/Scalar/LoopIdiomRecognize.cpp
+++ b/llvm/lib/Transforms/Scalar/LoopIdiomRecognize.cpp
@@ -115,14 +115,14 @@
 STATISTIC(NumShiftUntilZero,
           "Number of uncountable loops recognized as 'shift until zero' idiom");
 
-bool DisableLIRP::All;
+LLVM_THREAD_LOCAL bool DisableLIRP::All;
 static cl::opt<bool, true>
     DisableLIRPAll("disable-" DEBUG_TYPE "-all",
                    cl::desc("Options to disable Loop Idiom Recognize Pass."),
                    cl::location(DisableLIRP::All), cl::init(false),
                    cl::ReallyHidden);
 
-bool DisableLIRP::Memset;
+LLVM_THREAD_LOCAL bool DisableLIRP::Memset;
 static cl::opt<bool, true>
     DisableLIRPMemset("disable-" DEBUG_TYPE "-memset",
                       cl::desc("Proceed with loop idiom recognize pass, but do "
@@ -130,7 +130,7 @@
                       cl::location(DisableLIRP::Memset), cl::init(false),
                       cl::ReallyHidden);
 
-bool DisableLIRP::Memcpy;
+LLVM_THREAD_LOCAL bool DisableLIRP::Memcpy;
 static cl::opt<bool, true>
     DisableLIRPMemcpy("disable-" DEBUG_TYPE "-memcpy",
                       cl::desc("Proceed with loop idiom recognize pass, but do "
diff --git a/llvm/lib/Transforms/Scalar/RewriteStatepointsForGC.cpp b/llvm/lib/Transforms/Scalar/RewriteStatepointsForGC.cpp
--- a/llvm/lib/Transforms/Scalar/RewriteStatepointsForGC.cpp
+++ b/llvm/lib/Transforms/Scalar/RewriteStatepointsForGC.cpp
@@ -97,9 +97,9 @@
                            cl::init(6));
 
 #ifdef EXPENSIVE_CHECKS
-static bool ClobberNonLive = true;
+static LLVM_THREAD_LOCAL bool ClobberNonLive = true;
 #else
-static bool ClobberNonLive = false;
+static LLVM_THREAD_LOCAL bool ClobberNonLive = false;
 #endif
 
 static cl::opt<bool, true> ClobberNonLiveOverride("rs4gc-clobber-non-live",
diff --git a/llvm/lib/Transforms/Utils/LCSSA.cpp b/llvm/lib/Transforms/Utils/LCSSA.cpp
--- a/llvm/lib/Transforms/Utils/LCSSA.cpp
+++ b/llvm/lib/Transforms/Utils/LCSSA.cpp
@@ -58,9 +58,9 @@
 STATISTIC(NumLCSSA, "Number of live out of a loop variables");
 
 #ifdef EXPENSIVE_CHECKS
-static bool VerifyLoopLCSSA = true;
+static LLVM_THREAD_LOCAL bool VerifyLoopLCSSA = true;
 #else
-static bool VerifyLoopLCSSA = false;
+static LLVM_THREAD_LOCAL bool VerifyLoopLCSSA = false;
 #endif
 static cl::opt<bool, true>
     VerifyLoopLCSSAFlag("verify-loop-lcssa", cl::location(VerifyLoopLCSSA),
diff --git a/llvm/tools/bugpoint/BugDriver.h b/llvm/tools/bugpoint/BugDriver.h
--- a/llvm/tools/bugpoint/BugDriver.h
+++ b/llvm/tools/bugpoint/BugDriver.h
@@ -39,7 +39,7 @@
 
 class CC;
 
-extern bool DisableSimplifyCFG;
+extern LLVM_THREAD_LOCAL bool DisableSimplifyCFG;
 
 /// BugpointIsInterrupted - Set to true when the user presses ctrl-c.
 ///
diff --git a/llvm/tools/bugpoint/ExtractFunction.cpp b/llvm/tools/bugpoint/ExtractFunction.cpp
--- a/llvm/tools/bugpoint/ExtractFunction.cpp
+++ b/llvm/tools/bugpoint/ExtractFunction.cpp
@@ -36,7 +36,7 @@
 #define DEBUG_TYPE "bugpoint"
 
 namespace llvm {
-bool DisableSimplifyCFG = false;
+LLVM_THREAD_LOCAL bool DisableSimplifyCFG = false;
 extern cl::opt<std::string> OutputPrefix;
 } // End llvm namespace
 
diff --git a/llvm/tools/llc/llc.cpp b/llvm/tools/llc/llc.cpp
--- a/llvm/tools/llc/llc.cpp
+++ b/llvm/tools/llc/llc.cpp
@@ -191,7 +191,7 @@
 };
 }
 
-static RunPassOption RunPassOpt;
+static LLVM_THREAD_LOCAL RunPassOption RunPassOpt;
 
 static cl::opt<RunPassOption, true, cl::parser<std::string>> RunPass(
     "run-pass",
diff --git a/llvm/tools/llvm-buildozer/CMakeLists.txt b/llvm/tools/llvm-buildozer/CMakeLists.txt
new file mode 100644
--- /dev/null
+++ b/llvm/tools/llvm-buildozer/CMakeLists.txt
@@ -0,0 +1,13 @@
+set(LLVM_LINK_COMPONENTS
+  Core
+  Support
+  )
+
+add_llvm_tool(llvm-buildozer
+  buildozer-main.cpp
+  LoadEXE.cpp
+  CompDB.cpp
+
+  DEPENDS
+  intrinsics_gen
+  )
\ No newline at end of file
diff --git a/llvm/tools/llvm-buildozer/CompDB.h b/llvm/tools/llvm-buildozer/CompDB.h
new file mode 100644
--- /dev/null
+++ b/llvm/tools/llvm-buildozer/CompDB.h
@@ -0,0 +1,28 @@
+//===---------- Buildozer - A Lightweight LLVM Build System ---------------===//
+//
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
+//
+//===----------------------------------------------------------------------===//
+
+#include "llvm/ADT/StringRef.h"
+#include "llvm/Support/StringSaver.h"
+#include <vector>
+
+namespace buildozer {
+struct WorkUnit {
+  llvm::StringRef Directory;
+  llvm::StringRef File;
+  llvm::StringRef Output;
+  llvm::SmallVector<const char *, 0> Arguments;
+};
+typedef std::vector<WorkUnit> CompilationSeq;
+
+struct CompilationDB {
+  CompilationSeq Build;
+  llvm::BumpPtrAllocator BumpAlloc;
+  llvm::StringSaver Saver{BumpAlloc};
+};
+void ReadCompilationDatabase(llvm::StringRef FilePath, CompilationDB &DB);
+} // namespace buildozer
\ No newline at end of file
diff --git a/llvm/tools/llvm-buildozer/CompDB.cpp b/llvm/tools/llvm-buildozer/CompDB.cpp
new file mode 100644
--- /dev/null
+++ b/llvm/tools/llvm-buildozer/CompDB.cpp
@@ -0,0 +1,44 @@
+//===---------- Buildozer - A Lightweight LLVM Build System ---------------===//
+//
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
+//
+//===----------------------------------------------------------------------===//
+
+#include "CompDB.h"
+#include "llvm/Support/JSON.h"
+#include "llvm/Support/MemoryBuffer.h"
+
+namespace buildozer {
+void ReadCompilationDatabase(llvm::StringRef FilePath, CompilationDB &DB) {
+  auto F = llvm::MemoryBuffer::getFile(FilePath);
+  if (auto E = F.getError())
+    return; // errorCodeToError(err);
+
+  auto Doc = llvm::json::parse((*F)->getBuffer());
+  if (!Doc) {
+    consumeError(Doc.takeError());
+    return;
+  }
+
+  llvm::json::Array *All = Doc->getAsArray();
+  for (llvm::json::Value &E : *All) {
+    llvm::json::Object *O = E.getAsObject();
+    DB.Build.emplace_back();
+    WorkUnit &W = DB.Build.back();
+
+    W.Directory = DB.Saver.save(*O->getString("directory")).data();
+    auto File = O->getString("file");
+    if (File)
+      W.File = DB.Saver.save(*File).data();
+    W.Output = DB.Saver.save(*O->getString("output")).data();
+
+    llvm::json::Array *Args = O->getArray("arguments");
+    for (llvm::json::Value &Arg : *Args) {
+      llvm::StringRef S = *Arg.getAsString();
+      W.Arguments.push_back(DB.Saver.save(S).data());
+    }
+  }
+}
+} // namespace buildozer
\ No newline at end of file
diff --git a/llvm/tools/llvm-buildozer/LoadEXE.h b/llvm/tools/llvm-buildozer/LoadEXE.h
new file mode 100644
--- /dev/null
+++ b/llvm/tools/llvm-buildozer/LoadEXE.h
@@ -0,0 +1,18 @@
+//===---------- Buildozer - A Lightweight LLVM Build System ---------------===//
+//
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
+//
+//===----------------------------------------------------------------------===//
+
+#include "llvm/ADT/StringRef.h"
+
+namespace buildozer {
+// returns a ModuleIndex
+int ImportEXE(llvm::StringRef EXE);
+void Launch(int ModuleIndex, llvm::StringRef CurDir,
+            const llvm::SmallVectorImpl<const char *> &Argv);
+void Terminate(int ModuleIndex, std::string &StdErr, std::string &StdOut);
+void TerminateAll();
+} // namespace buildozer
\ No newline at end of file
diff --git a/llvm/tools/llvm-buildozer/LoadEXE.cpp b/llvm/tools/llvm-buildozer/LoadEXE.cpp
new file mode 100644
--- /dev/null
+++ b/llvm/tools/llvm-buildozer/LoadEXE.cpp
@@ -0,0 +1,620 @@
+//===---------- Buildozer - A Lightweight LLVM Build System ---------------===//
+//
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
+//
+//===----------------------------------------------------------------------===//
+
+#include "llvm/ADT/StringRef.h"
+#include "llvm/Support/Allocator.h"
+#include "llvm/Support/ConvertUTF.h"
+#include "llvm/Support/CrashRecoveryContext.h"
+#include "llvm/Support/InitLLVM.h"
+#include "llvm/Support/Path.h"
+#include "llvm/Support/StringSaver.h"
+#include "llvm/Support/Windows/WindowsSupport.h"
+
+#include <dbghelp.h>
+#include <windows.h>
+#include <winnt.h>
+#include <winternl.h>
+
+#include <thread>
+#include <vector>
+
+#pragma comment(lib, "dbghelp.lib")
+
+struct ExecModule {
+  llvm::StringRef FullPath;
+  llvm::StringRef Name;
+  HANDLE Handle{};
+  void *TLSInitBuffer{}; // .tls buffer after CRT initialization
+  HANDLE ExitEvent{};
+  HANDLE TLSThreadHandle{};
+
+  typedef int(__thiscall *MAIN)(int, const char **);
+  MAIN Main;
+
+  typedef void(__thiscall *SETCURDIR)(const wchar_t *);
+  SETCURDIR SD;
+
+  typedef void(__thiscall *SETMODULE)(void * /*ModuleHandle*/);
+  SETMODULE SMod;
+
+  typedef void(WINAPI *DYNTLSINIT)(PVOID, DWORD /*dwReason*/, LPVOID);
+  DYNTLSINIT InitTLS;
+
+  typedef void(WINAPI *DYNTLSDTOR)(HANDLE, DWORD /*dwReason*/, LPVOID);
+  DYNTLSDTOR DestroyTLS;
+
+  typedef void(__thiscall *CAPTUREOUT)(llvm::StringRef &StdErr,
+                                       llvm::StringRef &StdOut);
+  CAPTUREOUT CaptureOutput;
+
+  static ExecModule &get(int ModuleIndex);
+};
+
+std::vector<ExecModule> LoadedModules;
+llvm::BumpPtrAllocator Alloc;
+llvm::StringSaver Saver(Alloc);
+
+ExecModule &ExecModule::get(int ModuleIndex) {
+  assert(ModuleIndex > 0 && ModuleIndex <= (int)LoadedModules.size());
+  ExecModule &M = LoadedModules[ModuleIndex - 1];
+  return M;
+}
+
+// ----------------------------------------------------------------------------
+
+typedef __kernel_entry NTSTATUS(__stdcall *NTQUERYINFORMATIONPROCESS)(
+    IN HANDLE ProcessHandle, IN PROCESSINFOCLASS ProcessInformationClass,
+    OUT PVOID ProcessInformation, IN ULONG ProcessInformationLength,
+    OUT PULONG ReturnLength);
+
+typedef NTSTATUS(__thiscall *LDRPHANDLETLSDATA)(
+    __inout PLDR_DATA_TABLE_ENTRY ModuleEntry);
+
+struct IATRESULTS {
+  enum class FAILUREREASON {
+    SUCCESS = 0,
+    OTHER = 1,
+    NOTFOUND = 2,
+    CANNOTPATCH = 3,
+  };
+  struct FUNCTIONINFO {
+    std::string name;
+    size_t ord = 0;
+    FAILUREREASON f = FAILUREREASON::SUCCESS;
+  };
+  struct MODULEINFO {
+    std::string name;
+    HINSTANCE handle = 0;
+    FAILUREREASON f = FAILUREREASON::SUCCESS;
+    std::vector<FUNCTIONINFO> functions;
+  };
+
+  std::vector<MODULEINFO> modules;
+};
+
+static bool PatchProcessBytes(void *Target, llvm::StringRef Data) {
+  HANDLE H = GetCurrentProcess();
+  DWORD R =
+      WriteProcessMemory(H, (LPVOID *)Target, Data.data(), Data.size(), NULL);
+  if (R)
+    return true;
+  if (GetLastError() != ERROR_NOACCESS)
+    return false;
+
+  DWORD dwOldProtect;
+  if (!VirtualProtect((LPVOID)Target, Data.size(), PAGE_WRITECOPY,
+                      &dwOldProtect))
+    return false;
+
+  R = WriteProcessMemory(H, (LPVOID *)Target, Data.data(), Data.size(), NULL);
+
+  if (!VirtualProtect((LPVOID)Target, Data.size(), dwOldProtect, &dwOldProtect))
+    return false;
+
+  return R;
+}
+
+static void RemapIAT(HINSTANCE H, IATRESULTS *res = nullptr) {
+  // Get IAT size
+  DWORD ulsize = 0;
+  PIMAGE_IMPORT_DESCRIPTOR pImportDesc =
+      (PIMAGE_IMPORT_DESCRIPTOR)ImageDirectoryEntryToData(
+          H, TRUE, IMAGE_DIRECTORY_ENTRY_IMPORT, &ulsize);
+  if (!pImportDesc)
+    return;
+
+  // Loop names
+  for (; pImportDesc->Name; pImportDesc++) {
+    PSTR pszModName = (PSTR)((PBYTE)H + pImportDesc->Name);
+    if (!pszModName)
+      break;
+
+    IATRESULTS::MODULEINFO m;
+
+    m.name = pszModName;
+
+    HINSTANCE hImportDLL = LoadLibraryA(pszModName);
+    if (!hImportDLL) {
+      m.f = IATRESULTS::FAILUREREASON::NOTFOUND;
+      if (res)
+        res->modules.push_back(m);
+      continue;
+    }
+    m.handle = hImportDLL;
+    m.f = IATRESULTS::FAILUREREASON::SUCCESS;
+
+    // Get caller's import address table (IAT) for the callee's functions
+    PIMAGE_THUNK_DATA pThunk =
+        (PIMAGE_THUNK_DATA)((PBYTE)H + pImportDesc->FirstThunk);
+
+    // Replace current function address with new function address
+    for (; pThunk->u1.Function; pThunk++) {
+      IATRESULTS::FUNCTIONINFO fu;
+
+      FARPROC pfnNew = 0;
+      size_t rva = 0;
+#ifdef _WIN64
+      if (pThunk->u1.Ordinal & IMAGE_ORDINAL_FLAG64)
+#else
+      if (pThunk->u1.Ordinal & IMAGE_ORDINAL_FLAG32)
+#endif
+      {
+        // Ordinal
+#ifdef _WIN64
+        size_t ord = IMAGE_ORDINAL64(pThunk->u1.Ordinal);
+#else
+        size_t ord = IMAGE_ORDINAL32(pThunk->u1.Ordinal);
+#endif
+
+        fu.ord = ord;
+        m.functions.push_back(fu);
+        PROC *ppfn = (PROC *)&pThunk->u1.Function;
+        if (!ppfn) {
+          fu.f = IATRESULTS::FAILUREREASON::NOTFOUND;
+          m.functions.push_back(fu);
+          continue;
+        }
+        rva = (size_t)pThunk;
+
+        char fe[100] = {0};
+        sprintf_s(fe, 100, "#%zu", ord);
+        pfnNew = GetProcAddress(hImportDLL, (LPCSTR)ord);
+        if (!pfnNew) {
+          fu.f = IATRESULTS::FAILUREREASON::NOTFOUND;
+          m.functions.push_back(fu);
+          continue;
+        }
+      } else {
+        // Get the address of the function address
+        PROC *ppfn = (PROC *)&pThunk->u1.Function;
+        if (!ppfn) {
+          fu.f = IATRESULTS::FAILUREREASON::NOTFOUND;
+          m.functions.push_back(fu);
+          continue;
+        }
+        rva = (size_t)pThunk;
+        PSTR fName = (PSTR)H;
+        fName += pThunk->u1.Function;
+        fName += 2;
+        if (!fName)
+          break;
+        fu.name = fName;
+        pfnNew = GetProcAddress(hImportDLL, fName);
+        if (!pfnNew) {
+          fu.f = IATRESULTS::FAILUREREASON::NOTFOUND;
+          m.functions.push_back(fu);
+          continue;
+        }
+      }
+
+      if (!PatchProcessBytes((LPVOID *)rva, llvm::StringRef((char *)&pfnNew,
+                                                            sizeof(pfnNew)))) {
+        fu.f = IATRESULTS::FAILUREREASON::CANNOTPATCH;
+        continue;
+      }
+      m.functions.push_back(fu);
+    }
+    if (res)
+      res->modules.push_back(m);
+  }
+}
+
+static void *GetSymbolFromDebInfo(llvm::StringRef Sym) {
+  ULONG64 buffer[(sizeof(SYMBOL_INFO) + MAX_SYM_NAME * sizeof(TCHAR) +
+                  sizeof(ULONG64) - 1) /
+                 sizeof(ULONG64)];
+  PSYMBOL_INFO pSymbol = (PSYMBOL_INFO)buffer;
+
+  pSymbol->SizeOfStruct = sizeof(SYMBOL_INFO);
+  pSymbol->MaxNameLen = MAX_SYM_NAME;
+
+  if (!SymFromName(GetCurrentProcess(), Sym.data(), pSymbol)) {
+    DWORD error = GetLastError();
+    (void)error;
+    return nullptr;
+  }
+
+  return (void *)pSymbol->Address;
+}
+
+static void InitDebInfo(llvm::StringRef SearchPath) {
+  static bool SymbolsInitialized{};
+  if (!SymbolsInitialized) {
+    SymSetOptions(0);
+
+    std::string Path("C:\\symbols\\;");
+    Path += SearchPath.str();
+
+    if (!SymInitialize(GetCurrentProcess(), Path.c_str(), TRUE)) {
+      DWORD error = GetLastError();
+      printf("SymInitialize returned error : %lu\n", error);
+      return;
+    }
+    SymbolsInitialized = true;
+  }
+}
+
+static NTQUERYINFORMATIONPROCESS GetNtQueryInformationProcess() {
+  static NTQUERYINFORMATIONPROCESS pNtQueryInformationProcess;
+  if (!pNtQueryInformationProcess) {
+    HMODULE hNtDll = LoadLibraryA("NtDll.dll");
+    pNtQueryInformationProcess = (NTQUERYINFORMATIONPROCESS)GetProcAddress(
+        hNtDll, "NtQueryInformationProcess");
+    FreeLibrary(hNtDll);
+  }
+  return pNtQueryInformationProcess;
+}
+
+static void PatchRPMalloc(ExecModule &M) {
+
+  // This is to only have one instance of RPMalloc across all modules
+
+  typedef void *(__thiscall * MALLOC)(size_t);
+  typedef void(__thiscall * FREE)(void *);
+  typedef void *(__thiscall * CALLOC)(size_t, size_t);
+  typedef void *(__thiscall * REALLOC)(void *, size_t);
+  typedef void(__thiscall * HOOKTABLE)(uintptr_t *);
+
+  std::string ModuleName = M.Name.str();
+
+  // Get the target module alloc functions
+
+  /*MALLOC Malloc = (MALLOC)GetSymbolFromDebInfo(ModuleName + "!malloc");
+  FREE Free = (FREE)GetSymbolFromDebInfo(ModuleName + "!free");
+  REALLOC Realloc = (REALLOC)GetSymbolFromDebInfo(ModuleName + "!realloc");
+  CALLOC Calloc = (CALLOC)GetSymbolFromDebInfo(ModuleName + "!calloc");
+
+  MALLOC OtherRpMalloc = (MALLOC)GetSymbolFromDebInfo(ModuleName + "!rpmalloc");
+  FREE OtherRpFree = (FREE)GetSymbolFromDebInfo(ModuleName + "!rpfree");
+  REALLOC OtherRpRealloc =
+      (REALLOC)GetSymbolFromDebInfo(ModuleName + "!rprealloc");
+  CALLOC OtherRpCalloc = (CALLOC)GetSymbolFromDebInfo(ModuleName +
+  "!rpcalloc");*/
+
+  HOOKTABLE Hook =
+      (HOOKTABLE)GetSymbolFromDebInfo(ModuleName + "!HookAllocators");
+
+  // Get Buildozer RPMalloc functions
+
+  MALLOC RpMalloc = (MALLOC)GetSymbolFromDebInfo("llvm-buildozer!rpmalloc");
+  FREE RpFree = (FREE)GetSymbolFromDebInfo("llvm-buildozer!rpfree");
+  REALLOC RpRealloc = (REALLOC)GetSymbolFromDebInfo("llvm-buildozer!rprealloc");
+  CALLOC RpCalloc = (CALLOC)GetSymbolFromDebInfo("llvm-buildozer!rpcalloc");
+
+  uintptr_t Table[4]{
+      reinterpret_cast<uintptr_t>(RpMalloc),
+      reinterpret_cast<uintptr_t>(RpFree),
+      reinterpret_cast<uintptr_t>(RpCalloc),
+      reinterpret_cast<uintptr_t>(RpRealloc),
+  };
+  Hook(Table);
+
+  /*auto PatchJmp = [&](void *Dest, void *Other, void *Target) {
+    char *I = (char *)Dest;
+    while (true) {
+      unsigned OtherOffset = (char *)Other - ((char *)I + 5);
+      if (*(unsigned char *)I == 0xE8 &&
+          *(DWORD *)((char *)I + 1) == OtherOffset) {
+
+        DWORD NewOffset = (char *)Target - ((char *)I + 5);
+        PatchProcessBytes(I + 1,
+                          llvm::StringRef((char *)&NewOffset, sizeof(DWORD)));
+        break;
+      }
+      ++I;
+    }
+  };
+
+  PatchJmp(reinterpret_cast<void *>(Malloc),
+           reinterpret_cast<void *>(OtherRpMalloc),
+           reinterpret_cast<void *>(RpMalloc));
+  PatchJmp(reinterpret_cast<void *>(Free),
+           reinterpret_cast<void *>(OtherRpFree),
+           reinterpret_cast<void *>(RpFree));
+  PatchJmp(reinterpret_cast<void *>(Realloc),
+           reinterpret_cast<void *>(OtherRpRealloc),
+           reinterpret_cast<void *>(RpRealloc));
+  PatchJmp(reinterpret_cast<void *>(Calloc),
+           reinterpret_cast<void *>(OtherRpCalloc),
+           reinterpret_cast<void *>(RpCalloc));*/
+}
+
+static void InitializeStaticTLS(HINSTANCE h) {
+  DWORD ulsize = 0;
+  PIMAGE_TLS_DIRECTORY64 pTLS =
+      (PIMAGE_TLS_DIRECTORY64)ImageDirectoryEntryToData(
+          h, TRUE, IMAGE_DIRECTORY_ENTRY_TLS, &ulsize);
+  if (!pTLS)
+    return;
+
+  static LDRPHANDLETLSDATA handleTLS;
+  if (!handleTLS) {
+    handleTLS = (LDRPHANDLETLSDATA)GetSymbolFromDebInfo("LdrpHandleTlsData");
+  }
+
+  NTQUERYINFORMATIONPROCESS pNtQueryInformationProcess =
+      GetNtQueryInformationProcess();
+
+  auto hp = GetCurrentProcess();
+
+  PROCESS_BASIC_INFORMATION BasicInfo;
+  DWORD dwReturnLength = 0;
+  NTSTATUS Status = pNtQueryInformationProcess(
+      hp, ProcessBasicInformation, &BasicInfo,
+      sizeof(PROCESS_BASIC_INFORMATION), &dwReturnLength);
+  (void)Status;
+
+  PPEB pPeb = BasicInfo.PebBaseAddress;
+
+  PIMAGE_TLS_DIRECTORY64 thisTLS =
+      (PIMAGE_TLS_DIRECTORY64)ImageDirectoryEntryToData(
+          pPeb->Reserved3[1], TRUE, IMAGE_DIRECTORY_ENTRY_TLS, &ulsize);
+  if (!thisTLS)
+    return;
+
+  PTEB pTEB = NtCurrentTeb();
+  (void)pTEB;
+
+  PLIST_ENTRY CurrentEntry = pPeb->Ldr->InMemoryOrderModuleList.Flink;
+  PLDR_DATA_TABLE_ENTRY Current = NULL;
+
+  while (CurrentEntry != &pPeb->Ldr->InMemoryOrderModuleList &&
+         CurrentEntry != NULL) {
+    Current = CONTAINING_RECORD(CurrentEntry, LDR_DATA_TABLE_ENTRY,
+                                InMemoryOrderLinks);
+    if (Current->DllBase == h) {
+      handleTLS(Current); // <--------------- the magic happens here
+      break;
+    }
+
+    CurrentEntry = CurrentEntry->Flink;
+  }
+}
+
+static void *SaveTLS(HANDLE H) {
+  DWORD Size = 0;
+  PIMAGE_TLS_DIRECTORY64 TLS =
+      (PIMAGE_TLS_DIRECTORY64)ImageDirectoryEntryToData(
+          H, TRUE, IMAGE_DIRECTORY_ENTRY_TLS, &Size);
+  if (!TLS)
+    return nullptr;
+
+  unsigned Len = TLS->EndAddressOfRawData - TLS->StartAddressOfRawData;
+  void *Buf = llvm::safe_malloc(Len);
+
+  PTEB TEB = NtCurrentTeb();
+  (void)TEB;
+
+  uint64_t **ProcessTLS =
+      (uint64_t **)TEB->Reserved1[11]; // ThreadLocalStoragePointer
+
+  // Copy from current Process TLS static storage, not from PE's .tls
+  memcpy(Buf, *(ProcessTLS + *(unsigned int *)TLS->AddressOfIndex), Len);
+
+  return Buf;
+}
+
+static void ResetTLS(HANDLE H, void *Buffer = nullptr) {
+  DWORD Size = 0;
+  PIMAGE_TLS_DIRECTORY64 TLS =
+      (PIMAGE_TLS_DIRECTORY64)ImageDirectoryEntryToData(
+          H, TRUE, IMAGE_DIRECTORY_ENTRY_TLS, &Size);
+  if (!TLS)
+    return;
+
+  /*enum { ProcessTlsInformation = 35 };
+
+  typedef struct _THREAD_TLS_INFORMATION
+  {
+      ULONG Flags;
+      PVOID NewTlsData;
+      PVOID OldTlsData;
+      HANDLE ThreadId;
+  } THREAD_TLS_INFORMATION, *PTHREAD_TLS_INFORMATION;
+
+  typedef struct _PROCESS_TLS_INFORMATION
+  {
+      ULONG Flags;
+      ULONG OperationType;
+      ULONG ThreadDataCount;
+      ULONG TlsIndex;
+      ULONG PreviousCount;
+      THREAD_TLS_INFORMATION ThreadData[1];
+  } PROCESS_TLS_INFORMATION, *PPROCESS_TLS_INFORMATION;
+
+  auto hp = GetCurrentProcess();
+
+  enum : uint32_t { STATUS_INFO_LENGTH_MISMATCH = 0xC0000004L };
+
+  NTQUERYINFORMATIONPROCESS pNtQueryInformationProcess =
+  GetNtQueryInformationProcess();
+
+  DWORD dwReturnLength = 0;
+  NTSTATUS Status = pNtQueryInformationProcess(hp,
+  (PROCESSINFOCLASS)ProcessTlsInformation, nullptr, 0, &dwReturnLength); if
+  (Status != STATUS_INFO_LENGTH_MISMATCH) return;
+
+  void *ProcInfo = malloc(dwReturnLength);
+
+  Status = pNtQueryInformationProcess(hp,
+  (PROCESSINFOCLASS)ProcessTlsInformation, ProcInfo, dwReturnLength,
+  &dwReturnLength);*/
+
+  PTEB TEB = NtCurrentTeb();
+
+  uint64_t **ProcessTLS =
+      (uint64_t **)TEB->Reserved1[11]; // ThreadLocalStoragePointer
+
+  unsigned Len = TLS->EndAddressOfRawData - TLS->StartAddressOfRawData;
+  void *SrcBuf = Buffer ? Buffer : (void *)TLS->StartAddressOfRawData;
+
+  // Copy to current Process TLS static storage
+  memcpy(*(ProcessTLS + *(unsigned int *)TLS->AddressOfIndex), SrcBuf, Len);
+
+  // free(ProcInfo);
+}
+
+static BOOL EnumModulesCallback(PCSTR ModuleName, DWORD64 BaseOfDll,
+                                PVOID UserContext) {
+  return TRUE;
+}
+
+static void InitializeCRT(ExecModule &M) {
+  if (!SymRefreshModuleList(GetCurrentProcess())) {
+    DWORD error = GetLastError();
+    printf("SymLoadModuleEx returned error : %lu\n", error);
+  }
+
+  if (!SymEnumerateModules(GetCurrentProcess(), &EnumModulesCallback,
+                           nullptr)) {
+    DWORD error = GetLastError();
+    printf("EnumerateLoadedModules returned error : %lu\n", error);
+  }
+
+  std::string ModuleName = M.Name.str();
+
+  typedef int(__stdcall * MAINCRT)();
+  MAINCRT Main = (MAINCRT)GetSymbolFromDebInfo(ModuleName + "!mainCRTStartup");
+
+  typedef void(__thiscall * INITBUILDOZER)(void * /*InitEvent*/,
+                                           void * /*ExitEvent*/);
+  INITBUILDOZER INIT = (INITBUILDOZER)GetSymbolFromDebInfo(
+      ModuleName + "!llvm::InitLLVM::InitFromBuildozer");
+
+  HANDLE IE = CreateEvent(0, 0, 0, 0);
+  HANDLE EE = CreateEvent(0, 0, 0, 0);
+  std::thread T([&]() {
+    llvm::CrashRecoveryContext CRC;
+    CRC.RunSafely([&] {
+      INIT(IE, EE);
+      Main();
+    });
+  });
+  WaitForSingleObject(IE, INFINITE);
+  llvm::SmallVector<wchar_t, MAX_PATH> WThreadName;
+  std::string ThreadName = "CRT Init for " + ModuleName;
+  llvm::sys::windows::UTF8ToUTF16(ThreadName.c_str(), WThreadName);
+  SetThreadDescription(T.native_handle(), WThreadName.data());
+  SuspendThread(T.native_handle());
+
+  M.ExitEvent = EE;
+  M.TLSThreadHandle = T.native_handle();
+  T.detach();
+}
+
+void FindEntryPoints(ExecModule &M) {
+  std::string ModuleName = M.Name.str();
+
+  typedef void(__thiscall * SKIPINIT)();
+  SKIPINIT SI = (SKIPINIT)GetSymbolFromDebInfo(ModuleName +
+                                               "!llvm::InitLLVM::SkipInitLLVM");
+  SI();
+
+  M.Main = (ExecModule::MAIN)GetSymbolFromDebInfo(ModuleName + "!main");
+
+  M.SD = (ExecModule::SETCURDIR)GetSymbolFromDebInfo(
+      ModuleName + "!SetCurrentDirectoryBackdoor");
+
+  M.SMod = (ExecModule::SETMODULE)GetSymbolFromDebInfo(
+      ModuleName + "!llvm::InitLLVM::SetCurrentModuleBackdoor");
+
+  M.InitTLS = (ExecModule::DYNTLSINIT)GetSymbolFromDebInfo(ModuleName +
+                                                           "!__dyn_tls_init");
+  M.DestroyTLS = (ExecModule::DYNTLSDTOR)GetSymbolFromDebInfo(
+      ModuleName + "!__dyn_tls_dtor");
+
+  M.CaptureOutput = (ExecModule::CAPTUREOUT)GetSymbolFromDebInfo(
+      ModuleName + "!CaptureLocalOutput");
+
+  // Save in-memory static TLS storage, after CRT init, so that we can restore
+  // it on every call to the module's main()
+  M.TLSInitBuffer = SaveTLS(M.Handle);
+}
+
+namespace buildozer {
+int ImportEXE(llvm::StringRef EXE) {
+  ExecModule M;
+  llvm::StringRef N = llvm::sys::path::filename(EXE);
+  M.Name = Saver.save(N.substr(0, N.rfind('.')));
+  M.FullPath = Saver.save(llvm::sys::path::parent_path(EXE));
+
+  HINSTANCE H = LoadLibraryA(EXE.str().c_str());
+  if (!H)
+    return 0;
+  M.Handle = H;
+
+  RemapIAT(H);
+  InitDebInfo(M.FullPath);
+  PatchRPMalloc(M);
+  InitializeStaticTLS(H);
+  InitializeCRT(M);
+  FindEntryPoints(M);
+
+  LoadedModules.push_back(M);
+  return LoadedModules.size();
+}
+
+void Launch(int ModuleIndex, llvm::StringRef CurDir,
+            const llvm::SmallVectorImpl<const char *> &Argv) {
+  ExecModule &M = ExecModule::get(ModuleIndex);
+
+  ResetTLS(M.Handle, M.TLSInitBuffer);
+
+  M.InitTLS(nullptr, DLL_THREAD_ATTACH, nullptr);
+
+  llvm::SmallVector<wchar_t, MAX_PATH> WPath;
+  llvm::sys::windows::widenPath(CurDir, WPath);
+
+  M.SD(WPath.begin());
+
+  M.SMod(M.Handle);
+
+  M.Main(Argv.size(), const_cast<const char **>(Argv.data()));
+}
+
+void Terminate(int ModuleIndex, std::string &StdErr, std::string &StdOut) {
+  ExecModule &M = ExecModule::get(ModuleIndex);
+
+  llvm::StringRef Err, Out;
+  M.CaptureOutput(Err, Out);
+  StdErr = Err.str();
+  StdOut = Out.str();
+
+  M.DestroyTLS(nullptr, DLL_THREAD_DETACH, nullptr);
+}
+
+void TerminateAll() {
+  for (auto &M : LoadedModules) {
+    ResumeThread(M.TLSThreadHandle);
+    SetEvent(M.ExitEvent);
+    // wait for thread termination
+    WaitForSingleObject(M.TLSThreadHandle, INFINITE);
+  }
+  LoadedModules.clear();
+}
+} // namespace buildozer
\ No newline at end of file
diff --git a/llvm/tools/llvm-buildozer/buildozer-main.cpp b/llvm/tools/llvm-buildozer/buildozer-main.cpp
new file mode 100644
--- /dev/null
+++ b/llvm/tools/llvm-buildozer/buildozer-main.cpp
@@ -0,0 +1,196 @@
+//===---------- Buildozer - A Lightweight LLVM Build System ---------------===//
+//
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
+//
+//===----------------------------------------------------------------------===//
+
+#include "CompDB.h"
+#include "LoadEXE.h"
+#include "llvm/ADT/StringSet.h"
+#include "llvm/Support/CrashRecoveryContext.h"
+#include "llvm/Support/ErrorOr.h"
+#include "llvm/Support/FileSystem.h"
+#include "llvm/Support/InitLLVM.h"
+#include "llvm/Support/Path.h"
+#include "llvm/Support/RandomNumberGenerator.h"
+#include "llvm/Support/ThreadPool.h"
+#include "llvm/Support/Threading.h"
+#include "llvm/Support/WithColor.h"
+#include "llvm/Support/raw_ostream.h"
+#include <map>
+#include <mutex>
+//#include "C:\Users\aganea\Downloads\rpmalloc-1.4.0\rpmalloc\rpmalloc.h"
+
+static int ClangM{};
+static int LLDM{};
+static int ScanDepsM{};
+
+void LoadPlugins(llvm::StringRef DirPath) {
+  // To ensure the CRT init is enclosed into the CRC
+  llvm::CrashRecoveryContext::Enable();
+
+  llvm::SmallString<128> ExeFullPath = DirPath;
+  llvm::sys::path::append(ExeFullPath, "clang-cl.exe");
+  ClangM = buildozer::ImportEXE(ExeFullPath);
+  // LLDM = buildozer::ImportEXE("lld-link.exe");
+  // ScanDepsM = buildozer::ImportEXE("clang-scan-deps.exe");
+  // int TblGen = buildozer::ImportEXE("llvm-tblgen.exe");
+  // int CTblGen = buildozer::ImportEXE("clang-tblgen.exe");
+}
+
+static std::deque<size_t> BuildQueue(const buildozer::CompilationDB &DB,
+                                     llvm::StringSet<> &PCHInProgress) {
+  std::deque<size_t> Q;
+  for (unsigned I = 0; I < DB.Build.size(); ++I) {
+    const buildozer::WorkUnit &WU = DB.Build.at(I);
+    if (WU.Output.endswith(".pch")) {
+      Q.push_front(I);
+      PCHInProgress.insert(llvm::sys::path::filename(WU.Output));
+    } else {
+      Q.push_back(I);
+    }
+  }
+  return Q;
+}
+
+static buildozer::WorkUnit *PopNext(std::deque<size_t> &Q,
+                                    buildozer::CompilationDB &DB,
+                                    llvm::StringSet<> &PCHInProgress) {
+  if (Q.empty())
+    return nullptr;
+  buildozer::WorkUnit *WU{};
+  for (std::deque<size_t>::iterator I = Q.begin(); I != Q.end(); ++I) {
+    WU = &DB.Build.at(*I);
+
+    auto Fp = find_if(WU->Arguments, [](auto &A) {
+      return llvm::StringRef(A).startswith("/Fp");
+    });
+    if (Fp != WU->Arguments.end()) {
+      auto Yu = find_if(WU->Arguments, [](auto &A) {
+        return llvm::StringRef(A).startswith("/Yu");
+      });
+      if (Yu != WU->Arguments.end()) {
+        llvm::StringRef File = llvm::sys::path::filename(llvm::StringRef(*Fp));
+        // If the corresponding PCH is still building, skip this file and treat
+        // it later
+        if (PCHInProgress.count(File))
+          continue;
+      }
+    }
+    Q.erase(I);
+    break;
+  }
+  return WU;
+}
+
+static void FinishPCH(buildozer::WorkUnit *WU,
+                      llvm::StringSet<> &PCHInProgress) {
+  if (!WU->Output.endswith(".pch"))
+    return;
+  auto It = PCHInProgress.find(llvm::sys::path::filename(WU->Output));
+  PCHInProgress.erase(It);
+}
+
+int ExecuteDatabase(buildozer::CompilationDB &DB) {
+  unsigned NumWorkers = llvm::hardware_concurrency().compute_thread_count() + 2;
+  std::vector<std::thread> WorkerThreads;
+  std::atomic<int> Error{};
+  std::mutex Lock;
+  llvm::StringSet<> PCHInProgress;
+  std::deque<size_t> ActiveQueue = BuildQueue(DB, PCHInProgress);
+  std::mutex PrintLock;
+
+  for (unsigned I = 0; I < NumWorkers; ++I) {
+    auto Worker = [&Lock, &PCHInProgress, &ActiveQueue, &DB, &Error,
+                   &PrintLock]() {
+      while (true) {
+        buildozer::WorkUnit *WU{};
+        {
+          std::unique_lock<std::mutex> LockGuard(Lock);
+          WU = PopNext(ActiveQueue, DB, PCHInProgress);
+          if (!WU)
+            break;
+
+          //////// TEST - only process first CPP
+          // ActiveQueue.clear();
+          /*static unsigned Count{};
+          if (Count >= 2)
+            break;
+          ++Count;*/
+        }
+
+        int Mod{};
+        llvm::StringRef Exe(WU->Arguments[0]);
+        if (Exe.contains_lower("clang-cl"))
+          Mod = ClangM;
+        // if (Exe.contains_lower("lld-link"))
+        //  Mod = LLDM;
+        else
+          continue;
+
+        if (Mod == LLDM) {
+          WU->Arguments.push_back("/threads:no");
+        }
+
+        llvm::CrashRecoveryContext CRC;
+        // CRC.EnableExceptionHandler = true;
+        if (!CRC.RunSafely([&] {
+              buildozer::Launch(Mod, WU->Directory, WU->Arguments);
+            })) {
+          unsigned ExceptionType = CRC.RetCode & 0xF0000000;
+          if (ExceptionType == 0xE0000000)
+            Error = CRC.RetCode & ~0xF0000000; // internal LLVM error
+          else if (ExceptionType == 0x80000000 || ExceptionType == 0xC0000000)
+            Error = 1; // don't propagate crash
+          else
+            Error = 1;
+
+          {
+            std::unique_lock<std::mutex> LockGuard(Lock);
+            ActiveQueue.clear(); // stop the machines
+          }
+        }
+        std::string StdErr, StdOut;
+        buildozer::Terminate(Mod, StdErr, StdOut);
+
+        FinishPCH(WU, PCHInProgress);
+
+        if (!StdErr.empty() || !StdOut.empty()) {
+          std::unique_lock<std::mutex> LockGuard(PrintLock);
+          llvm::outs() << "--> " << WU->Output << "\n";
+          llvm::outs() << StdOut;
+          llvm::errs() << StdErr;
+        }
+      }
+      // buildozer::TerminateThread(/*mod?*/);
+    };
+    WorkerThreads.emplace_back(std::move(Worker));
+  }
+  for (auto &W : WorkerThreads)
+    W.join();
+  return Error;
+}
+
+void TestStringMap(buildozer::CompilationDB &DB);
+void TestGlobalMap(buildozer::CompilationDB &DB);
+
+int main(int argc, const char **argv) {
+  llvm::InitLLVM X(argc, argv);
+
+  LoadPlugins(llvm::sys::path::parent_path(argv[0]));
+
+  auto *DBName = argc > 1 ? argv[1] : "compile_commands.json";
+
+  buildozer::CompilationDB DB;
+  buildozer::ReadCompilationDatabase(DBName, DB);
+
+  ExecuteDatabase(DB);
+
+  buildozer::TerminateAll();
+
+  // rpmalloc_finalize();
+
+  return 0;
+}
diff --git a/llvm/tools/llvm-cfi-verify/lib/FileAnalysis.h b/llvm/tools/llvm-cfi-verify/lib/FileAnalysis.h
--- a/llvm/tools/llvm-cfi-verify/lib/FileAnalysis.h
+++ b/llvm/tools/llvm-cfi-verify/lib/FileAnalysis.h
@@ -46,7 +46,7 @@
 
 struct GraphResult;
 
-extern bool IgnoreDWARFFlag;
+extern LLVM_THREAD_LOCAL bool IgnoreDWARFFlag;
 
 enum class CFIProtectionStatus {
   // This instruction is protected by CFI.
diff --git a/llvm/tools/llvm-cfi-verify/lib/FileAnalysis.cpp b/llvm/tools/llvm-cfi-verify/lib/FileAnalysis.cpp
--- a/llvm/tools/llvm-cfi-verify/lib/FileAnalysis.cpp
+++ b/llvm/tools/llvm-cfi-verify/lib/FileAnalysis.cpp
@@ -42,7 +42,7 @@
 namespace llvm {
 namespace cfi_verify {
 
-bool IgnoreDWARFFlag;
+LLVM_THREAD_LOCAL bool IgnoreDWARFFlag;
 
 static cl::opt<bool, true> IgnoreDWARFArg(
     "ignore-dwarf",
diff --git a/llvm/tools/llvm-cfi-verify/lib/GraphBuilder.h b/llvm/tools/llvm-cfi-verify/lib/GraphBuilder.h
--- a/llvm/tools/llvm-cfi-verify/lib/GraphBuilder.h
+++ b/llvm/tools/llvm-cfi-verify/lib/GraphBuilder.h
@@ -46,8 +46,8 @@
 namespace llvm {
 namespace cfi_verify {
 
-extern uint64_t SearchLengthForUndef;
-extern uint64_t SearchLengthForConditionalBranch;
+extern LLVM_THREAD_LOCAL uint64_t SearchLengthForUndef;
+extern LLVM_THREAD_LOCAL uint64_t SearchLengthForConditionalBranch;
 
 struct ConditionalBranchNode {
   uint64_t Address;
diff --git a/llvm/tools/llvm-cfi-verify/lib/GraphBuilder.cpp b/llvm/tools/llvm-cfi-verify/lib/GraphBuilder.cpp
--- a/llvm/tools/llvm-cfi-verify/lib/GraphBuilder.cpp
+++ b/llvm/tools/llvm-cfi-verify/lib/GraphBuilder.cpp
@@ -38,8 +38,8 @@
 namespace llvm {
 namespace cfi_verify {
 
-uint64_t SearchLengthForUndef;
-uint64_t SearchLengthForConditionalBranch;
+LLVM_THREAD_LOCAL uint64_t SearchLengthForUndef;
+LLVM_THREAD_LOCAL uint64_t SearchLengthForConditionalBranch;
 
 static cl::opt<uint64_t, true> SearchLengthForUndefArg(
     "search-length-undef",
diff --git a/llvm/tools/llvm-profgen/ProfileGenerator.h b/llvm/tools/llvm-profgen/ProfileGenerator.h
--- a/llvm/tools/llvm-profgen/ProfileGenerator.h
+++ b/llvm/tools/llvm-profgen/ProfileGenerator.h
@@ -211,7 +211,7 @@
 public:
   // Deduplicate adjacent repeated context sequences up to a given sequence
   // length. -1 means no size limit.
-  static int32_t MaxCompressionSize;
+  static LLVM_THREAD_LOCAL int32_t MaxCompressionSize;
 };
 
 using ProbeCounterMap = std::unordered_map<const PseudoProbe *, uint64_t>;
diff --git a/llvm/tools/llvm-profgen/ProfileGenerator.cpp b/llvm/tools/llvm-profgen/ProfileGenerator.cpp
--- a/llvm/tools/llvm-profgen/ProfileGenerator.cpp
+++ b/llvm/tools/llvm-profgen/ProfileGenerator.cpp
@@ -52,7 +52,7 @@
 namespace sampleprof {
 
 // Initialize the MaxCompressionSize to -1 which means no size limit
-int32_t CSProfileGenerator::MaxCompressionSize = -1;
+LLVM_THREAD_LOCAL int32_t CSProfileGenerator::MaxCompressionSize = -1;
 
 static bool
 usePseudoProbes(const BinarySampleCounterMap &BinarySampleCounters) {
diff --git a/llvm/tools/llvm-xray/llvm-xray.cpp b/llvm/tools/llvm-xray/llvm-xray.cpp
--- a/llvm/tools/llvm-xray/llvm-xray.cpp
+++ b/llvm/tools/llvm-xray/llvm-xray.cpp
@@ -31,7 +31,7 @@
     if (*SC) {
       // If no subcommand was provided, we need to explicitly check if this is
       // the top-level subcommand.
-      if (SC == &*cl::TopLevelSubCommand) {
+      if (cl::isTopLevel(SC)) {
         cl::PrintHelpMessage(false, true);
         return 0;
       }
diff --git a/llvm/unittests/Support/CommandLineTest.cpp b/llvm/unittests/Support/CommandLineTest.cpp
--- a/llvm/unittests/Support/CommandLineTest.cpp
+++ b/llvm/unittests/Support/CommandLineTest.cpp
@@ -98,8 +98,7 @@
   static const char ArgString[] = "new-test-option";
   static const char ValueString[] = "Integer";
 
-  StringMap<cl::Option *> &Map =
-      cl::getRegisteredOptions(*cl::TopLevelSubCommand);
+  StringMap<cl::Option *> &Map = cl::getRegisteredOptions();
 
   ASSERT_TRUE(Map.count("test-option") == 1) <<
     "Could not find option in map.";
@@ -390,8 +389,7 @@
   ASSERT_EQ(cl::NotHidden, TestOption2.getOptionHiddenFlag())
       << "Hid extra option that should be visable.";
 
-  StringMap<cl::Option *> &Map =
-      cl::getRegisteredOptions(*cl::TopLevelSubCommand);
+  StringMap<cl::Option *> &Map = cl::getRegisteredOptions();
   ASSERT_EQ(cl::NotHidden, Map["help"]->getOptionHiddenFlag())
       << "Hid default option that should be visable.";
 }
@@ -415,8 +413,7 @@
   ASSERT_EQ(cl::NotHidden, TestOption3.getOptionHiddenFlag())
       << "Hid extra option that should be visable.";
 
-  StringMap<cl::Option *> &Map =
-      cl::getRegisteredOptions(*cl::TopLevelSubCommand);
+  StringMap<cl::Option *> &Map = cl::getRegisteredOptions();
   ASSERT_EQ(cl::NotHidden, Map["help"]->getOptionHiddenFlag())
       << "Hid default option that should be visable.";
 }
@@ -490,8 +487,7 @@
   cl::ResetCommandLineParser();
 
   StackSubCommand SC1("sc1", "First subcommand");
-  StackOption<bool> AllOpt("everywhere", cl::sub(*cl::AllSubCommands),
-                           cl::init(false));
+  StackOption<bool> AllOpt("everywhere", cl::allSub(), cl::init(false));
   StackSubCommand SC2("sc2", "Second subcommand");
 
   const char *args[] = {"prog", "-everywhere"};
@@ -527,8 +523,7 @@
 TEST(CommandLineTest, ReparseCommandLineOptions) {
   cl::ResetCommandLineParser();
 
-  StackOption<bool> TopLevelOpt("top-level", cl::sub(*cl::TopLevelSubCommand),
-                                cl::init(false));
+  StackOption<bool> TopLevelOpt("top-level", cl::topLevel(), cl::init(false));
 
   const char *args[] = {"prog", "-top-level"};
 
@@ -575,10 +570,10 @@
 TEST(CommandLineTest, RemoveFromTopLevelSubCommand) {
   cl::ResetCommandLineParser();
 
-  StackOption<bool> TopLevelRemove(
-      "top-level-remove", cl::sub(*cl::TopLevelSubCommand), cl::init(false));
-  StackOption<bool> TopLevelKeep(
-      "top-level-keep", cl::sub(*cl::TopLevelSubCommand), cl::init(false));
+  StackOption<bool> TopLevelRemove("top-level-remove", cl::topLevel(),
+                                   cl::init(false));
+  StackOption<bool> TopLevelKeep("top-level-keep", cl::topLevel(),
+                                 cl::init(false));
 
   const char *args[] = {"prog", "-top-level-remove"};
 
@@ -599,10 +594,9 @@
 
   StackSubCommand SC1("sc1", "First Subcommand");
   StackSubCommand SC2("sc2", "Second Subcommand");
-  StackOption<bool> RemoveOption("remove-option", cl::sub(*cl::AllSubCommands),
+  StackOption<bool> RemoveOption("remove-option", cl::allSub(),
                                  cl::init(false));
-  StackOption<bool> KeepOption("keep-option", cl::sub(*cl::AllSubCommands),
-                               cl::init(false));
+  StackOption<bool> KeepOption("keep-option", cl::allSub(), cl::init(false));
 
   const char *args0[] = {"prog", "-remove-option"};
   const char *args1[] = {"prog", "sc1", "-remove-option"};
@@ -680,12 +674,11 @@
 TEST(CommandLineTest, DefaultOptions) {
   cl::ResetCommandLineParser();
 
-  StackOption<std::string> Bar("bar", cl::sub(*cl::AllSubCommands),
-                               cl::DefaultOption);
+  StackOption<std::string> Bar("bar", cl::allSub(), cl::DefaultOption);
   StackOption<std::string, cl::alias> Bar_Alias(
       "b", cl::desc("Alias for -bar"), cl::aliasopt(Bar), cl::DefaultOption);
 
-  StackOption<bool> Foo("foo", cl::init(false), cl::sub(*cl::AllSubCommands),
+  StackOption<bool> Foo("foo", cl::init(false), cl::allSub(),
                         cl::DefaultOption);
   StackOption<bool, cl::alias> Foo_Alias("f", cl::desc("Alias for -foo"),
                                          cl::aliasopt(Foo), cl::DefaultOption);
@@ -1020,7 +1013,7 @@
 
   cl::ResetAllOptionOccurrences();
 
-  for (auto &OM : cl::getRegisteredOptions(*cl::TopLevelSubCommand)) {
+  for (auto &OM : cl::getRegisteredOptions()) {
     cl::Option *O = OM.second;
     if (O->ArgStr == "opt2") {
       continue;
diff --git a/llvm/utils/TableGen/TableGen.cpp b/llvm/utils/TableGen/TableGen.cpp
--- a/llvm/utils/TableGen/TableGen.cpp
+++ b/llvm/utils/TableGen/TableGen.cpp
@@ -1,3 +1,4 @@
+
 //===- TableGen.cpp - Top-Level TableGen implementation for LLVM ----------===//
 //
 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
diff --git a/polly/lib/Analysis/ScopBuilder.cpp b/polly/lib/Analysis/ScopBuilder.cpp
--- a/polly/lib/Analysis/ScopBuilder.cpp
+++ b/polly/lib/Analysis/ScopBuilder.cpp
@@ -66,7 +66,7 @@
 STATISTIC(InfeasibleScops,
           "Number of SCoPs with statically infeasible context.");
 
-bool polly::ModelReadOnlyScalars;
+LLVM_THREAD_LOCAL bool polly::ModelReadOnlyScalars;
 
 // The maximal number of dimensions we allow during invariant load construction.
 // More complex access ranges will result in very high compile time and are also
diff --git a/polly/lib/Analysis/ScopDetection.cpp b/polly/lib/Analysis/ScopDetection.cpp
--- a/polly/lib/Analysis/ScopDetection.cpp
+++ b/polly/lib/Analysis/ScopDetection.cpp
@@ -101,7 +101,7 @@
              "region is considered profitable"),
     cl::Hidden, cl::ValueRequired, cl::init(100000000), cl::cat(PollyCategory));
 
-bool polly::PollyProcessUnprofitable;
+LLVM_THREAD_LOCAL bool polly::PollyProcessUnprofitable;
 
 static cl::opt<bool, true> XPollyProcessUnprofitable(
     "polly-process-unprofitable",
@@ -126,7 +126,7 @@
              "ANY of the regexes provided."),
     cl::ZeroOrMore, cl::CommaSeparated, cl::cat(PollyCategory));
 
-bool polly::PollyAllowFullFunction;
+LLVM_THREAD_LOCAL bool polly::PollyAllowFullFunction;
 
 static cl::opt<bool, true>
     XAllowFullFunction("polly-detect-full-functions",
@@ -147,7 +147,7 @@
                    cl::Hidden, cl::init(false), cl::ZeroOrMore,
                    cl::cat(PollyCategory));
 
-bool polly::PollyAllowUnsignedOperations;
+LLVM_THREAD_LOCAL bool polly::PollyAllowUnsignedOperations;
 
 static cl::opt<bool, true> XPollyAllowUnsignedOperations(
     "polly-allow-unsigned-operations",
@@ -155,7 +155,7 @@
     cl::location(PollyAllowUnsignedOperations), cl::Hidden, cl::ZeroOrMore,
     cl::init(true), cl::cat(PollyCategory));
 
-bool polly::PollyUseRuntimeAliasChecks;
+LLVM_THREAD_LOCAL bool polly::PollyUseRuntimeAliasChecks;
 
 static cl::opt<bool, true> XPollyUseRuntimeAliasChecks(
     "polly-use-runtime-alias-checks",
@@ -219,7 +219,7 @@
                 cl::Hidden, cl::init(false), cl::ZeroOrMore,
                 cl::cat(PollyCategory));
 
-bool polly::PollyInvariantLoadHoisting;
+LLVM_THREAD_LOCAL bool polly::PollyInvariantLoadHoisting;
 
 static cl::opt<bool, true> XPollyInvariantLoadHoisting(
     "polly-invariant-load-hoisting", cl::desc("Hoist invariant loads."),
@@ -229,8 +229,8 @@
 /// The minimal trip count under which loops are considered unprofitable.
 static const unsigned MIN_LOOP_TRIP_COUNT = 8;
 
-bool polly::PollyTrackFailures = false;
-bool polly::PollyDelinearize = false;
+LLVM_THREAD_LOCAL bool polly::PollyTrackFailures = false;
+LLVM_THREAD_LOCAL bool polly::PollyDelinearize = false;
 StringRef polly::PollySkipFnAttr = "polly.skip.fn";
 
 //===----------------------------------------------------------------------===//
diff --git a/polly/lib/Analysis/ScopInfo.cpp b/polly/lib/Analysis/ScopInfo.cpp
--- a/polly/lib/Analysis/ScopInfo.cpp
+++ b/polly/lib/Analysis/ScopInfo.cpp
@@ -150,7 +150,7 @@
              "(does not scale well)"),
     cl::Hidden, cl::init(false), cl::cat(PollyCategory));
 
-bool polly::UseInstructionNames;
+LLVM_THREAD_LOCAL bool polly::UseInstructionNames;
 
 static cl::opt<bool, true> XUseInstructionNames(
     "polly-use-llvm-names",
diff --git a/polly/lib/CodeGen/BlockGenerators.cpp b/polly/lib/CodeGen/BlockGenerators.cpp
--- a/polly/lib/CodeGen/BlockGenerators.cpp
+++ b/polly/lib/CodeGen/BlockGenerators.cpp
@@ -35,7 +35,7 @@
                              cl::Hidden, cl::init(false), cl::ZeroOrMore,
                              cl::cat(PollyCategory));
 
-bool PollyDebugPrinting;
+LLVM_THREAD_LOCAL bool PollyDebugPrinting;
 static cl::opt<bool, true> DebugPrintingX(
     "polly-codegen-add-debug-printing",
     cl::desc("Add printf calls that show the values loaded/stored."),
diff --git a/polly/lib/CodeGen/CodeGeneration.cpp b/polly/lib/CodeGen/CodeGeneration.cpp
--- a/polly/lib/CodeGen/CodeGeneration.cpp
+++ b/polly/lib/CodeGen/CodeGeneration.cpp
@@ -54,7 +54,7 @@
                             cl::Hidden, cl::init(false), cl::ZeroOrMore,
                             cl::cat(PollyCategory));
 
-bool polly::PerfMonitoring;
+LLVM_THREAD_LOCAL bool polly::PerfMonitoring;
 
 static cl::opt<bool, true>
     XPerfMonitoring("polly-codegen-perf-monitoring",
diff --git a/polly/lib/CodeGen/LoopGenerators.cpp b/polly/lib/CodeGen/LoopGenerators.cpp
--- a/polly/lib/CodeGen/LoopGenerators.cpp
+++ b/polly/lib/CodeGen/LoopGenerators.cpp
@@ -24,9 +24,9 @@
 using namespace llvm;
 using namespace polly;
 
-int polly::PollyNumThreads;
-OMPGeneralSchedulingType polly::PollyScheduling;
-int polly::PollyChunkSize;
+LLVM_THREAD_LOCAL int polly::PollyNumThreads;
+LLVM_THREAD_LOCAL OMPGeneralSchedulingType polly::PollyScheduling;
+LLVM_THREAD_LOCAL int polly::PollyChunkSize;
 
 static cl::opt<int, true>
     XPollyNumThreads("polly-num-threads",
diff --git a/polly/lib/CodeGen/PPCGCodeGeneration.cpp b/polly/lib/CodeGen/PPCGCodeGeneration.cpp
--- a/polly/lib/CodeGen/PPCGCodeGeneration.cpp
+++ b/polly/lib/CodeGen/PPCGCodeGeneration.cpp
@@ -85,7 +85,7 @@
                                    cl::init(false), cl::ZeroOrMore,
                                    cl::cat(PollyCategory));
 
-bool polly::PollyManagedMemory;
+LLVM_THREAD_LOCAL bool polly::PollyManagedMemory;
 static cl::opt<bool, true>
     XManagedMemory("polly-acc-codegen-managed-memory",
                    cl::desc("Generate Host kernel code assuming"
@@ -117,7 +117,7 @@
                cl::desc("Minimal number of compute statements to run on GPU."),
                cl::Hidden, cl::init(10 * 512 * 512));
 
-GPURuntime polly::GPURuntimeChoice;
+LLVM_THREAD_LOCAL GPURuntime polly::GPURuntimeChoice;
 static cl::opt<GPURuntime, true> XGPURuntimeChoice(
     "polly-gpu-runtime", cl::desc("The GPU Runtime API to target"),
     cl::values(clEnumValN(GPURuntime::CUDA, "libcudart",
@@ -127,7 +127,7 @@
     cl::location(polly::GPURuntimeChoice), cl::init(GPURuntime::CUDA),
     cl::ZeroOrMore, cl::cat(PollyCategory));
 
-GPUArch polly::GPUArchChoice;
+LLVM_THREAD_LOCAL GPUArch polly::GPUArchChoice;
 static cl::opt<GPUArch, true>
     XGPUArchChoice("polly-gpu-arch", cl::desc("The GPU Architecture to target"),
                    cl::values(clEnumValN(GPUArch::NVPTX64, "nvptx64",
diff --git a/polly/lib/Support/RegisterPasses.cpp b/polly/lib/Support/RegisterPasses.cpp
--- a/polly/lib/Support/RegisterPasses.cpp
+++ b/polly/lib/Support/RegisterPasses.cpp
@@ -111,7 +111,7 @@
                           ),
            cl::init(TARGET_CPU), cl::ZeroOrMore, cl::cat(PollyCategory));
 
-VectorizerChoice polly::PollyVectorizerChoice;
+LLVM_THREAD_LOCAL VectorizerChoice polly::PollyVectorizerChoice;
 static cl::opt<polly::VectorizerChoice, true> Vectorizer(
     "polly-vectorizer", cl::desc("Select the vectorization strategy"),
     cl::values(