[bugpoint] construct a plausible TargetMachine for simplifyCFG

[vtjnash]

Summary

Added in https://reviews.llvm.org/D22845, I do not really know why
simplifyCFG here needs the TTI, so I assumed it would be better if it
had the precise information for the TM it is trying to bugpoint, and not
only the minimal DataLayout Concept.

(We can sprinkle a bit of const into here once https://reviews.llvm.org/D120518 lands)

[vtjnash]

fix

[vtjnash]

bump?

[bjope]

Sorry, I don't know much about bugpoint to understand if this is feasible or not. I doubt that the CFG simplification done by bugpoint really need to take target specific costs etc into account? We just want to simplify the flow, but not optimize it for a given target, right?
I don't find the motivation that strong and there are no test cases etc included that show any gains.

But maybe you could try to find some reviewers that know more about llvm-bugpoint. Unfortunately it seems like there haven't been many functional commits to the tool lately (looking at git log), so I do not really have any immediate candidates to add as reviewers.

llvm/tools/bugpoint/BugDriver.h

 class PassInfo;
 class Module;
 class GlobalVariable;
 class Function;
 class BasicBlock;
 class AbstractInterpreter;
 class Instruction;
 class LLVMContext;
+class TargetMachine;
 
 class CC;
 
 extern 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
   std::string ReferenceOutputFile; // Name of `good' output file
   std::unique_ptr<Module> Program; // The raw program, linked together
+  const TargetMachine *TM;
   std::vector<std::string> PassesToRun;
   AbstractInterpreter *Interpreter;     // How to run the program
   AbstractInterpreter *SafeInterpreter; // To generate reference output, etc.
   CC *cc;
   bool run_find_bugs;
   unsigned Timeout;
   unsigned MemoryLimit;
   bool UseValgrind;
public:
   /// functions that are not under consideration.
   Error debugCodeGenerator();
 
   /// isExecutingJIT - Returns true if bugpoint is currently testing the JIT
   ///
   bool isExecutingJIT();
 
   Module &getProgram() const { return *Program; }
+  const TargetMachine *getTargetMachine();
 
   /// Set the current module to the specified module, returning the old one.
   std::unique_ptr<Module> swapProgramIn(std::unique_ptr<Module> M);
 
   AbstractInterpreter *switchToSafeInterpreter() {
     AbstractInterpreter *Old = Interpreter;
     Interpreter = (AbstractInterpreter *)SafeInterpreter;
     return Old;

 void DeleteFunctionBody(Function *F);
 
 /// Given a module and a list of functions in the module, split the functions
 /// OUT of the specified module, and place them in the new module.
 std::unique_ptr<Module>
 SplitFunctionsOutOfModule(Module *M, const std::vector<Function *> &F,
                           ValueToValueMapTy &VMap);
 
+void setTargetTriple(StringRef TheTriple);
+
 } // End llvm namespace
 
 #endif

llvm/tools/bugpoint/BugDriver.cpp

 //===----------------------------------------------------------------------===//
 
 #include "BugDriver.h"
 #include "ToolRunner.h"
 #include "llvm/IR/Module.h"
 #include "llvm/IR/Verifier.h"
 #include "llvm/IRReader/IRReader.h"
 #include "llvm/Linker/Linker.h"
+#include "llvm/MC/TargetRegistry.h"
 #include "llvm/Pass.h"
 #include "llvm/Support/CommandLine.h"
 #include "llvm/Support/FileUtilities.h"
 #include "llvm/Support/Host.h"
 #include "llvm/Support/SourceMgr.h"
 #include "llvm/Support/raw_ostream.h"
+#include "llvm/Target/TargetMachine.h"
 #include <memory>
 using namespace llvm;
 
 namespace llvm {
 Triple TargetTriple;
+std::unique_ptr<TargetMachine> TheTargetMachine;
+void setTargetTriple(StringRef TheTriple) {
+  TargetTriple = Triple(TheTriple);
+
+  // Construct a plausible TM, for simplifyCFG needs
+  std::string Error;
+  const Target *TheTarget =
+      TargetRegistry::lookupTarget(TheTriple.str(), Error);
+  if (!TheTarget) {
+    errs() << "warning: bugpoint could not allocate Target: " << Error << "\n";
+    return;
+  }
+  StringRef CPUStr("");
+  StringRef FeaturesStr("");
+  Optional<Reloc::Model> RM;
+  Optional<CodeModel::Model> CM;
+  CodeGenOpt::Level OLvl = CodeGenOpt::Default;
+  TargetOptions Options;
+  TheTargetMachine.reset(TheTarget->createTargetMachine(
+      TheTriple, CPUStr, FeaturesStr, Options, RM, CM, OLvl));
+  if (!TheTargetMachine)
+    errs() << "warning: bugpoint could not allocate TargetMachine\n";
+}
 }
 
 DiscardTemp::~DiscardTemp() {
   if (SaveTemps) {
     if (Error E = File.keep())
       errs() << "Failed to keep temp file " << toString(std::move(E)) << '\n';
     return;
   }

 // otherwise the raw input run through an interpreter is used as the reference
 // source.
 //
 cl::opt<std::string> OutputFile("output",
                                 cl::desc("Specify a reference program output "
                                          "(for miscompilation detection)"));
 }
 
+const TargetMachine *BugDriver::getTargetMachine() {
+  return TheTargetMachine.get();
+}
+
 /// If we reduce or update the program somehow, call this method to update
 /// bugdriver with it.  This deletes the old module and sets the specified one
 /// as the current program.
 void BugDriver::setNewProgram(std::unique_ptr<Module> M) {
   Program = std::move(M);
 }
 
 /// getPassesString - Turn a list of passes into a string which indicates the
std::unique_ptr<Module> llvm::parseInputFile(StringRef Filename,
   // If we don't have an override triple, use the first one to configure
   // bugpoint, or use the host triple if none provided.
   if (TargetTriple.getTriple().empty()) {
     Triple TheTriple(Result->getTargetTriple());
 
     if (TheTriple.getTriple().empty())
       TheTriple.setTriple(sys::getDefaultTargetTriple());
 
-    TargetTriple.setTriple(TheTriple.getTriple());
+    setTargetTriple(TheTriple.getTriple());
   }
 
   Result->setTargetTriple(TargetTriple.getTriple()); // override the triple
   return Result;
 }
 
 std::unique_ptr<Module> BugDriver::swapProgramIn(std::unique_ptr<Module> M) {
   std::unique_ptr<Module> OldProgram = std::move(Program);

llvm/tools/bugpoint/CrashDebugger.cpp

 #include "llvm/IR/Instructions.h"
 #include "llvm/IR/LegacyPassManager.h"
 #include "llvm/IR/Module.h"
 #include "llvm/IR/ValueSymbolTable.h"
 #include "llvm/IR/Verifier.h"
 #include "llvm/Pass.h"
 #include "llvm/Support/CommandLine.h"
 #include "llvm/Support/FileUtilities.h"
+#include "llvm/Target/TargetMachine.h"
 #include "llvm/Transforms/Scalar.h"
 #include "llvm/Transforms/Utils/BasicBlockUtils.h"
 #include "llvm/Transforms/Utils/Cloning.h"
 #include "llvm/Transforms/Utils/Local.h"
 #include <set>
 using namespace llvm;
 
 namespace {

 
 namespace {
 /// SimplifyCFG reducer - This works by calling SimplifyCFG on each basic block
 /// in the program.
 
 class ReduceSimplifyCFG : public ListReducer<const BasicBlock *> {
   BugDriver &BD;
   BugTester TestFn;
-  TargetTransformInfo TTI;
 
 public:
-  ReduceSimplifyCFG(BugDriver &bd, BugTester testFn)
-      : BD(bd), TestFn(testFn), TTI(bd.getProgram().getDataLayout()) {}
+  ReduceSimplifyCFG(BugDriver &bd, BugTester testFn) : BD(bd), TestFn(testFn) {}
 
   Expected<TestResult> doTest(std::vector<const BasicBlock *> &Prefix,
                               std::vector<const BasicBlock *> &Kept) override {
     if (!Kept.empty() && TestBlocks(Kept))
       return KeepSuffix;
     if (!Prefix.empty() && TestBlocks(Prefix))
       return KeepPrefix;
     return NoFailure;
   }
 
   bool TestBlocks(std::vector<const BasicBlock *> &Prefix);
 };
 }
 
 bool ReduceSimplifyCFG::TestBlocks(std::vector<const BasicBlock *> &BBs) {
   // Clone the program to try hacking it apart...
   ValueToValueMapTy VMap;
   std::unique_ptr<Module> M = CloneModule(BD.getProgram(), VMap);
+  const TargetMachine *TM = BD.getTargetMachine();
 
   // Convert list to set for fast lookup...
   SmallPtrSet<const BasicBlock *, 8> Blocks;
   for (const auto *BB : BBs)
     Blocks.insert(cast<BasicBlock>(VMap[BB]));
 
   outs() << "Checking for crash with CFG simplifying:";
   unsigned NumPrint = Blocks.size();
   if (NumPrint > 10)
     NumPrint = 10;
   for (unsigned i = 0, e = NumPrint; i != e; ++i)
     outs() << " " << BBs[i]->getName();
   if (NumPrint < Blocks.size())
     outs() << "... <" << Blocks.size() << " total>";
   outs() << ": ";
 
   // The following may destroy some blocks, so we save them first
   std::vector<std::pair<std::string, std::string>> BlockInfo;
 
   for (const BasicBlock *BB : Blocks)
     BlockInfo.emplace_back(std::string(BB->getParent()->getName()),
                            std::string(BB->getName()));
 
   // Loop over and delete any hack up any blocks that are not listed...
-  for (auto &F : *M)
+  for (auto &F : *M) {
+    TargetTransformInfo TTI = TM ? TM->getTargetTransformInfo(F)
+                                 : TargetTransformInfo(M->getDataLayout());
     // Loop over all of the basic blocks and remove them if they are unneeded.
     for (Function::iterator BBIt = F.begin(); BBIt != F.end();) {
       if (!Blocks.count(&*BBIt)) {
         ++BBIt;
         continue;
       }
       simplifyCFG(&*BBIt++, TTI);
     }
+  }
   // Verify we didn't break anything
   std::vector<std::string> Passes;
   Passes.push_back("verify");
   std::unique_ptr<Module> New = BD.runPassesOn(M.get(), Passes);
   if (!New) {
     errs() << "verify failed!\n";
     exit(1);
   }

llvm/tools/bugpoint/ExecutionDriver.cpp

 //===- ExecutionDriver.cpp - Allow execution of LLVM program --------------===//
 //
 // 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 code used to execute the program utilizing one of the
 // various ways of running LLVM bitcode.
 //
 //===----------------------------------------------------------------------===//
 
 #include "BugDriver.h"
 #include "ToolRunner.h"
+#include "llvm/IR/Module.h"
 #include "llvm/Support/CommandLine.h"
 #include "llvm/Support/Debug.h"
 #include "llvm/Support/FileUtilities.h"
 #include "llvm/Support/Program.h"
 #include "llvm/Support/SystemUtils.h"
 #include "llvm/Support/raw_ostream.h"
 #include <fstream>
 
Expected<std::string> BugDriver::executeProgram(const Module &Program,
   }
   OutputFile = std::string(UniqueFile.str());
 
   // Figure out which shared objects to run, if any.
   std::vector<std::string> SharedObjs(AdditionalSOs);
   if (!SharedObj.empty())
     SharedObjs.push_back(SharedObj);
 
-  Expected<int> RetVal = AI->ExecuteProgram(BitcodeFile, InputArgv, InputFile,
-                                            OutputFile, AdditionalLinkerArgs,
-                                            SharedObjs, Timeout, MemoryLimit);
+  Expected<int> RetVal = AI->ExecuteProgram(
+      BitcodeFile, InputArgv, InputFile, OutputFile,
+      Triple(Program.getTargetTriple()), AdditionalLinkerArgs, SharedObjs,
+      Timeout, MemoryLimit);
   if (Error E = RetVal.takeError())
     return std::move(E);
 
   if (*RetVal == -1) {
     errs() << "<timeout>";
     static bool FirstTimeout = true;
     if (FirstTimeout) {
       outs()
BugDriver::executeProgramSafely(const Module &Program,
                                 const std::string &OutputFile) const {
   return executeProgram(Program, OutputFile, "", "", SafeInterpreter);
 }
 
 Expected<std::string>
 BugDriver::compileSharedObject(const std::string &BitcodeFile) {
   assert(Interpreter && "Interpreter should have been created already!");
   std::string OutputFile;
+  Triple TargetTriple(Program->getTargetTriple());
 
   // Using the known-good backend.
   Expected<CC::FileType> FT =
       SafeInterpreter->OutputCode(BitcodeFile, OutputFile);
   if (Error E = FT.takeError())
     return std::move(E);
 
   std::string SharedObjectFile;
   if (Error E = cc->MakeSharedObject(OutputFile, *FT, SharedObjectFile,
-                                     AdditionalLinkerArgs))
+                                     TargetTriple, AdditionalLinkerArgs))
     return std::move(E);
 
   // Remove the intermediate C file
   sys::fs::remove(OutputFile);
 
   return SharedObjectFile;
 }
 

llvm/tools/bugpoint/Miscompilation.cpp

if (isExecutingJIT()) {
     outs() << "  ./" << TestModuleBC << ".exe";
   }
   for (unsigned i = 0, e = InputArgv.size(); i != e; ++i)
     outs() << " " << InputArgv[i];
   outs() << '\n';
   outs() << "The shared object was created with:\n  llc -march=c "
          << SafeModuleBC.str() << " -o temporary.c\n"
          << "  cc -xc temporary.c -O2 -o " << *SharedObject;
-  if (TargetTriple.getArch() == Triple::sparc)
+  if (Triple(getProgram().getTargetTriple()).getArch() == Triple::sparc)
     outs() << " -G"; // Compile a shared library, `-G' for Sparc
   else
     outs() << " -fPIC -shared"; // `-shared' for Linux/X86, maybe others
 
   outs() << " -fno-strict-aliasing\n";
 
   return Error::success();
 }

llvm/tools/bugpoint/ToolRunner.h

 #include "llvm/Support/Path.h"
 #include "llvm/Support/SystemUtils.h"
 #include <exception>
 #include <vector>
 
 namespace llvm {
 
 extern cl::opt<bool> SaveTemps;
-extern Triple TargetTriple;
 
 class LLC;
 
 //===---------------------------------------------------------------------===//
 // CC abstraction
 //
 class CC {
   std::string CCPath;              // The path to the cc executable.
public:
   /// arguments.  Standard input is specified with InputFile, and standard
   /// Output is captured to the specified OutputFile location.  The SharedLibs
   /// option specifies optional native shared objects that can be loaded into
   /// the program for execution.
   ///
   Expected<int> ExecuteProgram(
       const std::string &ProgramFile, const std::vector<std::string> &Args,
       FileType fileType, const std::string &InputFile,
-      const std::string &OutputFile,
+      const std::string &OutputFile, const Triple &TargetTriple,
       const std::vector<std::string> &CCArgs = std::vector<std::string>(),
       unsigned Timeout = 0, unsigned MemoryLimit = 0);
 
   /// MakeSharedObject - This compiles the specified file (which is either a .c
   /// file or a .s file) into a shared object.
   ///
   Error MakeSharedObject(const std::string &InputFile, FileType fileType,
-                         std::string &OutputFile,
+                         std::string &OutputFile, const Triple &TargetTriple,
                          const std::vector<std::string> &ArgsForCC);
 };
 
 //===---------------------------------------------------------------------===//
 /// AbstractInterpreter Class - Subclasses of this class are used to execute
 /// LLVM bitcode in a variety of ways.  This abstract interface hides this
 /// complexity behind a simple interface.
 ///
public:
   /// ExecuteProgram - Run the specified bitcode file, emitting output to the
   /// specified filename.  This sets RetVal to the exit code of the program or
   /// returns an Error if a problem was encountered that prevented execution of
   /// the program.
   ///
   virtual Expected<int> ExecuteProgram(
       const std::string &Bitcode, const std::vector<std::string> &Args,
       const std::string &InputFile, const std::string &OutputFile,
+      const Triple &TargetTriple,
       const std::vector<std::string> &CCArgs = std::vector<std::string>(),
       const std::vector<std::string> &SharedLibs = std::vector<std::string>(),
       unsigned Timeout = 0, unsigned MemoryLimit = 0) = 0;
 };
 
 //===---------------------------------------------------------------------===//
 // LLC Implementation of AbstractIntepreter interface
 //
public:
   /// code.  This does not produce any output, it is only used when debugging
   /// the code generator.  Returns false if the code generator fails.
   Error compileProgram(const std::string &Bitcode, unsigned Timeout = 0,
                        unsigned MemoryLimit = 0) override;
 
   Expected<int> ExecuteProgram(
       const std::string &Bitcode, const std::vector<std::string> &Args,
       const std::string &InputFile, const std::string &OutputFile,
+      const Triple &TargetTriple,
       const std::vector<std::string> &CCArgs = std::vector<std::string>(),
       const std::vector<std::string> &SharedLibs = std::vector<std::string>(),
       unsigned Timeout = 0, unsigned MemoryLimit = 0) override;
 
   Expected<CC::FileType> OutputCode(const std::string &Bitcode,
                                     std::string &OutFile, unsigned Timeout = 0,
                                     unsigned MemoryLimit = 0) override;
 };

llvm/tools/bugpoint/ToolRunner.cpp

LLI(const std::string &Path, const std::vector<std::string> *Args)
     if (Args) {
       ToolArgs = *Args;
     }
   }
 
   Expected<int> ExecuteProgram(
       const std::string &Bitcode, const std::vector<std::string> &Args,
       const std::string &InputFile, const std::string &OutputFile,
-      const std::vector<std::string> &CCArgs,
+      const Triple &TargetTriple, const std::vector<std::string> &CCArgs,
       const std::vector<std::string> &SharedLibs = std::vector<std::string>(),
       unsigned Timeout = 0, unsigned MemoryLimit = 0) override;
 };
 }
 
 Expected<int> LLI::ExecuteProgram(const std::string &Bitcode,
                                   const std::vector<std::string> &Args,
                                   const std::string &InputFile,
                                   const std::string &OutputFile,
+                                  const Triple &TargetTriple,
                                   const std::vector<std::string> &CCArgs,
                                   const std::vector<std::string> &SharedLibs,
                                   unsigned Timeout, unsigned MemoryLimit) {
   std::vector<StringRef> LLIArgs;
   LLIArgs.push_back(LLIPath);
   LLIArgs.push_back("-force-interpreter=true");
 
   for (std::vector<std::string>::const_iterator i = SharedLibs.begin(),
CustomCompiler(const std::string &CompilerCmd,
       : CompilerCommand(CompilerCmd), CompilerArgs(std::move(CompArgs)) {}
 
   Error compileProgram(const std::string &Bitcode, unsigned Timeout = 0,
                        unsigned MemoryLimit = 0) override;
 
   Expected<int> ExecuteProgram(
       const std::string &Bitcode, const std::vector<std::string> &Args,
       const std::string &InputFile, const std::string &OutputFile,
+      const Triple &TargetTriple,
       const std::vector<std::string> &CCArgs = std::vector<std::string>(),
       const std::vector<std::string> &SharedLibs = std::vector<std::string>(),
       unsigned Timeout = 0, unsigned MemoryLimit = 0) override {
     return make_error<StringError>(
         "Execution not supported with -compile-custom",
         inconvertibleErrorCode());
   }
 };

 public:
   CustomExecutor(const std::string &ExecutionCmd,
                  std::vector<std::string> ExecArgs)
       : ExecutionCommand(ExecutionCmd), ExecutorArgs(std::move(ExecArgs)) {}
 
   Expected<int> ExecuteProgram(
       const std::string &Bitcode, const std::vector<std::string> &Args,
       const std::string &InputFile, const std::string &OutputFile,
-      const std::vector<std::string> &CCArgs,
+      const Triple &TargetTriple, const std::vector<std::string> &CCArgs,
       const std::vector<std::string> &SharedLibs = std::vector<std::string>(),
       unsigned Timeout = 0, unsigned MemoryLimit = 0) override;
 };
 }
 
 Expected<int> CustomExecutor::ExecuteProgram(
     const std::string &Bitcode, const std::vector<std::string> &Args,
     const std::string &InputFile, const std::string &OutputFile,
-    const std::vector<std::string> &CCArgs,
+    const Triple &TargetTriple, const std::vector<std::string> &CCArgs,
     const std::vector<std::string> &SharedLibs, unsigned Timeout,
     unsigned MemoryLimit) {
 
   std::vector<StringRef> ProgramArgs;
   ProgramArgs.push_back(ExecutionCommand);
 
   for (std::size_t i = 0; i < ExecutorArgs.size(); ++i)
     ProgramArgs.push_back(ExecutorArgs[i]);
if (Error E = Result.takeError())
     return E;
   return Error::success();
 }
 
 Expected<int> LLC::ExecuteProgram(const std::string &Bitcode,
                                   const std::vector<std::string> &Args,
                                   const std::string &InputFile,
                                   const std::string &OutputFile,
+                                  const Triple &TargetTriple,
                                   const std::vector<std::string> &ArgsForCC,
                                   const std::vector<std::string> &SharedLibs,
                                   unsigned Timeout, unsigned MemoryLimit) {
 
   std::string OutputAsmFile;
   Expected<CC::FileType> FileKind =
       OutputCode(Bitcode, OutputAsmFile, Timeout, MemoryLimit);
   FileRemover OutFileRemover(OutputAsmFile, !SaveTemps);
   if (Error E = FileKind.takeError())
     return std::move(E);
 
   std::vector<std::string> CCArgs(ArgsForCC);
   llvm::append_range(CCArgs, SharedLibs);
 
   // Assuming LLC worked, compile the result with CC and run it.
   return cc->ExecuteProgram(OutputAsmFile, Args, *FileKind, InputFile,
-                            OutputFile, CCArgs, Timeout, MemoryLimit);
+                            OutputFile, TargetTriple, CCArgs, Timeout,
+                            MemoryLimit);
 }
 
 /// createLLC - Try to find the LLC executable
 ///
 LLC *AbstractInterpreter::createLLC(const char *Argv0, std::string &Message,
                                     const std::string &CCBinary,
                                     const std::vector<std::string> *Args,
                                     const std::vector<std::string> *CCArgs,
JIT(const std::string &Path, const std::vector<std::string> *Args)
     if (Args) {
       ToolArgs = *Args;
     }
   }
 
   Expected<int> ExecuteProgram(
       const std::string &Bitcode, const std::vector<std::string> &Args,
       const std::string &InputFile, const std::string &OutputFile,
+      const Triple &TargetTriple,
       const std::vector<std::string> &CCArgs = std::vector<std::string>(),
       const std::vector<std::string> &SharedLibs = std::vector<std::string>(),
       unsigned Timeout = 0, unsigned MemoryLimit = 0) override;
 };
 }
 
 Expected<int> JIT::ExecuteProgram(const std::string &Bitcode,
                                   const std::vector<std::string> &Args,
                                   const std::string &InputFile,
                                   const std::string &OutputFile,
+                                  const Triple &TargetTriple,
                                   const std::vector<std::string> &CCArgs,
                                   const std::vector<std::string> &SharedLibs,
                                   unsigned Timeout, unsigned MemoryLimit) {
   // Construct a vector of parameters, incorporating those from the command-line
   std::vector<StringRef> JITArgs;
   JITArgs.push_back(LLIPath);
   JITArgs.push_back("-force-interpreter=false");
 
static bool IsARMArchitecture(std::vector<StringRef> Args) {
   return false;
 }
 
 Expected<int> CC::ExecuteProgram(const std::string &ProgramFile,
                                  const std::vector<std::string> &Args,
                                  FileType fileType,
                                  const std::string &InputFile,
                                  const std::string &OutputFile,
+                                 const Triple &TargetTriple,
                                  const std::vector<std::string> &ArgsForCC,
                                  unsigned Timeout, unsigned MemoryLimit) {
   std::vector<StringRef> CCArgs;
 
   CCArgs.push_back(CCPath);
 
   if (TargetTriple.getArch() == Triple::x86)
     CCArgs.push_back("-m32");
if (RemoteClientPath.empty()) {
     outs().flush();
     return RunProgramRemotelyWithTimeout(RemoteClientPath, ProgramArgs,
                                          InputFile, OutputFile, OutputFile,
                                          Timeout, MemoryLimit);
   }
 }
 
 Error CC::MakeSharedObject(const std::string &InputFile, FileType fileType,
-                           std::string &OutputFile,
+                           std::string &OutputFile, const Triple &TargetTriple,
                            const std::vector<std::string> &ArgsForCC) {
   SmallString<128> UniqueFilename;
   std::error_code EC = sys::fs::createUniqueFile(
       InputFile + "-%%%%%%%" + LTDL_SHLIB_EXT, UniqueFilename);
   if (EC) {
     errs() << "Error making unique filename: " << EC.message() << "\n";
     exit(1);
   }

llvm/tools/bugpoint/bugpoint.cpp

#endif
   cl::ParseCommandLineOptions(argc, argv,
                               "LLVM automatic testcase reducer. See\nhttp://"
                               "llvm.org/cmds/bugpoint.html"
                               " for more information.\n");
 #ifndef DEBUG_BUGPOINT
   sys::SetInterruptFunction(BugpointInterruptFunction);
 #endif
 
-  LLVMContext Context;
   // If we have an override, set it and then track the triple we want Modules
   // to use.
   if (!OverrideTriple.empty()) {
-    TargetTriple.setTriple(Triple::normalize(OverrideTriple));
-    outs() << "Override triple set to '" << TargetTriple.getTriple() << "'\n";
+    std::string TargetTriple = Triple::normalize(OverrideTriple);
+    setTargetTriple(TargetTriple);
+    outs() << "Override triple set to '" << TargetTriple << "'\n";
   }
 
   if (MemoryLimit < 0) {
     // Set the default MemoryLimit.  Be sure to update the flag's description if
     // you change this.
     if (sys::RunningOnValgrind() || UseValgrind)
       MemoryLimit = 800;
     else
       MemoryLimit = 400;
 #if (LLVM_ADDRESS_SANITIZER_BUILD || LLVM_MEMORY_SANITIZER_BUILD ||            \
      LLVM_THREAD_SANITIZER_BUILD)
     // Starting from kernel 4.9 memory allocated with mmap is counted against
     // RLIMIT_DATA. Sanitizers need to allocate tens of terabytes for shadow.
     MemoryLimit = 0;
 #endif
   }
 
+  LLVMContext Context;
   BugDriver D(argv[0], FindBugs, TimeoutValue, MemoryLimit, UseValgrind,
               Context);
   if (D.addSources(InputFilenames))
     return 1;
 
   AddToDriver PM(D);
 
   if (StandardLinkOpts) {