[LTOCodeGenerator] Use lto::Config for options (NFC).

[fhahn]

Summary

This patch removes some options that have been duplicated in
LTOCodeGenerator and instead use lto::Config directly to manage the
options.

This is a cleanup after 6a59f0560648.

[tejohnson]

lgtm

llvm/include/llvm/LTO/legacy/LTOCodeGenerator.h

 /// C++ class which implements the opaque lto_code_gen_t type.
 ///
 struct LTOCodeGenerator {
   static const char *getVersionString();
 
   LTOCodeGenerator(LLVMContext &Context);
   ~LTOCodeGenerator();
 
-  /// Return a lto::Config object which contains the options set in
-  /// LTOCodeGenerator.
-  lto::Config toConfig() const;
-
   /// Merge given module.  Return true on success.
   ///
   /// Resets \a HasVerifiedInput.
   bool addModule(struct LTOModule *);
 
   /// Set the destination module.
   ///
   /// Resets \a HasVerifiedInput.
   void setModule(std::unique_ptr<LTOModule> M);
 
   void setAsmUndefinedRefs(struct LTOModule *);
   void setTargetOptions(const TargetOptions &Options);
   void setDebugInfo(lto_debug_model);
-  void setCodePICModel(Optional<Reloc::Model> Model) { RelocModel = Model; }
+  void setCodePICModel(Optional<Reloc::Model> Model) {
+    Config.RelocModel = Model;
+  }
 
   /// Set the file type to be emitted (assembly or object code).
   /// The default is CGFT_ObjectFile.
-  void setFileType(CodeGenFileType FT) { FileType = FT; }
+  void setFileType(CodeGenFileType FT) { Config.CGFileType = FT; }
 
-  void setCpu(StringRef MCpu) { this->MCpu = std::string(MCpu); }
-  void setAttrs(std::vector<std::string> MAttrs) { this->MAttrs = MAttrs; }
+  void setCpu(StringRef MCpu) { Config.CPU = std::string(MCpu); }
+  void setAttrs(std::vector<std::string> MAttrs) { Config.MAttrs = MAttrs; }
   void setOptLevel(unsigned OptLevel);
 
   void setShouldInternalize(bool Value) { ShouldInternalize = Value; }
   void setShouldEmbedUselists(bool Value) { ShouldEmbedUselists = Value; }
 
   /// Restore linkage of globals
   ///
   /// When set, the linkage of globals will be restored prior to code
struct LTOCodeGenerator {
   /// ParallelismLevel threads.  Output files will be written to the streams
   /// created using the \p AddStream callback. Returns true on success.
   ///
   /// Calls \a verifyMergedModuleOnce().
   bool compileOptimized(lto::AddStreamFn AddStream, unsigned ParallelismLevel);
 
   /// Enable the Freestanding mode: indicate that the optimizer should not
   /// assume builtins are present on the target.
-  void setFreestanding(bool Enabled) { Freestanding = Enabled; }
+  void setFreestanding(bool Enabled) { Config.Freestanding = Enabled; }
 
-  void setDisableVerify(bool Value) { DisableVerify = Value; }
+  void setDisableVerify(bool Value) { Config.DisableVerify = Value; }
 
-  void setUseNewPM(bool Value) { UseNewPM = Value; }
+  void setUseNewPM(bool Value) { Config.UseNewPM = Value; }
 
   void setDiagnosticHandler(lto_diagnostic_handler_t, void *);
 
   LLVMContext &getContext() { return Context; }
 
   void resetMergedModule() { MergedModule.reset(); }
   void DiagnosticHandler(const DiagnosticInfo &DI);
 
private:
 
   LLVMContext &Context;
   std::unique_ptr<Module> MergedModule;
   std::unique_ptr<Linker> TheLinker;
   std::unique_ptr<TargetMachine> TargetMach;
   bool EmitDwarfDebugInfo = false;
   bool ScopeRestrictionsDone = false;
   bool HasVerifiedInput = false;
-  Optional<Reloc::Model> RelocModel;
   StringSet<> MustPreserveSymbols;
   StringSet<> AsmUndefinedRefs;
   StringMap<GlobalValue::LinkageTypes> ExternalSymbols;
   std::vector<std::string> CodegenOptions;
   std::string FeatureStr;
-  std::string MCpu;
-  std::vector<std::string> MAttrs;
   std::string NativeObjectPath;
-  TargetOptions Options;
-  CodeGenOpt::Level CGOptLevel = CodeGenOpt::Default;
   const Target *MArch = nullptr;
   std::string TripleStr;
-  unsigned OptLevel = 2;
   lto_diagnostic_handler_t DiagHandler = nullptr;
   void *DiagContext = nullptr;
   bool ShouldInternalize = EnableLTOInternalization;
   bool ShouldEmbedUselists = false;
   bool ShouldRestoreGlobalsLinkage = false;
-  CodeGenFileType FileType = CGFT_ObjectFile;
   std::unique_ptr<ToolOutputFile> DiagnosticOutputFile;
-  bool Freestanding = false;
   std::unique_ptr<ToolOutputFile> StatsFile = nullptr;
-  bool DisableVerify = false;
-  bool UseNewPM = LLVM_ENABLE_NEW_PASS_MANAGER;
+
+  lto::Config Config;
 };
 }
 #endif

llvm/lib/LTO/LTOCodeGenerator.cpp

cl::opt<std::string> LTOStatsFile(
     cl::Hidden);
 }
 
 LTOCodeGenerator::LTOCodeGenerator(LLVMContext &Context)
     : Context(Context), MergedModule(new Module("ld-temp.o", Context)),
       TheLinker(new Linker(*MergedModule)) {
   Context.setDiscardValueNames(LTODiscardValueNames);
   Context.enableDebugTypeODRUniquing();
-}
-
-LTOCodeGenerator::~LTOCodeGenerator() {}
 
-lto::Config LTOCodeGenerator::toConfig() const {
-  lto::Config Conf;
-  Conf.CGFileType = FileType;
-  Conf.CPU = MCpu;
-  Conf.MAttrs = MAttrs;
-  Conf.RelocModel = RelocModel;
-  Conf.Options = Options;
-  Conf.CodeModel = None;
-  Conf.StatsFile = LTOStatsFile;
-  Conf.OptLevel = OptLevel;
-  Conf.Freestanding = Freestanding;
-  Conf.PTO.LoopVectorization = OptLevel > 1;
-  Conf.PTO.SLPVectorization = OptLevel > 1;
-  Conf.DisableVerify = DisableVerify;
-  Conf.PreCodeGenPassesHook = [](legacy::PassManager &PM) {
+  Config.CodeModel = None;
+  Config.StatsFile = LTOStatsFile;
+  Config.PreCodeGenPassesHook = [](legacy::PassManager &PM) {
     PM.add(createObjCARCContractPass());
   };
-  Conf.UseNewPM = UseNewPM;
-
-  return Conf;
 }
 
+LTOCodeGenerator::~LTOCodeGenerator() {}
+
 void LTOCodeGenerator::setAsmUndefinedRefs(LTOModule *Mod) {
   const std::vector<StringRef> &undefs = Mod->getAsmUndefinedRefs();
   for (int i = 0, e = undefs.size(); i != e; ++i)
     AsmUndefinedRefs.insert(undefs[i]);
 }
 
 bool LTOCodeGenerator::addModule(LTOModule *Mod) {
   assert(&Mod->getModule().getContext() == &Context &&
void LTOCodeGenerator::setModule(std::unique_ptr<LTOModule> Mod) {
   TheLinker = std::make_unique<Linker>(*MergedModule);
   setAsmUndefinedRefs(&*Mod);
 
   // We've just changed the input, so let's make sure we verify it.
   HasVerifiedInput = false;
 }
 
 void LTOCodeGenerator::setTargetOptions(const TargetOptions &Options) {
-  this->Options = Options;
+  Config.Options = Options;
 }
 
 void LTOCodeGenerator::setDebugInfo(lto_debug_model Debug) {
   switch (Debug) {
   case LTO_DEBUG_MODEL_NONE:
     EmitDwarfDebugInfo = false;
     return;
 
   case LTO_DEBUG_MODEL_DWARF:
     EmitDwarfDebugInfo = true;
     return;
   }
   llvm_unreachable("Unknown debug format!");
 }
 
 void LTOCodeGenerator::setOptLevel(unsigned Level) {
-  OptLevel = Level;
-  switch (OptLevel) {
+  Config.OptLevel = Level;
+  Config.PTO.LoopVectorization = Config.OptLevel > 1;
+  Config.PTO.SLPVectorization = Config.OptLevel > 1;
+  switch (Config.OptLevel) {
   case 0:
-    CGOptLevel = CodeGenOpt::None;
+    Config.CGOptLevel = CodeGenOpt::None;
     return;
   case 1:
-    CGOptLevel = CodeGenOpt::Less;
+    Config.CGOptLevel = CodeGenOpt::Less;
     return;
   case 2:
-    CGOptLevel = CodeGenOpt::Default;
+    Config.CGOptLevel = CodeGenOpt::Default;
     return;
   case 3:
-    CGOptLevel = CodeGenOpt::Aggressive;
+    Config.CGOptLevel = CodeGenOpt::Aggressive;
     return;
   }
   llvm_unreachable("Unknown optimization level!");
 }
 
 bool LTOCodeGenerator::writeMergedModules(StringRef Path) {
   if (!determineTarget())
     return false;

 }
 
 bool LTOCodeGenerator::compileOptimizedToFile(const char **Name) {
   // make unique temp output file to put generated code
   SmallString<128> Filename;
 
   auto AddStream =
       [&](size_t Task) -> std::unique_ptr<lto::NativeObjectStream> {
-    StringRef Extension(FileType == CGFT_AssemblyFile ? "s" : "o");
+    StringRef Extension(Config.CGFileType == CGFT_AssemblyFile ? "s" : "o");
 
     int FD;
     std::error_code EC =
         sys::fs::createTemporaryFile("lto-llvm", Extension, FD, Filename);
     if (EC)
       emitError(EC.message());
 
     return std::make_unique<lto::NativeObjectStream>(
bool LTOCodeGenerator::determineTarget() {
   MArch = TargetRegistry::lookupTarget(TripleStr, ErrMsg);
   if (!MArch) {
     emitError(ErrMsg);
     return false;
   }
 
   // Construct LTOModule, hand over ownership of module and target. Use MAttr as
   // the default set of features.
-  SubtargetFeatures Features(join(MAttrs, ""));
+  SubtargetFeatures Features(join(Config.MAttrs, ""));
   Features.getDefaultSubtargetFeatures(Triple);
   FeatureStr = Features.getString();
   // Set a default CPU for Darwin triples.
-  if (MCpu.empty() && Triple.isOSDarwin()) {
+  if (Config.CPU.empty() && Triple.isOSDarwin()) {
     if (Triple.getArch() == llvm::Triple::x86_64)
-      MCpu = "core2";
+      Config.CPU = "core2";
     else if (Triple.getArch() == llvm::Triple::x86)
-      MCpu = "yonah";
+      Config.CPU = "yonah";
     else if (Triple.isArm64e())
-      MCpu = "apple-a12";
+      Config.CPU = "apple-a12";
     else if (Triple.getArch() == llvm::Triple::aarch64 ||
              Triple.getArch() == llvm::Triple::aarch64_32)
-      MCpu = "cyclone";
+      Config.CPU = "cyclone";
   }
 
   TargetMach = createTargetMachine();
   assert(TargetMach && "Unable to create target machine");
 
   return true;
 }
 
 std::unique_ptr<TargetMachine> LTOCodeGenerator::createTargetMachine() {
   assert(MArch && "MArch is not set!");
   return std::unique_ptr<TargetMachine>(MArch->createTargetMachine(
-      TripleStr, MCpu, FeatureStr, Options, RelocModel, None, CGOptLevel));
+      TripleStr, Config.CPU, FeatureStr, Config.Options, Config.RelocModel,
+      None, Config.CGOptLevel));
 }
 
 // If a linkonce global is present in the MustPreserveSymbols, we need to make
 // sure we honor this. To force the compiler to not drop it, we add it to the
 // "llvm.compiler.used" global.
 void LTOCodeGenerator::preserveDiscardableGVs(
     Module &TheModule,
     llvm::function_ref<bool(const GlobalValue &)> mustPreserveGV) {
bool LTOCodeGenerator::optimize() {
   this->applyScopeRestrictions();
 
   // Write LTOPostLink flag for passes that require all the modules.
   MergedModule->addModuleFlag(Module::Error, "LTOPostLink", 1);
 
   // Add an appropriate DataLayout instance for this module...
   MergedModule->setDataLayout(TargetMach->createDataLayout());
 
-  lto::Config Conf = toConfig();
 
   ModuleSummaryIndex CombinedIndex(false);
   TargetMach = createTargetMachine();
-  if (!opt(Conf, TargetMach.get(), 0, *MergedModule, /*IsThinLTO=*/false,
+  if (!opt(Config, TargetMach.get(), 0, *MergedModule, /*IsThinLTO=*/false,
            /*ExportSummary=*/&CombinedIndex, /*ImportSummary=*/nullptr,
            /*CmdArgs*/ std::vector<uint8_t>())) {
     emitError("LTO middle-end optimizations failed");
     return false;
   }
 
   return true;
 }
 
 bool LTOCodeGenerator::compileOptimized(lto::AddStreamFn AddStream,
                                         unsigned ParallelismLevel) {
   if (!this->determineTarget())
     return false;
 
   // We always run the verifier once on the merged module.  If it has already
   // been called in optimize(), this call will return early.
   verifyMergedModuleOnce();
 
   // Re-externalize globals that may have been internalized to increase scope
   // for splitting
   restoreLinkageForExternals();
 
-  lto::Config Conf = toConfig();
   ModuleSummaryIndex CombinedIndex(false);
 
-  Error Err =
-      backend(Conf, AddStream, ParallelismLevel, *MergedModule, CombinedIndex);
+  Error Err = backend(Config, AddStream, ParallelismLevel, *MergedModule,
+                      CombinedIndex);
   assert(!Err && "unexpected code-generation failure");
   (void)Err;
 
   // If statistics were requested, save them to the specified file or
   // print them out after codegen.
   if (StatsFile)
     PrintStatisticsJSON(StatsFile->os());
   else if (AreStatisticsEnabled())