[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.

291

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

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

285

I'll change that to just return.

291

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

588–589

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

588–589

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

588–589

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

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

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

Thanks, the code is gone now

202

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/LTO.h

 
 /// This class wraps an output stream for a native object. Most clients should
 /// just be able to return an instance of this base class from the stream
 /// callback, but if a client needs to perform some action after the stream is
 /// written to, that can be done by deriving from this class and overriding the
 /// destructor.
 class NativeObjectStream {
 public:
-  NativeObjectStream(std::unique_ptr<raw_pwrite_stream> OS) : OS(std::move(OS)) {}
-  std::unique_ptr<raw_pwrite_stream> OS;
+  NativeObjectStream(std::unique_ptr<raw_pwrite_stream> OS)
+      : OS_(std::move(OS)) {
+    this->OS = &*this->OS_;
+  }
+  NativeObjectStream(raw_pwrite_stream *OS) : OS(OS) {}
+  /// NativeObjectStream may own the allocation of the used raw_pwrite_stream,
+  /// if the caller requested that.
+  std::unique_ptr<raw_pwrite_stream> OS_;
+  raw_pwrite_stream *OS;
   virtual ~NativeObjectStream() = default;
 };
 
 /// This type defines the callback to add a native object that is generated on
 /// the fly.
 ///
 /// Stream callbacks must be thread safe.
 using AddStreamFn =

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/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 {
   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/Caching.cpp

struct CacheStream : NativeObjectStream {
                   sys::fs::TempFile TempFile, std::string EntryPath,
                   unsigned Task)
           : NativeObjectStream(std::move(OS)), AddBuffer(std::move(AddBuffer)),
             TempFile(std::move(TempFile)), EntryPath(std::move(EntryPath)),
             Task(Task) {}
 
       ~CacheStream() {
         // Make sure the stream is closed before committing it.
-        OS.reset();
+        OS_.reset();
+        OS = nullptr;
 
         // Open the file first to avoid racing with a cache pruner.
         ErrorOr<std::unique_ptr<MemoryBuffer>> MBOrErr =
             MemoryBuffer::getOpenFile(
                 sys::fs::convertFDToNativeFile(TempFile.FD), TempFile.TmpName,
                 /*FileSize=*/-1, /*RequiresNullTerminator=*/false);
         if (!MBOrErr)
           report_fatal_error(Twine("Failed to open new cache file ") +

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::compileOptimizedToFile(const char **Name) {
   if (EC) {
     emitError(EC.message());
     return false;
   }
 
   // generate object file
   ToolOutputFile objFile(Filename, FD);
 
   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;
   }
 
   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;
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) {
   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);
+  auto AddStream =
+      [&](size_t Task) -> std::unique_ptr<lto::NativeObjectStream> {
+    return std::make_unique<lto::NativeObjectStream>(Out[Task]);
+  };
 
   // Re-externalize globals that may have been internalized to increase scope
   // for splitting
   restoreLinkageForExternals();
 
+  lto::Config Conf = toConfig();
+  ModuleSummaryIndex CombinedIndex(false);
+
   // Do code generation. We need to preserve the module in case the client calls
   // writeMergedModules() after compilation, but we only need to allow this at
-  // parallelism level 1. This is achieved by having splitCodeGen return the
-  // original module at parallelism level 1 which we then assign back to
-  // MergedModule.
-  MergedModule = splitCodeGen(std::move(MergedModule), Out, {},
-                              [&]() { return createTargetMachine(); }, FileType,
-                              ShouldRestoreGlobalsLinkage);
+  // parallelism level 1. lto::backend will return back the unmodified
+  // MergedModule if parallelism level is 1.
+  auto Result = backend(Conf, AddStream, Out.size(), std::move(MergedModule),
+                        CombinedIndex);
+  if (Result && *Result)
+    MergedModule = std::move(*Result);
 
   // 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