NFC. opt_storage refactored toward thread local options

[yrouban]

Summary

This patch refactors the template class cl::opt_storage<DataType, false, true> to make it possible to override the access to the stored DataType. This is needed for the patch

• D53424 Enable thread specific cl::opt values for multi-threaded support

Having DataType extended by cl::opt_storage it is impossible to control reads and writes of the base DataType using instances of cl::opt_storage because the dot-operator cannot be overridden.

cl::opt<std::string> MyOption;
...
if (MyOption.empty())

In this snippet empty() is applied directly to the base type of MyOption (which is DataType) without use of any operator.

This patch makes cl::opt_storage<DataType, false, true> wrap DataType as a field as it is done in cl::opt_storage<DataType, false, false>.
In addition to the getValue() methods to access to the field there are added operators *, -> and data type conversion for convenience.
Two templates are added for most frequently used methods for DataType=std::string: empty() and StringRef().
All places in the LLVM code are fixed accordingly. There are several fixes in project clang (D53428).
All changes except in CommandLine.h are straightforward. Similar changes should be done in all dependent projects if needed.

include/llvm/Support/CommandLine.h

public:
   const OptionValue<DataType> &getDefault() const { return Default; }
 };
 
 // Define how to hold a class type object, such as a string.  Since we can
 // inherit from a class, we do so.  This makes us exactly compatible with the
 // object in all cases that it is used.
 //
 template <class DataType>
-class opt_storage<DataType, false, true> : public DataType {
+class opt_storage<DataType, false, true> {
 public:
+  DataType Value;
   OptionValue<DataType> Default;
 
+  opt_storage() : Value(DataType()), Default(DataType()) {}
+
   template <class T> void setValue(const T &V, bool initial = false) {
-    DataType::operator=(V);
+    Value = V;
     if (initial)
       Default = V;
   }
 
-  DataType &getValue() { return *this; }
-  const DataType &getValue() const { return *this; }
+  DataType &getValue() { return Value; }
+  const DataType &getValue() const { return Value; }
 
   const OptionValue<DataType> &getDefault() const { return Default; }
+
+  operator DataType() const { return getValue(); }
+
+  DataType &operator*() { return getValue(); }
+  DataType *operator->() { return &getValue(); }
+  const DataType *operator->() const { return &getValue(); }
+  const DataType &operator*() const { return getValue(); }
+  operator DataType&() { return getValue(); }
+  operator const DataType&() const { return getValue(); }
+
+  operator StringRef() const { return StringRef(getValue()); }
+  bool empty() { return getValue().empty(); }
 };
 
 // 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:

lib/CodeGen/MachineBlockPlacement.cpp

else if (AlignAllNonFallThruBlocks) {
     // specific alignment.
     for (auto MBI = std::next(MF.begin()), MBE = MF.end(); MBI != MBE; ++MBI) {
       auto LayoutPred = std::prev(MBI);
       if (!LayoutPred->isSuccessor(&*MBI))
         MBI->setAlignment(AlignAllNonFallThruBlocks);
     }
   }
   if (ViewBlockLayoutWithBFI != GVDT_None &&
-      (ViewBlockFreqFuncName.empty() ||
+      (ViewBlockFreqFuncName->empty() ||
        F->getFunction().getName().equals(ViewBlockFreqFuncName))) {
     MBFI->view("MBP." + MF.getName(), false);
   }
 
 
   // We always return true as we have no way to track whether the final order
   // differs from the original order.
   return true;

lib/TableGen/Main.cpp

static int createDependencyFile(const TGParser &Parser, const char *argv0) {
   if (OutputFilename == "-")
     return reportError(argv0, "the option -d must be used together with -o\n");
 
   std::error_code EC;
   ToolOutputFile DepOut(DependFilename, EC, sys::fs::F_Text);
   if (EC)
     return reportError(argv0, "error opening " + DependFilename + ":" +
                                   EC.message() + "\n");
-  DepOut.os() << OutputFilename << ":";
+  DepOut.os() << *OutputFilename << ":";
   for (const auto &Dep : Parser.getDependencies()) {
     DepOut.os() << ' ' << Dep.first;
   }
   DepOut.os() << "\n";
   DepOut.keep();
   return 0;
 }
 
 int llvm::TableGenMain(char *argv0, TableGenMainFn *MainFn) {
   RecordKeeper Records;
 
   // Parse the input file.
   ErrorOr<std::unique_ptr<MemoryBuffer>> FileOrErr =
-      MemoryBuffer::getFileOrSTDIN(InputFilename);
+      MemoryBuffer::getFileOrSTDIN(*InputFilename);
   if (std::error_code EC = FileOrErr.getError())
     return reportError(argv0, "Could not open input file '" + InputFilename +
                                   "': " + EC.message() + "\n");
 
   // Tell SrcMgr about this buffer, which is what TGParser will pick up.
   SrcMgr.AddNewSourceBuffer(std::move(*FileOrErr), SMLoc());
 
   // Record the location of the include directory so that the lexer can find
   // it later.
   SrcMgr.setIncludeDirs(IncludeDirs);
 
   TGParser Parser(SrcMgr, Records);
 
   if (Parser.ParseFile())
     return 1;
 
   std::error_code EC;
   ToolOutputFile Out(OutputFilename, EC, sys::fs::F_Text);
   if (EC)
     return reportError(argv0, "error opening " + OutputFilename + ":" +
                                   EC.message() + "\n");
-  if (!DependFilename.empty()) {
+  if (!DependFilename->empty()) {
     if (int Ret = createDependencyFile(Parser, argv0))
       return Ret;
   }
 
   if (MainFn(Out.os(), Records))
     return 1;
 
   if (ErrorsPrinted > 0)
     return reportError(argv0, Twine(ErrorsPrinted) + " errors.\n");
 
   // Declare success.
   Out.keep();
   return 0;
 }

lib/Target/Mips/MipsOs16.cpp

for (BasicBlock::const_iterator I = BB->begin(), E = BB->end();
           return true;
       }
     }
   return false;
 }
 
 
 bool MipsOs16::runOnModule(Module &M) {
-  bool usingMask = Mips32FunctionMask.length() > 0;
+  bool usingMask = Mips32FunctionMask->length() > 0;
   bool doneUsingMask = false; // this will make it stop repeating
 
   LLVM_DEBUG(dbgs() << "Run on Module MipsOs16 \n"
-                    << Mips32FunctionMask << "\n");
+                    << *Mips32FunctionMask << "\n");
   if (usingMask)
-    LLVM_DEBUG(dbgs() << "using mask \n" << Mips32FunctionMask << "\n");
+    LLVM_DEBUG(dbgs() << "using mask \n" << *Mips32FunctionMask << "\n");
 
   unsigned int functionIndex = 0;
   bool modified = false;
 
   for (auto &F : M) {
     if (F.isDeclaration())
       continue;
 
     LLVM_DEBUG(dbgs() << "Working on " << F.getName() << "\n");
     if (usingMask) {
       if (!doneUsingMask) {
-        if (functionIndex == Mips32FunctionMask.length())
+        if (functionIndex == Mips32FunctionMask->length())
           functionIndex = 0;
-        switch (Mips32FunctionMask[functionIndex]) {
+        switch ((*Mips32FunctionMask)[functionIndex]) {
         case '1':
           LLVM_DEBUG(dbgs() << "mask forced mips32: " << F.getName() << "\n");
           F.addFnAttr("nomips16");
           break;
         case '.':
           doneUsingMask = true;
           break;
         default:

lib/Transforms/IPO/BlockExtractor.cpp

 ModulePass *llvm::createBlockExtractorPass() { return new BlockExtractor(); }
 ModulePass *llvm::createBlockExtractorPass(
     const SmallVectorImpl<BasicBlock *> &BlocksToExtract, bool EraseFunctions) {
   return new BlockExtractor(BlocksToExtract, EraseFunctions);
 }
 
 /// Gets all of the blocks specified in the input file.
 void BlockExtractor::loadFile() {
-  auto ErrOrBuf = MemoryBuffer::getFile(BlockExtractorFile);
+  auto ErrOrBuf = MemoryBuffer::getFile(*BlockExtractorFile);
   if (ErrOrBuf.getError())
     report_fatal_error("BlockExtractor couldn't load the file.");
   // Read the file.
   auto &Buf = *ErrOrBuf;
   SmallVector<StringRef, 16> Lines;
   Buf->getBuffer().split(Lines, '\n', /*MaxSplit=*/-1,
                          /*KeepEmpty=*/false);
   for (const auto &Line : Lines) {

lib/Transforms/IPO/LowerTypeTests.cpp

 }
 
 bool LowerTypeTestsModule::runForTesting(Module &M) {
   ModuleSummaryIndex Summary(/*HaveGVs=*/false);
 
   // Handle the command-line summary arguments. This code is for testing
   // purposes only, so we handle errors directly.
   if (!ClReadSummary.empty()) {
-    ExitOnError ExitOnErr("-lowertypetests-read-summary: " + ClReadSummary +
+    ExitOnError ExitOnErr("-lowertypetests-read-summary: " + *ClReadSummary +
                           ": ");
     auto ReadSummaryFile =
-        ExitOnErr(errorOrToExpected(MemoryBuffer::getFile(ClReadSummary)));
+        ExitOnErr(errorOrToExpected(MemoryBuffer::getFile(*ClReadSummary)));
 
     yaml::Input In(ReadSummaryFile->getBuffer());
     In >> Summary;
     ExitOnErr(errorCodeToError(In.error()));
   }
 
   bool Changed =
       LowerTypeTestsModule(
           M, ClSummaryAction == PassSummaryAction::Export ? &Summary : nullptr,
           ClSummaryAction == PassSummaryAction::Import ? &Summary : nullptr)
           .lower();
 
   if (!ClWriteSummary.empty()) {
-    ExitOnError ExitOnErr("-lowertypetests-write-summary: " + ClWriteSummary +
+    ExitOnError ExitOnErr("-lowertypetests-write-summary: " + *ClWriteSummary +
                           ": ");
     std::error_code EC;
     raw_fd_ostream OS(ClWriteSummary, EC, sys::fs::F_Text);
     ExitOnErr(errorCodeToError(EC));
 
     yaml::Output Out(OS);
     Out << Summary;
   }

lib/Transforms/IPO/WholeProgramDevirt.cpp

bool DevirtModule::runForTesting(
     Module &M, function_ref<AAResults &(Function &)> AARGetter,
     function_ref<OptimizationRemarkEmitter &(Function *)> OREGetter,
     function_ref<DominatorTree &(Function &)> LookupDomTree) {
   ModuleSummaryIndex Summary(/*HaveGVs=*/false);
 
   // Handle the command-line summary arguments. This code is for testing
   // purposes only, so we handle errors directly.
   if (!ClReadSummary.empty()) {
-    ExitOnError ExitOnErr("-wholeprogramdevirt-read-summary: " + ClReadSummary +
+    ExitOnError ExitOnErr("-wholeprogramdevirt-read-summary: " + *ClReadSummary +
                           ": ");
     auto ReadSummaryFile =
-        ExitOnErr(errorOrToExpected(MemoryBuffer::getFile(ClReadSummary)));
+        ExitOnErr(errorOrToExpected(MemoryBuffer::getFile(*ClReadSummary)));
 
     yaml::Input In(ReadSummaryFile->getBuffer());
     In >> Summary;
     ExitOnErr(errorCodeToError(In.error()));
   }
 
   bool Changed =
       DevirtModule(
           M, AARGetter, OREGetter, LookupDomTree,
           ClSummaryAction == PassSummaryAction::Export ? &Summary : nullptr,
           ClSummaryAction == PassSummaryAction::Import ? &Summary : nullptr)
           .run();
 
   if (!ClWriteSummary.empty()) {
     ExitOnError ExitOnErr(
-        "-wholeprogramdevirt-write-summary: " + ClWriteSummary + ": ");
+        "-wholeprogramdevirt-write-summary: " + *ClWriteSummary + ": ");
     std::error_code EC;
     raw_fd_ostream OS(ClWriteSummary, EC, sys::fs::F_Text);
     ExitOnErr(errorCodeToError(EC));
 
     yaml::Output Out(OS);
     Out << Summary;
   }
 

lib/Transforms/Instrumentation/AddressSanitizer.cpp

for (size_t AccessIsWrite = 0; AccessIsWrite <= 1; AccessIsWrite++) {
       }
       AsanErrorCallbackSized[AccessIsWrite][Exp] =
           checkSanitizerInterfaceFunction(M.getOrInsertFunction(
               kAsanReportErrorTemplate + ExpStr + TypeStr + "_n" + EndingStr,
               FunctionType::get(IRB.getVoidTy(), Args2, false)));
 
       AsanMemoryAccessCallbackSized[AccessIsWrite][Exp] =
           checkSanitizerInterfaceFunction(M.getOrInsertFunction(
-              ClMemoryAccessCallbackPrefix + ExpStr + TypeStr + "N" + EndingStr,
+              *ClMemoryAccessCallbackPrefix + ExpStr + TypeStr + "N" + EndingStr,
               FunctionType::get(IRB.getVoidTy(), Args2, false)));
 
       for (size_t AccessSizeIndex = 0; AccessSizeIndex < kNumberOfAccessSizes;
            AccessSizeIndex++) {
         const std::string Suffix = TypeStr + itostr(1ULL << AccessSizeIndex);
         AsanErrorCallback[AccessIsWrite][Exp][AccessSizeIndex] =
             checkSanitizerInterfaceFunction(M.getOrInsertFunction(
                 kAsanReportErrorTemplate + ExpStr + Suffix + EndingStr,
                 FunctionType::get(IRB.getVoidTy(), Args1, false)));
 
         AsanMemoryAccessCallback[AccessIsWrite][Exp][AccessSizeIndex] =
             checkSanitizerInterfaceFunction(M.getOrInsertFunction(
-                ClMemoryAccessCallbackPrefix + ExpStr + Suffix + EndingStr,
+                *ClMemoryAccessCallbackPrefix + ExpStr + Suffix + EndingStr,
                 FunctionType::get(IRB.getVoidTy(), Args1, false)));
       }
     }
   }
 
   const std::string MemIntrinCallbackPrefix =
       CompileKernel ? std::string("") : ClMemoryAccessCallbackPrefix;
   AsanMemmove = checkSanitizerInterfaceFunction(M.getOrInsertFunction(

lib/Transforms/Instrumentation/ControlHeightReduction.cpp

static cl::opt<std::string> CHRFunctionList(
     "chr-function-list", cl::init(""), cl::Hidden,
     cl::desc("Specify file to retrieve the list of functions to apply CHR to"));
 
 static StringSet<> CHRModules;
 static StringSet<> CHRFunctions;
 
 static void parseCHRFilterFiles() {
   if (!CHRModuleList.empty()) {
-    auto FileOrErr = MemoryBuffer::getFile(CHRModuleList);
+    auto FileOrErr = MemoryBuffer::getFile(*CHRModuleList);
     if (!FileOrErr) {
-      errs() << "Error: Couldn't read the chr-module-list file " << CHRModuleList << "\n";
+      errs() << "Error: Couldn't read the chr-module-list file " << *CHRModuleList << "\n";
       std::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);
+    auto FileOrErr = MemoryBuffer::getFile(*CHRFunctionList);
     if (!FileOrErr) {
-      errs() << "Error: Couldn't read the chr-function-list file " << CHRFunctionList << "\n";
+      errs() << "Error: Couldn't read the chr-function-list file " << *CHRFunctionList << "\n";
       std::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())

lib/Transforms/Instrumentation/GCOVProfiling.cpp

GCOVOptions GCOVOptions::getDefault() {
   GCOVOptions Options;
   Options.EmitNotes = true;
   Options.EmitData = true;
   Options.UseCfgChecksum = false;
   Options.NoRedZone = false;
   Options.FunctionNamesInData = true;
   Options.ExitBlockBeforeBody = DefaultExitBlockBeforeBody;
 
-  if (DefaultGCOVVersion.size() != 4) {
+  if (DefaultGCOVVersion->size() != 4) {
     llvm::report_fatal_error(std::string("Invalid -default-gcov-version: ") +
-                             DefaultGCOVVersion);
+                             *DefaultGCOVVersion);
   }
-  memcpy(Options.Version, DefaultGCOVVersion.c_str(), 4);
+  memcpy(Options.Version, DefaultGCOVVersion->c_str(), 4);
   return Options;
 }
 
 namespace {
 class GCOVFunction;
 
 class GCOVProfiler {
 public:

lib/Transforms/Instrumentation/HWAddressSanitizer.cpp

 void HWAddressSanitizer::initializeCallbacks(Module &M) {
   IRBuilder<> IRB(*C);
   for (size_t AccessIsWrite = 0; AccessIsWrite <= 1; AccessIsWrite++) {
     const std::string TypeStr = AccessIsWrite ? "store" : "load";
     const std::string EndingStr = Recover ? "_noabort" : "";
 
     HwasanMemoryAccessCallbackSized[AccessIsWrite] =
         checkSanitizerInterfaceFunction(M.getOrInsertFunction(
-            ClMemoryAccessCallbackPrefix + TypeStr + "N" + EndingStr,
+            *ClMemoryAccessCallbackPrefix + TypeStr + "N" + EndingStr,
             FunctionType::get(IRB.getVoidTy(), {IntptrTy, IntptrTy}, false)));
 
     for (size_t AccessSizeIndex = 0; AccessSizeIndex < kNumberOfAccessSizes;
          AccessSizeIndex++) {
       HwasanMemoryAccessCallback[AccessIsWrite][AccessSizeIndex] =
           checkSanitizerInterfaceFunction(M.getOrInsertFunction(
-              ClMemoryAccessCallbackPrefix + TypeStr +
+              *ClMemoryAccessCallbackPrefix + TypeStr +
                   itostr(1ULL << AccessSizeIndex) + EndingStr,
               FunctionType::get(IRB.getVoidTy(), {IntptrTy}, false)));
     }
   }
 
   HwasanTagMemoryFunc = checkSanitizerInterfaceFunction(M.getOrInsertFunction(
       "__hwasan_tag_memory", IRB.getVoidTy(), Int8PtrTy, Int8Ty, IntptrTy));
   HwasanGenerateTagFunc = checkSanitizerInterfaceFunction(

tools/bugpoint/ExecutionDriver.cpp

if (BitcodeFile.empty()) {
     CreatedBitcode = true;
   }
 
   // Remove the temporary bitcode file when we are done.
   std::string BitcodePath(BitcodeFile);
   FileRemover BitcodeFileRemover(BitcodePath, CreatedBitcode && !SaveTemps);
 
   if (OutputFile.empty())
-    OutputFile = OutputPrefix + "-execution-output-%%%%%%%";
+    OutputFile = *OutputPrefix + "-execution-output-%%%%%%%";
 
   // Check to see if this is a valid output filename...
   SmallString<128> UniqueFile;
   std::error_code EC = sys::fs::createUniqueFile(OutputFile, UniqueFile);
   if (EC) {
     errs() << ToolName << ": Error making unique filename: " << EC.message()
            << "\n";
     exit(1);

tools/bugpoint/Miscompilation.cpp

while (1) {
     if (Failure) {
       BD.switchToInterpreter(AI);
 
       // Merged program doesn't work anymore!
       errs() << "  *** ERROR: Loop extraction broke the program. :("
              << " Please report a bug!\n";
       errs() << "      Continuing on with un-loop-extracted version.\n";
 
-      BD.writeProgramToFile(OutputPrefix + "-loop-extract-fail-tno.bc",
+      BD.writeProgramToFile(*OutputPrefix + "-loop-extract-fail-tno.bc",
                             *ToNotOptimize);
-      BD.writeProgramToFile(OutputPrefix + "-loop-extract-fail-to.bc",
+      BD.writeProgramToFile(*OutputPrefix + "-loop-extract-fail-to.bc",
                             *ToOptimize);
-      BD.writeProgramToFile(OutputPrefix + "-loop-extract-fail-to-le.bc",
+      BD.writeProgramToFile(*OutputPrefix + "-loop-extract-fail-to-le.bc",
                             *ToOptimizeLoopExtracted);
 
-      errs() << "Please submit the " << OutputPrefix
+      errs() << "Please submit the " << *OutputPrefix
              << "-loop-extract-fail-*.bc files.\n";
       return MadeChange;
     }
     BD.switchToInterpreter(AI);
 
     outs() << "  Testing after loop extraction:\n";
     // Clone modules, the tester function will free them.
     std::unique_ptr<Module> TOLEBackup =

tools/bugpoint/OptimizerDriver.cpp

 
 /// This function is used to output the current Program to a file named
 /// "bugpoint-ID.bc".
 void BugDriver::EmitProgressBitcode(const Module &M, const std::string &ID,
                                     bool NoFlyer) const {
   // Output the input to the current pass to a bitcode file, emit a message
   // telling the user how to reproduce it: opt -foo blah.bc
   //
-  std::string Filename = OutputPrefix + "-" + ID + ".bc";
+  std::string Filename = *OutputPrefix + "-" + ID + ".bc";
   if (writeProgramToFile(Filename, M)) {
     errs() << "Error opening file '" << Filename << "' for writing!\n";
     return;
   }
 
   outs() << "Emitted bitcode to '" << Filename << "'\n";
   if (NoFlyer || PassesToRun.empty())
     return;

tools/bugpoint/ToolRunner.cpp

Message = "Cannot find `" + CCBinary + "' in PATH: " +
               CCPath.getError().message() + "\n";
     return nullptr;
   }
 
   std::string RemoteClientPath;
   if (!RemoteClient.empty()) {
     auto Path = sys::findProgramByName(RemoteClient);
     if (!Path) {
-      Message = "Cannot find `" + RemoteClient + "' in PATH: " +
+      Message = "Cannot find `" + *RemoteClient + "' in PATH: " +
                 Path.getError().message() + "\n";
       return nullptr;
     }
     RemoteClientPath = *Path;
   }
 
   Message = "Found CC: " + *CCPath + "\n";
   return new CC(*CCPath, RemoteClientPath, Args);
 }

tools/llc/llc.cpp

static int compileModule(char **argv, LLVMContext &Context) {
   Triple TheTriple;
 
   bool SkipModule = MCPU == "help" ||
                     (!MAttrs.empty() && MAttrs.front() == "help");
 
   // If user just wants to list available options, skip module loading
   if (!SkipModule) {
     if (InputLanguage == "mir" ||
-        (InputLanguage == "" && StringRef(InputFilename).endswith(".mir"))) {
+        (InputLanguage == "" && StringRef(*InputFilename).endswith(".mir"))) {
       MIR = createMIRParserFromFile(InputFilename, Err, Context);
       if (MIR)
         M = MIR->parseIRModule();
     } else
       M = parseIRFile(InputFilename, Err, Context, false);
     if (!M) {
       Err.print(argv[0], WithColor::error(errs(), argv[0]));
       return 1;
static int compileModule(char **argv, LLVMContext &Context) {
   // This needs to be done after setting datalayout since it calls verifier
   // to check debug info whereas verifier relies on correct datalayout.
   UpgradeDebugInfo(*M);
 
   // Verify module immediately to catch problems before doInitialization() is
   // called on any passes.
   if (!NoVerify && verifyModule(*M, &errs())) {
     std::string Prefix =
-        (Twine(argv[0]) + Twine(": ") + Twine(InputFilename)).str();
+        (Twine(argv[0]) + Twine(": ") + Twine(*InputFilename)).str();
     WithColor::error(errs(), Prefix) << "input module is broken!\n";
     return 1;
   }
 
   // Override function attributes based on CPUStr, FeaturesStr, and command line
   // flags.
   setFunctionAttributes(CPUStr, FeaturesStr, *M);
 

tools/lli/lli.cpp

int main(int argc, char **argv, char * const *envp) {
 
   // If the user specifically requested an argv[0] to pass into the program,
   // do it now.
   if (!FakeArgv0.empty()) {
     InputFile = static_cast<std::string>(FakeArgv0);
   } else {
     // Otherwise, if there is a .bc suffix on the executable strip it off, it
     // might confuse the program.
-    if (StringRef(InputFile).endswith(".bc"))
-      InputFile.erase(InputFile.length() - 3);
+    if (StringRef(*InputFile).endswith(".bc"))
+      InputFile->erase(InputFile->length() - 3);
   }
 
   // Add the module's name to the start of the vector of arguments to main().
   InputArgv.insert(InputArgv.begin(), InputFile);
 
   // Call the main function from M as if its signature were:
   //   int main (int argc, char **argv, const char **envp)
   // using the contents of Args to determine argc & argv, and the contents of
   // EnvVars to determine envp.
   //
   Function *EntryFn = Mod->getFunction(EntryFunc);
   if (!EntryFn) {
     WithColor::error(errs(), argv[0])
-        << '\'' << EntryFunc << "\' function not found in module.\n";
+        << '\'' << *EntryFunc << "\' function not found in module.\n";
     return -1;
   }
 
   // Reset errno to zero on entry to main.
   errno = 0;
 
   int Result = -1;
 
   // Sanity check use of remote-jit: LLI currently only supports use of the
   // remote JIT on Unix platforms.
   if (RemoteMCJIT) {
 #ifndef LLVM_ON_UNIX
     WithColor::warning(errs(), argv[0])
         << "host does not support external remote targets.\n";
     WithColor::note() << "defaulting to local execution\n";
     return -1;
 #else
     if (ChildExecPath.empty()) {
       WithColor::error(errs(), argv[0])
           << "-remote-mcjit requires -mcjit-remote-process.\n";
       exit(1);
-    } else if (!sys::fs::can_execute(ChildExecPath)) {
+    } else if (!sys::fs::can_execute(*ChildExecPath)) {
       WithColor::error(errs(), argv[0])
-          << "unable to find usable child executable: '" << ChildExecPath
+          << "unable to find usable child executable: '" << *ChildExecPath
           << "'\n";
       return -1;
     }
 #endif
   }
 
   if (!RemoteMCJIT) {
     // If the program doesn't explicitly call exit, we will need the Exit
if (ChildPID == 0) {
     // Close the parent ends of the pipes
     close(PipeFD[0][1]);
     close(PipeFD[1][0]);
 
 
     // Execute the child process.
     std::unique_ptr<char[]> ChildPath, ChildIn, ChildOut;
     {
-      ChildPath.reset(new char[ChildExecPath.size() + 1]);
-      std::copy(ChildExecPath.begin(), ChildExecPath.end(), &ChildPath[0]);
-      ChildPath[ChildExecPath.size()] = '\0';
+      ChildPath.reset(new char[ChildExecPath->size() + 1]);
+      std::copy(ChildExecPath->begin(), ChildExecPath->end(), &ChildPath[0]);
+      ChildPath[ChildExecPath->size()] = '\0';
       std::string ChildInStr = utostr(PipeFD[0][0]);
       ChildIn.reset(new char[ChildInStr.size() + 1]);
       std::copy(ChildInStr.begin(), ChildInStr.end(), &ChildIn[0]);
       ChildIn[ChildInStr.size()] = '\0';
       std::string ChildOutStr = utostr(PipeFD[1][1]);
       ChildOut.reset(new char[ChildOutStr.size() + 1]);
       std::copy(ChildOutStr.begin(), ChildOutStr.end(), &ChildOut[0]);
       ChildOut[ChildOutStr.size()] = '\0';
     }
 
     char * const args[] = { &ChildPath[0], &ChildIn[0], &ChildOut[0], nullptr };
-    int rc = execv(ChildExecPath.c_str(), args);
+    int rc = execv(ChildExecPath->c_str(), args);
     if (rc != 0)
       perror("Error executing child process: ");
     llvm_unreachable("Error executing child process");
   }
   // else we're the parent...
 
   // Close the child ends of the pipes
   close(PipeFD[0][0]);
   close(PipeFD[1][1]);
 
   // Return an RPC channel connected to our end of the pipes.
   return llvm::make_unique<FDRawChannel>(PipeFD[1][0], PipeFD[0][1]);
 #endif
 }

tools/llvm-bcanalyzer/llvm-bcanalyzer.cpp

if (ParseBlock(Stream, BlockInfo, BlockID, 0, CurStreamType))
       return true;
     ++NumTopBlocks;
   }
 
   if (Dump) outs() << "\n\n";
 
   uint64_t BufferSizeBits = Stream.getBitcodeBytes().size() * CHAR_BIT;
   // Print a summary of the read file.
-  outs() << "Summary of " << InputFilename << ":\n";
+  outs() << "Summary of " << *InputFilename << ":\n";
   outs() << "         Total size: ";
   PrintSize(BufferSizeBits);
   outs() << "\n";
   outs() << "        Stream type: ";
   switch (CurStreamType) {
   case UnknownBitstream:
     outs() << "unknown\n";
     break;

tools/llvm-cat/llvm-cat.cpp

for (const auto &InputFilename : InputFilenames) {
       OwnedMods.push_back(std::move(M));
     }
     Writer.writeStrtab();
   }
 
   std::error_code EC;
   raw_fd_ostream OS(OutputFilename, EC, sys::fs::OpenFlags::F_None);
   if (EC) {
-    errs() << argv[0] << ": cannot open " << OutputFilename << " for writing: "
+    errs() << argv[0] << ": cannot open " << *OutputFilename << " for writing: "
            << EC.message();
     return 1;
   }
 
   OS.write(Buffer.data(), Buffer.size());
   return 0;
 }

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

void printInstructionInformation(const FileAnalysis &Analysis,
 
   if (PrintGraphs)
     Graph.printToDOT(Analysis, outs());
 }
 
 void printInstructionStatus(unsigned BlameLine, bool CFIProtected,
                             const DILineInfo &LineInfo) {
   if (BlameLine) {
-    outs() << "Blacklist Match: " << BlacklistFilename << ":" << BlameLine
+    outs() << "Blacklist Match: " << *BlacklistFilename << ":" << BlameLine
            << "\n";
     if (CFIProtected)
       outs() << "====> Unexpected Protected\n";
     else
       outs() << "====> Expected Unprotected\n";
 
     if (PrintBlameContextAll)
       printBlameContext(LineInfo, PrintBlameContextAll);
if (IgnoreDWARFFlag) {
       else
         UnexpectedUnprotected++;
       continue;
     }
 
     auto InliningInfo = Analysis.symbolizeInlinedCode(Address);
     if (!InliningInfo || InliningInfo->getNumberOfFrames() == 0) {
       errs() << "Failed to symbolise " << format_hex(Address, 2)
-             << " with line tables from " << InputFilename << "\n";
+             << " with line tables from " << *InputFilename << "\n";
       exit(EXIT_FAILURE);
     }
 
     const auto &LineInfo = InliningInfo->getFrame(0);
 
     // Print the inlining symbolisation of this instruction.
     if (!Summarize) {
       for (uint32_t i = 0; i < InliningInfo->getNumberOfFrames(); ++i) {
outs() << formatv("\nTotal Indirect CF Instructions: {0}\n"
                     UnexpectedUnprotected,
                     ((double)UnexpectedUnprotected) / IndirectCFInstructions);
 
   if (!SpecialCaseList)
     return;
 
   outs() << "\nBlacklist Results:\n";
   for (const auto &KV : BlameCounter) {
-    outs() << "  " << BlacklistFilename << ":" << KV.first << " affects "
+    outs() << "  " << *BlacklistFilename << ":" << KV.first << " affects "
            << KV.second << " indirect CF instructions.\n";
   }
 }
 
 int main(int argc, char **argv) {
   cl::ParseCommandLineOptions(
       argc, argv,
       "Identifies whether Control Flow Integrity protects all indirect control "

tools/llvm-cov/CodeCoverage.cpp

int CodeCoverageTool::run(Command Cmd, int argc, const char **argv) {
   cl::alias NumThreadsA("j", cl::desc("Alias for --num-threads"),
                         cl::aliasopt(NumThreads));
 
   auto commandLineParser = [&, this](int argc, const char **argv) -> int {
     cl::ParseCommandLineOptions(argc, argv, "LLVM code coverage tool\n");
     ViewOpts.Debug = DebugDump;
 
     if (!CovFilename.empty())
-      ObjectFilenames.emplace_back(CovFilename);
+      ObjectFilenames.emplace_back(*CovFilename);
     for (const std::string &Filename : CovFilenames)
       ObjectFilenames.emplace_back(Filename);
     if (ObjectFilenames.empty()) {
       errs() << "No filenames specified!\n";
       ::exit(1);
     }
 
     ViewOpts.Format = Format;
     switch (ViewOpts.Format) {
     case CoverageViewOptions::OutputFormat::Text:
       ViewOpts.Colors = UseColor == cl::BOU_UNSET
                             ? sys::Process::StandardOutHasColors()
                             : UseColor == cl::BOU_TRUE;
       break;
     case CoverageViewOptions::OutputFormat::HTML:
       if (UseColor == cl::BOU_FALSE)
         errs() << "Color output cannot be disabled when generating html.\n";
       ViewOpts.Colors = true;
       break;
     }
 
     // If path-equivalence was given and is a comma seperated pair then set
     // PathRemapping.
-    auto EquivPair = StringRef(PathRemap).split(',');
+    auto EquivPair = StringRef(*PathRemap).split(',');
     if (!(EquivPair.first.empty() && EquivPair.second.empty()))
       PathRemapping = EquivPair;
 
     // If a demangler is supplied, check if it exists and register it.
     if (DemanglerOpts.size()) {
       auto DemanglerPathOrErr = sys::findProgramByName(DemanglerOpts[0]);
       if (!DemanglerPathOrErr) {
         error("Could not find the demangler!",

tools/llvm-cov/TestingSupport.cpp

int convertForTestingMain(int argc, const char *argv[]) {
   uint64_t ProfileNamesAddress = ProfileNames.getAddress();
   StringRef CoverageMappingData;
   StringRef ProfileNamesData;
   if (CoverageMapping.getContents(CoverageMappingData) ||
       ProfileNames.getContents(ProfileNamesData))
     return 1;
 
   int FD;
-  if (auto Err = sys::fs::openFileForWrite(OutputFilename, FD)) {
+  if (auto Err = sys::fs::openFileForWrite(*OutputFilename, FD)) {
     errs() << "error: " << Err.message() << "\n";
     return 1;
   }
 
   raw_fd_ostream OS(FD, true);
   OS << "llvmcovmtestdata";
   encodeULEB128(ProfileNamesData.size(), OS);
   encodeULEB128(ProfileNamesAddress, OS);
   OS << ProfileNamesData;
   // Coverage mapping data is expected to have an alignment of 8.
   for (unsigned Pad = OffsetToAlignment(OS.tell(), 8); Pad; --Pad)
     OS.write(uint8_t(0));
   OS << CoverageMappingData;
 
   return 0;
 }

tools/llvm-cxxmap/llvm-cxxmap.cpp

static void remapSymbols(MemoryBuffer &OldSymbolFile,
   }
 }
 
 int main(int argc, const char *argv[]) {
   InitLLVM X(argc, argv);
 
   cl::ParseCommandLineOptions(argc, argv, "LLVM C++ mangled name remapper\n");
 
-  auto OldSymbolBufOrError = MemoryBuffer::getFileOrSTDIN(OldSymbolFile);
+  auto OldSymbolBufOrError = MemoryBuffer::getFileOrSTDIN(*OldSymbolFile);
   if (!OldSymbolBufOrError)
     exitWithErrorCode(OldSymbolBufOrError.getError(), OldSymbolFile);
 
-  auto NewSymbolBufOrError = MemoryBuffer::getFileOrSTDIN(NewSymbolFile);
+  auto NewSymbolBufOrError = MemoryBuffer::getFileOrSTDIN(*NewSymbolFile);
   if (!NewSymbolBufOrError)
     exitWithErrorCode(NewSymbolBufOrError.getError(), NewSymbolFile);
 
-  auto RemappingBufOrError = MemoryBuffer::getFileOrSTDIN(RemappingFile);
+  auto RemappingBufOrError = MemoryBuffer::getFileOrSTDIN(*RemappingFile);
   if (!RemappingBufOrError)
     exitWithErrorCode(RemappingBufOrError.getError(), RemappingFile);
 
   std::error_code EC;
-  raw_fd_ostream OS(OutputFilename.data(), EC, sys::fs::F_Text);
+  raw_fd_ostream OS(OutputFilename->data(), EC, sys::fs::F_Text);
   if (EC)
     exitWithErrorCode(EC, OutputFilename);
 
   remapSymbols(*OldSymbolBufOrError.get(), *NewSymbolBufOrError.get(),
                *RemappingBufOrError.get(), OS);
 }

tools/llvm-dis/llvm-dis.cpp

int main(int argc, char **argv) {
   ExitOnErr.setBanner(std::string(argv[0]) + ": error: ");
 
   LLVMContext Context;
   Context.setDiagnosticHandler(
       llvm::make_unique<LLVMDisDiagnosticHandler>(argv[0]));
   cl::ParseCommandLineOptions(argc, argv, "llvm .bc -> .ll disassembler\n");
 
   std::unique_ptr<MemoryBuffer> MB =
-      ExitOnErr(errorOrToExpected(MemoryBuffer::getFileOrSTDIN(InputFilename)));
+      ExitOnErr(errorOrToExpected(MemoryBuffer::getFileOrSTDIN(*InputFilename)));
   std::unique_ptr<Module> M = ExitOnErr(getLazyBitcodeModule(
       *MB, Context, /*ShouldLazyLoadMetadata=*/true, SetImporting));
   if (MaterializeMetadata)
     ExitOnErr(M->materializeMetadata());
   else
     ExitOnErr(M->materializeAll());
 
   BitcodeLTOInfo LTOInfo = ExitOnErr(getBitcodeLTOInfo(*MB));

tools/llvm-dwarfdump/llvm-dwarfdump.cpp

if (Help) {
     return 0;
   }
 
   std::unique_ptr<ToolOutputFile> OutputFile;
   if (!OutputFilename.empty()) {
     std::error_code EC;
     OutputFile = llvm::make_unique<ToolOutputFile>(OutputFilename, EC,
                                                      sys::fs::F_None);
-    error("Unable to open output file" + OutputFilename, EC);
+    error("Unable to open output file" + *OutputFilename, EC);
     // Don't remove output file if we exit with an error.
     OutputFile->keep();
   }
 
   raw_ostream &OS = OutputFile ? OutputFile->os() : outs();
   bool OffsetRequested = false;
 
   // Defaults to dumping all sections, unless brief mode is specified in which
   // case only the .debug_info section in dumped.
 #define HANDLE_DWARF_SECTION(ENUM_NAME, ELF_NAME, CMDLINE_NAME)                \
-  if (Dump##ENUM_NAME.IsRequested) {                                           \
+  if (Dump##ENUM_NAME->IsRequested) {                                           \
     DumpType |= DIDT_##ENUM_NAME;                                              \
-    if (Dump##ENUM_NAME.HasValue) {                                            \
-      DumpOffsets[DIDT_ID_##ENUM_NAME] = Dump##ENUM_NAME.Val;                  \
+    if (Dump##ENUM_NAME->HasValue) {                                            \
+      DumpOffsets[DIDT_ID_##ENUM_NAME] = Dump##ENUM_NAME->Val;                  \
       OffsetRequested = true;                                                  \
     }                                                                          \
   }
 #include "llvm/BinaryFormat/Dwarf.def"
 #undef HANDLE_DWARF_SECTION
   if (DumpUUID)
     DumpType |= DIDT_UUID;
   if (DumpAll)

tools/llvm-dwp/llvm-dwp.cpp

if (!MCE)
     return error("no code emitter for target " + TripleName, Context);
 
   // Create the output file.
   std::error_code EC;
   raw_fd_ostream OutFile(OutputFilename, EC, sys::fs::F_None);
   Optional<buffer_ostream> BOS;
   raw_pwrite_stream *OS;
   if (EC)
-    return error(Twine(OutputFilename) + ": " + EC.message(), Context);
+    return error(Twine(*OutputFilename) + ": " + EC.message(), Context);
   if (OutFile.supportsSeeking()) {
     OS = &OutFile;
   } else {
     BOS.emplace(OutFile);
     OS = BOS.getPointer();
   }
 
   MCTargetOptions MCOptions = InitMCTargetOptionsFromFlags();

tools/llvm-exegesis/llvm-exegesis.cpp

static unsigned getOpcodeOrDie(const llvm::MCInstrInfo &MCInstrInfo) {
   if (!SnippetsFile.empty())
     return 0;
   if (OpcodeIndex > 0)
     return OpcodeIndex;
   // Resolve opcode name -> opcode.
   for (unsigned I = 0, E = MCInstrInfo.getNumOpcodes(); I < E; ++I)
     if (MCInstrInfo.getName(I) == OpcodeName)
       return I;
-  llvm::report_fatal_error(llvm::Twine("unknown opcode ").concat(OpcodeName));
+  llvm::report_fatal_error(llvm::Twine("unknown opcode ").concat(*OpcodeName));
 }
 
 // Generates code snippets for opcode `Opcode`.
 static llvm::Expected<std::vector<BenchmarkCode>>
 generateSnippets(const LLVMState &State, unsigned Opcode) {
   const std::unique_ptr<SnippetGenerator> Generator =
       State.getExegesisTarget().createSnippetGenerator(BenchmarkMode, State);
   if (!Generator)

tools/llvm-lto/llvm-lto.cpp

static void createCombinedModuleSummaryIndex() {
   for (auto &Filename : InputFilenames) {
     ExitOnError ExitOnErr("llvm-lto: error loading file '" + Filename + "': ");
     std::unique_ptr<MemoryBuffer> MB =
         ExitOnErr(errorOrToExpected(MemoryBuffer::getFileOrSTDIN(Filename)));
     ExitOnErr(readModuleSummaryIndex(*MB, CombinedIndex, NextModuleId++));
   }
   std::error_code EC;
   assert(!OutputFilename.empty());
-  raw_fd_ostream OS(OutputFilename + ".thinlto.bc", EC,
+  raw_fd_ostream OS(*OutputFilename + ".thinlto.bc", EC,
                     sys::fs::OpenFlags::F_None);
   error(EC, "error opening the file '" + OutputFilename + ".thinlto.bc'");
   WriteIndexToFile(CombinedIndex, OS);
   OS.close();
 }
 
 /// Parse the thinlto_prefix_replace option into the \p OldPrefix and
 /// \p NewPrefix strings, if it was specified.
 static void getThinLTOOldAndNewPrefix(std::string &OldPrefix,
                                       std::string &NewPrefix) {
-  assert(ThinLTOPrefixReplace.empty() ||
-         ThinLTOPrefixReplace.find(";") != StringRef::npos);
+  assert(ThinLTOPrefixReplace->empty() ||
+         ThinLTOPrefixReplace->find(";") != StringRef::npos);
   StringRef PrefixReplace = ThinLTOPrefixReplace;
   std::pair<StringRef, StringRef> Split = PrefixReplace.split(";");
   OldPrefix = Split.first.str();
   NewPrefix = Split.second.str();
 }
 
 /// Given the original \p Path to an output file, replace any path
 /// prefix matching \p OldPrefix with \p NewPrefix. Also, create the
for (auto &ModPath : Index.modulePaths()) {
     InputBuffers.push_back(std::move(*InputOrErr));
   }
   return InputBuffers;
 }
 
 std::unique_ptr<ModuleSummaryIndex> loadCombinedIndex() {
   if (ThinLTOIndex.empty())
     report_fatal_error("Missing -thinlto-index for ThinLTO promotion stage");
-  ExitOnError ExitOnErr("llvm-lto: error loading file '" + ThinLTOIndex +
+  ExitOnError ExitOnErr("llvm-lto: error loading file '" + *ThinLTOIndex +
                         "': ");
   return ExitOnErr(getModuleSummaryIndexForFile(ThinLTOIndex));
 }
 
 static std::unique_ptr<Module> loadModule(StringRef Filename,
                                           LLVMContext &Ctx) {
   SMDiagnostic Err;
   std::unique_ptr<Module> M(parseIRFile(Filename, Err, Ctx));
int main(int argc, char **argv) {
   for (unsigned i = 0; i < ExportedSymbols.size(); ++i)
     CodeGen.addMustPreserveSymbol(ExportedSymbols[i]);
 
   // Add all the dso symbols to the table of symbols to expose.
   for (unsigned i = 0; i < KeptDSOSyms.size(); ++i)
     CodeGen.addMustPreserveSymbol(KeptDSOSyms[i]);
 
   // Set cpu and attrs strings for the default target/subtarget.
-  CodeGen.setCpu(MCPU.c_str());
+  CodeGen.setCpu(MCPU->c_str());
 
   CodeGen.setOptLevel(OptLevel - '0');
 
   std::string attrs;
   for (unsigned i = 0; i < MAttrs.size(); ++i) {
     if (i > 0)
       attrs.append(",");
     attrs.append(MAttrs[i]);

tools/llvm-lto2/llvm-lto2.cpp

static int run(int argc, char **argv) {
   Conf.MAttrs = MAttrs;
   if (auto RM = getRelocModel())
     Conf.RelocModel = *RM;
   Conf.CodeModel = getCodeModel();
 
   Conf.DebugPassManager = DebugPassManager;
 
   if (SaveTemps)
-    check(Conf.addSaveTemps(OutputFilename + "."),
+    check(Conf.addSaveTemps(*OutputFilename + "."),
           "Config::addSaveTemps failed");
 
   // Optimization remarks.
   Conf.RemarksFilename = OptRemarksOutput;
   Conf.RemarksWithHotness = OptRemarksWithHotness;
 
   Conf.SampleProfile = SamplePGOFile;
 
for (auto UnusedRes : CommandLineResolutions)
                    << UnusedRes.first.first << ',' << UnusedRes.first.second
                    << '\n';
   }
   if (HasErrors)
     return 1;
 
   auto AddStream =
       [&](size_t Task) -> std::unique_ptr<lto::NativeObjectStream> {
-    std::string Path = OutputFilename + "." + utostr(Task);
+    std::string Path = *OutputFilename + "." + utostr(Task);
 
     std::error_code EC;
     auto S = llvm::make_unique<raw_fd_ostream>(Path, EC, sys::fs::F_None);
     check(EC, Path);
     return llvm::make_unique<lto::NativeObjectStream>(std::move(S));
   };
 
   auto AddBuffer = [&](size_t Task, std::unique_ptr<MemoryBuffer> MB) {

tools/llvm-mc/llvm-mc.cpp

int main(int argc, char **argv) {
   setDwarfDebugProducer();
 
   const char *ProgName = argv[0];
   const Target *TheTarget = GetTarget(ProgName);
   if (!TheTarget)
     return 1;
   // Now that GetTarget() has (potentially) replaced TripleName, it's safe to
   // construct the Triple object.
-  Triple TheTriple(TripleName);
+  Triple TheTriple(*TripleName);
 
   ErrorOr<std::unique_ptr<MemoryBuffer>> BufferPtr =
-      MemoryBuffer::getFileOrSTDIN(InputFilename);
+      MemoryBuffer::getFileOrSTDIN(*InputFilename);
   if (std::error_code EC = BufferPtr.getError()) {
     WithColor::error(errs(), ProgName)
-        << InputFilename << ": " << EC.message() << '\n';
+        << *InputFilename << ": " << EC.message() << '\n';
     return 1;
   }
   MemoryBuffer *Buffer = BufferPtr->get();
 
   SourceMgr SrcMgr;
 
   // Tell SrcMgr about this buffer, which is what the parser will pick up.
   SrcMgr.AddNewSourceBuffer(std::move(*BufferPtr), SMLoc());
int main(int argc, char **argv) {
   std::unique_ptr<MCStreamer> Str;
 
   std::unique_ptr<MCInstrInfo> MCII(TheTarget->createMCInstrInfo());
   std::unique_ptr<MCSubtargetInfo> STI(
       TheTarget->createMCSubtargetInfo(TripleName, MCPU, FeaturesStr));
 
   MCInstPrinter *IP = nullptr;
   if (FileType == OFT_AssemblyFile) {
-    IP = TheTarget->createMCInstPrinter(Triple(TripleName), OutputAsmVariant,
+    IP = TheTarget->createMCInstPrinter(Triple(*TripleName), OutputAsmVariant,
                                         *MAI, *MCII, *MRI);
 
     if (!IP) {
       WithColor::error()
           << "unable to create instruction printer for target triple '"
           << TheTriple.normalize() << "' with assembly variant "
           << OutputAsmVariant << ".\n";
       return 1;

tools/llvm-mca/llvm-mca.cpp

EnableAllViews("all-views",
                    cl::desc("Print all views including hardware statistics"),
                    cl::cat(ViewOptions), cl::init(false));
 
 namespace {
 
 const Target *getTarget(const char *ProgName) {
   if (TripleName.empty())
     TripleName = Triple::normalize(sys::getDefaultTargetTriple());
-  Triple TheTriple(TripleName);
+  Triple TheTriple(*TripleName);
 
   // Get the target specific parser.
   std::string Error;
   const Target *TheTarget =
       TargetRegistry::lookupTarget(ArchName, TheTriple, Error);
   if (!TheTarget) {
     errs() << ProgName << ": " << Error;
     return nullptr;
int main(int argc, char **argv) {
   // registered target, then exit with an error message.
   const char *ProgName = argv[0];
   const Target *TheTarget = getTarget(ProgName);
   if (!TheTarget)
     return 1;
 
   // GetTarget() may replaced TripleName with a default triple.
   // For safety, reconstruct the Triple object.
-  Triple TheTriple(TripleName);
+  Triple TheTriple(*TripleName);
 
   ErrorOr<std::unique_ptr<MemoryBuffer>> BufferPtr =
-      MemoryBuffer::getFileOrSTDIN(InputFilename);
+      MemoryBuffer::getFileOrSTDIN(*InputFilename);
   if (std::error_code EC = BufferPtr.getError()) {
-    WithColor::error() << InputFilename << ": " << EC.message() << '\n';
+    WithColor::error() << *InputFilename << ": " << EC.message() << '\n';
     return 1;
   }
 
   // Apply overrides to llvm-mca specific options.
   processViewOptions();
 
   SourceMgr SrcMgr;
 
int main(int argc, char **argv) {
   mca::CodeRegions Regions(SrcMgr);
   MCStreamerWrapper Str(Ctx, Regions);
 
   std::unique_ptr<MCInstrInfo> MCII(TheTarget->createMCInstrInfo());
 
   std::unique_ptr<MCInstrAnalysis> MCIA(
       TheTarget->createMCInstrAnalysis(MCII.get()));
 
-  if (!MCPU.compare("native"))
+  if (!MCPU->compare("native"))
     MCPU = llvm::sys::getHostCPUName();
 
   std::unique_ptr<MCSubtargetInfo> STI(
       TheTarget->createMCSubtargetInfo(TripleName, MCPU, /* FeaturesStr */ ""));
   if (!STI->isCPUStringValid(MCPU))
     return 1;
 
   if (!PrintInstructionTables && !STI->getSchedModel().isOutOfOrder()) {
-    WithColor::error() << "please specify an out-of-order cpu. '" << MCPU
+    WithColor::error() << "please specify an out-of-order cpu. '" << *MCPU
                        << "' is an in-order cpu.\n";
     return 1;
   }
 
   if (!STI->getSchedModel().hasInstrSchedModel()) {
     WithColor::error()
         << "unable to find instruction-level scheduling information for"
-        << " target triple '" << TheTriple.normalize() << "' and cpu '" << MCPU
+        << " target triple '" << TheTriple.normalize() << "' and cpu '" << *MCPU
         << "'.\n";
 
     if (STI->getSchedModel().InstrItineraries)
       WithColor::note()
-          << "cpu '" << MCPU << "' provides itineraries. However, "
+          << "cpu '" << *MCPU << "' provides itineraries. However, "
           << "instruction itineraries are currently unsupported.\n";
     return 1;
   }
 
   std::unique_ptr<MCAsmParser> P(createMCAsmParser(SrcMgr, Ctx, Str, *MAI));
   MCAsmLexer &Lexer = P->getLexer();
   MCACommentConsumer CC(Regions);
   Lexer.setCommentConsumer(&CC);
if (std::error_code EC = OF.getError()) {
     WithColor::error() << EC.message() << '\n';
     return 1;
   }
 
   unsigned AssemblerDialect = P->getAssemblerDialect();
   if (OutputAsmVariant >= 0)
     AssemblerDialect = static_cast<unsigned>(OutputAsmVariant);
   std::unique_ptr<MCInstPrinter> IP(TheTarget->createMCInstPrinter(
-      Triple(TripleName), AssemblerDialect, *MAI, *MCII, *MRI));
+      Triple(*TripleName), AssemblerDialect, *MAI, *MCII, *MRI));
   if (!IP) {
     WithColor::error()
         << "unable to create instruction printer for target triple '"
         << TheTriple.normalize() << "' with assembly variant "
         << AssemblerDialect << ".\n";
     return 1;
   }
 

tools/llvm-modextract/llvm-modextract.cpp

static cl::opt<unsigned> ModuleIndex("n", cl::Required,
                                      cl::value_desc("index"));
 
 int main(int argc, char **argv) {
   cl::ParseCommandLineOptions(argc, argv, "Module extractor");
 
   ExitOnError ExitOnErr("llvm-modextract: error: ");
 
   std::unique_ptr<MemoryBuffer> MB =
-      ExitOnErr(errorOrToExpected(MemoryBuffer::getFileOrSTDIN(InputFilename)));
+      ExitOnErr(errorOrToExpected(MemoryBuffer::getFileOrSTDIN(*InputFilename)));
   std::vector<BitcodeModule> Ms = ExitOnErr(getBitcodeModuleList(*MB));
 
   LLVMContext Context;
   if (ModuleIndex >= Ms.size()) {
     errs() << "llvm-modextract: error: module index out of range; bitcode file "
               "contains "
            << Ms.size() << " module(s)\n";
     return 1;

tools/llvm-objdump/MachODump.cpp

 bool ArchAll = false;
 
 static std::string ThumbTripleName;
 
 static const Target *GetTarget(const MachOObjectFile *MachOObj,
                                const char **McpuDefault,
                                const Target **ThumbTarget) {
   // Figure out the target triple.
-  llvm::Triple TT(TripleName);
+  llvm::Triple TT(*TripleName);
   if (TripleName.empty()) {
     TT = MachOObj->getArchTriple(McpuDefault);
     TripleName = TT.str();
   }
 
   if (TT.getArch() == Triple::arm) {
     // We've inferred a 32-bit ARM target from the object file. All MachO CPUs
     // that support ARM are also capable of Thumb mode.
if (TheTarget && ThumbTripleName.empty())
     return TheTarget;
 
   *ThumbTarget = TargetRegistry::lookupTarget(ThumbTripleName, Error);
   if (*ThumbTarget)
     return TheTarget;
 
   errs() << "llvm-objdump: error: unable to get target for '";
   if (!TheTarget)
-    errs() << TripleName;
+    errs() << *TripleName;
   else
     errs() << ThumbTripleName;
   errs() << "', see --version and --triple.\n";
   return nullptr;
 }
 
 struct SymbolSorter {
   bool operator()(const SymbolRef &A, const SymbolRef &B) {
static void DisassembleMachO(StringRef Filename, MachOObjectFile *MachOOF,
   if (RelInfo) {
     Symbolizer.reset(TheTarget->createMCSymbolizer(
         TripleName, SymbolizerGetOpInfo, SymbolizerSymbolLookUp,
         &SymbolizerInfo, &Ctx, std::move(RelInfo)));
     DisAsm->setSymbolizer(std::move(Symbolizer));
   }
   int AsmPrinterVariant = AsmInfo->getAssemblerDialect();
   std::unique_ptr<MCInstPrinter> IP(TheTarget->createMCInstPrinter(
-      Triple(TripleName), AsmPrinterVariant, *AsmInfo, *InstrInfo, *MRI));
+      Triple(*TripleName), AsmPrinterVariant, *AsmInfo, *InstrInfo, *MRI));
   // Set the display preference for hex vs. decimal immediates.
   IP->setPrintImmHex(PrintImmHex);
   // Comment stream and backing vector.
   SmallString<128> CommentsToEmit;
   raw_svector_ostream CommentStream(CommentsToEmit);
   // FIXME: Setting the CommentStream in the InstPrinter is problematic in that
   // if it is done then arm64 comments for string literals don't get printed
   // and some constant get printed instead and not setting it causes intel
   // (32-bit and 64-bit) comments printed with different spacing before the
   // comment causing different diffs with the 'C' disassembler library API.
   // IP->setCommentStream(CommentStream);
 
   if (!AsmInfo || !STI || !DisAsm || !IP) {
     errs() << "error: couldn't initialize disassembler for target "
-           << TripleName << '\n';
+           << *TripleName << '\n';
     return;
   }
 
   // Set up separate thumb disassembler if needed.
   std::unique_ptr<const MCRegisterInfo> ThumbMRI;
   std::unique_ptr<const MCAsmInfo> ThumbAsmInfo;
   std::unique_ptr<const MCSubtargetInfo> ThumbSTI;
   std::unique_ptr<MCDisassembler> ThumbDisAsm;
#endif
   ObjectFile *DbgObj = MachOOF;
   std::unique_ptr<MemoryBuffer> DSYMBuf;
   // Try to find debug info and set up the DIContext for it.
   if (UseDbg) {
     // A separate DSym file path was specified, parse it as a macho file,
     // get the sections and supply it to the section name parsing machinery.
     if (!DSYMFile.empty()) {
       ErrorOr<std::unique_ptr<MemoryBuffer>> BufOrErr =
-          MemoryBuffer::getFileOrSTDIN(DSYMFile);
+          MemoryBuffer::getFileOrSTDIN(*DSYMFile);
       if (std::error_code EC = BufOrErr.getError()) {
         errs() << "llvm-objdump: " << Filename << ": " << EC.message() << '\n';
         return;
       }
       Expected<std::unique_ptr<MachOObjectFile>> DbgObjCheck =
           ObjectFile::createMachOObjectFile(BufOrErr.get()->getMemBufferRef());
 
       if (DbgObjCheck.takeError())
for (const SymbolRef &Symbol : MachOOF->symbols()) {
           report_error(MachOOF->getFileName(), SymNameOrErr.takeError());
         StringRef SymName = *SymNameOrErr;
         AddrMap[Address] = SymName;
         if (!DisSymName.empty() && DisSymName == SymName)
           DisSymNameFound = true;
       }
     }
     if (!DisSymName.empty() && !DisSymNameFound) {
-      outs() << "Can't find -dis-symname: " << DisSymName << "\n";
+      outs() << "Can't find -dis-symname: " << *DisSymName << "\n";
       return;
     }
     // Set up the block of info used by the Symbolizer call backs.
     SymbolizerInfo.verbose = !NoSymbolicOperands;
     SymbolizerInfo.O = MachOOF;
     SymbolizerInfo.S = Sections[SectIdx];
     SymbolizerInfo.AddrMap = &AddrMap;
     SymbolizerInfo.Sections = &Sections;
for (unsigned SymIdx = 0; SymIdx != Symbols.size(); SymIdx++) {
       SymbolRef::Type ST = *STOrErr;
       if (ST != SymbolRef::ST_Function && ST != SymbolRef::ST_Data)
         continue;
 
       // Make sure the symbol is defined in this section.
       bool containsSym = Sections[SectIdx].containsSymbol(Symbols[SymIdx]);
       if (!containsSym) {
         if (!DisSymName.empty() && DisSymName == SymName) {
-          outs() << "-dis-symname: " << DisSymName << " not in the section\n";
+          outs() << "-dis-symname: " << *DisSymName << " not in the section\n";
           return;
         }
         continue;
       }
       // The __mh_execute_header is special and we need to deal with that fact
       // this symbol is before the start of the (__TEXT,__text) section and at the
       // address of the start of the __TEXT segment.  This is because this symbol
       // is an N_SECT symbol in the (__TEXT,__text) but its address is before the

tools/llvm-objdump/llvm-objdump.cpp

report_error(Obj->getFileName(), "no subtarget info for target " +
                  TripleName);
   std::unique_ptr<const MCInstrInfo> MII(TheTarget->createMCInstrInfo());
   if (!MII)
     report_error(Obj->getFileName(), "no instruction info for target " +
                  TripleName);
   MCObjectFileInfo MOFI;
   MCContext Ctx(AsmInfo.get(), MRI.get(), &MOFI);
   // FIXME: for now initialize MCObjectFileInfo with default values
-  MOFI.InitMCObjectFileInfo(Triple(TripleName), false, Ctx);
+  MOFI.InitMCObjectFileInfo(Triple(*TripleName), false, Ctx);
 
   std::unique_ptr<MCDisassembler> DisAsm(
     TheTarget->createMCDisassembler(*STI, Ctx));
   if (!DisAsm)
     report_error(Obj->getFileName(), "no disassembler for target " +
-                 TripleName);
+                 *TripleName);
 
   std::unique_ptr<const MCInstrAnalysis> MIA(
       TheTarget->createMCInstrAnalysis(MII.get()));
 
   int AsmPrinterVariant = AsmInfo->getAssemblerDialect();
   std::unique_ptr<MCInstPrinter> IP(TheTarget->createMCInstPrinter(
-      Triple(TripleName), AsmPrinterVariant, *AsmInfo, *MII, *MRI));
+      Triple(*TripleName), AsmPrinterVariant, *AsmInfo, *MII, *MRI));
   if (!IP)
     report_error(Obj->getFileName(), "no instruction printer for target " +
                  TripleName);
   IP->setPrintImmHex(PrintImmHex);
-  PrettyPrinter &PIP = selectPrettyPrinter(Triple(TripleName));
+  PrettyPrinter &PIP = selectPrettyPrinter(Triple(*TripleName));
 
   StringRef Fmt = Obj->getBytesInAddress() > 4 ? "\t\t%016" PRIx64 ":  " :
                                                  "\t\t\t%08" PRIx64 ":  ";
 
   SourcePrinter SP(Obj, TheTarget->getName());
 
   // Create a mapping, RelocSecs = SectionRelocMap[S], where sections
   // in RelocSecs contain the relocations for section S.

tools/llvm-opt-report/OptReport.cpp

if (Pass == "inline") {
       LI.InterleaveCount = InterleaveCount;
       UpdateLLII(LI.Vectorized);
     }
   }
 }
 
 static bool readLocationInfo(LocationInfoTy &LocationInfo) {
   ErrorOr<std::unique_ptr<MemoryBuffer>> Buf =
-      MemoryBuffer::getFileOrSTDIN(InputFileName);
+      MemoryBuffer::getFileOrSTDIN(*InputFileName);
   if (std::error_code EC = Buf.getError()) {
-    WithColor::error() << "Can't open file " << InputFileName << ": "
+    WithColor::error() << "Can't open file " << *InputFileName << ": "
                        << EC.message() << "\n";
     return false;
   }
 
   SourceMgr SM;
   yaml::Stream Stream(Buf.get()->getBuffer(), SM);
   collectLocationInfo(Stream, LocationInfo);
 
   return true;
 }
 
 static bool writeReport(LocationInfoTy &LocationInfo) {
   std::error_code EC;
   llvm::raw_fd_ostream OS(OutputFileName, EC,
               llvm::sys::fs::F_Text);
   if (EC) {
-    WithColor::error() << "Can't open file " << OutputFileName << ": "
+    WithColor::error() << "Can't open file " << *OutputFileName << ": "
                        << EC.message() << "\n";
     return false;
   }
 
   bool FirstFile = true;
   for (auto &FI : LocationInfo) {
     SmallString<128> FileName(FI.first);
     if (!InputRelDir.empty()) {
-      if (std::error_code EC = sys::fs::make_absolute(InputRelDir, FileName)) {
+      if (std::error_code EC = sys::fs::make_absolute(*InputRelDir, FileName)) {
         WithColor::error() << "Can't resolve file path to " << FileName << ": "
                            << EC.message() << "\n";
         return false;
       }
     }
 
     const auto &FileInfo = FI.second;
 

tools/llvm-pdbutil/llvm-pdbutil.cpp

if (to_integer(opts::exportstream::Stream, Index)) {
       outs() << "Dumping contents of stream index " << Index << " to file "
              << OutFileName << ".\n";
     }
   }
 
   if (!Success) {
     InfoStream &IS = cantFail(File.getPDBInfoStream());
     Index = ExitOnErr(IS.getNamedStreamIndex(opts::exportstream::Stream));
-    outs() << "Dumping contents of stream '" << opts::exportstream::Stream
+    outs() << "Dumping contents of stream '" << *opts::exportstream::Stream
            << "' (index " << Index << ") to file " << OutFileName << ".\n";
   }
 
   SourceStream = MappedBlockStream::createIndexedStream(
       File.getMsfLayout(), File.getMsfBuffer(), Index, File.getAllocator());
   auto OutFile = ExitOnErr(
       FileOutputBuffer::create(OutFileName, SourceStream->getLength()));
   FileBufferByteStream DestStream(std::move(OutFile), llvm::support::little);
int main(int Argc, const char **Argv) {
   InitLLVM X(Argc, Argv);
   ExitOnErr.setBanner("llvm-pdbutil: ");
 
   cl::ParseCommandLineOptions(Argc, Argv, "LLVM PDB Dumper\n");
 
   if (opts::BytesSubcommand) {
     if (!parseRange(opts::bytes::DumpBlockRangeOpt,
                     opts::bytes::DumpBlockRange)) {
-      errs() << "Argument '" << opts::bytes::DumpBlockRangeOpt
+      errs() << "Argument '" << *opts::bytes::DumpBlockRangeOpt
              << "' invalid format.\n";
       errs().flush();
       exit(1);
     }
     if (!parseRange(opts::bytes::DumpByteRangeOpt,
                     opts::bytes::DumpByteRange)) {
-      errs() << "Argument '" << opts::bytes::DumpByteRangeOpt
+      errs() << "Argument '" << *opts::bytes::DumpByteRangeOpt
              << "' invalid format.\n";
       errs().flush();
       exit(1);
     }
   }
 
   if (opts::DumpSubcommand) {
     if (opts::dump::RawAll) {

tools/llvm-profdata/llvm-profdata.cpp

cl::opt<uint32_t> TopNFunctions(
       cl::desc("Show the list of functions with the largest internal counts"));
 
   cl::ParseCommandLineOptions(argc, argv, "LLVM profile data summary\n");
 
   if (OutputFilename.empty())
     OutputFilename = "-";
 
   std::error_code EC;
-  raw_fd_ostream OS(OutputFilename.data(), EC, sys::fs::F_Text);
+  raw_fd_ostream OS(OutputFilename->data(), EC, sys::fs::F_Text);
   if (EC)
     exitWithErrorCode(EC, OutputFilename);
 
   if (ShowAllFunctions && !ShowFunction.empty())
     WithColor::warning() << "-function argument ignored: showing all functions\n";
 
   std::vector<uint32_t> Cutoffs(DetailedSummaryCutoffs.begin(),
                                 DetailedSummaryCutoffs.end());

tools/llvm-rtdyld/llvm-rtdyld.cpp

for (auto &FM : MemMgr.FunctionMemory) {
     if (auto EC = sys::Memory::protectMappedMemory(FM,
                                                    sys::Memory::MF_READ |
                                                    sys::Memory::MF_EXEC))
       ErrorAndExit("unable to mark function executable: '" + EC.message() +
                    "'");
   }
 
   // Dispatch to _main().
-  errs() << "loaded '" << EntryPoint << "' at: " << (void*)MainAddress << "\n";
+  errs() << "loaded '" << *EntryPoint << "' at: " << (void*)MainAddress << "\n";
 
   int (*Main)(int, const char**) =
     (int(*)(int,const char**)) uintptr_t(MainAddress);
   const char **Argv = new const char*[2];
   // Use the name of the first input object module as argv[0] for the target.
   Argv[0] = InputFileList[0].c_str();
   Argv[1] = nullptr;
   return Main(1, Argv);
static int linkAndVerify() {
   std::unique_ptr<MCDisassembler> Disassembler(
     TheTarget->createMCDisassembler(*STI, Ctx));
   if (!Disassembler)
     ErrorAndExit("Unable to create disassembler!");
 
   std::unique_ptr<MCInstrInfo> MII(TheTarget->createMCInstrInfo());
 
   std::unique_ptr<MCInstPrinter> InstPrinter(
-      TheTarget->createMCInstPrinter(Triple(TripleName), 0, *MAI, *MII, *MRI));
+      TheTarget->createMCInstPrinter(Triple(*TripleName), 0, *MAI, *MII, *MRI));
 
   // Load any dylibs requested on the command line.
   loadDylibs();
 
   // Instantiate a dynamic linker.
   TrivialMemoryManager MemMgr;
   doPreallocation(MemMgr);
   RuntimeDyld Dyld(MemMgr, MemMgr);

tools/llvm-split/llvm-split.cpp

if (!M) {
     Err.print(argv[0], errs());
     return 1;
   }
 
   unsigned I = 0;
   SplitModule(std::move(M), NumOutputs, [&](std::unique_ptr<Module> MPart) {
     std::error_code EC;
     std::unique_ptr<ToolOutputFile> Out(
-        new ToolOutputFile(OutputFilename + utostr(I++), EC, sys::fs::F_None));
+        new ToolOutputFile(*OutputFilename + utostr(I++), EC, sys::fs::F_None));
     if (EC) {
       errs() << EC.message() << '\n';
       exit(1);
     }
 
     verifyModule(*MPart);
     WriteBitcodeToFile(*MPart, Out->os());
 
     // Declare success.
     Out->keep();
   }, PreserveLocals);
 
   return 0;
 }

tools/llvm-xray/xray-account.cpp

 
 static CommandRegistration Unused(&Account, []() -> Error {
   InstrumentationMap Map;
   if (!AccountInstrMap.empty()) {
     auto InstrumentationMapOrError = loadInstrumentationMap(AccountInstrMap);
     if (!InstrumentationMapOrError)
       return joinErrors(make_error<StringError>(
                             Twine("Cannot open instrumentation map '") +
-                                AccountInstrMap + "'",
+                                *AccountInstrMap + "'",
                             std::make_error_code(std::errc::invalid_argument)),
                         InstrumentationMapOrError.takeError());
     Map = std::move(*InstrumentationMapOrError);
   }
 
   std::error_code EC;
   raw_fd_ostream OS(AccountOutput, EC, sys::fs::OpenFlags::F_Text);
   if (EC)
     return make_error<StringError>(
-        Twine("Cannot open file '") + AccountOutput + "' for writing.", EC);
+        Twine("Cannot open file '") + *AccountOutput + "' for writing.", EC);
 
   const auto &FunctionAddresses = Map.getFunctionAddresses();
   symbolize::LLVMSymbolizer::Options Opts(
       symbolize::FunctionNameKind::LinkageName, true, true, false, "");
   symbolize::LLVMSymbolizer Symbolizer(Opts);
   llvm::xray::FuncIdConversionHelper FuncIdHelper(AccountInstrMap, Symbolizer,
                                                   FunctionAddresses);
   xray::LatencyAccountant FCA(FuncIdHelper, AccountDeduceSiblingCalls);
   auto TraceOrErr = loadTraceFile(AccountInput);
   if (!TraceOrErr)
     return joinErrors(
         make_error<StringError>(
-            Twine("Failed loading input file '") + AccountInput + "'",
+            Twine("Failed loading input file '") + *AccountInput + "'",
             std::make_error_code(std::errc::executable_format_error)),
         TraceOrErr.takeError());
 
   auto &T = *TraceOrErr;
   for (const auto &Record : T) {
     if (FCA.accountRecord(Record))
       continue;
     errs()
for (const auto &ThreadStack : FCA.getPerThreadFunctionStack()) {
       }
       auto Level = ThreadStack.second.size();
       for (const auto &Entry : llvm::reverse(ThreadStack.second))
         errs() << "  #" << Level-- << "\t"
                << FuncIdHelper.SymbolOrNumber(Entry.first) << '\n';
     }
     if (!AccountKeepGoing)
       return make_error<StringError>(
-          Twine("Failed accounting function calls in file '") + AccountInput +
+          Twine("Failed accounting function calls in file '") + *AccountInput +
               "'.",
           std::make_error_code(std::errc::executable_format_error));
   }
   switch (AccountOutputFormat) {
   case AccountOutputFormats::TEXT:
     FCA.exportStatsAsText(OS, T.getFileHeader());
     break;
   case AccountOutputFormats::CSV:
     FCA.exportStatsAsCSV(OS, T.getFileHeader());
     break;
   }
 
   return Error::success();
 });

tools/llvm-xray/xray-converter.cpp

 static CommandRegistration Unused(&Convert, []() -> Error {
   // FIXME: Support conversion to BINARY when upgrading XRay trace versions.
   InstrumentationMap Map;
   if (!ConvertInstrMap.empty()) {
     auto InstrumentationMapOrError = loadInstrumentationMap(ConvertInstrMap);
     if (!InstrumentationMapOrError)
       return joinErrors(make_error<StringError>(
                             Twine("Cannot open instrumentation map '") +
-                                ConvertInstrMap + "'",
+                                *ConvertInstrMap + "'",
                             std::make_error_code(std::errc::invalid_argument)),
                         InstrumentationMapOrError.takeError());
     Map = std::move(*InstrumentationMapOrError);
   }
 
   const auto &FunctionAddresses = Map.getFunctionAddresses();
   symbolize::LLVMSymbolizer::Options Opts(
       symbolize::FunctionNameKind::LinkageName, true, true, false, "");
   symbolize::LLVMSymbolizer Symbolizer(Opts);
   llvm::xray::FuncIdConversionHelper FuncIdHelper(ConvertInstrMap, Symbolizer,
                                                   FunctionAddresses);
   llvm::xray::TraceConverter TC(FuncIdHelper, ConvertSymbolize);
   std::error_code EC;
   raw_fd_ostream OS(ConvertOutput, EC,
                     ConvertOutputFormat == ConvertFormats::BINARY
                         ? sys::fs::OpenFlags::F_None
                         : sys::fs::OpenFlags::F_Text);
   if (EC)
     return make_error<StringError>(
-        Twine("Cannot open file '") + ConvertOutput + "' for writing.", EC);
+        Twine("Cannot open file '") + *ConvertOutput + "' for writing.", EC);
 
   auto TraceOrErr = loadTraceFile(ConvertInput, ConvertSortInput);
   if (!TraceOrErr)
     return joinErrors(
         make_error<StringError>(
-            Twine("Failed loading input file '") + ConvertInput + "'.",
+            Twine("Failed loading input file '") + *ConvertInput + "'.",
             std::make_error_code(std::errc::executable_format_error)),
         TraceOrErr.takeError());
 
   auto &T = *TraceOrErr;
   switch (ConvertOutputFormat) {
   case ConvertFormats::YAML:
     TC.exportAsYAML(T, OS);
     break;

tools/llvm-xray/xray-extract.cpp

 
 } // namespace
 
 static CommandRegistration Unused(&Extract, []() -> Error {
   auto InstrumentationMapOrError = loadInstrumentationMap(ExtractInput);
   if (!InstrumentationMapOrError)
     return joinErrors(make_error<StringError>(
                           Twine("Cannot extract instrumentation map from '") +
-                              ExtractInput + "'.",
+                              *ExtractInput + "'.",
                           std::make_error_code(std::errc::invalid_argument)),
                       InstrumentationMapOrError.takeError());
 
   std::error_code EC;
   raw_fd_ostream OS(ExtractOutput, EC, sys::fs::OpenFlags::F_Text);
   if (EC)
     return make_error<StringError>(
-        Twine("Cannot open file '") + ExtractOutput + "' for writing.", EC);
+        Twine("Cannot open file '") + *ExtractOutput + "' for writing.", EC);
   const auto &FunctionAddresses =
       InstrumentationMapOrError->getFunctionAddresses();
   symbolize::LLVMSymbolizer::Options Opts(
       symbolize::FunctionNameKind::LinkageName, true, true, false, "");
   symbolize::LLVMSymbolizer Symbolizer(Opts);
   llvm::xray::FuncIdConversionHelper FuncIdHelper(ExtractInput, Symbolizer,
                                                   FunctionAddresses);
   exportAsYAML(*InstrumentationMapOrError, OS, FuncIdHelper);
   return Error::success();
 });

tools/llvm-xray/xray-fdr-dump.cpp

static cl::opt<std::string> DumpInput(cl::Positional,
                                       cl::Required, cl::sub(Dump));
 static cl::opt<bool> DumpVerify("verify",
                                 cl::desc("verify structure of the log"),
                                 cl::init(false), cl::sub(Dump));
 
 static CommandRegistration Unused(&Dump, []() -> Error {
   // Open the file provided.
   int Fd;
-  if (auto EC = sys::fs::openFileForRead(DumpInput, Fd))
+  if (auto EC = sys::fs::openFileForRead(*DumpInput, Fd))
     return createStringError(EC, "Cannot open file '%s' for read.",
-                             DumpInput.c_str());
+                             DumpInput->c_str());
 
   uint64_t FileSize;
-  if (auto EC = sys::fs::file_size(DumpInput, FileSize))
+  if (auto EC = sys::fs::file_size(*DumpInput, FileSize))
     return createStringError(EC, "Failed to get file size for '%s'.",
-                             DumpInput.c_str());
+                             DumpInput->c_str());
 
   std::error_code EC;
   sys::fs::mapped_file_region MappedFile(
       Fd, sys::fs::mapped_file_region::mapmode::readonly, FileSize, 0, EC);
 
   DataExtractor DE(StringRef(MappedFile.data(), MappedFile.size()), true, 8);
   uint32_t OffsetPtr = 0;
 

tools/llvm-xray/xray-graph-diff.cpp

if (!GDROrErr)
     return GDROrErr.takeError();
 
   auto &GDR = *GDROrErr;
 
   std::error_code EC;
   raw_fd_ostream OS(GraphDiffOutput, EC, sys::fs::OpenFlags::F_Text);
   if (EC)
     return make_error<StringError>(
-        Twine("Cannot open file '") + GraphDiffOutput + "' for writing.", EC);
+        Twine("Cannot open file '") + *GraphDiffOutput + "' for writing.", EC);
 
   GDR.exportGraphAsDOT(OS, GraphDiffEdgeLabel, GraphDiffEdgeColor,
                        GraphDiffVertexLabel, GraphDiffVertexColor,
                        GraphDiffVertexLabelTrunc);
 
   return Error::success();
 });

tools/llvm-xray/xray-graph.cpp

 
 Expected<GraphRenderer> GraphRenderer::Factory::getGraphRenderer() {
   InstrumentationMap Map;
   if (!GraphInstrMap.empty()) {
     auto InstrumentationMapOrError = loadInstrumentationMap(GraphInstrMap);
     if (!InstrumentationMapOrError)
       return joinErrors(
           make_error<StringError>(
-              Twine("Cannot open instrumentation map '") + GraphInstrMap + "'",
+              Twine("Cannot open instrumentation map '") + *GraphInstrMap + "'",
               std::make_error_code(std::errc::invalid_argument)),
           InstrumentationMapOrError.takeError());
     Map = std::move(*InstrumentationMapOrError);
   }
 
   const auto &FunctionAddresses = Map.getFunctionAddresses();
 
   symbolize::LLVMSymbolizer::Options Opts(
static CommandRegistration Unused(&GraphC, []() -> Error {
   F.KeepGoing = GraphKeepGoing;
   F.DeduceSiblingCalls = GraphDeduceSiblingCalls;
   F.InstrMap = GraphInstrMap;
 
   auto TraceOrErr = loadTraceFile(GraphInput, true);
 
   if (!TraceOrErr)
     return make_error<StringError>(
-        Twine("Failed loading input file '") + GraphInput + "'",
+        Twine("Failed loading input file '") + *GraphInput + "'",
         make_error_code(llvm::errc::invalid_argument));
 
   F.Trace = std::move(*TraceOrErr);
   auto GROrError = F.getGraphRenderer();
   if (!GROrError)
     return GROrError.takeError();
   auto &GR = *GROrError;
 
   std::error_code EC;
   raw_fd_ostream OS(GraphOutput, EC, sys::fs::OpenFlags::F_Text);
   if (EC)
     return make_error<StringError>(
-        Twine("Cannot open file '") + GraphOutput + "' for writing.", EC);
+        Twine("Cannot open file '") + *GraphOutput + "' for writing.", EC);
 
   GR.exportGraphAsDOT(OS, GraphEdgeLabel, GraphEdgeColorType, GraphVertexLabel,
                       GraphVertexColorType);
   return Error::success();
 });

tools/llvm-xray/xray-stacks.cpp

static CommandRegistration Unused(&Stack, []() -> Error {
   // account to a single StackTrie, and just print the whole trie for now.
   StackTrie ST;
   InstrumentationMap Map;
   if (!StacksInstrMap.empty()) {
     auto InstrumentationMapOrError = loadInstrumentationMap(StacksInstrMap);
     if (!InstrumentationMapOrError)
       return joinErrors(
           make_error<StringError>(
-              Twine("Cannot open instrumentation map: ") + StacksInstrMap,
+              Twine("Cannot open instrumentation map: ") + *StacksInstrMap,
               std::make_error_code(std::errc::invalid_argument)),
           InstrumentationMapOrError.takeError());
     Map = std::move(*InstrumentationMapOrError);
   }
 
   if (SeparateThreadStacks && AggregateThreads)
     return make_error<StringError>(
         Twine("Can't specify options for per thread reporting and reporting "

tools/opt/opt.cpp

#endif
   // If we are supposed to override the target triple or data layout, do so now.
   if (!TargetTriple.empty())
     M->setTargetTriple(Triple::normalize(TargetTriple));
 
   // Immediately run the verifier to catch any problems before starting up the
   // pass pipelines.  Otherwise we can crash on broken code during
   // doInitialization().
   if (!NoVerify && verifyModule(*M, &errs())) {
-    errs() << argv[0] << ": " << InputFilename
+    errs() << argv[0] << ": " << *InputFilename
            << ": error: input module is broken!\n";
     return 1;
   }
 
   // Figure out what stream we are supposed to write to...
   std::unique_ptr<ToolOutputFile> Out;
   std::unique_ptr<ToolOutputFile> ThinLinkOut;
   if (NoOutput) {

tools/sancov/sancov.cpp

 // ---------- MAIN FUNCTIONALITY ----------
 
 std::string stripPathPrefix(std::string Path) {
   if (ClStripPathPrefix.empty())
     return Path;
   size_t Pos = Path.find(ClStripPathPrefix);
   if (Pos == std::string::npos)
     return Path;
-  return Path.substr(Pos + ClStripPathPrefix.size());
+  return Path.substr(Pos + ClStripPathPrefix->size());
 }
 
 static std::unique_ptr<symbolize::LLVMSymbolizer> createSymbolizer() {
   symbolize::LLVMSymbolizer::Options SymbolizerOptions;
   SymbolizerOptions.Demangle = ClDemangle;
   SymbolizerOptions.UseSymbolTable = true;
   return std::unique_ptr<symbolize::LLVMSymbolizer>(
       new symbolize::LLVMSymbolizer(SymbolizerOptions));

tools/sanstats/sanstats.cpp

const char *ReadModule(char SizeofPtr, const char *Begin, const char *End) {
   }
 }
 
 int main(int argc, char **argv) {
   cl::ParseCommandLineOptions(argc, argv,
                               "Sanitizer Statistics Processing Tool");
 
   ErrorOr<std::unique_ptr<MemoryBuffer>> MBOrErr =
-      MemoryBuffer::getFile(ClInputFile, -1, false);
+      MemoryBuffer::getFile(*ClInputFile, -1, false);
   if (!MBOrErr) {
-    errs() << argv[0] << ": " << ClInputFile << ": "
+    errs() << argv[0] << ": " << *ClInputFile << ": "
            << MBOrErr.getError().message() << '\n';
     return 1;
   }
   std::unique_ptr<MemoryBuffer> MB = std::move(MBOrErr.get());
   const char *Begin = MB->getBufferStart(), *End = MB->getBufferEnd();
   if (Begin == End) {
-    errs() << argv[0] << ": " << ClInputFile << ": short read\n";
+    errs() << argv[0] << ": " << *ClInputFile << ": short read\n";
     return 1;
   }
   char SizeofPtr = *Begin++;
   while (Begin != End) {
     Begin = ReadModule(SizeofPtr, Begin, End);
     if (Begin == nullptr) {
-      errs() << argv[0] << ": " << ClInputFile << ": short read\n";
+      errs() << argv[0] << ": " << *ClInputFile << ": short read\n";
       return 1;
     }
     assert(Begin <= End);
   }
 }

tools/verify-uselistorder/verify-uselistorder.cpp

int main(int argc, char **argv) {
   // Load the input module...
   std::unique_ptr<Module> M = parseIRFile(InputFilename, Err, Context);
 
   if (!M.get()) {
     Err.print(argv[0], errs());
     return 1;
   }
   if (verifyModule(*M, &errs())) {
-    errs() << argv[0] << ": " << InputFilename
+    errs() << argv[0] << ": " << *InputFilename
            << ": error: input module is broken!\n";
     return 1;
   }
 
   // Verify the use lists now and after reversing them.
   outs() << "*** verify-uselistorder ***\n";
   verifyUseListOrder(*M);
   outs() << "reverse\n";

tools/yaml2obj/yaml2obj.cpp

int main(int argc, char **argv) {
 
   if (OutputFilename.empty())
     OutputFilename = "-";
 
   std::error_code EC;
   std::unique_ptr<ToolOutputFile> Out(
       new ToolOutputFile(OutputFilename, EC, sys::fs::F_None));
   if (EC)
-    error("yaml2obj: Error opening '" + OutputFilename + "': " + EC.message());
+    error("yaml2obj: Error opening '" + *OutputFilename + "': " + EC.message());
 
   ErrorOr<std::unique_ptr<MemoryBuffer>> Buf =
-      MemoryBuffer::getFileOrSTDIN(Input);
+      MemoryBuffer::getFileOrSTDIN(*Input);
   if (!Buf)
     return 1;
 
   yaml::Input YIn(Buf.get()->getBuffer());
 
   int Res = convertYAML(YIn, Out->os());
   if (Res == 0)
     Out->keep();
 
   Out->os().flush();
   return Res;
 }

unittests/Support/CommandLineTest.cpp

 }
 #ifndef SKIP_ENVIRONMENT_TESTS
 
 const char test_env_var[] = "LLVM_TEST_COMMAND_LINE_FLAGS";
 
 cl::opt<std::string> EnvironmentTestOption("env-test-opt");
 TEST(CommandLineTest, ParseEnvironment) {
   TempEnvVar TEV(test_env_var, "-env-test-opt=hello");
-  EXPECT_EQ("", EnvironmentTestOption);
+  EXPECT_EQ("", *EnvironmentTestOption);
   cl::ParseEnvironmentOptions("CommandLineTest", test_env_var);
-  EXPECT_EQ("hello", EnvironmentTestOption);
+  EXPECT_EQ("hello", *EnvironmentTestOption);
 }
 
 // This test used to make valgrind complain
 // ("Conditional jump or move depends on uninitialised value(s)")
 //
 // Warning: Do not run any tests after this one that try to gain access to
 // registered command line options because this will likely result in a
 // SEGFAULT. This can occur because the cl::opt in the test below is declared
 // on the stack which will be destroyed after the test completes but the
 // command line system will still hold a pointer to a deallocated cl::Option.
 TEST(CommandLineTest, ParseEnvironmentToLocalVar) {
   // Put cl::opt on stack to check for proper initialization of fields.
   StackOption<std::string> EnvironmentTestOptionLocal("env-test-opt-local");
   TempEnvVar TEV(test_env_var, "-env-test-opt-local=hello-local");
-  EXPECT_EQ("", EnvironmentTestOptionLocal);
+  EXPECT_EQ("", *EnvironmentTestOptionLocal);
   cl::ParseEnvironmentOptions("CommandLineTest", test_env_var);
-  EXPECT_EQ("hello-local", EnvironmentTestOptionLocal);
+  EXPECT_EQ("hello-local", *EnvironmentTestOptionLocal);
 }
 
 #endif  // SKIP_ENVIRONMENT_TESTS
 
 TEST(CommandLineTest, UseOptionCategory) {
   StackOption<int> TestOption2("test-option", cl::cat(TestCategory));
 
   ASSERT_EQ(&TestCategory,TestOption2.Category) << "Failed to assign Option "
TEST(CommandLineTest, AliasesWithArguments) {
   for (size_t i = 0, e = array_lengthof(Inputs); i < e; ++i) {
     StackOption<std::string> Actual("actual");
     StackOption<bool> Extra("extra");
     StackOption<std::string> Input(cl::Positional);
 
     cl::alias Alias("alias", llvm::cl::aliasopt(Actual));
 
     cl::ParseCommandLineOptions(ARGC, Inputs[i]);
-    EXPECT_EQ("x", Actual);
+    EXPECT_EQ("x", *Actual);
     EXPECT_EQ(0, Input.getNumOccurrences());
 
     Alias.removeArgument();
   }
 }
 
 void testAliasRequired(int argc, const char *const *argv) {
   StackOption<std::string> Option("option", cl::Required);
   cl::alias Alias("o", llvm::cl::aliasopt(Option));
 
   cl::ParseCommandLineOptions(argc, argv);
-  EXPECT_EQ("x", Option);
+  EXPECT_EQ("x", *Option);
   EXPECT_EQ(1, Option.getNumOccurrences());
 
   Alias.removeArgument();
 }
 
 TEST(CommandLineTest, AliasRequired) {
   const char *opts1[] = { "-tool", "-option=x" };
   const char *opts2[] = { "-tool", "-o", "x" };

utils/FileCheck/FileCheck.cpp

if (!PrefixRE.isValid(REError)) {
     return 2;
   }
 
 
   SourceMgr SM;
 
   // Read the expected strings from the check file.
   ErrorOr<std::unique_ptr<MemoryBuffer>> CheckFileOrErr =
-      MemoryBuffer::getFileOrSTDIN(CheckFilename);
+      MemoryBuffer::getFileOrSTDIN(*CheckFilename);
   if (std::error_code EC = CheckFileOrErr.getError()) {
-    errs() << "Could not open check file '" << CheckFilename
+    errs() << "Could not open check file '" << *CheckFilename
            << "': " << EC.message() << '\n';
     return 2;
   }
   MemoryBuffer &CheckFile = *CheckFileOrErr.get();
 
   SmallString<4096> CheckFileBuffer;
   StringRef CheckFileText = FC.CanonicalizeFile(CheckFile, CheckFileBuffer);
 
   SM.AddNewSourceBuffer(MemoryBuffer::getMemBuffer(
                             CheckFileText, CheckFile.getBufferIdentifier()),
                         SMLoc());
 
   std::vector<FileCheckString> CheckStrings;
   if (FC.ReadCheckFile(SM, CheckFileText, PrefixRE, CheckStrings))
     return 2;
 
   // Open the file to check and add it to SourceMgr.
   ErrorOr<std::unique_ptr<MemoryBuffer>> InputFileOrErr =
-      MemoryBuffer::getFileOrSTDIN(InputFilename);
+      MemoryBuffer::getFileOrSTDIN(*InputFilename);
   if (std::error_code EC = InputFileOrErr.getError()) {
-    errs() << "Could not open input file '" << InputFilename
+    errs() << "Could not open input file '" << *InputFilename
            << "': " << EC.message() << '\n';
     return 2;
   }
   MemoryBuffer &InputFile = *InputFileOrErr.get();
 
   if (InputFile.getBufferSize() == 0 && !AllowEmptyInput) {
-    errs() << "FileCheck error: '" << InputFilename << "' is empty.\n";
+    errs() << "FileCheck error: '" << *InputFilename << "' is empty.\n";
     DumpCommandLine(argc, argv);
     return 2;
   }
 
   SmallString<4096> InputFileBuffer;
   StringRef InputFileText = FC.CanonicalizeFile(InputFile, InputFileBuffer);
 
   SM.AddNewSourceBuffer(MemoryBuffer::getMemBuffer(

utils/TableGen/AsmMatcherEmitter.cpp

static void emitMnemonicAliasVariant(raw_ostream &OS,const AsmMatcherInfo &Info,
   StringMatcher("Mnemonic", Cases, OS).Emit(Indent);
 }
 
 /// emitMnemonicAliases - If the target has any MnemonicAlias<> definitions,
 /// emit a function for them and return true, otherwise return false.
 static bool emitMnemonicAliases(raw_ostream &OS, const AsmMatcherInfo &Info,
                                 CodeGenTarget &Target) {
   // Ignore aliases when match-prefix is set.
-  if (!MatchPrefix.empty())
+  if (!MatchPrefix->empty())
     return false;
 
   std::vector<Record*> Aliases =
     Info.getRecords().getAllDerivedDefinitions("MnemonicAlias");
   if (Aliases.empty()) return false;
 
   OS << "static void applyMnemonicAliases(StringRef &Mnemonic, "
     "uint64_t Features, unsigned VariantID) {\n";

utils/TableGen/GlobalISelEmitter.cpp

void GroupMatcher::optimize() {
   }
   GlobalISelEmitter::optimizeRules<GroupMatcher>(Matchers, MatcherStorage)
       .swap(Matchers);
   GlobalISelEmitter::optimizeRules<SwitchMatcher>(Matchers, MatcherStorage)
       .swap(Matchers);
 }
 
 void GlobalISelEmitter::run(raw_ostream &OS) {
-  if (!UseCoverageFile.empty()) {
+  if (!UseCoverageFile->empty()) {
     RuleCoverage = CodeGenCoverage();
-    auto RuleCoverageBufOrErr = MemoryBuffer::getFile(UseCoverageFile);
+    auto RuleCoverageBufOrErr = MemoryBuffer::getFile(*UseCoverageFile);
     if (!RuleCoverageBufOrErr) {
       PrintWarning(SMLoc(), "Missing rule coverage data");
       RuleCoverage = None;
     } else {
       if (!RuleCoverage->parse(*RuleCoverageBufOrErr.get(), Target.getName())) {
         PrintWarning(SMLoc(), "Ignoring invalid or missing rule coverage data");
         RuleCoverage = None;
       }

utils/yaml-bench/YAMLBench.cpp

 
 int main(int argc, char **argv) {
   llvm::cl::ParseCommandLineOptions(argc, argv);
   bool ShowColors = UseColor == cl::BOU_UNSET
                         ? sys::Process::StandardOutHasColors()
                         : UseColor == cl::BOU_TRUE;
   if (Input.getNumOccurrences()) {
     ErrorOr<std::unique_ptr<MemoryBuffer>> BufOrErr =
-        MemoryBuffer::getFileOrSTDIN(Input);
+        MemoryBuffer::getFileOrSTDIN(*Input);
     if (!BufOrErr)
       return 1;
     MemoryBuffer &Buf = *BufOrErr.get();
 
     llvm::SourceMgr sm;
     if (DumpTokens) {
       yaml::dumpTokens(Buf.getBuffer(), outs());
     }