[LTO] Add option to generate optimization records

[anemet]

Summary

It is used to drive this from the clang driver via -mllvm.

Same option name is used as in opt.

[davide]

lib/LTO/LTOCodeGenerator.cpp

96–100

Side note, I very much dislike adding other cl::opt in library code, but this is what we have now. If I recall correctly, @beanz has plans for moving away of them, but not sure how far away it is.
If you use the new lib/LTO interface maybe you will be able to get rid of it (but you should use llvm-lto2 to test.

521–523

have you already diagnosed why?

570–571

nit, typo: Optimiation

[anemet]

lib/LTO/LTOCodeGenerator.cpp

96–100

Does the Darwin linker support the new interface?

521–523

I *think* that's a known bug in our linker. Mehdi can correct me if I am wrong.

[davide]

LGTM with the remaining comment fixed but please wait for a second opinion.

lib/LTO/LTOCodeGenerator.cpp

96–100

I don't know about ld64 (and I don't think you're talking about lld as it doesn't do LTO on Mach-O).
So, unfortunately, it seems that cl::opt is the only viable option.

521–523

Fair enough.

[mehdi_amini]

lib/LTO/LTOCodeGenerator.cpp

96–100

In general it is not OK to use cl::opt for "user interface" or "api option" in library.
However I don't believe there is any other option here, and as long as it is contained in the LTOCodeGenerator that's fine: cl::opt is the way to initialize it on Darwin.
That said I think we should contain them in lto.cpp and expose APIs in LTOCodeGenerator.
We added two in LTOCodegenerator already, but that wasn't the right thing to do.

519

s/Optimiation/Optimization/

521–523

This is similarly to clang that does not destroy the context in production, the Darwin linker does not clear any state before exiting.

[mehdi_amini]

llvm/trunk/lib/LTO/LTOCodeGenerator.cpp

570 ↗

(On Diff #78550)

Actually there is an issue with this code: the backend can also emit remarks, but they may not be in the file, or the file be truncated because you flushed early but not after the backend it complete.

[anemet]

llvm/trunk/lib/LTO/LTOCodeGenerator.cpp

570 ↗

(On Diff #78550)

So I guess we need to call this in compileOptimized. I'll take a look after the Thanksgiving break.

[anemet]

llvm/trunk/lib/LTO/LTOCodeGenerator.cpp

570 ↗

(On Diff #78550)

(For the record, there are no remarks emitted during codegen right now but that should hopefully change soon.)

[mehdi_amini]

llvm/trunk/lib/LTO/LTOCodeGenerator.cpp

570 ↗

(On Diff #78550)

Yes I think so. It seems that llvm::PrintStatistics(); is already handled here, this seems somehow the same concept.

[anemet]

For the record, this option was renamed to -lto-pass-remarks-output (r287627, r287628) because it broke LLVM_LINK_LLVM_DYLIB due to duplicate option name with opt.

[anemet]

llvm/trunk/lib/LTO/LTOCodeGenerator.cpp

570 ↗

(On Diff #78550)

Committed this in r288041.

include/llvm/LTO/legacy/LTOCodeGenerator.h

 #define LLVM_LTO_LTOCODEGENERATOR_H
 
 #include "llvm-c/lto.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/Support/ToolOutputFile.h"
 #include "llvm/Target/TargetMachine.h"
 #include "llvm/Target/TargetOptions.h"
 #include <string>
 #include <vector>
 
 namespace llvm {
 template <typename T> class ArrayRef;
   class LLVMContext;
private:
 
   static void DiagnosticHandler(const DiagnosticInfo &DI, void *Context);
 
   void DiagnosticHandler2(const DiagnosticInfo &DI);
 
   void emitError(const std::string &ErrMsg);
   void emitWarning(const std::string &ErrMsg);
 
+  bool setupOptimizationRemarks();
+  void finishOptimiationRemarks();
+
   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;
private:
   std::string TripleStr;
   unsigned OptLevel = 2;
   lto_diagnostic_handler_t DiagHandler = nullptr;
   void *DiagContext = nullptr;
   bool ShouldInternalize = true;
   bool ShouldEmbedUselists = false;
   bool ShouldRestoreGlobalsLinkage = false;
   TargetMachine::CodeGenFileType FileType = TargetMachine::CGFT_ObjectFile;
+  std::unique_ptr<tool_output_file> DiagnosticOutputFile;
 };
 }
 #endif

lib/LTO/LTOCodeGenerator.cpp

 #include "llvm/Support/CommandLine.h"
 #include "llvm/Support/FileSystem.h"
 #include "llvm/Support/Host.h"
 #include "llvm/Support/MemoryBuffer.h"
 #include "llvm/Support/Signals.h"
 #include "llvm/Support/TargetRegistry.h"
 #include "llvm/Support/TargetSelect.h"
 #include "llvm/Support/ToolOutputFile.h"
+#include "llvm/Support/YAMLTraits.h"
 #include "llvm/Support/raw_ostream.h"
 #include "llvm/Target/TargetLowering.h"
 #include "llvm/Target/TargetOptions.h"
 #include "llvm/Target/TargetRegisterInfo.h"
 #include "llvm/Target/TargetSubtargetInfo.h"
 #include "llvm/Transforms/IPO.h"
 #include "llvm/Transforms/IPO/Internalize.h"
 #include "llvm/Transforms/IPO/PassManagerBuilder.h"

 #ifdef NDEBUG
     cl::init(true),
 #else
     cl::init(false),
 #endif
     cl::Hidden);
 }
 
+static cl::opt<std::string>
+    RemarksFilename("pass-remarks-output",
+                    cl::desc("Output filename for pass remarks"),
+                    cl::value_desc("filename"));
+
 LTOCodeGenerator::LTOCodeGenerator(LLVMContext &Context)
     : Context(Context), MergedModule(new Module("ld-temp.o", Context)),
       TheLinker(new Linker(*MergedModule)) {
   Context.setDiscardValueNames(LTODiscardValueNames);
   Context.enableDebugTypeODRUniquing();
   initializeLTOPasses();
 }
 
if (BrokenDebugInfo) {
       emitWarning("Invalid debug info found, debug info will be stripped");
       StripDebugInfo(*MergedModule);
     }
   }
   if (verifyModule(*MergedModule, &dbgs()))
     report_fatal_error("Broken module found, compilation aborted!");
 }
 
+bool LTOCodeGenerator::setupOptimizationRemarks() {
+  if (RemarksFilename != "") {
+    std::error_code EC;
+    DiagnosticOutputFile = llvm::make_unique<tool_output_file>(
+        RemarksFilename, EC, sys::fs::F_None);
+    if (EC) {
+      errs() << EC.message() << '\n';
+      return false;
+    }
+    Context.setDiagnosticsOutputFile(
+        new yaml::Output(DiagnosticOutputFile->os()));
+  }
+  return true;
+}
+
+void LTOCodeGenerator::finishOptimiationRemarks() {
+  if (DiagnosticOutputFile) {
+    DiagnosticOutputFile->keep();
+    // FIXME: LTOCodeGenerator dtor is not invoked on Darwin
+    DiagnosticOutputFile->os().flush();
+  }
+}
+
 /// Optimize merged modules using various IPO passes
 bool LTOCodeGenerator::optimize(bool DisableVerify, bool DisableInline,
                                 bool DisableGVNLoadPRE,
                                 bool DisableVectorization) {
   if (!this->determineTarget())
     return false;
 
+  if (!setupOptimizationRemarks())
+    return false;
+
   // We always run the verifier once on the merged module, the `DisableVerify`
   // parameter only applies to subsequent verify.
   verifyMergedModuleOnce();
 
   // Mark which symbols can not be internalized
   this->applyScopeRestrictions();
 
   // Instantiate the pass manager to organize the passes.
bool LTOCodeGenerator::optimize(bool DisableVerify, bool DisableInline,
   PMB.VerifyInput = !DisableVerify;
   PMB.VerifyOutput = !DisableVerify;
 
   PMB.populateLTOPassManager(passes);
 
   // Run our queue of passes all at once now, efficiently.
   passes.run(*MergedModule);
 
+  finishOptimiationRemarks();
+
   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

test/LTO/X86/diagnostic-handler-remarks.ll

 ; RUN: llvm-nm %t.o | FileCheck %s -check-prefix NM
 
 ; RUN: llvm-lto -use-diagnostic-handler \
 ; RUN:         -exported-symbol _func2 \
 ; RUN:         -exported-symbol _main -o %t.o %t.bc 2>&1 | \
 ; RUN:     FileCheck %s -allow-empty
 ; RUN: llvm-nm %t.o | FileCheck %s -check-prefix NM
 
+; Optimization records are collected regardless of the diagnostic handler
+; RUN: llvm-lto -pass-remarks-output=%t.yaml \
+; RUN:          -exported-symbol _func2 \
+; RUN:          -exported-symbol _main -o %t.o %t.bc 2>&1 | \
+; RUN:     FileCheck %s -allow-empty
+; RUN: cat %t.yaml | FileCheck %s -check-prefix=YAML
+
 ; REMARKS: remark: {{.*}} foo inlined into main
 ; REMARKS: remark: {{.*}} loop not vectorized: cannot prove it is safe to reorder memory operations
 ; REMARKS_DH: llvm-lto: remark: {{.*}} foo inlined into main
 ; REMARKS_DH: llvm-lto: remark: {{.*}} loop not vectorized: cannot prove it is safe to reorder memory operations
 ; CHECK-NOT: remark:
 ; CHECK-NOT: llvm-lto:
 ; NM-NOT: foo
 ; NM: func2
 ; NM: main
 
+; YAML: --- !Passed
+; YAML: Pass:            inline
+; YAML: Name:            Inlined
+; YAML: Function:        main
+; YAML: Args:
+; YAML:   - Callee:          foo
+; YAML:   - String:          ' inlined into '
+; YAML:   - Caller:          main
+; YAML: ...
+
 target triple = "x86_64-apple-darwin"
 
 declare i32 @bar()
 
 define i32 @foo() {
   %a = call i32 @bar()
   ret i32 %a
 }