[ThinLTO] Implement -pass-remarks-output in ThinLTOCodeGenerator

[mehdi_amini]

Summary

This will also be added to the LTO API, right now this will
bring ThinLTO on par with Monolithic LTO on Darwin.

[mehdi_amini]

Teresa: there is some opportunity to improve the output to track what imported function was inlined or not. Piotr added some infrastructure, but likely not in the right format.

[tejohnson]

LGTM

Adding this to the LTO API as you mentioned would be good.

[anemet]

Thanks, Mehdi!

[davide]

llvm/trunk/lib/LTO/ThinLTOCodeGenerator.cpp

858–863 ↗

(On Diff #78638)

I'm working on refactoring this so we can share between old and new LTO API. I noticed that if you comment out this block of code, the test still passes. Any ideas on how we can better test this?

[davide]

llvm/trunk/lib/LTO/ThinLTOCodeGenerator.cpp

858–863 ↗

(On Diff #78638)

Fixed in r294784.

[anemet]

llvm/trunk/lib/LTO/ThinLTOCodeGenerator.cpp

858–863 ↗

(On Diff #78638)

Thanks!

llvm/lib/LTO/LTOCodeGenerator.cpp

cl::opt<bool> LTOStripInvalidDebugInfo(
     "lto-strip-invalid-debug-info",
     cl::desc("Strip invalid debug info metadata during LTO instead of aborting."),
 #ifdef NDEBUG
     cl::init(true),
 #else
     cl::init(false),
 #endif
     cl::Hidden);
-}
 
-static cl::opt<std::string>
-    RemarksFilename("pass-remarks-output",
+cl::opt<std::string>
+    LTORemarksFilename("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) {
       StripDebugInfo(*MergedModule);
     }
   }
   if (verifyModule(*MergedModule, &dbgs()))
     report_fatal_error("Broken module found, compilation aborted!");
 }
 
 bool LTOCodeGenerator::setupOptimizationRemarks() {
-  if (RemarksFilename != "") {
+  if (LTORemarksFilename != "") {
     std::error_code EC;
     DiagnosticOutputFile = llvm::make_unique<tool_output_file>(
-        RemarksFilename, EC, sys::fs::F_None);
+        LTORemarksFilename, EC, sys::fs::F_None);
     if (EC) {
       emitError(EC.message());
       return false;
     }
     Context.setDiagnosticsOutputFile(
         llvm::make_unique<yaml::Output>(DiagnosticOutputFile->os()));
   }
   return true;

llvm/lib/LTO/ThinLTOCodeGenerator.cpp

 #include "llvm/IRReader/IRReader.h"
 #include "llvm/LTO/LTO.h"
 #include "llvm/Linker/Linker.h"
 #include "llvm/MC/SubtargetFeature.h"
 #include "llvm/Object/IRObjectFile.h"
 #include "llvm/Object/ModuleSummaryIndexObjectFile.h"
 #include "llvm/Support/CachePruning.h"
 #include "llvm/Support/Debug.h"
+#include "llvm/Support/Error.h"
 #include "llvm/Support/Path.h"
 #include "llvm/Support/SHA1.h"
 #include "llvm/Support/TargetRegistry.h"
 #include "llvm/Support/ThreadPool.h"
 #include "llvm/Support/Threading.h"
+#include "llvm/Support/ToolOutputFile.h"
 #include "llvm/Target/TargetMachine.h"
 #include "llvm/Transforms/IPO.h"
 #include "llvm/Transforms/IPO/FunctionImport.h"
 #include "llvm/Transforms/IPO/Internalize.h"
 #include "llvm/Transforms/IPO/PassManagerBuilder.h"
 #include "llvm/Transforms/ObjCARC.h"
 #include "llvm/Transforms/Utils/FunctionImportUtils.h"
 
 #include <numeric>
 
 using namespace llvm;
 
 #define DEBUG_TYPE "thinlto"
 
 namespace llvm {
 // Flags -discard-value-names, defined in LTOCodeGenerator.cpp
 extern cl::opt<bool> LTODiscardValueNames;
+extern cl::opt<std::string> LTORemarksFilename;
 }
 
 namespace {
 
 static cl::opt<int>
     ThreadCount("threads", cl::init(llvm::heavyweight_hardware_concurrency()));
 
+Expected<std::unique_ptr<tool_output_file>>
+setupOptimizationRemarks(LLVMContext &Ctx, int Count) {
+  if (LTORemarksFilename.empty())
+    return nullptr;
+
+  std::string FileName =
+      LTORemarksFilename + ".thin." + llvm::utostr(Count) + ".yaml";
+  std::error_code EC;
+  auto DiagnosticOutputFile =
+      llvm::make_unique<tool_output_file>(FileName, EC, sys::fs::F_None);
+  if (EC)
+    return errorCodeToError(EC);
+  Ctx.setDiagnosticsOutputFile(
+      llvm::make_unique<yaml::Output>(DiagnosticOutputFile->os()));
+  DiagnosticOutputFile->keep();
+  return std::move(DiagnosticOutputFile);
+}
+
 // Simple helper to save temporary files for debug.
 static void saveTempBitcode(const Module &TheModule, StringRef TempDir,
                             unsigned count, StringRef Suffix) {
   if (TempDir.empty())
     return;
   // User asked to save temps, let dump the bitcode file after import.
   std::string SaveTempPath = (TempDir + llvm::utostr(count) + Suffix).str();
   std::error_code EC;
for (auto IndexCount : ModulesOrdering) {
             ProducedBinaries[count] = std::move(ErrOrBuffer.get());
             return;
           }
         }
 
         LLVMContext Context;
         Context.setDiscardValueNames(LTODiscardValueNames);
         Context.enableDebugTypeODRUniquing();
+        auto DiagFileOrErr = setupOptimizationRemarks(Context, count);
+        if (!DiagFileOrErr) {
+          errs() << "Error: " << toString(DiagFileOrErr.takeError()) << "\n";
+          report_fatal_error("ThinLTO: Can't get an output file for the "
+                             "remarks");
+        }
 
         // Parse module now
         auto TheModule = loadModuleFromBuffer(ModuleBuffer, Context, false);
 
         // Save temps: original file.
         saveTempBitcode(*TheModule, SaveTempsDir, count, ".0.original.bc");
 
         auto &ImportList = ImportLists[ModuleIdentifier];

llvm/test/ThinLTO/X86/Inputs/diagnostic-handler-remarks.ll

+target datalayout = "e-m:o-i64:64-f80:128-n8:16:32:64-S128"
+target triple = "x86_64-apple-macosx10.11.0"
+
+
+declare i32 @bar()
+define i32 @foo() {
+  %a = call i32 @bar()
+  ret i32 %a
+}
+

llvm/test/ThinLTO/X86/diagnostic-handler-remarks.ll

+; RUN: opt -module-summary %s -o %t1.bc
+; RUN: opt -module-summary %p/Inputs/diagnostic-handler-remarks.ll -o %t2.bc
+
+; Optimization records are collected regardless of the diagnostic handler
+; RUN: llvm-lto -thinlto-action=run \
+; RUN:          -pass-remarks-output=%t.yaml \
+; RUN:          -exported-symbol _func2 \
+; RUN:          -exported-symbol _main %t1.bc %t2.bc 2>&1 | \
+; RUN:     FileCheck %s -allow-empty
+; CHECK-NOT: remark:
+; CHECK-NOT: llvm-lto:
+
+
+; Verify that bar is imported and inlined into foo
+; RUN: cat %t.yaml.thin.0.yaml | FileCheck %s -check-prefix=YAML1
+; YAML1: --- !Passed
+; YAML1: Pass:            inline
+; YAML1: Name:            Inlined
+; YAML1: Function:        main
+; YAML1: Args:
+; YAML1:   - Callee:          foo
+; YAML1:   - String:          ' inlined into '
+; YAML1:   - Caller:          main
+; YAML1: ...
+
+
+; Verify that bar is imported and inlined into foo
+; RUN: cat %t.yaml.thin.1.yaml | FileCheck %s -check-prefix=YAML2
+; YAML2: --- !Passed
+; YAML2: Pass:            inline
+; YAML2: Name:            Inlined
+; YAML2: Function:        foo
+; YAML2: Args:
+; YAML2:   - Callee:          bar
+; YAML2:   - String:          ' inlined into '
+; YAML2:   - Caller:          foo
+; YAML2: ...
+
+
+target datalayout = "e-m:o-i64:64-f80:128-n8:16:32:64-S128"
+target triple = "x86_64-apple-macosx10.11.0"
+
+define i32 @bar() {
+  ret i32 42
+}
+declare i32 @foo()
+define i32 @main() {
+  %i = call i32 @foo()
+  ret i32 %i
+}
+