[llvm-reduce] Add support for LTO bitcode files

[ormris]

Summary

Adds support for reading and writing LTO bitcode files. While this feature can be replicated by stripping and regenerating summaries via opt, this patch makes reducing LTO bitcode a transparent process with no extra boiler-plate. This is especially useful when split LTO units are needed, as the process to generate them can be less than obvious.

[ormris]

Add context

[arsenm]

tools/llvm-reduce/ReducerWorkItem.cpp

425

Single quotes around newline

434

Why is this returning a default constructed ReducerWorkItem instead of null? I see some other places are doing this but I don't see how this makes sense

441

Why does an IR reduction need to initialize target info?

455

Why this change?

tools/llvm-reduce/llvm-reduce.cpp

121

Do you really need a pass manager (a legacy one at that) just to write out the file? Why isn't there a simple function to use?

137

Other places propagate the tool name from argv

144

Ditto

[ormris]

tools/llvm-reduce/ReducerWorkItem.cpp

425

Fixed.

434

I opted for this to stay consistent with the surrounding code. Nonetheless, nullptr is more efficient at the same task, so I'll go ahead and use that instead.

441

The ThinLTOBitcodeWriter pass depends on target info. It crashes without it.

455

That change is no longer needed. I'll remove it.

tools/llvm-reduce/llvm-reduce.cpp

121

Unfortunately, there isn't. If you look at opt, you'll see the same strategy.

137

Fixed. I've added the tool name to the TestRunner class, so that it's accessible.

144

See above.

[ormris]

• Add toolname to errors
• Remove unnecessary changes

[ormris]

ping

[ormris]

ping ping

[arsenm]

While I don't understand the LTO bitcode files, the reduce changes seem fine

llvm/tools/llvm-reduce/deltas/Delta.cpp

64–66 ↗

(On Diff #437250)

Don't need llvm:: and these look like they need line wrapping

[ormris]

Sounds good. Thanks for the review.

test/tools/llvm-reduce/Inputs/llvm-dis-and-filecheck.py

 
 
 import sys
+import os
 import subprocess
 
 llvm_dis = sys.argv[1]

 filecheck_args = [filecheck, ]
 filecheck_args.extend(sys.argv[3:-1])
 bitcode_file = sys.argv[-1]
+ir_file = bitcode_file + ".ll"
 
-disassemble = subprocess.Popen([llvm_dis, "-o", "-", bitcode_file],
-        stdout=subprocess.PIPE)
-check = subprocess.Popen(filecheck_args, stdin=disassemble.stdout)
-disassemble.stdout.close()
+disassemble = subprocess.Popen([llvm_dis, "-o", ir_file, bitcode_file])
+if os.path.exists(ir_file + ".0"):
+    ir_file = ir_file + ".0"
+
+disassemble.communicate()
+
+if disassemble.returncode != 0:
+    print("stderr:")
+    print(disassemble.stderr)
+    print("stdout:")
+    print(disassemble.stdout)
+    sys.exit(1)
+
+check=None
+with open(ir_file, "r") as ir:
+    check = subprocess.Popen(filecheck_args, stdin=ir, stdout=sys.stdout)
 check.communicate()
 sys.exit(check.returncode)

test/tools/llvm-reduce/fail-file-open.test

 
 This file will not be read. An invalid file path is fed to llvm-reduce.
 
-# CHECK: llvm-reduce{{.*}}: {{.*}}.NotAFileInTestingDir: error:
+# CHECK: llvm-reduce{{.*}}: error: {{.*}}.NotAFileInTestingDir:
 

test/tools/llvm-reduce/invalid-bitcode-error.ll

+; RUN: not %python %p/Inputs/llvm-dis-and-filecheck.py llvm-dis FileCheck %s %s 2>&1 | FileCheck %s
+; CHECK: stderr
+; CHECK: stdout

test/tools/llvm-reduce/temporary-files-as-bitcode-split.ll

+; RUN: opt --thinlto-bc --thinlto-split-lto-unit %s -o %t0
+; RUN: llvm-reduce -write-tmp-files-as-bitcode --delta-passes=basic-blocks %t0 -o %t1 \
+; RUN:     --test %python --test-arg %p/Inputs/llvm-dis-and-filecheck.py --test-arg llvm-dis --test-arg FileCheck --test-arg --check-prefixes=CHECK-ALL,CHECK-INTERESTINGNESS --test-arg %s
+; RUN: cat %t1* | FileCheck --check-prefixes=CHECK-ALL,CHECK-FINAL %s
+
+@g = internal global i8 42, !type !0
+
+; CHECK-INTERESTINGNESS: @callee(
+; CHECK-FINAL: declare void @callee()
+define void @callee() {
+  ret void
+}
+
+; CHECK-ALL: define void @caller()
+define void @caller() {
+entry:
+; CHECK-ALL: call void @callee()
+; CHECK-ALL: ret void
+  call void @callee()
+  ret void
+}
+define i8* @f() {
+  ; CHECK-ALL: ret i8* @g.{{([0-9a-f]{32})}}
+  ret i8* @g
+}
+
+!0 = !{i32 0, !"typeid"}

tools/llvm-reduce/CMakeLists.txt

   Support
   Target
   TransformUtils
+  IPO
   )
 
 add_llvm_tool(llvm-reduce

tools/llvm-reduce/ReducerWorkItem.h

 #ifndef LLVM_TOOLS_LLVM_REDUCE_REDUCERWORKITEM_H
 #define LLVM_TOOLS_LLVM_REDUCE_REDUCERWORKITEM_H
 
+#include "llvm/Bitcode/BitcodeReader.h"
 #include "llvm/CodeGen/MachineFunction.h"
 #include "llvm/CodeGen/MachineModuleInfo.h"
 #include "llvm/IR/Module.h"
+#include "llvm/IR/ModuleSummaryIndex.h"
 #include "llvm/Target/TargetMachine.h"
 
 using namespace llvm;

 class ReducerWorkItem {
 public:
   std::shared_ptr<Module> M;
+  std::unique_ptr<BitcodeLTOInfo> LTOInfo;
   std::unique_ptr<MachineModuleInfo> MMI;
 
   bool isMIR() const { return MMI != nullptr; }

tools/llvm-reduce/ReducerWorkItem.cpp

 //===----------------------------------------------------------------------===//
 
 #include "ReducerWorkItem.h"
+#include "llvm/Bitcode/BitcodeReader.h"
 #include "llvm/CodeGen/CommandFlags.h"
 #include "llvm/CodeGen/MIRParser/MIRParser.h"
 #include "llvm/CodeGen/MIRPrinter.h"

 #include "llvm/CodeGen/MachineModuleInfo.h"
 #include "llvm/CodeGen/MachineRegisterInfo.h"
 #include "llvm/CodeGen/TargetInstrInfo.h"
+#include "llvm/IR/ModuleSummaryIndex.h"
 #include "llvm/IR/Verifier.h"
 #include "llvm/IRReader/IRReader.h"
 #include "llvm/MC/TargetRegistry.h"
 #include "llvm/Support/Host.h"
+#include "llvm/Support/MemoryBufferRef.h"
 #include "llvm/Support/SourceMgr.h"
+#include "llvm/Support/TargetSelect.h"
 #include "llvm/Support/WithColor.h"
 #include "llvm/Target/TargetMachine.h"
 #include "llvm/Transforms/Utils/Cloning.h"

                                          cl::desc("Set the target triple"),
                                          cl::cat(LLVMReduceOptions));
 
+void readBitcode(ReducerWorkItem &M, MemoryBufferRef Data, LLVMContext &Ctx);
+
 static void cloneFrameInfo(
     MachineFrameInfo &DstMFI, const MachineFrameInfo &SrcMFI,
     const DenseMap<MachineBasicBlock *, MachineBasicBlock *> &Src2DstMBB) {

   return DstMF;
 }
 
+static void initializeTargetInfo() {
+  InitializeAllTargets();
+  InitializeAllTargetMCs();
+  InitializeAllAsmPrinters();
+  InitializeAllAsmParsers();
+}
+
 std::unique_ptr<ReducerWorkItem>
 parseReducerWorkItem(const char *ToolName, StringRef Filename,
                      LLVMContext &Ctxt, std::unique_ptr<TargetMachine> &TM,

   auto MMM = std::make_unique<ReducerWorkItem>();
 
   if (IsMIR) {
+    initializeTargetInfo();
+
     auto FileOrErr = MemoryBuffer::getFileOrSTDIN(Filename, /*IsText=*/true);
     if (std::error_code EC = FileOrErr.getError()) {
       WithColor::error(errs(), ToolName) << EC.message() << '\n';

     MMM->M = std::move(M);
   } else {
     SMDiagnostic Err;
-    std::unique_ptr<Module> Result = parseIRFile(Filename, Err, Ctxt);
-    if (!Result) {
-      Err.print(ToolName, errs());
+    ErrorOr<std::unique_ptr<MemoryBuffer>> MB = MemoryBuffer::getFileOrSTDIN(Filename);
+    if (std::error_code EC = MB.getError()) {
+      WithColor::error(errs(), ToolName) << Filename << ": " << EC.message() << "\n";
       return std::unique_ptr<ReducerWorkItem>();
     }
-    MMM->M = std::move(Result);
+
+    if (!isBitcode((const unsigned char *)(*MB)->getBufferStart(),
+                  (const unsigned char *)(*MB)->getBufferEnd())) {
+      std::unique_ptr<Module> Result = parseIRFile(Filename, Err, Ctxt);
+      if (!Result) {
+        Err.print(ToolName, errs());
+        return std::unique_ptr<ReducerWorkItem>();
+      }
+      MMM->M = std::move(Result);
+    } else {
+      readBitcode(*MMM, MemoryBufferRef(**MB), Ctxt);
+
+      if (MMM->LTOInfo->IsThinLTO && MMM->LTOInfo->EnableSplitLTOUnit)
+       initializeTargetInfo();
+    }
   }
   if (verifyReducerWorkItem(*MMM, &errs())) {
     WithColor::error(errs(), ToolName)

 std::unique_ptr<ReducerWorkItem>
 cloneReducerWorkItem(const ReducerWorkItem &MMM, const TargetMachine *TM) {
   auto CloneMMM = std::make_unique<ReducerWorkItem>();
-  if (TM) {
+  if (MMM.MMI) {
     // We're assuming the Module IR contents are always unchanged by MIR
     // reductions, and can share it as a constant.
     CloneMMM->M = MMM.M;

tools/llvm-reduce/deltas/Delta.cpp

 #include "Delta.h"
 #include "ReducerWorkItem.h"
 #include "llvm/ADT/STLExtras.h"
+#include "llvm/Analysis/ProfileSummaryInfo.h"
+#include "llvm/Analysis/ModuleSummaryAnalysis.h"
 #include "llvm/Bitcode/BitcodeReader.h"
 #include "llvm/Bitcode/BitcodeWriter.h"
 #include "llvm/CodeGen/MachineFunction.h"
+#include "llvm/IR/Module.h"
 #include "llvm/IR/Verifier.h"
+#include "llvm/MC/TargetRegistry.h"
 #include "llvm/Support/CommandLine.h"
+#include "llvm/Support/MemoryBufferRef.h"
 #include "llvm/Support/ThreadPool.h"
 #include "llvm/Support/ToolOutputFile.h"
 #include <fstream>

 
 void writeOutput(ReducerWorkItem &M, llvm::StringRef Message);
 
+void writeBitcode(ReducerWorkItem &M, llvm::raw_ostream &OutStream);
+
+void readBitcode(ReducerWorkItem &M, MemoryBufferRef Data, LLVMContext &Ctx);
+
 bool isReduced(ReducerWorkItem &M, TestRunner &Test,
                SmallString<128> &CurrentFilepath) {
   // Write ReducerWorkItem to tmp file

 
   if (TmpFilesAsBitcode) {
     llvm::raw_fd_ostream OutStream(FD, true);
-    WriteBitcodeToFile(M, OutStream);
+    writeBitcode(M, OutStream);
     OutStream.close();
     if (OutStream.has_error()) {
       errs() << "Error emitting bitcode to file '" << CurrentFilepath << "'!\n";

     std::vector<Chunk> &ChunksStillConsideredInteresting,
     SmallString<0> &OriginalBC, std::atomic<bool> &AnyReduced) {
   LLVMContext Ctx;
-  Expected<std::unique_ptr<Module>> MOrErr = parseBitcodeFile(
-      MemoryBufferRef(StringRef(OriginalBC.data(), OriginalBC.size()),
-                      "<llvm-reduce tmp module>"),
-      Ctx);
-  if (!MOrErr)
-    report_fatal_error("Failed to read bitcode");
   auto CloneMMM = std::make_unique<ReducerWorkItem>();
-  CloneMMM->M = std::move(MOrErr.get());
+  auto Data = MemoryBufferRef(StringRef(OriginalBC.data(), OriginalBC.size()),
+                              "<bc file>");
+  readBitcode(*CloneMMM, Data, Ctx);
 
   SmallString<0> Result;
   if (std::unique_ptr<ReducerWorkItem> ChunkResult =

                      Test, ExtractChunksFromModule, UninterestingChunks,
                      ChunksStillConsideredInteresting)) {
     raw_svector_ostream BCOS(Result);
-    WriteBitcodeToFile(*ChunkResult->M, BCOS);
+    writeBitcode(*ChunkResult, BCOS);
     // Communicate that the task reduced a chunk.
     AnyReduced = true;
   }

     SmallString<0> OriginalBC;
     if (NumJobs > 1) {
       raw_svector_ostream BCOS(OriginalBC);
-      WriteBitcodeToFile(*Test.getProgram().M, BCOS);
+      writeBitcode(Test.getProgram(), BCOS);
     }
 
     std::deque<std::shared_future<SmallString<0>>> TaskQueue;

             continue;
           }
 
-          Expected<std::unique_ptr<Module>> MOrErr = parseBitcodeFile(
-              MemoryBufferRef(StringRef(Res.data(), Res.size()),
-                              "<llvm-reduce tmp module>"),
-              Test.getProgram().M->getContext());
-          if (!MOrErr)
-            report_fatal_error("Failed to read bitcode");
           Result = std::make_unique<ReducerWorkItem>();
-          Result->M = std::move(MOrErr.get());
+          auto Data = MemoryBufferRef(StringRef(Res.data(), Res.size()),
+                                      "<bc file>");
+          readBitcode(*Result, Data, Test.getProgram().M->getContext());
           break;
         }
         // Forward I to the last chunk processed in parallel.

tools/llvm-reduce/llvm-reduce.cpp

 #include "DeltaManager.h"
 #include "ReducerWorkItem.h"
 #include "TestRunner.h"
+#include "llvm/Analysis/ProfileSummaryInfo.h"
+#include "llvm/Analysis/ModuleSummaryAnalysis.h"
 #include "llvm/ADT/SmallString.h"
+#include "llvm/Bitcode/BitcodeReader.h"
+#include "llvm/Bitcode/BitcodeWriter.h"
 #include "llvm/CodeGen/CommandFlags.h"
 #include "llvm/CodeGen/MachineFunction.h"
 #include "llvm/CodeGen/MachineModuleInfo.h"
+#include "llvm/IR/LegacyPassManager.h"
 #include "llvm/IR/LLVMContext.h"
 #include "llvm/IR/Verifier.h"
 #include "llvm/IRReader/IRReader.h"

 #include "llvm/Support/TargetSelect.h"
 #include "llvm/Support/WithColor.h"
 #include "llvm/Support/raw_ostream.h"
+#include "llvm/Transforms/IPO.h"
 #include <system_error>
 #include <vector>
 

 
 static codegen::RegisterCodeGenFlags CGF;
 
-static void initializeTargetInfo() {
-  InitializeAllTargets();
-  InitializeAllTargetMCs();
-  InitializeAllAsmPrinters();
-  InitializeAllAsmParsers();
-}
-
 void writeOutput(ReducerWorkItem &M, StringRef Message) {
   if (ReplaceInput) // In-place
     OutputFilename = InputFilename.c_str();

   errs() << Message << OutputFilename << "\n";
 }
 
+void writeBitcode(ReducerWorkItem &M, llvm::raw_ostream &OutStream) {
+  if (M.LTOInfo && M.LTOInfo->IsThinLTO && M.LTOInfo->EnableSplitLTOUnit) {
+    legacy::PassManager PM;
+    PM.add(llvm::createWriteThinLTOBitcodePass(OutStream));
+    PM.run(*(M.M));
+  } else {
+    std::unique_ptr<ModuleSummaryIndex> Index;
+    if (M.LTOInfo && M.LTOInfo->HasSummary) {
+      ProfileSummaryInfo PSI(M);
+      Index = std::make_unique<ModuleSummaryIndex>(
+          buildModuleSummaryIndex(M, nullptr, &PSI));
+    }
+    WriteBitcodeToFile(M, OutStream, Index.get());
+  }
+}
+
+void readBitcode(ReducerWorkItem &M, MemoryBufferRef Data, LLVMContext &Ctx) {
+  Expected<BitcodeFileContents> IF = llvm::getBitcodeFileContents(Data);
+  if (!IF) {
+    WithColor::error(errs()) << IF.takeError();
+    exit(1);
+  }
+  BitcodeModule BM = IF->Mods[0];
+  Expected<BitcodeLTOInfo> LI = BM.getLTOInfo();
+  Expected<std::unique_ptr<Module>> MOrErr = BM.parseModule(Ctx);
+  if (!LI || !MOrErr) {
+    WithColor::error(errs()) << IF.takeError();
+    exit(1);
+  }
+  M.LTOInfo = std::make_unique<BitcodeLTOInfo>(*LI);
+  M.M = std::move(MOrErr.get());
+}
+
 int main(int Argc, char **Argv) {
   InitLLVM X(Argc, Argv);
 

     return 0;
   }
 
-  if (ReduceModeMIR)
-    initializeTargetInfo();
-
   LLVMContext Context;
   std::unique_ptr<TargetMachine> TM;