[LTO] Adds a "CodeGenOnly" option. Allows the client to skip the optimizer.

[mehdi_amini]

Summary

Slowly getting on par with libLTO

[tejohnson]

Looks fine but need a test? Is this used for debugging?

[mehdi_amini]

It will be tested by test/ThinLTO/X86/funcimport.ll as soon as ThinLTOCodeGenerator is converted (llvm-lto -thinlto-action=codegen).
Unfortunately, llvm-lto2 is far from on par with llvm-lto at this point and makes it hard to test specific parts of the API.

[davide]

Shouldn't this be semantically equivalent to -O0 ?

[mehdi_amini]

In D23615#520723, @davide wrote:

Shouldn't this be semantically equivalent to -O0 ?

Not really, O0 runs the always inliner, and uses fast-isel.

[davide]

Looks good then. Thanks Mehdi!

[pcc]

It looks like we never added testing for this flag. Can we remove it?

[mehdi_amini]

This commit was part of the series to get rid of ThinLTOCodeGenerator. Removing this would makes the current state of the "new LTO" further away of the features exposed by ThinLTOCodeGenerator.

llvm/trunk/include/llvm/LTO/Config.h

struct Config {
   TargetOptions Options;
   std::vector<std::string> MAttrs;
   Reloc::Model RelocModel = Reloc::PIC_;
   CodeModel::Model CodeModel = CodeModel::Default;
   CodeGenOpt::Level CGOptLevel = CodeGenOpt::Default;
   unsigned OptLevel = 2;
   bool DisableVerify = false;
 
+  /// Disable entirely the optimizer, including importing for ThinLTO
+  bool CodeGenOnly = false;
+
   /// Setting this field will replace target triples in input files with this
   /// triple.
   std::string OverrideTriple;
 
   /// Setting this field will replace unspecified target triples in input files
   /// with this triple.
   std::string DefaultTriple;
 

llvm/trunk/lib/LTO/LTO.cpp

Error LTO::run(AddOutputFn AddOutput) {
   return runThinLTO(AddOutput);
 }
 
 Error LTO::runRegularLTO(AddOutputFn AddOutput) {
   if (Conf.PreOptModuleHook &&
       !Conf.PreOptModuleHook(0, *RegularLTO.CombinedModule))
     return Error();
 
+  if (!Conf.CodeGenOnly) {
     for (const auto &R : GlobalResolutions) {
       if (R.second.IRName.empty())
         continue;
       if (R.second.Partition != 0 &&
           R.second.Partition != GlobalResolution::External)
         continue;
 
-    GlobalValue *GV = RegularLTO.CombinedModule->getNamedValue(R.second.IRName);
+      GlobalValue *GV =
+          RegularLTO.CombinedModule->getNamedValue(R.second.IRName);
       // Ignore symbols defined in other partitions.
       if (!GV || GV->hasLocalLinkage())
         continue;
       GV->setUnnamedAddr(R.second.UnnamedAddr ? GlobalValue::UnnamedAddr::Global
                                               : GlobalValue::UnnamedAddr::None);
       if (R.second.Partition == 0)
         GV->setLinkage(GlobalValue::InternalLinkage);
     }
 
     if (Conf.PostInternalizeModuleHook &&
         !Conf.PostInternalizeModuleHook(0, *RegularLTO.CombinedModule))
       return Error();
-
+  }
   return backend(Conf, AddOutput, RegularLTO.ParallelCodeGenParallelismLevel,
                  std::move(RegularLTO.CombinedModule));
 }
 
 /// This class defines the interface to the ThinLTO backend.
 class lto::ThinBackendProc {
 protected:
   Config &Conf;

llvm/trunk/lib/LTO/LTOBackend.cpp

Error lto::backend(Config &C, AddOutputFn AddOutput,
                    std::unique_ptr<Module> M) {
   Expected<const Target *> TOrErr = initAndLookupTarget(C, *M);
   if (!TOrErr)
     return TOrErr.takeError();
 
   std::unique_ptr<TargetMachine> TM =
       createTargetMachine(C, M->getTargetTriple(), *TOrErr);
 
+  if (!C.CodeGenOnly)
     if (!opt(C, TM.get(), 0, *M, /*IsThinLto=*/false))
       return Error();
 
   if (ParallelCodeGenParallelismLevel == 1)
     codegen(C, TM.get(), AddOutput, 0, *M);
   else
     splitCodeGen(C, TM.get(), AddOutput, ParallelCodeGenParallelismLevel,
                  std::move(M));
   return Error();
 }
 
 Error lto::thinBackend(Config &Conf, unsigned Task, AddOutputFn AddOutput,
                        Module &Mod, ModuleSummaryIndex &CombinedIndex,
                        const FunctionImporter::ImportMapTy &ImportList,
                        const GVSummaryMapTy &DefinedGlobals,
                        MapVector<StringRef, MemoryBufferRef> &ModuleMap) {
   Expected<const Target *> TOrErr = initAndLookupTarget(Conf, Mod);
   if (!TOrErr)
     return TOrErr.takeError();
 
   std::unique_ptr<TargetMachine> TM =
       createTargetMachine(Conf, Mod.getTargetTriple(), *TOrErr);
 
+  if (Conf.CodeGenOnly) {
+    codegen(Conf, TM.get(), AddOutput, Task, Mod);
+    return Error();
+  }
+
   if (Conf.PreOptModuleHook && !Conf.PreOptModuleHook(Task, Mod))
     return Error();
 
   renameModuleForThinLTO(Mod, CombinedIndex);
 
   thinLTOResolveWeakForLinkerModule(Mod, DefinedGlobals);
 
   if (Conf.PostPromoteModuleHook && !Conf.PostPromoteModuleHook(Task, Mod))