[LTO] Use lto::backend for code generation.

[fhahn]

Summary

This patch updates LTOCodeGenerator to use the utilities provided by
LTOBackend to run middle-end optimizations and backend code generation.

This is a first step towards unifying the code used by libLTO's C API
and the newer, C++ interface (see PR41541).

The immediate motivation is to allow using the new pass manager when
doing LTO using libLTO's C API, which is used on Darwin, among others.

With the changes, there are no codegen/stats differences when building
MultiSource/SPEC2000/SPEC2006 on Darwin X86 with LTO, compared
to without the patch.

[tejohnson]

Thanks, I'll take a look hopefully today. As I just mentioned in the bug, ThinLTOCodeGenerator has the same issue - will you be migrating that as well?

[tejohnson]

Haven't looked at the detailed changes yet, but a couple of high level comments/questions below.

llvm/lib/LTO/LTOCodeGenerator.cpp

286

Looks like there is a remaining call to this compileOptimized from llvm-lto.cpp. Should that be switched and compileOptimized removed? Without it left in llvm-lto.cpp, I'm wondering if the removal of initializeLTOPasses above will be an issue since llvm-lto.cpp is still invoking the old PM.

290

Note that backend() when not called in CodeGenOnly mode will pretty much just call opt() and codegen(). With some more restructuring you wouldn't need separate calls to opt() from optimize() and backend with CodeGenOnly=1 here, but rather a single call to backend. Maybe just add a FIXME or other note to that effect here? Because it seems like longer term some of this could be cleaned up.

[fhahn]

In D94487#2492933, @tejohnson wrote:

Thanks, I'll take a look hopefully today. As I just mentioned in the bug, ThinLTOCodeGenerator has the same issue - will you be migrating that as well?

Yes, I can do that as well, once LTOCodeGenerator.cpp is wrapped up.

llvm/include/llvm/LTO/LTO.h

199 ↗

(On Diff #316044)

this could do with a comment. The changes here are because the existing uses allocate a new raw_pwrite_stream in a closure, and NativeObjectStream owns that. but in LTOCodeGenerator, we already opened the stream earlier, so we just have a regular pointer.

llvm/lib/LTO/LTOCodeGenerator.cpp

284

I'll change that to just return.

290

Because it seems like longer term some of this could be cleaned up.

Agreed, I think the long-term plan is to further unify/simplify the code. But given that the test coverage of the code is relatively limited, I think it would be safest if we move in small, incremental steps, to limit any breakage and make it easier to track down issues.

[steven_wu]

I think this is good to be a first step. The approach is correct and left some small suggestion above. The linter warnings need to be fixed as well.

Thanks for working on this.

llvm/lib/LTO/LTOCodeGenerator.cpp

134

You need to remove the function declaration in include/llvm/LTO/legacy/LTOCodeGenerator.h

582–583

I will try to remove all legacy pass manager from LTOCodegenerator in one commit to avoid complication. You can do ThinLTOCodeGenerator in a separate commit.

[fhahn]

llvm/lib/LTO/LTOCodeGenerator.cpp

582–583

I think for that it might be best to expose the extension registration mechanism via lto::Config, so we can just configure it so it gets added to the pass manager used by splitCodegenand do not have to use a separate pass manager here?

[fhahn]

llvm/lib/LTO/LTOCodeGenerator.cpp

582–583

There's a patch that tackles this: D94547

[fhahn]

Rebased after splitting off a few more changes, updated code to create lto::Config object.

[fhahn]

Rebase after recent changes to D95222

[fhahn]

Rebased after all required patches except D95222 landed. All original issues should have been addressed now, so it is no longer WIP.

[steven_wu]

LGTM with only one comment.

llvm/include/llvm/LTO/LTO.h

202 ↗

(On Diff #319881)

I guess this only exists to support bool compileOptimized(ArrayRef<raw_pwrite_stream *> Out)?

That seems to only an interface used in llvm-lto which is a test tool. I wonder if we can just change the interface so we don't need to worry about if NativeObjectStream owning the output stream or not.

[dexonsmith]

llvm/include/llvm/LTO/LTO.h

198 ↗

(On Diff #319881)

As a drive-by comment: if this sticks around, please make construct this from a reference to prevent raw owned pointers from coming in this way (if we need a constructor from nullptr the unique_ptr constructor will still work). (That said, I agree with Steven that changing the test tool would be better.)

[fhahn]

Update compileOptimized to take AddStream callback and parallelism level, instead of outstream pointers.

[fhahn]

Remove stray newline

[fhahn]

Update llvm-lto to preserve existing behavior for -o -, undo unnecessary test changes;

llvm/include/llvm/LTO/LTO.h

198 ↗

(On Diff #319881)

Thanks, the code is gone now

202 ↗

(On Diff #319881)

I guess this only exists to support bool compileOptimized(ArrayRef<raw_pwrite_stream *> Out)?

There's a another users in LTOCodegenerator, but that can also be updated. I changed to interface to accept and AddStream callback and the parallelism level. This code is not longer needed.

[steven_wu]

This looks clean. LGTM. ThinLTO change in a separate commit?

[fhahn]

Thanks everyone!

In D94487#2531347, @steven_wu wrote:

This looks clean. LGTM. ThinLTO change in a separate commit?

I am planning on first moving/re-using as much from LTO.cpp and then take a look at ThinLTO

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

 
 #include "llvm-c/lto.h"
 #include "llvm/ADT/ArrayRef.h"
 #include "llvm/ADT/SmallPtrSet.h"
 #include "llvm/ADT/StringMap.h"
 #include "llvm/ADT/StringSet.h"
 #include "llvm/IR/GlobalValue.h"
 #include "llvm/IR/Module.h"
+#include "llvm/LTO/Config.h"
+#include "llvm/LTO/LTO.h"
 #include "llvm/Support/CommandLine.h"
 #include "llvm/Support/Error.h"
 #include "llvm/Support/ToolOutputFile.h"
 #include "llvm/Target/TargetMachine.h"
 #include "llvm/Target/TargetOptions.h"
 #include <string>
 #include <vector>
 

 /// 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.
struct LTOCodeGenerator {
   /// Calls \a verifyMergedModuleOnce().
   bool optimize();
 
   /// Compiles the merged optimized module into a single output file. It brings
   /// the output to a buffer, and returns the buffer to the caller. Return NULL
   /// if the compilation was not successful.
   std::unique_ptr<MemoryBuffer> compileOptimized();
 
-  /// Compile the merged optimized module into out.size() output files each
+  /// Compile the merged optimized module \p ParallelismLevel output files each
   /// representing a linkable partition of the module. If out contains more
-  /// than one element, code generation is done in parallel with out.size()
-  /// threads.  Output files will be written to members of out. Returns true on
-  /// success.
+  /// than one element, code generation is done in parallel with \p
+  /// 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(ArrayRef<raw_pwrite_stream *> Out);
+  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 setDisableVerify(bool Value) { DisableVerify = Value; }
 
   void setDiagnosticHandler(lto_diagnostic_handler_t, void *);
 
   LLVMContext &getContext() { return Context; }
 
   void resetMergedModule() { MergedModule.reset(); }
   void DiagnosticHandler(const DiagnosticInfo &DI);
 
 private:
-  void initializeLTOPasses();
-
   /// Verify the merged module on first call.
   ///
   /// Sets \a HasVerifiedInput on first call and doesn't run again on the same
   /// input.
   void verifyMergedModuleOnce();
 
   bool compileOptimizedToFile(const char **Name);
   void restoreLinkageForExternals();

llvm/lib/LTO/LTOCodeGenerator.cpp

 #include "llvm/IR/LLVMRemarkStreamer.h"
 #include "llvm/IR/LegacyPassManager.h"
 #include "llvm/IR/Mangler.h"
 #include "llvm/IR/Module.h"
 #include "llvm/IR/PassTimingInfo.h"
 #include "llvm/IR/Verifier.h"
 #include "llvm/InitializePasses.h"
 #include "llvm/LTO/LTO.h"
+#include "llvm/LTO/LTOBackend.h"
 #include "llvm/LTO/legacy/LTOModule.h"
 #include "llvm/LTO/legacy/UpdateCompilerUsed.h"
 #include "llvm/Linker/Linker.h"
 #include "llvm/MC/MCAsmInfo.h"
 #include "llvm/MC/MCContext.h"
 #include "llvm/MC/SubtargetFeature.h"
 #include "llvm/Remarks/HotnessThresholdParser.h"
 #include "llvm/Support/CommandLine.h"
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();
-  initializeLTOPasses();
 }
 
 LTOCodeGenerator::~LTOCodeGenerator() {}
 
-// Initialize LTO passes. Please keep this function in sync with
-// PassManagerBuilder::populateLTOPassManager(), and make sure all LTO
-// passes are initialized.
-void LTOCodeGenerator::initializeLTOPasses() {
-  PassRegistry &R = *PassRegistry::getPassRegistry();
-
-  initializeInternalizeLegacyPassPass(R);
-  initializeIPSCCPLegacyPassPass(R);
-  initializeGlobalOptLegacyPassPass(R);
-  initializeConstantMergeLegacyPassPass(R);
-  initializeDAHPass(R);
-  initializeInstructionCombiningPassPass(R);
-  initializeSimpleInlinerPass(R);
-  initializePruneEHPass(R);
-  initializeGlobalDCELegacyPassPass(R);
-  initializeOpenMPOptLegacyPassPass(R);
-  initializeArgPromotionPass(R);
-  initializeJumpThreadingPass(R);
-  initializeSROALegacyPassPass(R);
-  initializeAttributorLegacyPassPass(R);
-  initializeAttributorCGSCCLegacyPassPass(R);
-  initializePostOrderFunctionAttrsLegacyPassPass(R);
-  initializeReversePostOrderFunctionAttrsLegacyPassPass(R);
-  initializeGlobalsAAWrapperPassPass(R);
-  initializeLegacyLICMPassPass(R);
-  initializeMergedLoadStoreMotionLegacyPassPass(R);
-  initializeGVNLegacyPassPass(R);
-  initializeMemCpyOptLegacyPassPass(R);
-  initializeDCELegacyPassPass(R);
-  initializeCFGSimplifyPassPass(R);
+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) {
+    PM.add(createObjCARCContractPass());
+  };
+
+  return Conf;
 }
 
 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::writeMergedModules(StringRef Path) {
 
   Out.keep();
   return true;
 }
 
 bool LTOCodeGenerator::compileOptimizedToFile(const char **Name) {
   // make unique temp output file to put generated code
   SmallString<128> Filename;
-  int FD;
 
-  StringRef Extension
-      (FileType == CGFT_AssemblyFile ? "s" : "o");
+  auto AddStream =
+      [&](size_t Task) -> std::unique_ptr<lto::NativeObjectStream> {
+    StringRef Extension(FileType == CGFT_AssemblyFile ? "s" : "o");
 
+    int FD;
     std::error_code EC =
         sys::fs::createTemporaryFile("lto-llvm", Extension, FD, Filename);
-  if (EC) {
+    if (EC)
       emitError(EC.message());
-    return false;
-  }
 
-  // generate object file
-  ToolOutputFile objFile(Filename, FD);
+    return std::make_unique<lto::NativeObjectStream>(
+        std::make_unique<llvm::raw_fd_ostream>(FD, true));
+  };
 
-  bool genResult = compileOptimized(&objFile.os());
-  objFile.os().close();
-  if (objFile.os().has_error()) {
-    emitError((Twine("could not write object file: ") + Filename + ": " +
-               objFile.os().error().message())
-                  .str());
-    objFile.os().clear_error();
-    sys::fs::remove(Twine(Filename));
-    return false;
-  }
+  bool genResult = compileOptimized(AddStream, 1);
 
-  objFile.keep();
   if (!genResult) {
     sys::fs::remove(Twine(Filename));
     return false;
   }
 
+  // If statistics were requested, save them to the specified file or
+  // print them out after codegen.
+  if (StatsFile)
+    PrintStatisticsJSON(StatsFile->os());
+  else if (AreStatisticsEnabled())
+    PrintStatistics();
+
   NativeObjectPath = Filename.c_str();
   *Name = NativeObjectPath.c_str();
   return true;
 }
 
 std::unique_ptr<MemoryBuffer>
 LTOCodeGenerator::compileOptimized() {
   const char *name;
   if (!compileOptimizedToFile(&name))
     return nullptr;
bool LTOCodeGenerator::optimize() {
   verifyMergedModuleOnce();
 
   // Mark which symbols can not be internalized
   this->applyScopeRestrictions();
 
   // Write LTOPostLink flag for passes that require all the modules.
   MergedModule->addModuleFlag(Module::Error, "LTOPostLink", 1);
 
-  // Instantiate the pass manager to organize the passes.
-  legacy::PassManager passes;
-
   // Add an appropriate DataLayout instance for this module...
   MergedModule->setDataLayout(TargetMach->createDataLayout());
 
-  passes.add(
-      createTargetTransformInfoWrapperPass(TargetMach->getTargetIRAnalysis()));
-
-  Triple TargetTriple(TargetMach->getTargetTriple());
-  PassManagerBuilder PMB;
-  PMB.LoopVectorize = true;
-  PMB.SLPVectorize = true;
-  PMB.Inliner = createFunctionInliningPass();
-  PMB.LibraryInfo = new TargetLibraryInfoImpl(TargetTriple);
-  if (Freestanding)
-    PMB.LibraryInfo->disableAllFunctions();
-  PMB.OptLevel = OptLevel;
-  PMB.VerifyInput = !DisableVerify;
-  PMB.VerifyOutput = !DisableVerify;
-
-  PMB.populateLTOPassManager(passes);
+  lto::Config Conf = toConfig();
 
-  // Run our queue of passes all at once now, efficiently.
-  passes.run(*MergedModule);
+  ModuleSummaryIndex CombinedIndex(false);
+  TargetMach = createTargetMachine();
+  if (!opt(Conf, 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(ArrayRef<raw_pwrite_stream *> Out) {
+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();
 
-  legacy::PassManager preCodeGenPasses;
-
-  // If the bitcode files contain ARC code and were compiled with optimization,
-  // the ObjCARCContractPass must be run, so do it unconditionally here.
-  preCodeGenPasses.add(createObjCARCContractPass());
-  preCodeGenPasses.run(*MergedModule);
-
   // Re-externalize globals that may have been internalized to increase scope
   // for splitting
   restoreLinkageForExternals();
 
-  splitCodeGen(
-      *MergedModule, Out, {}, [&]() { return createTargetMachine(); }, FileType,
-      ShouldRestoreGlobalsLinkage);
+  lto::Config Conf = toConfig();
+  ModuleSummaryIndex CombinedIndex(false);
+
+  Error Err =
+      backend(Conf, 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())
     PrintStatistics();
 

llvm/test/LTO/X86/disable-verify.ll

 ; RUN: llvm-as < %s >%t.bc
 ; RUN: llvm-lto -debug-pass=Arguments -exported-symbol=_f -o /dev/null %t.bc 2>&1 -disable-verify | FileCheck %s
 ; RUN: llvm-lto -debug-pass=Arguments -exported-symbol=_f -o /dev/null %t.bc 2>&1 | FileCheck %s -check-prefix=VERIFY
 
 target datalayout = "e-m:o-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128"
 target triple = "x86_64-apple-macosx10.10.0"
 
 ; -disable-verify should disable verification from the optimization pipeline.
 ; CHECK: Pass Arguments:
-; CHECK-NOT: -verify
+; CHECK-NOT: -verify {{.*}} -verify
 
 ; VERIFY: Pass Arguments: {{.*}} -verify {{.*}} -verify
 
 define void @f() {
 entry:
   ret void
 }

llvm/test/tools/lto/print-stats.ll

 ; RUN: llvm-as %s -o %t.o
 ; RUN: %ld64 -lto_library %llvmshlibdir/libLTO.dylib -arch x86_64 -dylib -mllvm -stats -o %t.dylib %t.o 2>&1 | FileCheck --check-prefix=STATS %s
 ; RUN: %ld64 -lto_library %llvmshlibdir/libLTO.dylib -arch x86_64 -dylib -o %t.dylib %t.o 2>&1 | FileCheck --check-prefix=NO_STATS %s
 ; REQUIRES: asserts
 
 target triple = "x86_64-apple-macosx10.8.0"
 
+define i32 @test(i32 %a) {
+  %r = add i32 %a, 1
+  %r.1 = add i32 1, %a
+  %r.2 = add i32 %r, %r.1
+  ret i32 %r.2
+}
+
 ; STATS: Statistics Collected
 ; NO_STATS-NOT: Statistics Collected

llvm/tools/llvm-lto/llvm-lto.cpp

if (SaveModuleFile) {
       std::string ModuleFilename = OutputFilename;
       ModuleFilename += ".merged.bc";
       std::string ErrMsg;
 
       if (!CodeGen.writeMergedModules(ModuleFilename))
         error("writing merged module failed.");
     }
 
-    std::list<ToolOutputFile> OSs;
-    std::vector<raw_pwrite_stream *> OSPtrs;
-    for (unsigned I = 0; I != Parallelism; ++I) {
+    auto AddStream =
+        [&](size_t Task) -> std::unique_ptr<lto::NativeObjectStream> {
       std::string PartFilename = OutputFilename;
       if (Parallelism != 1)
-        PartFilename += "." + utostr(I);
+        PartFilename += "." + utostr(Task);
+
       std::error_code EC;
-      OSs.emplace_back(PartFilename, EC, sys::fs::OF_None);
+      auto S =
+          std::make_unique<raw_fd_ostream>(PartFilename, EC, sys::fs::OF_None);
       if (EC)
         error("error opening the file '" + PartFilename + "': " + EC.message());
-      OSPtrs.push_back(&OSs.back().os());
-    }
+      return std::make_unique<lto::NativeObjectStream>(std::move(S));
+    };
 
-    if (!CodeGen.compileOptimized(OSPtrs))
+    if (!CodeGen.compileOptimized(AddStream, Parallelism))
       // Diagnostic messages should have been printed by the handler.
       error("error compiling the code");
 
-    for (ToolOutputFile &OS : OSs)
-      OS.keep();
   } else {
     if (Parallelism != 1)
       error("-j must be specified together with -o");
 
     if (SaveModuleFile)
       error(": -save-merged-module must be specified with -o");
 
     const char *OutputName = nullptr;