WIP: llvm-buildozer

[aganea]

Summary

This is a very early prototype for llvm-buildozer, a tool I've presented last year at the LLVM conference: https://www.youtube.com/watch?v=usPL_DROn4k

The overall goal is to switch the source code build model from a pool of processes, to a pool of threads.

Previously, a tool like ninja would both invoke the compiler and the linker .EXEs, based on a list of build actions, which are in turn built from a .ninja script containing a list of TUs and targets to compile. This model has the adverse effect of starting a new EXEs for each TU, having to call the initialization and compilation environnement detection, loading or mmap'ing of source files, etc. for each EXE instance. This comes with a high execution cost on Windows.

Our llvm-buildozer tool insteads takes a modified .CDB as an input, loads all necessary EXEs as DLLs once, and calls the build action internally, in a pool of threads, without dropping the EXEs, re-initializing the compiler or the heap. This evidently requires the compiler & link EXEs to be thread-safe, which represents the vast majority of our changes in this patch. With our llvm-buildozer tool, the rebuild times are decreased by 60%, tested on a 6-core, on a real-world game project: 20 min before -> 11 min 50 sec after.

As future work, if this idea passes RFC/community consensus, the goal after is to start working on inter-thread communication, such as sharing the state of the SourceManager or the tokenizer for a starter. Also a in-memory program repo, along the lines of SN-System's ideas could further avoid generating duplicate section/optimizations accross TUs.

This is an old prototype untouched since the LLVM conference, pasting this here only for reference purposes. I'm planning to get back to work on it at some point - or feel free in the meanwhile to pick anything interesting from this patch.

[tschuett]

When you extended the thread pool for high cores counts for Windows, I thought the other way around. I want to you use the distributed thinlto locally. Then each ninja job is single threaded and ninja can schedule everything. This probably won't be a desirable solution for Windows.

If you can get benefits out of inter-thread communication, then I am getting interested again.

[aganea]

In D86351#2230941, @tschuett wrote:

When you extended the thread pool for high cores counts for Windows, I thought the other way around. I want to you use the distributed thinlto locally. Then each ninja job is single threaded and ninja can schedule everything. This probably won't be a desirable solution for Windows.

This has been suggested by Bruce Dawson here: https://github.com/ninja-build/ninja/issues/1638 - although I haven't seen the prototype he mentions nor any figures. I feel that the direct and indirect costs for context switching between a pool of processes would be higher vs. a pool of threads in a single ongoing process, and that would increase with the number of cores. But I remain open to any idea, as long as it improves build times on Windows.

[aganea]

Rebase.

[arsenm]

llvm/lib/Analysis/MemorySSA.cpp

89

Do command line flags like this really need to be thread local? Wouldn't ever cl::opt need to be if this is?

[aganea]

llvm/lib/Analysis/MemorySSA.cpp

89

This was only for the PoC.

Values pointed by cl::opts -- that is either the internal cl::opt data or the static pointed by cl::location -- should be part of a context of some sort. LLD now has CommonLinkerContext plus a derived context per-driver. We probably need a "context" class along the same lines for the LLVM libs. Should it be part of LLVMContextImpl? Some options are read a bit earlier, before the LLVMContext is created.
The cl::opts themselves can remain static.

Unless we assume cl::opts are just for debugging, and move to tablegen any such globals that affect multi-threaded compilation?

clang/include/clang/Tooling/DependencyScanning/DependencyScanningFilesystem.h

public:
   static CachedFileSystemEntry createFileEntry(StringRef Filename,
                                                llvm::vfs::FileSystem &FS,
                                                bool Minimize = true);
 
   /// Create an entry that represents a directory on the filesystem.
   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(); }
 
   /// \returns The error or the file's contents.
   llvm::ErrorOr<StringRef> getContents() const {
     if (!MaybeStat)
       return MaybeStat.getError();

clang/lib/ASTMatchers/GtestMatchers.cpp

case GtestCmp::Ge:
     return functionDecl(hasName("::testing::internal::CmpHelperGE"));
   case GtestCmp::Gt:
     return functionDecl(hasName("::testing::internal::CmpHelperGT"));
   case GtestCmp::Le:
     return functionDecl(hasName("::testing::internal::CmpHelperLE"));
   case GtestCmp::Lt:
     return functionDecl(hasName("::testing::internal::CmpHelperLT"));
   }
+  llvm_unreachable("Unexpected GtestCmp!");
 }
 
 static llvm::StringRef getMacroTypeName(MacroType Macro) {
   switch (Macro) {
   case MacroType::Expect:
     return "EXPECT";
   case MacroType::Assert:
     return "ASSERT";
   case MacroType::On:
     return "ON";
   }
+  llvm_unreachable("Unexpected MacroType!");
 }
 
 static llvm::StringRef getComparisonTypeName(GtestCmp Cmp) {
   switch (Cmp) {
   case GtestCmp::Eq:
     return "EQ";
   case GtestCmp::Ne:
     return "NE";
   case GtestCmp::Ge:
     return "GE";
   case GtestCmp::Gt:
     return "GT";
   case GtestCmp::Le:
     return "LE";
   case GtestCmp::Lt:
     return "LT";
   }
+  llvm_unreachable("Unexpected GtestCmp!");
 }
 
 static std::string getMacroName(MacroType Macro, GtestCmp Cmp) {
   return (getMacroTypeName(Macro) + "_" + getComparisonTypeName(Cmp)).str();
 }
 
 static std::string getMacroName(MacroType Macro, llvm::StringRef Operation) {
   return (getMacroTypeName(Macro) + "_" + Operation).str();
gtestCallInternal(MacroType Macro, StatementMatcher MockCall, MockArgs Args) {
   case MockArgs::Some:
     return cxxMemberCallExpr(
         isExpandedFromMacro(getMacroName(Macro, "CALL")),
         callee(functionDecl(hasName(getSpecSetterName(Macro)))),
         onImplicitObjectArgument(ignoringImplicit(cxxOperatorCallExpr(
             hasOverloadedOperatorName("()"), argumentCountIs(3),
             hasArgument(0, ignoringImplicit(MockCall))))));
   }
+  llvm_unreachable("Unexpected MockArgs!");
 }
 
 static internal::BindableMatcher<Stmt>
 gtestCallInternal(MacroType Macro, StatementMatcher MockObject,
                   llvm::StringRef MockMethodName, MockArgs Args) {
   return gtestCallInternal(
       Macro,
       cxxMemberCallExpr(

clang/lib/CodeGen/CodeGenAction.cpp

case Backend_EmitLL:
     return CI.createDefaultOutputFile(false, InFile, "ll");
   case Backend_EmitBC:
     return CI.createDefaultOutputFile(true, InFile, "bc");
   case Backend_EmitNothing:
     return nullptr;
   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!");
 }
 
 std::unique_ptr<ASTConsumer>
 CodeGenAction::CreateASTConsumer(CompilerInstance &CI, StringRef InFile) {
   BackendAction BA = static_cast<BackendAction>(Act);

clang/lib/Driver/Driver.cpp

phases::ID Driver::getFinalPhase(const DerivedArgList &DAL,
                                  Arg **FinalPhaseArg) const {
   Arg *PhaseArg = nullptr;
   phases::ID FinalPhase;
 
   // -{E,EP,P,M,MM} only run the preprocessor.
   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.
   } else if ((PhaseArg = DAL.getLastArg(options::OPT__precompile))) {
     FinalPhase = phases::Precompile;
 
   // -{fsyntax-only,-analyze,emit-ast} only run up to the compiler.
   } else if ((PhaseArg = DAL.getLastArg(options::OPT_fsyntax_only)) ||

clang/lib/Driver/ToolChains/Clang.cpp

 #include "llvm/ADT/StringExtras.h"
 #include "llvm/Config/llvm-config.h"
 #include "llvm/Option/ArgList.h"
 #include "llvm/Support/CodeGen.h"
 #include "llvm/Support/Compiler.h"
 #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"
 #include "llvm/Support/YAMLParser.h"
 
 using namespace clang::driver;
 using namespace clang::driver::tools;
 using namespace clang;
void Clang::ConstructJob(Compilation &C, const JobAction &JA,
   }
 
   if (C.getDriver().embedBitcodeMarkerOnly() && !IsUsingLTO)
     CmdArgs.push_back("-fembed-bitcode=marker");
 
   // 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
   const bool IsAssertBuild = false;
 #else
   const bool IsAssertBuild = true;
 #endif
 

clang/lib/Frontend/CompilerInstance.cpp

for (OutputFile &OF : OutputFiles) {
     FileMgr->FixupRelativePath(NewOutFile);
     std::error_code EC = llvm::sys::fs::rename(OF.TempFilename, NewOutFile);
     if (!EC)
       continue;
     getDiagnostics().Report(diag::err_unable_to_rename_temp)
         << 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) {
     for (auto &Module : BuiltModules)
       llvm::sys::fs::remove(Module.second);
     BuiltModules.clear();
   }
 }

clang/lib/Tooling/CommonOptionsParser.cpp

 }
 
 llvm::Error CommonOptionsParser::init(
     int &argc, const char **argv, cl::OptionCategory &Category,
     llvm::cl::NumOccurrencesFlag OccurrencesFlag, const char *Overview) {
 
   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();
 
   cl::HideUnrelatedOptions(Category);
 
   std::string ErrorMessage;
   Compilations =
       FixedCompilationDatabase::loadFromCommandLine(argc, argv, ErrorMessage);

clang/lib/Tooling/DependencyScanning/CMakeLists.txt

 set(LLVM_LINK_COMPONENTS
+  BinaryFormat
   Core
   Support
   )
 
 add_clang_library(clangDependencyScanning
   DependencyScanningFilesystem.cpp
   DependencyScanningService.cpp
   DependencyScanningWorker.cpp

clang/lib/Tooling/DependencyScanning/DependencyScanningFilesystem.cpp

 //===- DependencyScanningFilesystem.cpp - clang-scan-deps fs --------------===//
 //
 // 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 "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"
 
 using namespace clang;
 using namespace tooling;
 using namespace dependencies;
 
 CachedFileSystemEntry CachedFileSystemEntry::createFileEntry(
     StringRef Filename, llvm::vfs::FileSystem &FS, bool Minimize) {
   // Load the file and its content from the file system.
   llvm::ErrorOr<std::unique_ptr<llvm::vfs::File>> MaybeFile =
       FS.openFileForRead(Filename);
   if (!MaybeFile)
     return MaybeFile.getError();
   llvm::ErrorOr<llvm::vfs::Status> Stat = (*MaybeFile)->status();
   if (!Stat)
     return Stat.getError();
 
   llvm::vfs::File &F = **MaybeFile;
   llvm::ErrorOr<std::unique_ptr<llvm::MemoryBuffer>> MaybeBuffer =
       F.getBuffer(Stat->getName());
   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.
     CachedFileSystemEntry Result;
     Result.MaybeStat = std::move(*Stat);
     Result.Contents.reserve(Buffer->getBufferSize() + 1);
     Result.Contents.append(Buffer->getBufferStart(), Buffer->getBufferEnd());
     // Implicitly null terminate the contents for Clang's lexer.

 llvm::ErrorOr<llvm::vfs::Status>
 DependencyScanningWorkerFilesystem::status(const Twine &Path) {
   SmallString<256> OwnedFilename;
   StringRef Filename = Path.toStringRef(OwnedFilename);
   const llvm::ErrorOr<const CachedFileSystemEntry *> Result =
       getOrCreateFileSystemEntry(Filename);
   if (!Result)
     return Result.getError();
+  if (!(*Result)->isValid())
+    return (*Result)->getErrorCode();
   return (*Result)->getStatus();
 }
 
 namespace {
 
 /// The VFS that is used by clang consumes the \c CachedFileSystemEntry using
 /// this subclass.
 class MinimizedVFSFile final : public llvm::vfs::File {

clang/tools/clang-refactor/ClangRefactor.cpp

 using namespace refactor;
 namespace cl = llvm::cl;
 
 namespace opts {
 
 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
 
 namespace {
 
 /// Stores the parsed `-selection` argument.
 class SourceSelectionArgument {
 public:

clang/tools/driver/driver.cpp

 #include "llvm/ADT/SmallString.h"
 #include "llvm/ADT/SmallVector.h"
 #include "llvm/Option/ArgList.h"
 #include "llvm/Option/OptTable.h"
 #include "llvm/Option/Option.h"
 #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"
 #include "llvm/Support/InitLLVM.h"
 #include "llvm/Support/Path.h"
 #include "llvm/Support/PrettyStackTrace.h"
 #include "llvm/Support/Process.h"
 #include "llvm/Support/Program.h"
 #include "llvm/Support/Regex.h"
 #include "llvm/Support/Signals.h"
 #include "llvm/Support/StringSaver.h"
 #include "llvm/Support/TargetSelect.h"
 #include "llvm/Support/Timer.h"
 #include "llvm/Support/raw_ostream.h"
 #include <memory>
 #include <set>
 #include <system_error>
+#include <windows.h>
 using namespace clang;
 using namespace clang::driver;
 using namespace llvm::opt;
 
 std::string GetExecutablePath(const char *Argv0, bool CanonicalPrefixes) {
   if (!CanonicalPrefixes) {
     SmallString<128> ExecutablePath(Argv0);
     // Do a PATH lookup if Argv0 isn't a valid path.
if (Tool == "-cc1gen-reproducer")
     return cc1gen_reproducer_main(makeArrayRef(ArgV).slice(2), ArgV[0],
                                   GetExecutablePathVP);
   // Reject unknown tools.
   llvm::errs() << "error: unknown integrated tool '" << Tool << "'. "
                << "Valid tools include '-cc1' and '-cc1as'.\n";
   return 1;
 }
 
+int ClangDriverMain(SmallVectorImpl<const char *> &Args);
+
 int main(int Argc, const char **Argv) {
   noteBottomOfStack();
   llvm::InitLLVM X(Argc, Argv);
   llvm::setBugReportMsg("PLEASE submit a bug report to " BUG_REPORT_URL
                         " and include the crash backtrace, preprocessed "
                         "source, and associated run script.\n");
   SmallVector<const char *, 256> Args(Argv, Argv + Argc);
 
   if (llvm::sys::Process::FixupStandardFileDescriptors())
     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;
   llvm::StringSaver Saver(A);
 
   // Parse response files using the GNU syntax, unless we're in CL mode. There
   // are two ways to put clang in CL compatibility mode: Args[0] is either
   // clang-cl or cl, or --driver-mode=cl is on the command line. The normal

lld/COFF/Chunks.h

public:
   void finalizeContents();
   void assignSubsectionRVAs();
 
   uint32_t getOutputCharacteristics() const override;
   StringRef getSectionName() const override { return ".rdata"; }
   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:
   llvm::StringTableBuilder builder;
   bool finalized = false;
 };
 
 // A chunk for common symbols. Common chunks don't have actual data.

lld/COFF/Chunks.cpp

uint8_t Baserel::getDefaultType() {
   case I386:
   case ARMNT:
     return IMAGE_REL_BASED_HIGHLOW;
   default:
     llvm_unreachable("unknown machine type");
   }
 }
 
-MergeChunk *MergeChunk::instances[Log2MaxSectionAlignment + 1] = {};
+LLVM_THREAD_LOCAL MergeChunk
+    *MergeChunk::instances[Log2MaxSectionAlignment + 1] = {};
 
 MergeChunk::MergeChunk(uint32_t alignment)
     : builder(StringTableBuilder::RAW, alignment) {
   setAlignment(alignment);
 }
 
 void MergeChunk::addSection(SectionChunk *c) {
   assert(isPowerOf2_32(c->getAlignment()));

lld/COFF/Config.h

struct Configuration {
   bool swaprunCD = false;
   bool swaprunNet = false;
   bool thinLTOEmitImportsFiles;
   bool thinLTOIndexOnly;
   bool autoImport = false;
   bool pseudoRelocs = false;
 };
 
-extern Configuration *config;
+extern LLVM_THREAD_LOCAL Configuration *config;
 
 } // namespace coff
 } // namespace lld
 
 #endif

lld/COFF/DebugTypes.h

public:
   /// Returns true if this type record should be omitted from the PDB, even if
   /// it is unique. This prevents a record from being added to the input ghash
   /// table.
   bool shouldOmitFromPdb(uint32_t ghashIdx) {
     return ghashIdx == endPrecompGHashIdx;
   }
 
   /// 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();
 
   static uint32_t countTypeServerPDBs();
   static uint32_t countPrecompObjs();
 
   /// Free heap allocated ghashes.

lld/COFF/DebugTypes.cpp

 
 public:
   // Information about the Precomp OBJ dependency, that needs to be loaded in
   // before merging this OBJ.
   PrecompRecord precompDependency;
 };
 } // 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) {
   instances.push_back(this);
 }
 
 // Vtable key method.
 TpiSource::~TpiSource() {

lld/COFF/Driver.h

 #include <memory>
 #include <set>
 #include <vector>
 
 namespace lld {
 namespace coff {
 
 class LinkerDriver;
-extern LinkerDriver *driver;
+extern LLVM_THREAD_LOCAL LinkerDriver *driver;
 
 using llvm::COFF::MachineTypes;
 using llvm::COFF::WindowsSubsystem;
 using llvm::Optional;
 
 class COFFOptTable : public llvm::opt::OptTable {
 public:
   COFFOptTable();

lld/COFF/Driver.cpp

 using namespace llvm;
 using namespace llvm::object;
 using namespace llvm::COFF;
 using namespace llvm::sys;
 
 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) {
   lld::stdoutOS = &stdoutOS;
   lld::stderrOS = &stderrOS;
 
   errorHandler().cleanupCallback = []() {
     TpiSource::clear();
static bool isCrtend(StringRef s) {
   return !s.empty() && s.drop_back().endswith("crtend");
 }
 
 // ErrorOr is not default constructible, so it cannot be used as the type
 // parameter of a future.
 // FIXME: We could open the file in createFutureForFile and avoid needing to
 // 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.
 static std::future<MBErrPair> createFutureForFile(std::string path) {
 #if _WIN32
   // On Windows, file I/O is relatively slow so it is best to do this
   // asynchronously.
   auto strategy = std::launch::async;
 #else
   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) {
   assert(config->machine != IMAGE_FILE_MACHINE_UNKNOWN);
   if (config->machine == I386)
     return saver.save("_" + sym);
   return sym;
 }
case file_magic::pecoff_executable:
     LLVM_FALLTHROUGH;
   default:
     error(mbref.getBufferIdentifier() + ": unknown file type");
     break;
   }
 }
 
 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
       // the option `/nodefaultlib` than a reference to a file in the root
       // directory.
       std::string nearest;
       if (optTable.findNearest(pathStr, nearest) > 1)
         error(msg);
       else
         error(msg + "; did you mean '" + nearest + "'");
     } else
-      driver->addBuffer(std::move(mbOrErr.first), wholeArchive, lazy);
+      driver->addBuffer(std::move(mbOrErr.get()), wholeArchive, lazy);
   });
 }
 
 void LinkerDriver::addArchiveBuffer(MemoryBufferRef mb, StringRef symName,
                                     StringRef parentName,
                                     uint64_t offsetInArchive) {
   file_magic magic = identify_magic(mb.getBuffer());
   if (magic == file_magic::coff_import_library) {
if (!c.getParent()->isThin()) {
     });
     return;
   }
 
   std::string childName = CHECK(
       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);
   });
 }
 
 static bool isDecorated(StringRef sym) {
   return sym.startswith("@") || sym.contains("@@") || sym.startswith("?") ||
          (!config->mingw && sym.contains('@'));
 }

lld/COFF/ICF.cpp

 #include <atomic>
 #include <vector>
 
 using namespace llvm;
 
 namespace lld {
 namespace coff {
 
-static Timer icfTimer("ICF", Timer::root());
+static LLVM_THREAD_LOCAL Timer icfTimer("ICF", Timer::root());
 
 class ICF {
 public:
   ICF(ICFLevel icfLevel) : icfLevel(icfLevel){};
   void run(ArrayRef<Chunk *> v);
 
 private:
   void segregate(size_t begin, size_t end, bool constant);

lld/COFF/InputFiles.h

uint32_t addRangeThunkSymbol(Symbol *thunk) {
     symbols.push_back(thunk);
     return symbols.size() - 1;
   }
 
   void includeResourceChunks();
 
   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
   // like stack guard, safeseh, /guard:cf, or other things.
   uint32_t feat00Flags = 0;
 
   // True if this object file is compatible with SEH.  COFF-specific and
   // x86-only. COFF spec 5.10.1. The .sxdata section.
public:
   ~PDBInputFile();
   static bool classof(const InputFile *f) { return f->kind() == PDBKind; }
   void parse() override;
 
   static void enqueue(StringRef path, ObjFile *fromFile);
 
   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;
 
   // This is the actual interface to the PDB (if it was opened successfully)
   std::unique_ptr<llvm::pdb::NativeSession> session;
 
   // If the PDB has a .debug$T stream, this tells how it will be handled.
   TpiSource *debugTypesObj = nullptr;
 };
 
 // This type represents import library members that contain DLL names
 // and symbols exported from the DLLs. See Microsoft PE/COFF spec. 7
 // for details about the format.
 class ImportFile : public InputFile {
 public:
   explicit ImportFile(MemoryBufferRef m) : InputFile(ImportKind, m) {}
 
   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;
   std::string dllName;
 
 private:
   void parse() override;
 
BitcodeFile(MemoryBufferRef mb, StringRef archiveName,
               uint64_t offsetInArchive);
   explicit BitcodeFile(MemoryBufferRef m, StringRef archiveName,
                        uint64_t offsetInArchive,
                        std::vector<Symbol *> &&symbols);
   ~BitcodeFile();
   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:
   void parse() override;
 
   std::vector<Symbol *> symbols;
 };
 

lld/COFF/InputFiles.cpp

std::string lld::toString(const coff::InputFile *file) {
   if (file->parentName.empty() || file->kind() == coff::InputFile::ImportKind)
     return std::string(file->getName());
 
   return (getBasename(file->parentName) + "(" + getBasename(file->getName()) +
           ")")
       .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
 /// alias to Target.
 static void checkAndSetWeakAlias(SymbolTable *symtab, InputFile *f,
                                  Symbol *source, Symbol *target) {
   if (auto *u = dyn_cast<Undefined>(source)) {
     if (u->weakAlias && u->weakAlias != target) {

lld/COFF/MarkLive.cpp

 #include "Symbols.h"
 #include "lld/Common/Timer.h"
 #include "llvm/ADT/STLExtras.h"
 #include <vector>
 
 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
 // from the final output.
 void markLive(ArrayRef<Chunk *> chunks) {
   ScopedTimer t(gctimer);
 
   // We build up a worklist of sections which have been marked as live. We only

lld/COFF/PDB.h

 void createPDB(SymbolTable *symtab,
                llvm::ArrayRef<OutputSection *> outputSections,
                llvm::ArrayRef<uint8_t> sectionTable,
                llvm::codeview::DebugInfo *buildId);
 
 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
 
 #endif

lld/COFF/PDB.cpp

 using namespace lld;
 using namespace lld::coff;
 
 using llvm::object::coff_section;
 using llvm::pdb::StringTableFixup;
 
 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;
 
 class PDBLinker {
   friend DebugSHandler;
 
 public:

lld/COFF/SymbolTable.h

private:
   std::pair<Symbol *, bool> insert(StringRef name, InputFile *f);
 
   std::vector<Symbol *> getSymsWithPrefix(StringRef prefix);
 
   llvm::DenseMap<llvm::CachedHashStringRef, Symbol *> symMap;
   std::unique_ptr<BitcodeCompiler> lto;
 };
 
-extern SymbolTable *symtab;
+extern LLVM_THREAD_LOCAL SymbolTable *symtab;
 
 std::vector<std::string> getSymbolLocations(ObjFile *file, uint32_t symIndex);
 
 } // namespace coff
 } // namespace lld
 
 #endif

lld/COFF/SymbolTable.cpp

 #include "llvm/Support/raw_ostream.h"
 #include <utility>
 
 using namespace llvm;
 
 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));
   file->parse();
 
   MachineTypes mt = file->getMachineType();
   if (config->machine == IMAGE_FILE_MACHINE_UNKNOWN) {
     config->machine = mt;

lld/COFF/Symbols.h

public:
 
   uint64_t getRVA() { return va - config->imageBase; }
   void setVA(uint64_t v) { va = v; }
   uint64_t getVA() const { return va; }
 
   // 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;
 };
 
 // This symbol is used for linker-synthesized symbols like __ImageBase and
 // __safe_se_handler_table.
 class DefinedSynthetic : public Defined {

lld/COFF/Symbols.cpp

 COFFSymbolRef DefinedCOFF::getCOFFSymbol() {
   size_t symSize = cast<ObjFile>(file)->getCOFFObj()->getSymbolTableEntrySize();
   if (symSize == sizeof(coff_symbol16))
     return COFFSymbolRef(reinterpret_cast<const coff_symbol16 *>(sym));
   assert(symSize == sizeof(coff_symbol32));
   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)
     return make<ImportThunkChunkX64>(s);
   if (machine == I386)
     return make<ImportThunkChunkX86>(s);
   if (machine == ARM64)
     return make<ImportThunkChunkARM64>(s);

lld/COFF/Writer.cpp

 
 static const int dosStubSize = sizeof(dos_header) + sizeof(dosProgram);
 static_assert(dosStubSize % 8 == 0, "DOSStub size must be multiple of 8");
 
 static const int numberOfDataDirectory = 16;
 
 // 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];
 }
 
 void OutputSection::clear() { outputSections.clear(); }
 
 namespace {
private:
   // are entirely linker-generated we can keep track of their locations using
   // the chunks that the linker creates. All .pdata chunks come from input
   // files, so we need to keep track of them separately.
   Chunk *firstPdata = nullptr;
   Chunk *lastPdata;
 };
 } // 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(); }
 
 void OutputSection::addChunk(Chunk *c) {
   chunks.push_back(c);
 }
 
 void OutputSection::insertChunkAtStart(Chunk *c) {

lld/Common/Memory.cpp

 //===- Memory.cpp ---------------------------------------------------------===//
 //
 // 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 "lld/Common/Memory.h"
 
 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)
     alloc->reset();
   bAlloc.Reset();
 }

lld/Common/Timer.cpp

 ScopedTimer::~ScopedTimer() { stop(); }
 
 Timer::Timer(llvm::StringRef name) : name(std::string(name)) {}
 Timer::Timer(llvm::StringRef name, Timer &parent) : name(std::string(name)) {
   parent.children.push_back(this);
 }
 
 Timer &Timer::root() {
-  static Timer rootTimer("Total Link Time");
+  static LLVM_THREAD_LOCAL Timer rootTimer("Total Link Time");
   return rootTimer;
 }
 
 void Timer::print() {
   double totalDuration = static_cast<double>(root().millis());
 
   // We want to print the grand total under all the intermediate phases, so we
   // print all children first, then print the total under that.

lld/include/lld/Common/Memory.h

 
 #include "llvm/Support/Allocator.h"
 #include "llvm/Support/StringSaver.h"
 #include <vector>
 
 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();
 
 // These two classes are hack to keep track of all
 // SpecificBumpPtrAllocator instances.
 struct SpecificAllocBase {
   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 {
   void reset() override { alloc.DestroyAll(); }
   llvm::SpecificBumpPtrAllocator<T> alloc;
 };
 
 // Use a static local for these singletons so they are only registered if an

llvm/include/llvm/ADT/iterator_range.h

 /// Note that code here follows more standards-based coding conventions as it
 /// is mirroring proposed interfaces for standardization.
 ///
 //===----------------------------------------------------------------------===//
 
 #ifndef LLVM_ADT_ITERATOR_RANGE_H
 #define LLVM_ADT_ITERATOR_RANGE_H
 
+#include <llvm/ADT/Optional.h>
 #include <utility>
 
 namespace llvm {
 
 /// A range adaptor for a pair of iterators.
 ///
 /// This just wraps two iterators into a range-compatible interface. Nothing
 /// fancy at all.
 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
   //      iterators.
   template <typename Container>
   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

llvm/include/llvm/Analysis/LoopAccessAnalysis.h

 
 /// Collection of parameters shared beetween the Loop Vectorizer and the
 /// Loop Access Analysis.
 struct VectorizerParams {
   /// Maximum SIMD width.
   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
 /// object to determine whether there vectorization is legal or not (and at
 /// which vectorization factor).
 ///
 /// Note: This class will compute a conservative dependence for access to
 /// different underlying pointers. Clients, such as the loop vectorizer, will

llvm/include/llvm/Analysis/ObjCARCAnalysisUtils.h

 
 namespace llvm {
 
 class AAResults;
 
 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.
 inline bool ModuleHasARC(const Module &M) {
   return
     M.getNamedValue("llvm.objc.retain") ||
     M.getNamedValue("llvm.objc.release") ||
     M.getNamedValue("llvm.objc.autorelease") ||

llvm/include/llvm/Analysis/RegionInfo.h

private:
 
   // Detect all regions in function and build the region tree.
   void calculate(FuncT &F);
 
 public:
   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)
   void dump() const;
 #endif
 
   void releaseMemory();
 

llvm/include/llvm/Analysis/RegionInfoImpl.h

void RegionInfoBase<Tr>::buildRegionsTree(DomTreeNodeT *N, RegionT *region) {
 
   for (DomTreeNodeBase<BlockT> *C : *N) {
     buildRegionsTree(C, region);
   }
 }
 
 #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>
+LLVM_THREAD_LOCAL
     typename Tr::RegionT::PrintStyle RegionInfoBase<Tr>::printStyle =
         RegionBase<Tr>::PrintNone;
 
 template <class Tr>
 void RegionInfoBase<Tr>::print(raw_ostream &OS) const {
   OS << "Region tree:\n";
   TopLevelRegion->print(OS, true, 0, printStyle);
   OS << "End region tree\n";
 }
 

llvm/include/llvm/BinaryFormat/Magic.h

enum Impl {
     coff_import_library, ///< COFF import library
     pecoff_executable,   ///< PECOFF executable file
     windows_resource,    ///< Windows compiled resource file (.res)
     xcoff_object_32,     ///< 32-bit XCOFF object file
     xcoff_object_64,     ///< 64-bit XCOFF object file
     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; }
 
   file_magic() = default;
   file_magic(Impl V) : V(V) {}
   operator Impl() const { return V; }
 

llvm/include/llvm/Pass.h

 // bottom), so the APIs exposed by these files are also automatically available
 // to all users of this file.
 //
 //===----------------------------------------------------------------------===//
 
 #ifndef LLVM_PASS_H
 #define LLVM_PASS_H
 
+#include "llvm/Support/Compiler.h"
 #include <string>
 
 namespace llvm {
 
 class AnalysisResolver;
 class AnalysisUsage;
 class Function;
 class ImmutablePass;
protected:
   /// skipped. This is the case when Attribute::OptimizeNone is set or when
   /// optimization bisect is over the limit.
   bool skipFunction(const Function &F) const;
 };
 
 /// 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
 
 // Include support files that contain important APIs commonly used by Passes,
 // but that we want to separate out to make it easier to read the header files.
 #include "llvm/PassAnalysisSupport.h"
 #include "llvm/PassSupport.h"
 
 #endif // LLVM_PASS_H

llvm/include/llvm/Support/CLData.h

+//===- 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

llvm/include/llvm/Support/CommandLine.h

 // the many example usages in tools/*/*.cpp
 //
 //===----------------------------------------------------------------------===//
 
 #ifndef LLVM_SUPPORT_COMMANDLINE_H
 #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"
 #include "llvm/ADT/SmallPtrSet.h"
 #include "llvm/ADT/SmallVector.h"
 #include "llvm/ADT/StringMap.h"
 #include "llvm/ADT/StringRef.h"
 #include "llvm/ADT/Twine.h"
 #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>
 #include <cstddef>
 #include <functional>
 #include <initializer_list>
 #include <string>
 #include <type_traits>
public:
   SmallVector<Option *, 4> PositionalOpts;
   SmallVector<Option *, 4> SinkOpts;
   StringMap<Option *> OptionsMap;
 
   Option *ConsumeAfterOpt = nullptr; // The ConsumeAfter option if it exists.
 };
 
 // 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
 //
 class Option {
   friend class alias;
 
   // handleOccurrences - Overriden by subclasses to handle the value passed into
public:
   bool isPositional() const { return getFormattingFlag() == cl::Positional; }
   bool isSink() const { return getMiscFlags() & cl::Sink; }
   bool isDefaultOption() const { return getMiscFlags() & cl::DefaultOption; }
 
   bool isConsumeAfter() const {
     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
   //
   void setArgStr(StringRef S);
   void setDescription(StringRef S) { HelpStr = S; }
   void setValueStr(StringRef S) { ValueStr = S; }
   void setNumOccurrencesFlag(enum NumOccurrencesFlag Val) { Occurrences = Val; }
public:
   // Prints option name followed by message.  Always returns true.
   bool error(const Twine &Message, StringRef ArgName = StringRef(), raw_ostream &Errs = llvm::errs());
   bool error(const Twine &Message, raw_ostream &Errs) {
     return error(Message, StringRef(), Errs);
   }
 
   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) {}
 };
 
 //===----------------------------------------------------------------------===//
 // Command line option modifiers that can be used to modify the behavior of
 // command line option parsers...
 //
 
 // desc - Modifier to set the description shown in the -help output...

 // store the results of the command line argument processing into, if they don't
 // want to store it in the option itself.
 //
 template <class Ty> struct LocationClass {
   Ty &Loc;
 
   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;
 
   cat(OptionCategory &c) : Category(c) {}
 
   template <class Opt> void apply(Opt &O) const { O.addCategory(Category); }
 };

 cb<typename detail::callback_traits<F>::result_type,
    typename detail::callback_traits<F>::arg_type>
 callback(F CB) {
   using result_type = typename detail::callback_traits<F>::result_type;
   using arg_type = typename detail::callback_traits<F>::arg_type;
   return cb<result_type, arg_type>(CB);
 }
 
+struct allSub : public sub {
+  allSub();
+};
+
+struct topLevel : public sub {
+  topLevel();
+};
+
 //===----------------------------------------------------------------------===//
 // OptionValue class
 
 // Support value comparison outside the template.
 struct GenericOptionValue {
   virtual bool compare(const GenericOptionValue &V) const = 0;
 
 protected:

 // Default storage class definition: external storage.  This implementation
 // assumes the user will specify a variable to store the data into with the
 // cl::location(x) modifier.
 //
 template <class DataType, bool ExternalStorage, bool isClass>
 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 "
                        "line option with external storage, "
                        "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;
   }
 
   template <class T> void setValue(const T &V, bool initial = false) {
     check_location();
     *Location = V;
     if (initial)
       Default = V;
template <class T> void setValue(const T &V, bool initial = false) {
     if (initial)
       Default = V;
   }
 
   DataType &getValue() { return *this; }
   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
 // this case, we store an instance through containment, and overload operators
 // to get at the value.
 //
 template <class DataType> class opt_storage<DataType, false, false> {
 public:
public:
   DataType getValue() const { return Value; }
 
   const OptionValue<DataType> &getDefault() const { return Default; }
 
   operator DataType() const { return getValue(); }
 
   // If the datatype is a pointer, support -> on it.
   DataType operator->() const { return Value; }
+
+protected:
+  void remapLocationToTLS() {}
 };
 
 //===----------------------------------------------------------------------===//
 // opt - A scalar command line option.
 //
 template <class DataType, bool ExternalStorage = false,
           class ParserClass = parser<DataType>>
 class opt : public Option,
             public opt_storage<DataType, ExternalStorage,
                                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 =
         typename ParserClass::parser_data_type();
     if (Parser.parse(*this, ArgName, Arg, Val))
       return true; // Parse error!
     this->setValue(Val);
     this->setPosition(pos);
class opt : public Option,
 
   void done() {
     addArgument();
     Parser.initialize();
   }
 
 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); }
 
   ParserClass &getParser() { return Parser; }
 
   template <class T> DataType &operator=(const T &Val) {
     this->setValue(Val);

 
 // Default storage class definition: external storage.  This implementation
 // assumes the user will specify a variable to store the data into with the
 // cl::location(x) modifier.
 //
 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;
     return false;
   }
 
   template <class T> void addValue(const T &V) {
     assert(Location != 0 && "cl::location(...) not specified for a command "
                             "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.
 // Originally this code inherited from std::vector. In transitioning to a new
 // API for command line options we should change this. The new implementation
 // of this list_storage specialization implements the minimum subset of the
 // std::vector API required for all the current clients.
 //
 // FIXME: Reduce this API to a more narrow subset of std::vector
 //
 template <class DataType> class list_storage<DataType, bool> {
   std::vector<DataType> Storage;
 
+protected:
+  void remapLocationToTLS() {}
+
 public:
   using iterator = typename std::vector<DataType>::iterator;
 
   iterator begin() { return Storage.begin(); }
   iterator end() { return Storage.end(); }
 
   using const_iterator = typename std::vector<DataType>::const_iterator;
 
public:
   }
   iterator insert(iterator pos, DataType &&value) {
     return Storage.insert(pos, value);
   }
 
   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; }
   const std::vector<DataType> *operator&() const { return &Storage; }
 
   template <class T> void addValue(const T &V) { Storage.push_back(V); }
 };
 
 //===----------------------------------------------------------------------===//
 // list - A list of command line options.
 //
 template <class DataType, class StorageClass = bool,
           class ParserClass = parser<DataType>>
 class list : public Option, public list_storage<DataType, StorageClass> {
   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();
   }
 
   void getExtraOptionNames(SmallVectorImpl<StringRef> &OptionNames) override {
     return Parser.getExtraOptionNames(OptionNames);
   }
 
class list : public Option, public list_storage<DataType, StorageClass> {
 
   void done() {
     addArgument();
     Parser.initialize();
   }
 
 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; }
 
   unsigned getPosition(unsigned optnum) const {
     assert(optnum < this->size() && "Invalid option index");
     return Positions[optnum];
   }
 

 // bits_storage class
 
 // Default storage class definition: external storage.  This implementation
 // assumes the user will specify a variable to store the data into with the
 // cl::location(x) modifier.
 //
 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);
     assert(BitPos < sizeof(unsigned) * CHAR_BIT &&
            "enum exceeds width of bit vector!");
     return 1 << BitPos;
   }
 
 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;
   }
 
   template <class T> void addValue(const T &V) {
     assert(Location != 0 && "cl::location(...) not specified for a command "
                             "line option with external storage!");
     *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;
   }
 };
 
 // Define how to hold bits.  Since we can inherit from a class, we do so.
 // This makes us exactly compatible with the bits in all cases that it is used.
 //
 template <class DataType> class bits_storage<DataType, bool> {
   unsigned Bits; // Where to store the bits...
 
   template <class T> static unsigned Bit(const T &V) {
     unsigned BitPos = (unsigned)V;
     assert(BitPos < sizeof(unsigned) * CHAR_BIT &&
            "enum exceeds width of bit vector!");
     return 1 << BitPos;
   }
 
 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; }
 };
 
 //===----------------------------------------------------------------------===//
 // bits - A bit vector of command options.
 //
 template <class DataType, class Storage = bool,
           class ParserClass = parser<DataType>>
 class bits : public Option, public bits_storage<DataType, Storage> {
   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();
   }
 
   void getExtraOptionNames(SmallVectorImpl<StringRef> &OptionNames) override {
     return Parser.getExtraOptionNames(OptionNames);
   }
 
class bits : public Option, public bits_storage<DataType, Storage> {
 
   void done() {
     addArgument();
     Parser.initialize();
   }
 
 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; }
 
   unsigned getPosition(unsigned optnum) const {
     assert(optnum < this->size() && "Invalid option index");
     return Positions[optnum];
   }
 

 
 //===----------------------------------------------------------------------===//
 // Aliased command line option (alias this name to a preexisting name)
 //
 
 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);
   }
 
   bool addOccurrence(unsigned pos, StringRef /*ArgName*/, StringRef Value,
                      bool MultiArg = false) override {
     return AliasFor->addOccurrence(pos, AliasFor->ArgStr, Value, MultiArg);
if (!Subs.empty())
       error("cl::alias must not have cl::sub(), aliased option's cl::sub() will be used!");
     Subs = AliasFor->Subs;
     Categories = AliasFor->Categories;
     addArgument();
   }
 
 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)
       error("cl::alias must only have one cl::aliasopt(...) specified!");
     AliasFor = &O;
   }
 
   template <class... Mods>

 ///
 /// This interface is useful for modifying options in libraries that are out of
 /// the control of the client. The options should be modified before calling
 /// llvm::cl::ParseCommandLineOptions().
 ///
 /// 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.
 ///
 /// \return A range of all SubCommand pointers registered with the parser.
 ///
 /// Typical usage:
 /// \code
 /// main(int argc, char* argv[]) {
 ///   llvm::cl::ParseCommandLineOptions(argc, argv);
 ///   for (auto* S : llvm::cl::getRegisteredSubcommands()) {
 ///     if (*S) {
 ///       std::cout << "Executing subcommand: " << S->getName() << std::endl;
 ///       // Execute some function based on the name...
 ///     }
 ///   }
 /// }
 /// \endcode
 ///
 /// This interface is useful for defining subcommands in libraries and
 /// the dispatch from a single point (like in the main function).
 iterator_range<typename SmallPtrSet<SubCommand *, 4>::iterator>
 getRegisteredSubcommands();
 
+bool isTopLevel(SubCommand *SC);
+
 //===----------------------------------------------------------------------===//
 // Standalone command line processing utilities.
 //
 
 /// Tokenizes a command line that can contain escapes and quotes.
 //
 /// The quoting rules match those used by GCC and other tools that use
 /// libiberty's buildargv() or expandargv() utilities, and do not match bash.

 
 /// Mark all options not part of this category as cl::ReallyHidden.
 ///
 /// \param Category the category of options to keep displaying
 ///
 /// 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.
 ///
 /// \param Categories the categories of options to keep displaying.
 ///
 /// 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
 /// a command line multiple times (especially useful for writing tests).
 void ResetAllOptionOccurrences();
 
 /// Reset the command line parser back to its initial state.  This
 /// removes

llvm/include/llvm/Support/Debug.h

 // LLVM_DEBUG() statements disappears, so it does not affect the runtime of the
 // code.
 //
 //===----------------------------------------------------------------------===//
 
 #ifndef LLVM_SUPPORT_DEBUG_H
 #define LLVM_SUPPORT_DEBUG_H
 
+#include "llvm/Support/Compiler.h"
+
 namespace llvm {
 
 class raw_ostream;
 
 #ifndef NDEBUG
 
 /// isCurrentDebugType - Return true if the specified string is the debug type
 /// specified on the command line, or if none was specified on the command line

 #define setCurrentDebugTypes(X, N)
 #define DEBUG_WITH_TYPE(TYPE, X) do { } while (false)
 #endif
 
 /// This boolean is set to true if the '-debug' command line option
 /// 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.
 ///
 /// These flags turns on/off that are expensive and are turned off by default,
 /// unless macro EXPENSIVE_CHECKS is defined. The flags allow selectively
 /// turning the checks on without need to recompile.
 /// \{
 
 /// 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;
 
 ///\}
 
 /// EnableDebugBuffering - This defaults to false.  If true, the debug
 /// stream will install signal handlers to dump any buffered debug
 /// output.  It allows clients to selectively allow the debug stream
 /// to install signal handlers if they are certain there will be no
 /// conflict.

llvm/include/llvm/Support/DebugCounter.h

 
 class DebugCounter {
 public:
   ~DebugCounter();
 
   /// 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
   // line option parsing. The main reason to register counters is to produce a
   // nice list of them on the command line, but i'm not sure this is worth it.
   static unsigned registerCounter(StringRef Name, StringRef Desc) {
     return instance().addCounter(std::string(Name), std::string(Desc));
   }
public:
 
   // Return the name and description of the counter with the given ID.
   std::pair<std::string, std::string> getCounterInfo(unsigned ID) const {
     return std::make_pair(RegisteredCounters[ID], Counters.lookup(ID).Desc);
   }
 
   // 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.
   //
   // Since DebugCounters are incompatible with threading (not only do they not
   // make sense, but we'll also see data races), this should only be used in
   // contexts where we're certain we won't spawn threads.
   static void enableAllCounters() { instance().Enabled = true; }
 
struct CounterInfo {
     std::string Desc;
   };
   DenseMap<unsigned, CounterInfo> Counters;
   CounterVector RegisteredCounters;
 
   // 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)                              \
   static const unsigned VARNAME =                                              \
       DebugCounter::registerCounter(COUNTERNAME, DESC)
 
 } // namespace llvm
 #endif

llvm/include/llvm/Support/Error.h

public:
   /// Check E. If it's in a success state then return the contained reference. If
   /// it's in a failure state log the error(s) and exit.
   template <typename T> T& operator()(Expected<T&> &&E) const {
     checkError(E.takeError());
     return *E;
   }
 
 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;
 };
 
 /// Conversion from Error to LLVMErrorRef for C error bindings.
 inline LLVMErrorRef wrap(Error Err) {
   return reinterpret_cast<LLVMErrorRef>(Err.takePayload().release());

llvm/include/llvm/Support/InitLLVM.h

public:
   InitLLVM(int &Argc, const char **&Argv,
            bool InstallPipeSignalExitHandler = true);
   InitLLVM(int &Argc, char **&Argv, bool InstallPipeSignalExitHandler = true)
       : InitLLVM(Argc, const_cast<const char **&>(Argv),
                  InstallPipeSignalExitHandler) {}
 
   ~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;
   Optional<PrettyStackTraceProgram> StackPrinter;
 };
 } // namespace llvm
 
 #endif

llvm/include/llvm/Support/Process.h

public:
   /// crash, rather than exiting the current process.
   /// Use \arg NoCleanup for calling _exit() instead of exit().
   LLVM_ATTRIBUTE_NORETURN
   static void Exit(int RetCode, bool NoCleanup = false);
 
 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);
 };
 
 }
 }
 
 #endif

llvm/include/llvm/Support/TargetRegistry.h

struct TargetRegistry {
   /// triple is used.
   ///
   /// \param ArchName - The architecture to use for finding a target.
   /// \param TheTriple - The triple to use for finding a target.  The
   /// triple is updated with canonical architecture name if a lookup
   /// 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
   /// @{
 
   /// RegisterTarget - Register the given target. Attempts to register a
   /// target which has already been registered will be ignored.
   ///

llvm/include/llvm/Support/circular_raw_ostream.h

public:
     /// buffering to be happening underneath it.
     ///
     /// "Owns" tells the circular_raw_ostream whether it is
     /// responsible for managing the held stream, doing memory
     /// management of it, etc.
     ///
     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;
       setStream(Stream, Owns);
     }
 
     ~circular_raw_ostream() override {
       flush();
       flushBufferWithBanner();
       releaseStream();
       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();
     }
 
     /// setStream - Tell the circular_raw_ostream to output a
     /// different stream.  "Owns" tells circular_raw_ostream whether
     /// it should take responsibility for managing the underlying
     /// stream.

llvm/include/llvm/Support/raw_os_ostream.h

class raw_os_ostream : public raw_ostream {
   /// write_impl - See raw_ostream::write_impl.
   void write_impl(const char *Ptr, size_t Size) override;
 
   /// current_pos - Return the current position within the stream, not
   /// counting the bytes currently in the buffer.
   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
 
 #endif

llvm/include/llvm/Support/raw_ostream.h

 /// buffered disciplines etc. It is a simple buffer that outputs
 /// a chunk at a time.
 class raw_ostream {
 public:
   // Class kinds to support LLVM-style RTTI.
   enum class OStreamKind {
     OK_OStream,
     OK_FDStream,
+    OK_PWriteStream,
+    OK_FDOStream,
+    OK_StrStream,
+    OK_SVecStream,
+    OK_NullStream,
+    OK_OSOStream,
+    OK_SHA1OStream,
+    OK_CircularStream
   };
 
 private:
   OStreamKind Kind;
 
   /// The buffer is handled in such a way that the buffer is
   /// uninitialized, unbuffered, or out of space when OutBufCur >=
   /// OutBufEnd. Thus a single comparison suffices to determine if we
public:
   // Enable or disable colors. Once enable_colors(false) is called,
   // changeColor() has no effect until enable_colors(true) is called.
   virtual void enable_colors(bool enable) { ColorEnabled = enable; }
 
   /// Tie this stream to the specified stream. Replaces any existing tied-to
   /// 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
   //===--------------------------------------------------------------------===//
 
 private:
   /// The is the piece of the class that is implemented by subclasses.  This
   /// writes the \p Size bytes starting at
   /// \p Ptr to the underlying stream.

 /// pwrite operation. This is useful for code that can mostly stream out data,
 /// but needs to patch in a header that needs to know the output size.
 class raw_pwrite_stream : public raw_ostream {
   virtual void pwrite_impl(const char *Ptr, size_t Size, uint64_t Offset) = 0;
   void anchor() override;
 
 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
     uint64_t Pos = tell();
     // /dev/null always reports a pos of 0, so we cannot perform this check
     // in that case.
     if (Pos)
       assert(Size + Offset <= Pos && "We don't support extending the stream");
 #endif
     pwrite_impl(Ptr, Size, Offset);
   }
+
+  static bool classof(const raw_ostream *s) {
+    return s->get_kind() == OStreamKind::OK_PWriteStream;
+  }
 };
 
 //===----------------------------------------------------------------------===//
 // File Output Streams
 //===----------------------------------------------------------------------===//
 
 /// A raw_ostream that writes to a file descriptor.
 ///
public:
   raw_fd_ostream(StringRef Filename, std::error_code &EC,
                  sys::fs::CreationDisposition Disp, sys::fs::FileAccess Access,
                  sys::fs::OpenFlags Flags);
 
   /// FD is the file descriptor that this writes to.  If ShouldClose is true,
   /// 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.
   uint64_t seek(uint64_t off);
 
   bool is_displayed() const override;
 
   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
   /// called to report the error. Use clear_error() after handling the error to
   /// avoid this behavior.
   ///
   ///   "Errors should never pass silently.
   ///    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.
   ///
   /// @returns RAII object that releases the lock upon leaving the scope, if the
   ///          locking was successful. Otherwise returns corresponding
   ///          error code.
   ///
   /// The function blocks the current thread until the lock become available or
public:
   ///
   /// It is used as @ref lock.
   LLVM_NODISCARD
   Expected<sys::fs::FileLocker> tryLockFor(std::chrono::milliseconds Timeout);
 };
 
 /// 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();
 
 //===----------------------------------------------------------------------===//
 // File Streams
 //===----------------------------------------------------------------------===//
 
public:
   /// \param Size The number of bytes to be read.
   ///
   /// On success, the number of bytes read is returned, and the file position is
   /// advanced by this number. On error, -1 is returned, use error() to get the
   /// error code.
   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;
+  }
 };
 
 //===----------------------------------------------------------------------===//
 // Output Stream Adaptors
 //===----------------------------------------------------------------------===//
 
 /// A raw_ostream that writes to an std::string.  This is a simple adaptor
 /// class. This class does not encounter output errors.
 class raw_string_ostream : public raw_ostream {
   std::string &OS;
 
   /// See raw_ostream::write_impl.
   void write_impl(const char *Ptr, size_t Size) override;
 
   /// Return the current position within the stream, not counting the bytes
   /// currently in the buffer.
   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() {
     flush();
     return OS;
   }
 
   void reserveExtraSpace(uint64_t ExtraSize) override {
class raw_svector_ostream : public raw_pwrite_stream {
   /// Return the current position within the stream.
   uint64_t current_pos() const override;
 
 public:
   /// Construct a new raw_svector_ostream.
   ///
   /// \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.
   StringRef str() const { return StringRef(OS.data(), OS.size()); }
 
   void reserveExtraSpace(uint64_t ExtraSize) override {
     OS.reserve(tell() + ExtraSize);
   }
 };
 
 /// A raw_ostream that discards all output.
 class raw_null_ostream : public raw_pwrite_stream {
   /// See raw_ostream::write_impl.
   void write_impl(const char *Ptr, size_t size) override;
   void pwrite_impl(const char *Ptr, size_t Size, uint64_t Offset) override;
 
   /// Return the current position within the stream, not counting the bytes
   /// currently in the buffer.
   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 {
   raw_ostream &OS;
   SmallVector<char, 0> Buffer;
 
   virtual void anchor() override;
 

llvm/include/llvm/Support/raw_sha1_ostream.h

class raw_sha1_ostream : public raw_ostream {
   SHA1 State;
 
   /// See raw_ostream::write_impl.
   void write_impl(const char *Ptr, size_t Size) override {
     State.update(ArrayRef<uint8_t>((const uint8_t *)Ptr, Size));
   }
 
 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();
     return State.result();
   }
 
   /// Reset the internal state to start over from scratch.
   void resetHash() { State.init(); }
 
   uint64_t current_pos() const override { return 0; }
 };
 
 } // end llvm namespace
 
 #endif

llvm/include/llvm/TableGen/TableGenBackend.h

 
 class StringRef;
 class raw_ostream;
 
 /// emitSourceFileHeader - Output an LLVM style file header to the specified
 /// raw_ostream.
 void emitSourceFileHeader(StringRef Desc, raw_ostream &OS);
 
-extern bool TimeRegions;
-
 } // End llvm namespace
 
 #endif

llvm/include/llvm/Transforms/IPO/Attributor.h

 /// this is not possible return `nullptr`. Note: this function basically knows
 /// how to cast various constants.
 Value *getWithType(Value &V, Type &Ty);
 
 } // namespace AA
 
 /// 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 {
   CHANGED,
   UNCHANGED,
 };
 
 ChangeStatus operator|(ChangeStatus l, ChangeStatus r);
if (!isValidState() && !RHS.isValidState())
       return true;
     if (undefIsContained() != RHS.undefIsContained())
       return false;
     return Set == RHS.getAssumedSet();
   }
 
   /// 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() {
     return PotentialValuesState(true);
   }
 
   static PotentialValuesState getBestState(PotentialValuesState &PVS) {
     return getBestState();

llvm/include/llvm/Transforms/Scalar/LoopIdiomRecognize.h

 
 class Loop;
 class LPMUpdater;
 
 /// Options to disable Loop Idiom Recognize, which can be shared with other
 /// 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.
 class LoopIdiomRecognizePass : public PassInfoMixin<LoopIdiomRecognizePass> {
 public:
   PreservedAnalyses run(Loop &L, LoopAnalysisManager &AM,
                         LoopStandardAnalysisResults &AR, LPMUpdater &U);
 };
 
 } // end namespace llvm
 
 #endif // LLVM_TRANSFORMS_SCALAR_LOOPIDIOMRECOGNIZE_H

llvm/lib/Analysis/LoopAccessAnalysis.cpp

 using namespace llvm;
 
 #define DEBUG_TYPE "loop-accesses"
 
 static cl::opt<unsigned, true>
 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,
                         cl::desc("Sets the vectorization interleave count. "
                                  "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(
     "memory-check-merge-threshold", cl::Hidden,
     cl::desc("Maximum number of comparisons done when trying to merge "
              "runtime memory checks. (default = 100)"),
     cl::init(100));
 

llvm/lib/Analysis/LoopInfo.cpp

 using namespace llvm;
 
 // Explicitly instantiate methods in LoopInfoImpl.h for IR-level Loops.
 template class llvm::LoopBase<BasicBlock, Loop>;
 template class llvm::LoopInfoBase<BasicBlock, Loop>;
 
 // 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),
                     cl::Hidden, cl::desc("Verify loop info (time consuming)"));
 
 //===----------------------------------------------------------------------===//
 // Loop implementation
 //

llvm/lib/Analysis/MemorySSA.cpp

 
 static cl::opt<unsigned> MaxCheckLimit(
     "memssa-check-limit", cl::Hidden, cl::init(100),
     cl::desc("The maximum number of stores/phis MemorySSA"
              "will consider trying to walk past (default = 100)"));
 
 // 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(
     "enable-mssa-loop-dependency", cl::Hidden, cl::init(true),
     cl::desc("Enable MemorySSA dependency for loop pass manager"));
 
 static cl::opt<bool, true>
     VerifyMemorySSAX("verify-memoryssa", cl::location(VerifyMemorySSA),

llvm/lib/Analysis/ModuleSummaryAnalysis.cpp

 #include <vector>
 
 using namespace llvm;
 
 #define DEBUG_TYPE "module-summary-analysis"
 
 // 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"),
     cl::values(clEnumValN(FunctionSummary::FSHT_None, "none", "None."),
                clEnumValN(FunctionSummary::FSHT_AllNonCritical,
                           "all-non-critical", "All non-critical edges."),
                clEnumValN(FunctionSummary::FSHT_All, "all", "All edges.")));
 

llvm/lib/Analysis/ObjCARCAnalysisUtils.cpp

 #include "llvm/Analysis/ObjCARCAnalysisUtils.h"
 #include "llvm/Analysis/AliasAnalysis.h"
 #include "llvm/Support/CommandLine.h"
 
 using namespace llvm;
 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);
 
 bool llvm::objcarc::IsPotentialRetainableObjPtr(const Value *Op,
                                                 AAResults &AA) {
   // First make the rudimentary check.
   if (!IsPotentialRetainableObjPtr(Op))

llvm/lib/BinaryFormat/Magic.cpp

if (Magic[1] == char(0x86) || Magic[1] == char(0xaa))
       return file_magic::coff_object;
     break;
 
   case 0x2d: // YAML '-'
     if (startswith(Magic, "--- !tapi") || startswith(Magic, "---\narchs:"))
       return file_magic::tapi_file;
     break;
 
+  case 'C':
+    if (startswith(Magic, "CPCH"))
+      return file_magic::clang_pch;
+    break;
+
   default:
     break;
   }
   return file_magic::unknown;
 }
 
 std::error_code llvm::identify_magic(const Twine &Path, file_magic &Result) {
   auto FileOrError = MemoryBuffer::getFile(Path, /*IsText=*/false,

llvm/lib/Bitcode/Writer/BitcodeWriter.cpp

 static cl::opt<uint32_t> FlushThreshold(
     "bitcode-flush-threshold", cl::Hidden, cl::init(512),
     cl::desc("The threshold (unit M) for flushing LLVM bitcode."));
 
 static cl::opt<bool> WriteRelBFToSummary(
     "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 {
 
 /// These are manifest constants used by the bitcode writer. They do not need to
 /// be kept in sync with the reader, but need to be consistent within this file.
 enum {
   // VALUE_SYMTAB_BLOCK abbrev id's.
   VST_ENTRY_8_ABBREV = bitc::FIRST_APPLICATION_ABBREV,

llvm/lib/CodeGen/MachineDominators.cpp

 #include "llvm/InitializePasses.h"
 #include "llvm/Support/CommandLine.h"
 
 using namespace llvm;
 
 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
 
 static cl::opt<bool, true> VerifyMachineDomInfoX(
     "verify-machine-dom-info", cl::location(VerifyMachineDomInfo), cl::Hidden,
     cl::desc("Verify machine dominator info (time consuming)"));
 
 namespace llvm {

llvm/lib/CodeGen/RegAllocBase.h

protected:
   static const char TimerGroupName[];
   static const char TimerGroupDescription[];
 
   /// Method called when the allocator is about to remove a LiveInterval.
   virtual void aboutToRemoveInterval(LiveInterval &LI) {}
 
 public:
   /// VerifyEnabled - True when -verify-regalloc is given.
-  static bool VerifyEnabled;
+  LLVM_THREAD_LOCAL static bool VerifyEnabled;
 
 private:
   void seedLiveRegs();
 };
 
 } // end namespace llvm
 
 #endif // LLVM_LIB_CODEGEN_REGALLOCBASE_H

llvm/lib/CodeGen/RegAllocBase.cpp

 // Temporary verification option until we can put verification inside
 // MachineVerifier.
 static cl::opt<bool, true>
     VerifyRegAlloc("verify-regalloc", cl::location(RegAllocBase::VerifyEnabled),
                    cl::Hidden, cl::desc("Verify during register allocation"));
 
 const char RegAllocBase::TimerGroupName[] = "regalloc";
 const char RegAllocBase::TimerGroupDescription[] = "Register Allocation";
-bool RegAllocBase::VerifyEnabled = false;
+LLVM_THREAD_LOCAL bool RegAllocBase::VerifyEnabled = false;
 
 //===----------------------------------------------------------------------===//
 //                         RegAllocBase Implementation
 //===----------------------------------------------------------------------===//
 
 // Pin the vtable to this file.
 void RegAllocBase::anchor() {}
 

llvm/lib/CodeGen/SelectionDAG/SelectionDAGBuilder.cpp

 using namespace llvm;
 using namespace PatternMatch;
 using namespace SwitchCG;
 
 #define DEBUG_TYPE "isel"
 
 /// 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),
                       cl::desc("Insert the experimental `assertalign` node."),
                       cl::ReallyHidden);
 
 static cl::opt<unsigned, true>
     LimitFPPrecision("limit-float-precision",

llvm/lib/ExecutionEngine/Interpreter/Execution.cpp

 #include "llvm/IR/Constants.h"
 #include "llvm/IR/DerivedTypes.h"
 #include "llvm/IR/GetElementPtrTypeIterator.h"
 #include "llvm/IR/Instructions.h"
 #include "llvm/Support/CommandLine.h"
 #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>
 using namespace llvm;
 
 #define DEBUG_TYPE "interpreter"
 
 STATISTIC(NumDynamicInsts, "Number of dynamic instructions executed");

 //===----------------------------------------------------------------------===//
 
 void Interpreter::exitCalled(GenericValue GV) {
   // runAtExitHandlers() assumes there are no stack frames, but
   // if exit() was called, then it had a stack frame. Blow away
   // 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
 /// back into the result variable if we are not returning void. The
 /// result variable may be the ExitValue, or the Value of the calling
 /// CallInst if there was a previous stack frame. This method may
 /// invalidate any ECStack iterators you have. This method also takes
 /// care of switching to the normal destination BB, if we are returning

llvm/lib/ExecutionEngine/TargetSelect.cpp

 TargetMachine *EngineBuilder::selectTarget(const Triple &TargetTriple,
                               StringRef MArch,
                               StringRef MCPU,
                               const SmallVectorImpl<std::string>& MAttrs) {
   Triple TheTriple(TargetTriple);
   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;
-    }
-  }
+  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 (!TheTarget)
 
   // Package up features to be passed to target/subtarget
   std::string FeaturesStr;
   if (!MAttrs.empty()) {
     SubtargetFeatures Features;
     for (unsigned i = 0; i != MAttrs.size(); ++i)
       Features.AddFeature(MAttrs[i]);
     FeaturesStr = Features.getString();

llvm/lib/IR/DiagnosticHandler.cpp

if (!Val.empty()) {
       if (!Pattern->isValid(RegexError))
         report_fatal_error("Invalid regular expression '" + Val +
                                "' in -pass-remarks: " + RegexError,
                            false);
     }
   }
 };
 
-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()
 static cl::opt<PassRemarksOpt, true, cl::parser<std::string>> PassRemarks(
     "pass-remarks", cl::value_desc("pattern"),
     cl::desc("Enable optimization remarks from passes whose name match "
              "the given regular expression"),
     cl::Hidden, cl::location(PassRemarksPassedOptLoc), cl::ValueRequired,

llvm/lib/IR/Dominators.cpp

 #include "llvm/InitializePasses.h"
 #include "llvm/Support/CommandLine.h"
 #include "llvm/Support/Debug.h"
 #include "llvm/Support/GenericDomTreeConstruction.h"
 #include "llvm/Support/raw_ostream.h"
 #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)"));
 
 #ifdef EXPENSIVE_CHECKS
 static constexpr bool ExpensiveChecksEnabled = true;
 #else
 static constexpr bool ExpensiveChecksEnabled = false;

llvm/lib/IR/LLVMContext.cpp

 #include "llvm/IR/DiagnosticInfo.h"
 #include "llvm/IR/DiagnosticPrinter.h"
 #include "llvm/IR/LLVMRemarkStreamer.h"
 #include "llvm/IR/Metadata.h"
 #include "llvm/IR/Module.h"
 #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>
 #include <string>
 #include <utility>
 
 using namespace llvm;
 
if (!isDiagnosticEnabled(DI))
     return;
 
   // Otherwise, print the message with a prefix based on the severity.
   DiagnosticPrinterRawOStream DP(errs());
   errs() << getDiagnosticMessagePrefix(DI.getSeverity()) << ": ";
   DI.print(DP);
   errs() << "\n";
   if (DI.getSeverity() == DS_Error)
-    exit(1);
+    sys::Process::Exit(1);
 }
 
 void LLVMContext::emitError(unsigned LocCookie, const Twine &ErrorStr) {
   diagnose(DiagnosticInfoInlineAsm(LocCookie, ErrorStr));
 }
 
 //===----------------------------------------------------------------------===//
 // Metadata Kind Uniquing

llvm/lib/IR/PassTimingInfo.cpp

 #include <string>
 
 using namespace llvm;
 
 #define DEBUG_TYPE "time-passes"
 
 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,
     cl::desc("Time each pass, printing elapsed time for each on exit"));
 
 static cl::opt<bool, true> EnableTimingPerRun(
     "time-passes-per-run", cl::location(TimePassesPerRun), cl::Hidden,
     cl::desc("Time each pass run, printing elapsed time for each run on exit"),

llvm/lib/IRReader/IRReader.cpp

 #include "llvm/Support/SourceMgr.h"
 #include "llvm/Support/Timer.h"
 #include "llvm/Support/raw_ostream.h"
 #include <system_error>
 
 using namespace llvm;
 
 namespace llvm {
-  extern bool TimePassesIsEnabled;
+extern LLVM_THREAD_LOCAL bool TimePassesIsEnabled;
 }
 
 const char TimeIRParsingGroupName[] = "irparse";
 const char TimeIRParsingGroupDescription[] = "LLVM IR Parsing";
 const char TimeIRParsingName[] = "parse";
 const char TimeIRParsingDescription[] = "Parse IR";
 
 std::unique_ptr<Module>

llvm/lib/LTO/LTOBackend.cpp

 #include "llvm/Object/ModuleSymbolTable.h"
 #include "llvm/Passes/PassBuilder.h"
 #include "llvm/Passes/PassPlugin.h"
 #include "llvm/Passes/StandardInstrumentations.h"
 #include "llvm/Support/Error.h"
 #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"
 #include "llvm/Support/ThreadPool.h"
 #include "llvm/Support/raw_ostream.h"
 #include "llvm/Target/TargetMachine.h"
 #include "llvm/Transforms/IPO.h"
 #include "llvm/Transforms/IPO/PassManagerBuilder.h"

 static cl::opt<bool> ThinLTOAssumeMerged(
     "thinlto-assume-merged", cl::init(false),
     cl::desc("Assume the input has already undergone ThinLTO function "
              "importing and the other pre-optimization pipeline changes."));
 
 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,
                            bool UseInputModulePath) {
   ShouldDiscardValueNames = false;
 
   std::error_code EC;
   ResolutionFile =

llvm/lib/MC/MCContext.cpp

 #include "llvm/MC/MCSymbolWasm.h"
 #include "llvm/MC/MCSymbolXCOFF.h"
 #include "llvm/MC/SectionKind.h"
 #include "llvm/Support/Casting.h"
 #include "llvm/Support/CommandLine.h"
 #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"
 #include <cassert>
 #include <cstdlib>
 #include <tuple>
 #include <utility>
 

 
 void MCContext::reportFatalError(SMLoc Loc, const Twine &Msg) {
   reportError(Loc, Msg);
 
   // If we reached here, we are failing ungracefully. Run the interrupt handlers
   // 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);
 }

llvm/lib/Object/Binary.cpp

case file_magic::macho_universal_binary:
     return MachOUniversalBinary::create(Buffer);
   case file_magic::windows_resource:
     return WindowsResource::createWindowsResource(Buffer);
   case file_magic::pdb:
     // PDB does not support the Binary interface.
     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:
     return MinidumpFile::create(Buffer);
   case file_magic::tapi_file:
     return TapiUniversal::create(Buffer);
   }
   llvm_unreachable("Unexpected Binary File Type");

llvm/lib/Object/ObjectFile.cpp

ObjectFile::createObjectFile(MemoryBufferRef Object, file_magic Type,
   case file_magic::unknown:
   case file_magic::bitcode:
   case file_magic::coff_cl_gl_object:
   case file_magic::archive:
   case file_magic::macho_universal_binary:
   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);
   case file_magic::elf:
   case file_magic::elf_relocatable:
   case file_magic::elf_executable:
   case file_magic::elf_shared_object:
   case file_magic::elf_core:

llvm/lib/Support/CMakeLists.txt

 include(GetLibraryName)
 
 if(LLVM_ENABLE_ZLIB)
   set(imported_libs ZLIB::ZLIB)
 endif()
 
 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)
   endif()
   if( HAVE_LIBDL )
     set(system_libs ${system_libs} ${CMAKE_DL_LIBS})
   endif()
   if( HAVE_BACKTRACE AND NOT "${Backtrace_LIBRARIES}" STREQUAL "" )
if (MSVC)
   set (delayload_flags delayimp -delayload:shell32.dll -delayload:ole32.dll)
 endif()
 
 # Link Z3 if the user wants to build it.
 if(LLVM_WITH_Z3)
   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)$")
     message(FATAL_ERROR "LLVM_INTEGRATED_CRT_ALLOC only works with /MT or /MTd. Use LLVM_USE_CRT_${uppercase_CMAKE_BUILD_TYPE} to set the appropriate option.")
   endif()
 
   string(REGEX REPLACE "(/|\\\\)$" "" LLVM_INTEGRATED_CRT_ALLOC "${LLVM_INTEGRATED_CRT_ALLOC}")
 

llvm/lib/Support/CommandLine.cpp

 #include "llvm/ADT/Twine.h"
 #include "llvm/Config/config.h"
 #include "llvm/Support/ConvertUTF.h"
 #include "llvm/Support/Debug.h"
 #include "llvm/Support/Error.h"
 #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"
 #include "llvm/Support/Process.h"
 #include "llvm/Support/StringSaver.h"
 #include "llvm/Support/VirtualFileSystem.h"
 #include "llvm/Support/raw_ostream.h"
 #include <cstdlib>
public:
 
   // This collects the different option categories that have been registered.
   SmallPtrSet<OptionCategory *, 16> RegisteredOptionCategories;
 
   // This collects the different subcommands that have been registered.
   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,
                                StringRef Overview, raw_ostream *Errs = nullptr,
                                bool LongOptionsUseDoubleDash = false);
 
   void addLiteralOption(Option &Opt, SubCommand *SC, StringRef Name) {
     if (Opt.hasArgStr())
       return;
     if (!SC->OptionsMap.insert(std::make_pair(Name, &Opt)).second) {
       errs() << ProgramName << ": CommandLine Error: Option '" << Name
              << "' registered more than once!\n";
       report_fatal_error("inconsistency in registered CommandLine options");
     }
 
     // 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;
         addLiteralOption(Opt, Sub, Name);
       }
     }
   }
 
   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);
     }
   }
 
   void addOption(Option *O, SubCommand *SC) {
     bool HadErrors = false;
void addOption(Option *O, SubCommand *SC) {
     // indicate serious issues such as conflicting option names or an
     // incorrectly
     // linked LLVM distribution.
     if (HadErrors)
       report_fatal_error("inconsistency in registered CommandLine options");
 
     // 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;
         addOption(O, Sub);
       }
     }
   }
 
   void addOption(Option *O, bool ProcessDefaultOption = false) {
     if (!ProcessDefaultOption && O->isDefaultOption()) {
       DefaultOptions.push_back(O);
       return;
     }
 
     if (O->Subs.empty()) {
-      addOption(O, &*TopLevelSubCommand);
+      addOption(O, &TopLevelSubCommand);
     } else {
       for (auto *SC : O->Subs)
         addOption(O, SC);
     }
   }
 
   void removeOption(Option *O, SubCommand *SC) {
     SmallVector<StringRef, 16> OptionNames;
else if (O->getMiscFlags() & cl::Sink)
         }
       }
     else if (O == Sub.ConsumeAfterOpt)
       Sub.ConsumeAfterOpt = nullptr;
   }
 
   void removeOption(Option *O) {
     if (O->Subs.empty())
-      removeOption(O, &*TopLevelSubCommand);
+      removeOption(O, &TopLevelSubCommand);
     else {
       if (O->isInAllSubCommands()) {
         for (auto *SC : RegisteredSubCommands)
           removeOption(O, SC);
       } else {
         for (auto *SC : O->Subs)
           removeOption(O, SC);
       }
if (!Sub.OptionsMap.insert(std::make_pair(NewName, O)).second) {
              << "' registered more than once!\n";
       report_fatal_error("inconsistency in registered CommandLine options");
     }
     Sub.OptionsMap.erase(O->ArgStr);
   }
 
   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)
           updateArgStr(O, NewName, SC);
       } else {
         for (auto *SC : O->Subs)
           updateArgStr(O, NewName, SC);
       }
assert(count_if(RegisteredSubCommands,
                       return (!sub->getName().empty()) &&
                              (Sub->getName() == sub->getName());
                     }) == 0 &&
            "Duplicate subcommands");
     RegisteredSubCommands.insert(sub);
 
     // 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())
           addOption(O, sub);
         else
           addLiteralOption(*O, sub, E.first());
       }
     }
void reset() {
     ProgramOverview = StringRef();
 
     MoreHelp.clear();
     RegisteredOptionCategories.clear();
 
     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;
 
   Option *LookupOption(SubCommand &Sub, StringRef &Arg, StringRef &Value);
   Option *LookupLongOption(SubCommand &Sub, StringRef &Arg, StringRef &Value,
                            bool LongOptionsUseDoubleDash, bool HaveDoubleDash) {
     Option *Opt = LookupOption(Sub, Arg, Value);
     if (Opt && LongOptionsUseDoubleDash && !HaveDoubleDash && !isGrouping(Opt))
       return nullptr;
     return Opt;
   }
   SubCommand *LookupSubCommand(StringRef Name);
 };
 
 } // 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)
     setMiscFlag(Grouping);
 }
 
 void Option::addCategory(OptionCategory &C) {
   assert(!Categories.empty() && "Categories cannot be empty.");
   // Maintain backward compatibility by replacing the default GeneralCategory
   // if it's still set.  Otherwise, just add the new one.  The GeneralCategory
   // must be explicitly added if you want multiple categories that include it.
   if (&C != &GeneralCategory && Categories[0] == &GeneralCategory)
     Categories[0] = &C;
   else if (!is_contained(Categories, &C))
     Categories.push_back(&C);
 }
 
 void Option::reset() {
   NumOccurrences = 0;
   setDefault();
   if (isDefaultOption())
     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() {
   PositionalOpts.clear();
   SinkOpts.clear();
   OptionsMap.clear();
 
   ConsumeAfterOpt = nullptr;
 }
 
 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.
 Option *CommandLineParser::LookupOption(SubCommand &Sub, StringRef &Arg,
                                         StringRef &Value) {
   // Reject all dashes.
   if (Arg.empty())
     return nullptr;
-  assert(&Sub != &*AllSubCommands);
+  assert(&Sub != &AllSubCommands);
 
   size_t EqualPos = Arg.find('=');
 
   // If we have an equals sign, remember the value.
   if (EqualPos == StringRef::npos) {
     // Look up the option.
     return Sub.OptionsMap.lookup(Arg);
   }
Option *CommandLineParser::LookupOption(SubCommand &Sub, StringRef &Arg,
 
   Value = Arg.substr(EqualPos + 1);
   Arg = Arg.substr(0, EqualPos);
   return I->second;
 }
 
 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;
 
     if (StringRef(S->getName()) == StringRef(Name))
       return S;
   }
-  return &*TopLevelSubCommand;
+  return &TopLevelSubCommand;
 }
 
 /// LookupNearestOption - Lookup the closest match to 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.
 static Option *LookupNearestOption(StringRef Arg,
                                    const StringMap<Option *> &OptionsMap,
bool cl::ParseCommandLineOptions(int argc, const char *const *argv,
   }
 
   // Append options from command line.
   for (int I = 1; I < argc; ++I)
     NewArgv.push_back(argv[I]);
   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,
 }
 
 void CommandLineParser::ResetAllOptionOccurrences() {
   // So that we can parse different command lines multiple times in succession
   // we reset all option values to look like they have never been seen before.
   for (auto *SC : RegisteredSubCommands) {
     for (auto &O : SC->OptionsMap)
       O.second->reset();
bool CommandLineParser::ParseCommandLineOptions(int argc,
 
   // Check out the positional arguments to collect information about them.
   unsigned NumPositionalRequired = 0;
 
   // Determine whether or not there are an unlimited number of positionals
   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;
   auto &PositionalOpts = ChosenSubCommand->PositionalOpts;
   auto &SinkOpts = ChosenSubCommand->SinkOpts;
   auto &OptionsMap = ChosenSubCommand->OptionsMap;
 
   for (auto *O: DefaultOptions) {
bool CommandLineParser::ParseCommandLineOptions(int argc,
 
   // Free all of the memory allocated to the map.  Command line options may only
   // be processed once!
   MoreHelp.clear();
 
   // 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;
 }
 
 //===----------------------------------------------------------------------===//
 // Option Base class implementation
 //
 
 bool Option::error(const Twine &Message, StringRef ArgName, raw_ostream &Errs) {
   if (!ArgName.data())
     ArgName = ArgStr;
   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;
 }
 
 bool Option::addOccurrence(unsigned pos, StringRef ArgName, StringRef Value,
                            bool MultiArg) {
   if (!MultiArg)
public:
 
   // Invoke the printer.
   void operator=(bool Value) {
     if (!Value)
       return;
     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;
 
     StrOptionPairVector Opts;
     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]";
     } else {
       if (!Sub->getDescription().empty()) {
         outs() << "SUBCOMMAND '" << Sub->getName()
                << "': " << Sub->getDescription() << "\n\n";
       }
-      outs() << "USAGE: " << GlobalParser->ProgramName << " " << Sub->getName()
+      outs() << "USAGE: " << GetParser()->ProgramName << " " << Sub->getName()
              << " [options]";
     }
 
     for (auto *Opt : PositionalOpts) {
       if (Opt->hasArgStr())
         outs() << " --" << Opt->ArgStr;
       outs() << " " << Opt->HelpStr;
     }
 
     // Print the consume after option info if it exists...
     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)
         MaxSubLen = std::max(MaxSubLen, strlen(Subs[i].first));
 
       outs() << "\n\n";
       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";
     }
 
     outs() << "\n\n";
 
     // Compute the maximum argument length...
     size_t MaxArgLen = 0;
     for (size_t i = 0, e = Opts.size(); i != e; ++i)
       MaxArgLen = std::max(MaxArgLen, Opts[i].second->getOptionWidth());
 
     outs() << "OPTIONS:\n";
     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();
   }
 };
 
 class CategorizedHelpPrinter : public HelpPrinter {
 public:
   explicit CategorizedHelpPrinter(bool showHidden) : HelpPrinter(showHidden) {}
 
   // Helper function for printOptions().

 
 protected:
   void printOptions(StrOptionPairVector &Opts, size_t MaxArgLen) override {
     std::vector<OptionCategory *> SortedCategories;
     std::map<OptionCategory *, std::vector<Option *>> CategorizedOptions;
 
     // 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);
     }
 
     // Sort the different option categories alphabetically.
     assert(SortedCategories.size() > 0 && "No option categories registered!");
     array_pod_sort(SortedCategories.begin(), SortedCategories.end(),
                    OptionCategoryCompare);
public:
   // Invoke the printer.
   void operator=(bool Value);
 };
 
 } // End anonymous namespace
 
 // 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");
 
 // Define uncategorized help printers.
 // --help-list is hidden by default because if Option categories are being used
 // then --help behaves the same as --help-list.
 static cl::opt<HelpPrinter, true, parser<bool>> HLOp(
     "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
 // been declared.
 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);
 
 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)
     return;
 
   // 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);
 
     CategorizedPrinter = true; // Invoke categorized printer
   } else
     UncategorizedPrinter = true; // Invoke uncategorized printer
 }
 
 // Print the value of each option.
-void cl::PrintOptionValues() { GlobalParser->printOptionValues(); }
+void cl::PrintOptionValues() { GetParser()->printOptionValues(); }
 
 void CommandLineParser::printOptionValues() {
   if (!PrintOptions && !PrintAllOptions)
     return;
 
   SmallVector<std::pair<const char *, Option *>, 128> Opts;
   sortOpts(ActiveSubCommand->OptionsMap, Opts, /*ShowHidden*/ true);
 
#endif
     OS << '\n';
   }
   void operator=(bool OptionWasSpecified) {
     if (!OptionWasSpecified)
       return;
 
     if (OverrideVersionPrinter != nullptr) {
       OverrideVersionPrinter(outs());
-      exit(0);
+      sys::Process::Exit(0);
     }
     print();
 
     // Iterate over any registered extra printers and call them to add further
     // information.
     if (ExtraVersionPrinters != nullptr) {
       outs() << '\n';
       for (const auto &I : *ExtraVersionPrinters)
         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"),
            cl::location(VersionPrinterInstance), cl::ValueDisallowed,
            cl::cat(GenericCategory));
 
 // Utility function for printing the help message.
 void cl::PrintHelpMessage(bool Hidden, bool Categorized) {

 
 void cl::AddExtraVersionPrinter(VersionPrinterTy func) {
   if (!ExtraVersionPrinters)
     ExtraVersionPrinters = new std::vector<VersionPrinterTy>;
 
   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;
 }
 
 iterator_range<typename SmallPtrSet<SubCommand *, 4>::iterator>
 cl::getRegisteredSubcommands() {
-  return GlobalParser->getRegisteredSubcommands();
+  return GetParser()->getRegisteredSubcommands();
 }
 
-void cl::HideUnrelatedOptions(cl::OptionCategory &Category, SubCommand &Sub) {
+bool cl::isTopLevel(SubCommand *SC) {
+  return &(GetParser()->TopLevelSubCommand) == SC;
+}
+
+void cl::HideUnrelatedOptions(cl::OptionCategory &Category) {
+  SubCommand &Sub = GetParser()->TopLevelSubCommand;
   for (auto &I : Sub.OptionsMap) {
     for (auto &Cat : I.second->Categories) {
       if (Cat != &Category &&
           Cat != &GenericCategory)
         I.second->setHiddenFlag(cl::ReallyHidden);
     }
   }
 }
 
-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)
         I.second->setHiddenFlag(cl::ReallyHidden);
     }
   }
 }
 
-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,
                                  const char *Overview) {
   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

llvm/lib/Support/Debug.cpp

 #undef setCurrentDebugTypes
 
 using namespace llvm;
 
 // Even though LLVM might be built with NDEBUG, define symbols that the code
 // 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;
 
 /// Return true if the specified string is the debug type
 /// specified on the command line, or if none was specified on the command line
 /// with the -debug-only=X option.
 bool isCurrentDebugType(const char *DebugType) {
   if (CurrentDebugType->empty())
void operator=(const std::string &Val) const {
     StringRef(Val).split(dbgTypes, ',', -1, false);
     for (auto dbgType : dbgTypes)
       CurrentDebugType->push_back(std::string(dbgType));
   }
 };
 
 } // 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)"),
           cl::Hidden, cl::ZeroOrMore, cl::value_desc("debug string"),
           cl::location(DebugOnlyOptLoc), cl::ValueRequired);
 // Signal handlers - dump debug output on termination.
 static void debug_user_sig_handler(void *Cookie) {
   // This is a bit sneaky.  Since this is under #ifndef NDEBUG, we

llvm/lib/Support/DebugCounter.cpp

 #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;
 
 namespace {
 // This class overrides the default list implementation of printing so we
 // can pretty print the list of debug counter options.  This type of
 // dynamic option is pretty rare (basically this and pass lists).
void printOptionInfo(size_t GlobalWidth) const override {
     // options are global and would pollute the global namespace with our
     // counters.  Rather than go that route, we have just overridden the
     // printing, which only a few things call anyway.
     outs() << "  -" << ArgStr;
     // All of the other options in CommandLine.cpp use ArgStr.size() + 6 for
     // 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;
       outs() << "    =" << Info.first;
       outs().indent(NumSpaces) << " -   " << Info.second << '\n';
     }
   }
 };

 static ManagedStatic<DebugCounter> DC;
 
 // Print information when destroyed, iff command line option is specified.
 DebugCounter::~DebugCounter() {
   if (isCountingEnabled() && PrintDebugCounter)
     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.
 void DebugCounter::push_back(const std::string &Val) {
   if (Val.empty())
     return;
   // The strings should come in as counter=value
   auto CounterPair = StringRef(Val).split('=');

llvm/lib/Support/Error.cpp

 //===----- lib/Support/Error.cpp - Error and associated utilities ---------===//
 //
 // 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/Support/Error.h"
 #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;
 
 namespace {
 
   enum class ErrorErrorCode : int {
     MultipleErrors = 1,

 
 LLVMErrorTypeId LLVMGetStringErrorTypeId() {
   return reinterpret_cast<void *>(&StringError::ID);
 }
 
 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

llvm/lib/Support/ErrorHandling.cpp

 #endif
 #if defined(_MSC_VER)
 # include <io.h>
 # include <fcntl.h>
 #endif
 
 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.
 // Do not use ManagedStatic, or that may allocate memory while attempting to
 // report an OOM.
 //
 // This usage of std::mutex has to be conditionalized behind ifdefs because
 // of this script:
 //   compiler-rt/lib/sanitizer_common/symbolizer/scripts/build_symbolizer.sh
 // That script attempts to statically link the LLVM symbolizer library with the
 // 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;
   ErrorHandlerUserData = user_data;
 }
 
 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;
 }
 
 void llvm::report_fatal_error(const char *Reason, bool GenCrashDiag) {
   report_fatal_error(Twine(Reason), GenCrashDiag);
 }
 
 void llvm::report_fatal_error(const std::string &Reason, bool GenCrashDiag) {
   report_fatal_error(Twine(Reason), GenCrashDiag);
 }
 
 void llvm::report_fatal_error(StringRef Reason, bool GenCrashDiag) {
   report_fatal_error(Twine(Reason), GenCrashDiag);
 }
 
 void llvm::report_fatal_error(const Twine &Reason, bool GenCrashDiag) {
   llvm::fatal_error_handler_t handler = nullptr;
   void* handlerData = nullptr;
   {
     // 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;
   }
 
   if (handler) {
     handler(handlerData, Reason.str(), GenCrashDiag);
   } else {
#endif
   sys::RunInterruptHandlers();
 
   abort();
 }
 
 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;
   BadAllocErrorHandlerUserData = user_data;
 }
 
 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;
 }
 
 void llvm::report_bad_alloc_error(const char *Reason, bool GenCrashDiag) {
   fatal_error_handler_t Handler = nullptr;
   void *HandlerData = nullptr;
   {
     // 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;
   }
 
   if (Handler) {
     Handler(HandlerData, Reason, GenCrashDiag);
     llvm_unreachable("bad alloc handler should not return");

llvm/lib/Support/InitLLVM.cpp

 #include "llvm/Support/ManagedStatic.h"
 #include "llvm/Support/PrettyStackTrace.h"
 #include "llvm/Support/Process.h"
 #include "llvm/Support/Signals.h"
 #include <string>
 
 #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
     // not perform a sigaction() for SIGPIPE unless a one-shot handler is
     // present, to allow long-lived processes (like lldb) to fully opt-out of
     // llvm's SIGPIPE handling and ignore the signal safely.
     sys::SetOneShotPipeSignalFunction(sys::DefaultOneShotPipeSignalHandler);
   // Initialize the stack printer after installing the one-shot pipe signal
#ifdef _WIN32
   // nullptr.  Do it to make it compatible with the real argv.
   Args.push_back(nullptr);
 
   Argc = Args.size() - 1;
   Argv = Args.data();
 #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; }

llvm/lib/Support/Process.cpp

 
 #include "llvm/Support/Process.h"
 #include "llvm/ADT/STLExtras.h"
 #include "llvm/ADT/StringExtras.h"
 #include "llvm/Config/config.h"
 #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"
 
 #include <stdlib.h> // for _Exit
 
 using namespace llvm;
 using namespace sys;
 

 
 bool Process::AreCoreFilesPrevented() { return coreFilesPrevented; }
 
 LLVM_ATTRIBUTE_NORETURN
 void Process::Exit(int RetCode, bool NoCleanup) {
   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
     ::exit(RetCode);
 }
 
 // Include the platform-specific parts of this class.
 #ifdef LLVM_ON_UNIX
 #include "Unix/Process.inc"
 #endif
 #ifdef _WIN32
 #include "Windows/Process.inc"
 #endif

llvm/lib/Support/Signals.cpp

 //===----------------------------------------------------------------------===//
 //=== WARNING: Implementation here must contain only TRULY operating system
 //===          independent code.
 //===----------------------------------------------------------------------===//
 
 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."),
                         cl::location(CrashDiagnosticsDirectory), cl::Hidden);
 
 constexpr char DisableSymbolizationEnv[] = "LLVM_DISABLE_SYMBOLIZATION";
 constexpr char LLVMSymbolizerPathEnv[] = "LLVM_SYMBOLIZER_PATH";
 

llvm/lib/Support/TargetRegistry.cpp

 //===--- TargetRegistry.cpp - Target registration -------------------------===//
 //
 // 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/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
   // specified an architecture to compile for. If so we have to look it up by
   // 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;
     }
 
     TheTarget = &*I;
 
     // Adjust the triple to match (if known), otherwise stick with the
     // given triple.
     Triple::ArchType Type = Triple::getArchTypeForLLVMName(ArchName);
if (!ArchName.empty()) {
     }
   }
 
   return TheTarget;
 }
 
 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)";
     return nullptr;
   }
   Triple::ArchType Arch = Triple(TT).getArch();
   auto ArchMatch = [&](const Target &T) { return T.ArchMatchFn(Arch); };
   auto I = find_if(targets(), ArchMatch);

 void TargetRegistry::RegisterTarget(Target &T, const char *Name,
                                     const char *ShortDesc,
                                     const char *BackendName,
                                     Target::ArchMatchFnTy ArchMatchFn,
                                     bool HasJIT) {
   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)
     return;
 
   // Add to the list of targets.
   T.Next = FirstTarget;
   FirstTarget = &T;
+  ++TargetsCount;
 
   T.Name = Name;
   T.ShortDesc = ShortDesc;
   T.BackendName = BackendName;
   T.ArchMatchFn = ArchMatchFn;
   T.HasJIT = HasJIT;
 }
 
 static int TargetArraySortFn(const std::pair<StringRef, const Target *> *LHS,
                              const std::pair<StringRef, const Target *> *RHS) {
   return LHS->first.compare(RHS->first);
 }
 
 void TargetRegistry::printRegisteredTargetsForVersion(raw_ostream &OS) {
   std::vector<std::pair<StringRef, const Target*> > Targets;
   size_t Width = 0;
-  for (const auto &T : TargetRegistry::targets()) {
+  {
+    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);
 
   OS << "  Registered Targets:\n";
   for (unsigned i = 0, e = Targets.size(); i != e; ++i) {
     OS << "    " << Targets[i].first;
     OS.indent(Width - Targets[i].first.size()) << " - "
       << Targets[i].second->getShortDescription() << '\n';
   }
   if (Targets.empty())
     OS << "    (none)\n";
 }

llvm/lib/Support/Timer.cpp

 
 #include "llvm/Support/Timer.h"
 #include "llvm/ADT/Statistic.h"
 #include "llvm/ADT/StringMap.h"
 #include "llvm/Config/config.h"
 #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"
 #include "llvm/Support/Signposts.h"
 #include "llvm/Support/YAMLTraits.h"
 #include "llvm/Support/raw_ostream.h"
 #include <limits>
 

 // being unspecified by C++.  Basically the problem is that a Statistic object
 // gets destroyed, which ends up calling 'GetLibSupportInfoOutputFile()'
 // (below), which calls this function.  LibSupportInfoOutputFilename used to be
 // a global variable, but sometimes it would get destroyed before the Statistic,
 // causing havoc to ensue.  We "fix" this by creating the string the first time
 // 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;
 }
 
 static ManagedStatic<sys::SmartMutex<true> > TimerLock;
 
 /// Allows llvm::Timer to emit signposts when supported.
 static ManagedStatic<SignpostEmitter> Signposts;
 

llvm/lib/Support/ToolOutputFile.cpp

 //===--- ToolOutputFile.cpp - Implement the ToolOutputFile class --------===//
 //
 // 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 implements the ToolOutputFile class.
 //
 //===----------------------------------------------------------------------===//
 
 #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;
 
 static bool isStdout(StringRef Filename) { return Filename == "-"; }
 
 ToolOutputFile::CleanupInstaller::CleanupInstaller(StringRef Filename)
     : Filename(std::string(Filename)), Keep(false) {
ToolOutputFile::CleanupInstaller::~CleanupInstaller() {
   // further need to clean it up on signals.
   sys::DontRemoveFileOnSignal(Filename);
 }
 
 ToolOutputFile::ToolOutputFile(StringRef Filename, std::error_code &EC,
                                sys::fs::OpenFlags Flags)
     : Installer(Filename) {
   if (isStdout(Filename)) {
-    OS = &outs();
+    OS = llvm::dyn_cast<raw_fd_ostream>(&outs());
     EC = std::error_code();
     return;
   }
   OSHolder.emplace(Filename, EC, Flags);
   OS = OSHolder.getPointer();
   // If open fails, no cleanup is needed.
   if (EC)
     Installer.Keep = true;
 }
 
 ToolOutputFile::ToolOutputFile(StringRef Filename, int FD)
     : Installer(Filename) {
   OSHolder.emplace(FD, true);
   OS = OSHolder.getPointer();
 }

llvm/lib/Support/Windows/Memory.inc

 /// platforms.
 void Memory::InvalidateInstructionCache(
     const void *Addr, size_t Len) {
   FlushInstructionCache(GetCurrentProcess(), Addr, Len);
 }
 
 } // 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

llvm/lib/Support/Windows/Path.inc

static bool is_separator(const wchar_t value) {
   case L'\\':
   case L'/':
     return true;
   default:
     return false;
   }
 }
 
+// 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 {
 
 // Convert a UTF-8 path to UTF-16. Also, if the absolute equivalent of the path
 // is longer than the limit that the Win32 Unicode File API can tolerate, make
 // it an absolute normalized path prefixed by '\\?\'.
 std::error_code widenPath(const Twine &Path8, SmallVectorImpl<wchar_t> &Path16,
                           size_t MaxPathLen) {
   assert(MaxPathLen <= MAX_PATH);
 
   // Several operations would convert Path8 to SmallString; more efficient to do
   // it once up front.
   SmallString<MAX_PATH> Path8Str;
   Path8.toVector(Path8Str);
 
   if (std::error_code EC = UTF8ToUTF16(Path8Str, Path16))
     return EC;
 
   const bool IsAbsolute = llvm::sys::path::is_absolute(Path8);
   size_t CurPathLen;
   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());
   }
 
   const char *const LongPathPrefix = "\\\\?\\";
 
   if ((Path16.size() + CurPathLen) < MaxPathLen ||

 
 } // end namespace windows
 
 namespace fs {
 
 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)
     return "";
 
   // Insufficient space is determined by a return value equal to the size of
   // the buffer passed in.
   if (Size == PathName.capacity())

 }
 
 std::error_code current_path(SmallVectorImpl<char> &result) {
   SmallVector<wchar_t, MAX_PATH> cur_path;
   DWORD len = MAX_PATH;
 
   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)
       return mapWindowsError(::GetLastError());
 
     // If there's insufficient space, the len returned is larger than the len
     // given.
   } while (len > cur_path.capacity());
 
   // On success, GetCurrentDirectoryW returns the number of characters not
   // including the null-terminator.
   cur_path.set_size(len);
   return UTF16ToUTF8(cur_path.begin(), cur_path.size(), result);
 }
 
 std::error_code set_current_path(const Twine &path) {
   // Convert to utf-16.
   SmallVector<wchar_t, 128> wide_path;
   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();
 }
 
 std::error_code create_directory(const Twine &path, bool IgnoreExisting,
                                  perms Perms) {
   SmallVector<wchar_t, 128> path_utf16;
 
   // CreateDirectoryW has a lower maximum path length as it must leave room for
   // an 8.3 filename.
   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);
   }
 
   return std::error_code();
 }
 
 // We can't use symbolic links for windows.
 std::error_code create_link(const Twine &to, const Twine &from) {
   // Convert to utf-16.
   SmallVector<wchar_t, 128> wide_from;
   SmallVector<wchar_t, 128> wide_to;
   if (std::error_code ec = widenPath(from, wide_from))
     return ec;
   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();
 }
 
 std::error_code create_hard_link(const Twine &to, const Twine &from) {
   return create_link(to, from);
 }
std::error_code remove(const Twine &path, bool IgnoreNonExisting) {
   // which one it is. We could stat() the file to determine that, but that would
   // cost us additional system calls, which can be slow in a directory
   // containing a large number of files. So instead we call CreateFile directly.
   // The important part is the FILE_FLAG_DELETE_ON_CLOSE flag, which causes the
   // file to be deleted once it is closed. We also use the flags
   // 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 |
           FILE_FLAG_OPEN_REPARSE_POINT | FILE_FLAG_DELETE_ON_CLOSE,
       NULL));
   if (!h) {
     std::error_code EC = mapWindowsError(::GetLastError());
     if (EC != errc::no_such_file_or_directory || !IgnoreNonExisting)
       return EC;
   }
 
   return std::error_code();
 }
 
 static std::error_code is_local_internal(SmallVectorImpl<wchar_t> &Path,
                                          bool &Result) {
   SmallVector<wchar_t, 128> VolumePath;
   size_t Len = 128;
   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;
 
     DWORD Err = ::GetLastError();
     if (Err != ERROR_INSUFFICIENT_BUFFER)
       return mapWindowsError(Err);
 

 }
 
 static std::error_code rename_internal(HANDLE FromHandle, const Twine &To,
                                        bool ReplaceIfExists) {
   SmallVector<wchar_t, 0> ToWide;
   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,
                                   RenameInfoBuf.size())) {
     unsigned Error = GetLastError();
     if (Error == ERROR_SUCCESS)
       Error = ERROR_CALL_NOT_IMPLEMENTED; // Wine doesn't always set error code.
     return mapWindowsError(Error);
for (unsigned Retry = 0; Retry != 200; ++Retry) {
 
     if (EC ==
         std::error_code(ERROR_CALL_NOT_IMPLEMENTED, std::system_category())) {
       // Wine doesn't support SetFileInformationByHandle in rename_internal.
       // Fall back to MoveFileEx.
       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());
     }
 
     if (!EC || EC != errc::permission_denied)
       return EC;
 
     // The destination file probably exists and is currently open in another
     // process, either because the file was opened without FILE_SHARE_DELETE or
     // it is mapped into memory (e.g. using MemoryBuffer). Rename it in order to
     // move it out of the way of the source file. Use FILE_FLAG_DELETE_ON_CLOSE
     // 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));
     if (!ToHandle) {
       auto EC = mapWindowsError(GetLastError());
       // Another process might have raced with us and moved the existing file
       // out of the way before we had a chance to open it. If that happens, try
       // to rename the source file again.
for (unsigned UniqueId = 0; UniqueId != 200; ++UniqueId) {
       std::string TmpFilename = (To + ".tmp" + utostr(UniqueId)).str();
       if (auto EC = rename_internal(ToHandle, TmpFilename, false)) {
         if (EC == errc::file_exists || EC == errc::permission_denied) {
           // Again, another process might have raced with us and moved the file
           // before we could move it. Check whether this is the case, as it
           // 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) {
             auto EC = mapWindowsError(GetLastError());
             if (EC == errc::no_such_file_or_directory)
               break;
             return EC;
           }
if (std::error_code EC = widenPath(From, WideFrom))
     return EC;
 
   ScopedFileHandle FromHandle;
   // Retry this a few times to defeat badly behaved file system scanners.
   for (unsigned Retry = 0; Retry != 200; ++Retry) {
     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)
       break;
 
     // We don't want to loop if the file doesn't exist.
     auto EC = mapWindowsError(GetLastError());
     if (EC == errc::no_such_file_or_directory)

 }
 
 std::error_code access(const Twine &Path, AccessMode Mode) {
   SmallVector<wchar_t, 128> PathUtf16;
 
   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.
     DWORD LastError = ::GetLastError();
     if (LastError != ERROR_FILE_NOT_FOUND &&
         LastError != ERROR_PATH_NOT_FOUND)
       return mapWindowsError(LastError);
     return errc::no_such_file_or_directory;
std::error_code status(const Twine &path, file_status &result, bool Follow) {
   if (isReservedName(path8)) {
     result = file_status(file_type::character_file);
     return std::error_code();
   }
 
   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);
 
   DWORD Flags = FILE_FLAG_BACKUP_SEMANTICS;
   // Handle reparse points.
   if (!Follow && (attr & FILE_ATTRIBUTE_REPARSE_POINT))
     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)
     return getStatus(INVALID_HANDLE_VALUE, result);
 
   return getStatus(h, result);
 }
 
unsigned getUmask() {
   return 0;
 }
 
 std::error_code setPermissions(const Twine &Path, perms Permissions) {
   SmallVector<wchar_t, 128> PathUTF16;
   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());
 
   // There are many Windows file attributes that are not to do with the file
   // permissions (e.g. FILE_ATTRIBUTE_HIDDEN). We need to be careful to preserve
   // them.
   if (Permissions & all_write) {
     Attributes &= ~FILE_ATTRIBUTE_READONLY;
     if (Attributes == 0)
       // FILE_ATTRIBUTE_NORMAL indicates no other attributes are set.
       Attributes |= FILE_ATTRIBUTE_NORMAL;
   }
   else {
     Attributes |= FILE_ATTRIBUTE_READONLY;
     // FILE_ATTRIBUTE_NORMAL is not compatible with any other attributes, so
     // remove it, if it is present.
     Attributes &= ~FILE_ATTRIBUTE_NORMAL;
   }
 
-  if (!::SetFileAttributesW(PathUTF16.begin(), Attributes))
+  if (!::SetFileAttributesW(PathAbsolutize(PathUTF16.begin()), Attributes))
     return mapWindowsError(GetLastError());
 
   return std::error_code();
 }
 
 std::error_code setPermissions(int FD, perms Permissions) {
   // FIXME Not implemented.
   return std::make_error_code(std::errc::not_supported);
if (PathUTF16Len > 0 && !is_separator(PathUTF16[PathUTF16Len - 1]) &&
     PathUTF16.push_back(L'*');
   } else {
     PathUTF16.push_back(L'*');
   }
 
   //  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());
 
   size_t FilenameLen = ::wcslen(FirstFind.cFileName);
   while ((FilenameLen == 1 && FirstFind.cFileName[0] == L'.') ||
          (FilenameLen == 2 && FirstFind.cFileName[0] == L'.' &&
                               FirstFind.cFileName[1] == L'.'))
if (std::error_code EC = widenPath(Name, PathUTF16))
     return EC;
 
   SECURITY_ATTRIBUTES SA;
   SA.nLength = sizeof(SA);
   SA.lpSecurityDescriptor = nullptr;
   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) {
     DWORD LastError = ::GetLastError();
     std::error_code EC = mapWindowsError(LastError);
     // Provide a better error message when trying to open directories.
     // This only runs if we failed to open the file, so there is probably
     // no performances issues.
std::error_code remove_directories(const Twine &path, bool IgnoreErrors) {
   // terminated, but since that null character is not considered part of the
   // vector's size, pushing another one will just consume that byte.  So we
   // need to push 2 null terminators.
   Path16.push_back(0);
   Path16.push_back(0);
 
   SHFILEOPSTRUCTW shfos = {};
   shfos.wFunc = FO_DELETE;
-  shfos.pFrom = Path16.data();
+  shfos.pFrom = PathAbsolutize(Path16.data());
   shfos.fFlags = FOF_NO_UI;
 
   int result = ::SHFileOperationW(&shfos);
   if (result != 0 && !IgnoreErrors)
     return mapWindowsError(result);
   return std::error_code();
 }
 

llvm/lib/Support/Windows/Process.inc

 
 // The Windows.h header must be after LLVM and standard headers.
 #include "llvm/Support/Windows/WindowsSupport.h"
 
 #include <direct.h>
 #include <io.h>
 #include <psapi.h>
 #include <shellapi.h>
+#include <winternl.h>
+#include <dbghelp.h>
 
 #if !defined(__MINGW32__)
  #pragma comment(lib, "psapi.lib")
  #pragma comment(lib, "shell32.lib")
 #endif
 
 //===----------------------------------------------------------------------===//
 //=== WARNING: Implementation here must contain only Win32 specific code
 //===          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)
 #endif
 
 using namespace llvm;
 
 Process::Pid Process::getProcessId() {
static std::error_code WildcardExpand(StringRef Arg,
   if (EC)
     return EC;
 
   // Search for matching files.
   // FIXME:  This assumes the wildcard is only in the file name and not in the
   // 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;
   }
 
   // Extract any directory part of the argument.
   SmallString<MAX_PATH> Dir = Arg;
   sys::path::remove_filename(Dir);
bool llvm::RunningWindows8OrGreater() {
   return GetWindowsOSVersion() >= llvm::VersionTuple(6, 2, 0, 0);
 }
 
 LLVM_ATTRIBUTE_NORETURN
 void Process::ExitNoCleanup(int RetCode) {
   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);
+}

llvm/lib/Support/Windows/Program.inc

 #include <malloc.h>
 #include <numeric>
 
 //===----------------------------------------------------------------------===//
 //=== WARNING: Implementation here must contain only Win32 specific code
 //===          and must not be UNIX code
 //===----------------------------------------------------------------------===//
 
+const wchar_t* PathAbsolutize(const wchar_t* data);
+
 namespace llvm {
 
 ProcessInfo::ProcessInfo() : Pid(0), Process(0), ReturnCode(0) {}
 
 ErrorOr<std::string> sys::findProgramByName(StringRef Name,
                                             ArrayRef<StringRef> Paths) {
   assert(!Name.empty() && "Must have a name!");
 
do {
       // Lets attach the extension manually. That is needed for files
       // with a point in name like aaa.bbb. SearchPathW will not add extension
       // from its argument to such files because it thinks they already had one.
       SmallVector<wchar_t, MAX_PATH> U16NameExt;
       if (std::error_code EC =
               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());
 
     if (Len == 0)
       continue;
 
     U16Result.set_size(Len);
 
static HANDLE RedirectIO(Optional<StringRef> Path, int fd,
   if (Path->empty()) {
     // Don't play long-path tricks on "NUL".
     if (windows::UTF8ToUTF16(fname, fnameUnicode))
       return INVALID_HANDLE_VALUE;
   } else {
     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) {
     MakeErrMsg(ErrMsg, fname + ": Can't open file for " +
         (fd ? "input" : "output"));
   }
 
   return h;

llvm/lib/Support/raw_ostream.cpp

 #include "llvm/ADT/STLExtras.h"
 #include "llvm/ADT/StringExtras.h"
 #include "llvm/Config/config.h"
 #include "llvm/Support/Compiler.h"
 #include "llvm/Support/ErrorHandling.h"
 #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"
 #include "llvm/Support/Program.h"
 #include <algorithm>
 #include <cctype>
 #include <cerrno>
 #include <cstdio>

 }
 
 void raw_fd_ostream::anchor() {}
 
 //===----------------------------------------------------------------------===//
 //  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);
   assert(!EC);
   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;
 }
 
 /// nulls() - This returns a reference to a raw_ostream which discards output.
 raw_ostream &llvm::nulls() {
   static raw_null_ostream S;
ssize_t raw_fd_stream::read(char *Ptr, size_t Size) {
   ssize_t Ret = ::read(get_fd(), (void *)Ptr, Size);
   if (Ret >= 0)
     inc_pos(Ret);
   else
     error_detected(std::error_code(errno, std::generic_category()));
   return Ret;
 }
 
-bool raw_fd_stream::classof(const raw_ostream *OS) {
-  return OS->get_kind() == OStreamKind::OK_FDStream;
-}
-
 //===----------------------------------------------------------------------===//
 //  raw_string_ostream
 //===----------------------------------------------------------------------===//
 
 raw_string_ostream::~raw_string_ostream() {
   flush();
 }
 

llvm/lib/TableGen/Error.cpp

 //===- Error.cpp - tblgen error handling helper routines --------*- 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 file contains error handling helper routines to pretty-print diagnostic
 // messages from tblgen.
 //
 //===----------------------------------------------------------------------===//
 
+#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>
 
 namespace llvm {
 
 SourceMgr SrcMgr;
 unsigned ErrorsPrinted = 0;
 

 }
 
 // Functions to print fatal notes.
 
 void PrintFatalNote(const Twine &Msg) {
   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
 // stored in it.
 void PrintFatalNote(const Record *Rec, const Twine &Msg) {
   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
 // stored in it.
 void PrintFatalNote(const RecordVal *RecVal, const Twine &Msg) {
   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.
 
 void PrintWarning(const Twine &Msg) { WithColor::warning() << Msg << "\n"; }
 
 void PrintWarning(ArrayRef<SMLoc> WarningLoc, const Twine &Msg) {
   PrintMessage(WarningLoc, SourceMgr::DK_Warning, Msg);

 }
 
 // Functions to print fatal errors.
 
 void PrintFatalError(const Twine &Msg) {
   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
 // stored in it.
 void PrintFatalError(const Record *Rec, const Twine &Msg) {
   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
 // stored in it.
 void PrintFatalError(const RecordVal *RecVal, const Twine &Msg) {
   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.
 // If not, print a nonfatal error along with the message.
 void CheckAssert(SMLoc Loc, Init *Condition, Init *Message) {
   auto *CondValue = dyn_cast_or_null<IntInit>(
                         Condition->convertInitializerTo(IntRecTy::get()));
   if (!CondValue)

llvm/lib/Target/AMDGPU/AMDGPULowerIntrinsics.cpp

 #include "llvm/Transforms/Utils/LowerMemIntrinsics.h"
 
 #define DEBUG_TYPE "amdgpu-lower-intrinsics"
 
 using namespace llvm;
 
 namespace {
 
-static int MaxStaticSize;
+static LLVM_THREAD_LOCAL int MaxStaticSize;
 
 static cl::opt<int, true> MemIntrinsicExpandSizeThresholdOpt(
   "amdgpu-mem-intrinsic-expand-size",
   cl::desc("Set minimum mem intrinsic size to expand in IR"),
   cl::location(MaxStaticSize),
   cl::init(1024),
   cl::Hidden);
 

llvm/lib/Target/AMDGPU/AMDGPUTargetMachine.h

 class AMDGPUTargetMachine : public LLVMTargetMachine {
 protected:
   std::unique_ptr<TargetLoweringObjectFile> TLOF;
 
   StringRef getGPUName(const Function &F) const;
   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,
                       Optional<Reloc::Model> RM, Optional<CodeModel::Model> CM,
                       CodeGenOpt::Level OL);
   ~AMDGPUTargetMachine() override;
 
   const TargetSubtargetInfo *getSubtargetImpl() const;

llvm/lib/Target/AMDGPU/AMDGPUTargetMachine.cpp

AMDGPUTargetMachine::AMDGPUTargetMachine(const Target &T, const Triple &TT,
   if (TT.getArch() == Triple::amdgcn) {
     if (getMCSubtargetInfo()->checkFeatures("+wavefrontsize64"))
       MRI.reset(llvm::createGCNMCRegisterInfo(AMDGPUDwarfFlavour::Wave64));
     else if (getMCSubtargetInfo()->checkFeatures("+wavefrontsize32"))
       MRI.reset(llvm::createGCNMCRegisterInfo(AMDGPUDwarfFlavour::Wave32));
   }
 }
 
-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;
 
 StringRef AMDGPUTargetMachine::getGPUName(const Function &F) const {
   Attribute GPUAttr = F.getFnAttribute("target-cpu");
   return GPUAttr.isValid() ? GPUAttr.getValueAsString() : getTargetCPU();
 }
 

llvm/lib/Target/AMDGPU/SIPreEmitPeephole.cpp

 #include "GCNSubtarget.h"
 #include "MCTargetDesc/AMDGPUMCTargetDesc.h"
 #include "llvm/CodeGen/MachineFunctionPass.h"
 
 using namespace llvm;
 
 #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,
     cl::desc(
         "Number of instructions before jumping over divergent control flow"),
     cl::location(SkipThreshold), cl::init(12));
 
 namespace {

llvm/lib/Target/RISCV/MCTargetDesc/RISCVBaseInfo.cpp

std::pair<unsigned, bool> RISCVVType::decodeVLMUL(RISCVII::VLMUL VLMUL) {
   case RISCVII::VLMUL::LMUL_4:
   case RISCVII::VLMUL::LMUL_8:
     return std::make_pair(1 << static_cast<unsigned>(VLMUL), false);
   case RISCVII::VLMUL::LMUL_F2:
   case RISCVII::VLMUL::LMUL_F4:
   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) {
   unsigned Sew = getSEW(VType);
   OS << "e" << Sew;
 
   unsigned LMul;
   bool Fractional;

llvm/lib/Target/TargetMachineC.cpp

 static LLVMTargetMachineRef wrap(const TargetMachine *P) {
   return reinterpret_cast<LLVMTargetMachineRef>(const_cast<TargetMachine *>(P));
 }
 static LLVMTargetRef wrap(const Target * P) {
   return reinterpret_cast<LLVMTargetRef>(const_cast<Target*>(P));
 }
 
 LLVMTargetRef LLVMGetFirstTarget() {
-  if (TargetRegistry::targets().begin() == TargetRegistry::targets().end()) {
+  if (TargetRegistry::targets().empty()) {
     return nullptr;
   }
 
   const Target *target = &*TargetRegistry::targets().begin();
   return wrap(target);
 }
 LLVMTargetRef LLVMGetNextTarget(LLVMTargetRef T) {
   return wrap(unwrap(T)->getNext());

llvm/lib/Target/X86/MCTargetDesc/X86AsmBackend.cpp

for (auto BranchType : BranchTypes) {
       }
     }
   }
 
   operator uint8_t() const { return AlignBranchKind; }
   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),
     cl::desc(
         "Control how the assembler should align branches with NOP. If the "
         "boundary's size is not 0, it should be a power of 2 and no less "
         "than 32. Branches will be aligned to prevent from being across or "
         "against the boundary of specified size. The default value 0 does not "

llvm/lib/ToolDrivers/llvm-lib/LibDriver.cpp

static std::string findInputFile(StringRef File, ArrayRef<StringRef> Paths) {
   return "";
 }
 
 static void fatalOpenError(llvm::Error E, Twine File) {
   if (!E)
     return;
   handleAllErrors(std::move(E), [&](const llvm::ErrorInfoBase &EIB) {
     llvm::errs() << "error opening '" << File << "': " << EIB.message() << '\n';
-    exit(1);
+    sys::Process::Exit(1);
   });
 }
 
 static void doList(opt::InputArgList& Args) {
   // lib.exe prints the contents of the first archive file.
   std::unique_ptr<MemoryBuffer> B;
   for (auto *Arg : Args.filtered(OPT_INPUT)) {
     // Create or open the archive object.

llvm/lib/Transforms/IPO/Attributor.cpp

MaxFixpointIterations("attributor-max-iterations", cl::Hidden,
                           cl::desc("Maximal number of fixpoint iterations."),
                           cl::init(32));
 
 static cl::opt<unsigned, true> MaxInitializationChainLengthX(
     "attributor-max-initialization-chain-length", cl::Hidden,
     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,
     cl::desc("Verify that max-iterations is a tight bound for a fixpoint"),
     cl::init(false));
 
 static cl::opt<bool> AnnotateDeclarationCallSites(
     "attributor-annotate-decl-cs", cl::Hidden,

llvm/lib/Transforms/IPO/AttributorAttributes.cpp

static cl::opt<bool> ManifestInternal(
     "attributor-manifest-internal", cl::Hidden,
     cl::desc("Manifest Attributor internal string attributes."),
     cl::init(false));
 
 static cl::opt<int> MaxHeapToStackSize("max-heap-to-stack-size", cl::init(128),
                                        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,
     cl::desc("Maximum number of potential values to be "
              "tracked for each position."),
     cl::location(llvm::PotentialConstantIntValuesState::MaxPotentialValues),
     cl::init(7));
 

llvm/lib/Transforms/Instrumentation/ControlHeightReduction.cpp

 #include "llvm/IR/Dominators.h"
 #include "llvm/IR/IRBuilder.h"
 #include "llvm/IR/MDBuilder.h"
 #include "llvm/IR/PassManager.h"
 #include "llvm/InitializePasses.h"
 #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"
 #include "llvm/Transforms/Utils/ValueMapper.h"
 
 #include <set>
 #include <sstream>
 

 static StringSet<> CHRModules;
 static StringSet<> CHRFunctions;
 
 static void parseCHRFilterFiles() {
   if (!CHRModuleList.empty()) {
     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;
     Buf.split(Lines, '\n');
     for (StringRef Line : Lines) {
       Line = Line.trim();
       if (!Line.empty())
         CHRModules.insert(Line);
     }
   }
   if (!CHRFunctionList.empty()) {
     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;
     Buf.split(Lines, '\n');
     for (StringRef Line : Lines) {
       Line = Line.trim();
       if (!Line.empty())
         CHRFunctions.insert(Line);

llvm/lib/Transforms/Instrumentation/GCOVProfiling.cpp

for (unsigned i = 0, e = CUNode->getNumOperands(); i != e; ++i) {
 
     Endian = M->getDataLayout().isLittleEndian() ? support::endianness::little
                                                  : support::endianness::big;
     unsigned FunctionIdent = 0;
     for (auto &F : M->functions()) {
       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;
 
       // Add the function line number to the lines of the entry block
       // to have a counter for the function definition.
       uint32_t Line = SP->getLine();
       auto Filename = getFilename(SP);

llvm/lib/Transforms/Scalar/LoopIdiomRecognize.cpp

 STATISTIC(NumMemSet, "Number of memset's formed from loop stores");
 STATISTIC(NumMemCpy, "Number of memcpy's formed from loop load+stores");
 STATISTIC(
     NumShiftUntilBitTest,
     "Number of uncountable loops recognized as 'shift until bitttest' idiom");
 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 "
                                "not convert loop(s) to memset."),
                       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 "
                                "not convert loop(s) to memcpy."),
                       cl::location(DisableLIRP::Memcpy), cl::init(false),
                       cl::ReallyHidden);
 
 static cl::opt<bool> UseLIRCodeSizeHeurs(

llvm/lib/Transforms/Scalar/RewriteStatepointsForGC.cpp

 
 // Cost threshold measuring when it is profitable to rematerialize value instead
 // of relocating it
 static cl::opt<unsigned>
 RematerializationThreshold("spp-rematerialization-threshold", cl::Hidden,
                            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",
                                                   cl::location(ClobberNonLive),
                                                   cl::Hidden);
 
 static cl::opt<bool>
     AllowStatepointWithNoDeoptInfo("rs4gc-allow-statepoint-with-no-deopt-info",

llvm/lib/Transforms/Utils/LCSSA.cpp

 #include "llvm/Transforms/Utils/SSAUpdater.h"
 using namespace llvm;
 
 #define DEBUG_TYPE "lcssa"
 
 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),
                         cl::Hidden,
                         cl::desc("Verify loop lcssa form (time consuming)"));
 
 /// Return true if the specified block is in the list.
 static bool isExitBlock(BasicBlock *BB,

llvm/tools/bugpoint/BugDriver.h

 class AbstractInterpreter;
 class Instruction;
 class LLVMContext;
 
 class DebugCrashes;
 
 class CC;
 
-extern bool DisableSimplifyCFG;
+extern LLVM_THREAD_LOCAL bool DisableSimplifyCFG;
 
 /// BugpointIsInterrupted - Set to true when the user presses ctrl-c.
 ///
 extern bool BugpointIsInterrupted;
 
 class BugDriver {
   LLVMContext &Context;
   const char *ToolName;            // argv[0] of bugpoint

llvm/tools/bugpoint/ExtractFunction.cpp

 #include "llvm/Transforms/Utils/Cloning.h"
 #include "llvm/Transforms/Utils/CodeExtractor.h"
 #include <set>
 using namespace llvm;
 
 #define DEBUG_TYPE "bugpoint"
 
 namespace llvm {
-bool DisableSimplifyCFG = false;
+LLVM_THREAD_LOCAL bool DisableSimplifyCFG = false;
 extern cl::opt<std::string> OutputPrefix;
 } // End llvm namespace
 
 namespace {
 cl::opt<bool> NoDCE("disable-dce",
                     cl::desc("Do not use the -dce pass to reduce testcases"));
 cl::opt<bool, true>
     NoSCFG("disable-simplifycfg", cl::location(DisableSimplifyCFG),

llvm/tools/llc/llc.cpp

void operator=(const std::string &Val) const {
     SmallVector<StringRef, 8> PassNames;
     StringRef(Val).split(PassNames, ',', -1, false);
     for (auto PassName : PassNames)
       RunPassNames->push_back(std::string(PassName));
   }
 };
 }
 
-static RunPassOption RunPassOpt;
+static LLVM_THREAD_LOCAL RunPassOption RunPassOpt;
 
 static cl::opt<RunPassOption, true, cl::parser<std::string>> RunPass(
     "run-pass",
     cl::desc("Run compiler only for specified passes (comma separated list)"),
     cl::value_desc("pass-name"), cl::ZeroOrMore, cl::location(RunPassOpt));
 
 static int compileModule(char **, LLVMContext &);
 

llvm/tools/llvm-buildozer/CMakeLists.txt

+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

llvm/tools/llvm-buildozer/CompDB.h

+//===---------- 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

llvm/tools/llvm-buildozer/CompDB.cpp

+//===---------- 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

llvm/tools/llvm-buildozer/LoadEXE.h

+//===---------- 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

llvm/tools/llvm-buildozer/LoadEXE.cpp

+//===---------- 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

llvm/tools/llvm-buildozer/buildozer-main.cpp

+//===---------- 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;
+}

llvm/tools/llvm-cfi-verify/lib/FileAnalysis.h

 #include <string>
 #include <unordered_map>
 
 namespace llvm {
 namespace cfi_verify {
 
 struct GraphResult;
 
-extern bool IgnoreDWARFFlag;
+extern LLVM_THREAD_LOCAL bool IgnoreDWARFFlag;
 
 enum class CFIProtectionStatus {
   // This instruction is protected by CFI.
   PROTECTED,
   // The instruction is not an indirect control flow instruction, and thus
   // shouldn't be protected.
   FAIL_NOT_INDIRECT_CF,
   // There is a path to the instruction that was unexpected.

llvm/tools/llvm-cfi-verify/lib/FileAnalysis.cpp

 
 
 using Instr = llvm::cfi_verify::FileAnalysis::Instr;
 using LLVMSymbolizer = llvm::symbolize::LLVMSymbolizer;
 
 namespace llvm {
 namespace cfi_verify {
 
-bool IgnoreDWARFFlag;
+LLVM_THREAD_LOCAL bool IgnoreDWARFFlag;
 
 static cl::opt<bool, true> IgnoreDWARFArg(
     "ignore-dwarf",
     cl::desc(
         "Ignore all DWARF data. This relaxes the requirements for all "
         "statically linked libraries to have been compiled with '-g', but "
         "will result in false positives for 'CFI unprotected' instructions."),
     cl::location(IgnoreDWARFFlag), cl::init(false));

llvm/tools/llvm-cfi-verify/lib/GraphBuilder.h

 #include <string>
 #include <unordered_map>
 
 using Instr = llvm::cfi_verify::FileAnalysis::Instr;
 
 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;
   uint64_t Target;
   uint64_t Fallthrough;
   // Does this conditional branch look like it's used for CFI protection? i.e.
   //  - The exit point of a basic block whos entry point is {target|fallthrough}
   //    is a CFI trap, and...

llvm/tools/llvm-cfi-verify/lib/GraphBuilder.cpp

 #include "llvm/Support/raw_ostream.h"
 
 
 using Instr = llvm::cfi_verify::FileAnalysis::Instr;
 
 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",
     cl::desc("Specify the maximum amount of instructions "
              "to inspect when searching for an undefined "
              "instruction from a conditional branch."),
     cl::location(SearchLengthForUndef), cl::init(2));
 

llvm/tools/llvm-profgen/ProfileGenerator.h

void populateFunctionBoundarySamples(StringRef ContextId,
                                        FunctionSamples &FunctionProfile,
                                        const BranchSample &BranchCounters,
                                        ProfiledBinary *Binary);
   void populateInferredFunctionSamples();
 
 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>;
 
 class PseudoProbeCSProfileGenerator : public CSProfileGenerator {
 
 public:
   PseudoProbeCSProfileGenerator(const BinarySampleCounterMap &Counters)

llvm/tools/llvm-profgen/ProfileGenerator.cpp

 
 using namespace llvm;
 using namespace sampleprof;
 
 namespace llvm {
 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) {
   return BinarySampleCounters.size() &&
          BinarySampleCounters.begin()->first->usePseudoProbes();
 }
 
 std::unique_ptr<ProfileGenerator>

llvm/tools/llvm-xray/llvm-xray.cpp

int main(int argc, char *argv[]) {
   cl::ParseCommandLineOptions(argc, argv,
                               "XRay Tools\n\n"
                               "  This program consolidates multiple XRay trace "
                               "processing tools for convenient access.\n");
   for (auto *SC : cl::getRegisteredSubcommands()) {
     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;
       }
       if (auto C = dispatch(SC)) {
         ExitOnError("llvm-xray: ")(C());
         return 0;
       }
     }
   }
 
   // If all else fails, we still print the usage message.
   cl::PrintHelpMessage(false, true);
   return 0;
 }

llvm/unittests/Support/CommandLineTest.cpp

 cl::OptionCategory TestCategory("Test Options", "Description");
 TEST(CommandLineTest, ModifyExisitingOption) {
   StackOption<int> TestOption("test-option", cl::desc("old description"));
 
   static const char Description[] = "New description";
   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.";
 
   cl::Option *Retrieved = Map["test-option"];
   ASSERT_EQ(&TestOption, Retrieved) << "Retrieved wrong option.";
 
   ASSERT_NE(Retrieved->Categories.end(),
TEST(CommandLineTest, HideUnrelatedOptions) {
 
   cl::HideUnrelatedOptions(TestCategory);
 
   ASSERT_EQ(cl::ReallyHidden, TestOption1.getOptionHiddenFlag())
       << "Failed to hide extra option.";
   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.";
 }
 
 cl::OptionCategory TestCategory2("Test Options set 2", "Description");
 
 TEST(CommandLineTest, HideUnrelatedOptionsMulti) {
   StackOption<int> TestOption1("multi-hide-option-1");
   StackOption<int> TestOption2("multi-hide-option-2", cl::cat(TestCategory));
   StackOption<int> TestOption3("multi-hide-option-3", cl::cat(TestCategory2));
 
   const cl::OptionCategory *VisibleCategories[] = {&TestCategory,
                                                    &TestCategory2};
 
   cl::HideUnrelatedOptions(makeArrayRef(VisibleCategories));
 
   ASSERT_EQ(cl::ReallyHidden, TestOption1.getOptionHiddenFlag())
       << "Failed to hide extra option.";
   ASSERT_EQ(cl::NotHidden, TestOption2.getOptionHiddenFlag())
       << "Hid extra option that should be visable.";
   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.";
 }
 
 TEST(CommandLineTest, SetValueInSubcategories) {
   cl::ResetCommandLineParser();
 
   StackSubCommand SC1("sc1", "First subcommand");
TEST(CommandLineTest, LookupFailsInWrongSubCommand) {
   OS.flush();
   EXPECT_FALSE(Errs.empty());
 }
 
 TEST(CommandLineTest, AddToAllSubCommands) {
   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"};
   const char *args2[] = {"prog", "sc1", "-everywhere"};
   const char *args3[] = {"prog", "sc2", "-everywhere"};
 
   std::string Errs;
   raw_string_ostream OS(Errs);
TEST(CommandLineTest, AddToAllSubCommands) {
   // Since all parsing succeeded, the error message should be empty.
   OS.flush();
   EXPECT_TRUE(Errs.empty());
 }
 
 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"};
 
   EXPECT_FALSE(TopLevelOpt);
   EXPECT_TRUE(
       cl::ParseCommandLineOptions(2, args, StringRef(), &llvm::nulls()));
   EXPECT_TRUE(TopLevelOpt);
 
TEST(CommandLineTest, RemoveFromRegularSubCommand) {
   EXPECT_FALSE(cl::ParseCommandLineOptions(3, args, StringRef(), &OS));
   OS.flush();
   EXPECT_FALSE(Errs.empty());
 }
 
 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"};
 
   EXPECT_FALSE(TopLevelRemove);
   EXPECT_TRUE(
       cl::ParseCommandLineOptions(2, args, StringRef(), &llvm::nulls()));
   EXPECT_TRUE(TopLevelRemove);
 
   TopLevelRemove.removeArgument();
 
   cl::ResetAllOptionOccurrences();
   EXPECT_FALSE(
       cl::ParseCommandLineOptions(2, args, StringRef(), &llvm::nulls()));
 }
 
 TEST(CommandLineTest, RemoveFromAllSubCommands) {
   cl::ResetCommandLineParser();
 
   StackSubCommand SC1("sc1", "First Subcommand");
   StackSubCommand SC2("sc2", "Second Subcommand");
-  StackOption<bool> RemoveOption("remove-option", cl::sub(*cl::AllSubCommands),
-                                 cl::init(false));
-  StackOption<bool> KeepOption("keep-option", cl::sub(*cl::AllSubCommands),
+  StackOption<bool> RemoveOption("remove-option", cl::allSub(),
                                  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"};
   const char *args2[] = {"prog", "sc2", "-remove-option"};
 
   // It should work for all subcommands including the top-level.
   EXPECT_FALSE(RemoveOption);
   EXPECT_TRUE(
if (*S) {
       EXPECT_EQ("sc2", S->getName());
     }
   }
 }
 
 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);
 
   StackSubCommand SC1("sc1", "First Subcommand");
   // Override "-b" and change type in sc1 SubCommand.
   StackOption<bool> SC1_B("b", cl::sub(SC1), cl::init(false));
   StackSubCommand SC2("sc2", "Second subcommand");
TEST(CommandLineTest, SetDefautValue) {
   EXPECT_TRUE(Opt2);
   EXPECT_TRUE(Opt3 == 3);
 
   Opt2 = false;
   Opt3 = 1;
 
   cl::ResetAllOptionOccurrences();
 
-  for (auto &OM : cl::getRegisteredOptions(*cl::TopLevelSubCommand)) {
+  for (auto &OM : cl::getRegisteredOptions()) {
     cl::Option *O = OM.second;
     if (O->ArgStr == "opt2") {
       continue;
     }
     O->setDefault();
   }
 
   EXPECT_TRUE(Opt1 == "true");

llvm/utils/TableGen/TableGen.cpp

+
 //===- TableGen.cpp - Top-Level TableGen implementation for LLVM ----------===//
 //
 // 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
 //
 //===----------------------------------------------------------------------===//
 //

polly/lib/Analysis/ScopBuilder.cpp

 
 #define DEBUG_TYPE "polly-scops"
 
 STATISTIC(ScopFound, "Number of valid Scops");
 STATISTIC(RichScopFound, "Number of Scops containing a loop");
 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
 // unlikely to result in good code. This value is very high and should only
 // trigger for corner cases (e.g., the "dct_luma" function in h264, SPEC2006).
 static int const MaxDimensionsInAccessRange = 9;
 
 static cl::opt<bool, true> XModelReadOnlyScalars(

polly/lib/Analysis/ScopDetection.cpp

 // a value of around 40 has been working to avoid run-time regressions with
 // Polly while still exposing interesting optimization opportunities.
 static cl::opt<int> ProfitabilityMinPerLoopInstructions(
     "polly-detect-profitability-min-per-loop-insts",
     cl::desc("The minimal number of per-loop instructions before a single loop "
              "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",
     cl::desc(
         "Process scops that are unlikely to benefit from Polly optimizations."),
     cl::location(PollyProcessUnprofitable), cl::init(false), cl::ZeroOrMore,
     cl::cat(PollyCategory));
 
 static cl::list<std::string> OnlyFunctions(
     "polly-only-func",
     cl::desc("Only run on functions that match a regex. "
              "Multiple regexes can be comma separated. "
              "Scop detection will run on all functions that match "
              "ANY of the regexes provided."),
     cl::ZeroOrMore, cl::CommaSeparated, cl::cat(PollyCategory));
 
 static cl::list<std::string> IgnoredFunctions(
     "polly-ignore-func",
     cl::desc("Ignore functions that match a regex. "
              "Multiple regexes can be comma separated. "
              "Scop detection will ignore all functions that match "
              "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",
                        cl::desc("Allow the detection of full functions"),
                        cl::location(polly::PollyAllowFullFunction),
                        cl::init(false), cl::cat(PollyCategory));
 
 static cl::opt<std::string> OnlyRegion(
     "polly-only-region",
     cl::desc("Only run on certain regions (The provided identifier must "
              "appear in the name of the region's entry block"),
     cl::value_desc("identifier"), cl::ValueRequired, cl::init(""),
     cl::cat(PollyCategory));
 
 static cl::opt<bool>
     IgnoreAliasing("polly-ignore-aliasing",
                    cl::desc("Ignore possible aliasing of the array bases"),
                    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",
     cl::desc("Allow unsigned operations such as comparisons or zero-extends."),
     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",
     cl::desc("Use runtime alias checks to resolve possible aliasing."),
     cl::location(PollyUseRuntimeAliasChecks), cl::Hidden, cl::ZeroOrMore,
     cl::init(true), cl::cat(PollyCategory));
 
 static cl::opt<bool>
PollyDelinearizeX("polly-delinearize",
                       cl::ZeroOrMore, cl::init(true), cl::cat(PollyCategory));
 
 static cl::opt<bool>
     VerifyScops("polly-detect-verify",
                 cl::desc("Verify the detected SCoPs after each transformation"),
                 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."),
     cl::location(PollyInvariantLoadHoisting), cl::Hidden, cl::ZeroOrMore,
     cl::init(false), cl::cat(PollyCategory));
 
 /// 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";
 
 //===----------------------------------------------------------------------===//
 // Statistics.
 
 STATISTIC(NumScopRegions, "Number of scops");
 STATISTIC(NumLoopsInScop, "Number of loops in scops");
 STATISTIC(NumScopsDepthZero, "Number of scops with maximal loop depth 0");

polly/lib/Analysis/ScopInfo.cpp

static cl::opt<bool> PollyIgnoreParamBounds(
     cl::Hidden, cl::init(false), cl::cat(PollyCategory));
 
 static cl::opt<bool> PollyPreciseFoldAccesses(
     "polly-precise-fold-accesses",
     cl::desc("Fold memory accesses to model more possible delinearizations "
              "(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",
     cl::desc("Use LLVM-IR names when deriving statement names"),
     cl::location(UseInstructionNames), cl::Hidden, cl::init(false),
     cl::ZeroOrMore, cl::cat(PollyCategory));
 
 static cl::opt<bool> PollyPrintInstructions(

polly/lib/CodeGen/BlockGenerators.cpp

 using namespace llvm;
 using namespace polly;
 
 static cl::opt<bool> Aligned("enable-polly-aligned",
                              cl::desc("Assumed aligned memory accesses."),
                              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."),
     cl::location(PollyDebugPrinting), cl::Hidden, cl::init(false),
     cl::ZeroOrMore, cl::cat(PollyCategory));
 
 static cl::opt<bool> TraceStmts(
     "polly-codegen-trace-stmts",

polly/lib/CodeGen/CodeGeneration.cpp

 
 #define DEBUG_TYPE "polly-codegen"
 
 static cl::opt<bool> Verify("polly-codegen-verify",
                             cl::desc("Verify the function generated by Polly"),
                             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",
                     cl::desc("Add run-time performance monitoring"), cl::Hidden,
                     cl::location(polly::PerfMonitoring), cl::init(false),
                     cl::ZeroOrMore, cl::cat(PollyCategory));
 
 STATISTIC(ScopsProcessed, "Number of SCoP processed");

polly/lib/CodeGen/LoopGenerators.cpp

 #include "llvm/IR/Dominators.h"
 #include "llvm/IR/Module.h"
 #include "llvm/Support/CommandLine.h"
 #include "llvm/Transforms/Utils/BasicBlockUtils.h"
 
 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",
                      cl::desc("Number of threads to use (0 = auto)"),
                      cl::Hidden, cl::location(polly::PollyNumThreads),
                      cl::init(0), cl::cat(PollyCategory));
 
 static cl::opt<OMPGeneralSchedulingType, true> XPollyScheduling(

polly/lib/CodeGen/PPCGCodeGeneration.cpp

static cl::opt<bool> SharedMemory("polly-acc-use-shared",
                                   cl::desc("Use shared memory"), cl::Hidden,
                                   cl::init(false), cl::ZeroOrMore,
                                   cl::cat(PollyCategory));
 static cl::opt<bool> PrivateMemory("polly-acc-use-private",
                                    cl::desc("Use private memory"), cl::Hidden,
                                    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"
                             " that all memory has been"
                             " declared as managed memory"),
                    cl::location(PollyManagedMemory), cl::Hidden,
                    cl::init(false), cl::ZeroOrMore, cl::cat(PollyCategory));
 
CudaVersion("polly-acc-cuda-version",
                 cl::desc("The CUDA version to compile for"), cl::Hidden,
                 cl::init("sm_30"), cl::ZeroOrMore, cl::cat(PollyCategory));
 
 static cl::opt<int>
     MinCompute("polly-acc-mincompute",
                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",
                           "use the CUDA Runtime API"),
                clEnumValN(GPURuntime::OpenCL, "libopencl",
                           "use the OpenCL Runtime API")),
     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",
                                          "target NVIDIA 64-bit architecture"),
                               clEnumValN(GPUArch::SPIR32, "spir32",
                                          "target SPIR 32-bit architecture"),
                               clEnumValN(GPUArch::SPIR64, "spir64",
                                          "target SPIR 64-bit architecture")),

polly/lib/Support/RegisterPasses.cpp

#ifdef GPU_CODEGEN
                           ,
                       clEnumValN(TARGET_GPU, "gpu", "generate GPU code"),
                       clEnumValN(TARGET_HYBRID, "hybrid",
                                  "generate GPU code (preferably) or CPU code")
 #endif
                           ),
            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(
         clEnumValN(polly::VECTORIZER_NONE, "none", "No Vectorization"),
         clEnumValN(polly::VECTORIZER_POLLY, "polly",
                    "Polly internal vectorizer"),
         clEnumValN(
             polly::VECTORIZER_STRIPMINE, "stripmine",