ELF: Remove member variables that are used only in one function.

[davide]

Reasonable, thanks.

ELF/LTO.h

public:
   void add(BitcodeFile &F);
   std::vector<std::unique_ptr<InputFile>> compile();
 
 private:
   std::vector<std::unique_ptr<InputFile>> runSplitCodegen(
       const std::function<std::unique_ptr<llvm::TargetMachine>()> &TMFactory);
 
   std::unique_ptr<llvm::Module> Combined;
-  llvm::IRMover Mover;
   std::vector<SmallString<0>> OwningData;
   llvm::StringSet<> InternalizedSyms;
   llvm::StringSet<> AsmUndefinedRefs;
-  std::string TheTriple;
 };
 }
 }
 
 #endif

ELF/LTO.cpp

 static bool shouldInternalize(const SmallPtrSet<GlobalValue *, 8> &Used,
                               Symbol *S, GlobalValue *GV) {
   if (S->IsUsedInRegularObj || Used.count(GV))
     return false;
   return !S->includeInDynsym();
 }
 
 BitcodeCompiler::BitcodeCompiler()
-    : Combined(new llvm::Module("ld-temp.o", Driver->Context)),
-      Mover(*Combined) {}
+    : Combined(new llvm::Module("ld-temp.o", Driver->Context)) {}
 
 static void undefine(Symbol *S) {
   replaceBody<Undefined>(S, S->body()->getName(), STV_DEFAULT, S->body()->Type);
 }
 
 static void handleUndefinedAsmRefs(const BasicSymbolRef &Sym, GlobalValue *GV,
                                    StringSet<> &AsmUndefinedRefs) {
   // GV associated => not an assembly symbol, bail out.
for (const BasicSymbolRef &Sym : Obj->symbols()) {
     case llvm::GlobalValue::LinkOnceODRLinkage:
       GV->setLinkage(GlobalValue::WeakODRLinkage);
       break;
     }
 
     Keep.push_back(GV);
   }
 
+  IRMover Mover(*Combined);
   if (Error E = Mover.move(Obj->takeModule(), Keep,
                            [](GlobalValue &, IRMover::ValueAdder) {})) {
     handleAllErrors(std::move(E), [&](const llvm::ErrorInfoBase &EIB) {
       fatal("failed to link module " + F.getName() + ": " + EIB.message());
     });
   }
 }
 
std::vector<std::unique_ptr<InputFile>> BitcodeCompiler::runSplitCodegen(
   }
 
   return ObjFiles;
 }
 
 // Merge all the bitcode files we have seen, codegen the result
 // and return the resulting ObjectFile.
 std::vector<std::unique_ptr<InputFile>> BitcodeCompiler::compile() {
-  TheTriple = Combined->getTargetTriple();
   for (const auto &Name : InternalizedSyms) {
     GlobalValue *GV = Combined->getNamedValue(Name.first());
     assert(GV);
     internalize(*GV);
   }
 
+  std::string TheTriple = Combined->getTargetTriple();
   std::string Msg;
   const Target *T = TargetRegistry::lookupTarget(TheTriple, Msg);
   if (!T)
     fatal("target not found: " + Msg);
 
   // LLD supports the new relocations.
   TargetOptions Options = InitTargetOptionsFromCodeGenFlags();
   Options.RelaxELFRelocations = true;