Add support for multi-module bitcode files to llvm-dis

[ormris]

Summary

This change would allow llvm-dis to disassemble multi-module bitcode
files, including the associated module summary. This will allow the
disassembler to work with all current bitcode formats transparently.

[tejohnson]

LGTM - nice improvement!

[pcc]

The way I imagined this might work is that llvm-dis would write out the modules concatenated with some kind of delimiter between them. Then llvm-as would be taught to expect the same input and produce a multi-module file from it, which would allow an easy way to produce multi-module files. Does that sound like it might work better?

[MaskRay]

In D70153#1744929, @pcc wrote:

The way I imagined this might work is that llvm-dis would write out the modules concatenated with some kind of delimiter between them. Then llvm-as would be taught to expect the same input and produce a multi-module file from it, which would allow an easy way to produce multi-module files. Does that sound like it might work better?

I like the delimiter approach.

llvm/test/Assembler/multi-mod-disassemble.ll

7

diff -> cmp

[tejohnson]

In D70153#1744929, @pcc wrote:

The way I imagined this might work is that llvm-dis would write out the modules concatenated with some kind of delimiter between them. Then llvm-as would be taught to expect the same input and produce a multi-module file from it, which would allow an easy way to produce multi-module files. Does that sound like it might work better?

I think that is a good approach in the end, but since this is strictly better than the current situation, I wouldn't mind having this in as an interim fix.

[ormris]

Thanks for the review! I'll go ahead and commit this.

[ormris]

llvm/test/Assembler/multi-mod-disassemble.ll

7

Will fix before commit.

llvm/test/Assembler/multi-mod-disassemble.ll

+; RUN: llvm-as %s -o %t.o
+; RUN: llvm-cat -b -o %t2.o %t.o %t.o
+; RUN: llvm-dis -o %t3 %t2.o
+; RUN: llvm-as -o %t4.o %t3.0
+; RUN: llvm-as -o %t5.o %t3.1
+; RUN: cmp %t4.o %t5.o
+; RUN: llvm-cat -b -o %t6.o %t5.o %t4.o
+; RUN: llvm-dis -o %t7.o %t6.o
+; RUN: diff %t7.o.0 %t7.o.1
+; RUN: FileCheck < %t7.o.0 %s
+; RUN: FileCheck < %t7.o.1 %s
+
+; CHECK: source_filename = "{{.*}}multi-mod-disassemble.ll"
+target datalayout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128"
+target triple = "x86_64-unknown-linux-gnu"

llvm/test/Assembler/multi-summary-disassemble.ll

+; RUN: llvm-as %s -o %t.o
+; RUN: llvm-cat -b -o %t2.o %t.o %t.o
+; RUN: llvm-dis -o %t3 %t2.o
+; RUN: llvm-as -o %t4.o %t3.0
+; RUN: llvm-as -o %t5.o %t3.1
+; RUN: cmp %t4.o %t5.o
+; RUN: llvm-cat -b -o %t6.o %t5.o %t4.o
+; RUN: llvm-dis -o %t7.o %t6.o
+; RUN: diff %t7.o.0 %t7.o.1
+; RUN: FileCheck < %t7.o.0 %s
+; RUN: FileCheck < %t7.o.1 %s
+
+; ModuleID = 'multi-summary-disassemble.o'
+
+^0 = module: (path: "multi-summary-disassemble.ll", hash: (1369602428, 2747878711, 259090915, 2507395659, 1141468049))
+^1 = gv: (guid: 3, summaries: (function: (module: ^0, flags: (linkage: internal, notEligibleToImport: 0, live: 0, dsoLocal: 1), insts: 1)))
+; CHECK: ^0 = module: (path:
+; CHECK: ^1 = gv: (guid: 3, summaries: (function: (module: ^0,

llvm/test/Bitcode/invalid.test

 
 EXTRACT-ARRAY: EXTRACTVAL: Invalid array index
 EXTRACT-STRUCT: EXTRACTVAL: Invalid struct index
 EXTRACT-IDXS: EXTRACTVAL: Invalid type
 INSERT-ARRAY: INSERTVAL: Invalid array index
 INSERT-STRUCT: INSERTVAL: Invalid struct index
 INSERT-IDXS: INSERTVAL: Invalid type
 
-RUN: not llvm-dis -disable-output %p/Inputs/invalid-no-proper-module.bc 2>&1 | \
-RUN:   FileCheck --check-prefix=NO-MODULE %s
-
-NO-MODULE: Expected a single module
-
 RUN: not llvm-dis -disable-output %p/Inputs/invalid-fp-shift.bc 2>&1 | \
 RUN:   FileCheck --check-prefix=FP-SHIFT %s
 
 FP-SHIFT: Invalid record
 
 RUN: not llvm-dis -disable-output %p/Inputs/invalid-abbrev-vbr-size-too-big.bc 2>&1 | \
 RUN:   FileCheck --check-prefix=HUGE-ABBREV-OP %s
 RUN: not llvm-dis -disable-output %p/Inputs/invalid-abbrev-fixed-size-too-big.bc 2>&1 | \

llvm/test/Bitcode/multi-module.ll

 ; RUN: llvm-cat -o %t %s %S/Inputs/multi-module.ll
-; RUN: not llvm-dis -o - %t 2>&1 | FileCheck --check-prefix=ERROR %s
-; ERROR: Expected a single module
 
 ; RUN: llvm-bcanalyzer -dump %t | FileCheck --check-prefix=BCA %s
 
 ; RUN: llvm-modextract -n 0 -o - %t | llvm-dis | FileCheck --check-prefix=IR1 %s
 ; RUN: llvm-modextract -n 1 -o - %t | llvm-dis | FileCheck --check-prefix=IR2 %s
 
 ; RUN: llvm-as -o %t1 %s
 ; RUN: llvm-as -o %t2 %S/Inputs/multi-module.ll
 ; RUN: llvm-cat -o %t %t1 %t2
-; RUN: not llvm-dis -o - %t 2>&1 | FileCheck --check-prefix=ERROR %s
 ; RUN: llvm-bcanalyzer -dump %t | FileCheck --check-prefix=BCA %s
 
 ; RUN: llvm-cat -b -o %t %t1 %t2
-; RUN: not llvm-dis -o - %t 2>&1 | FileCheck --check-prefix=ERROR %s
 ; RUN: llvm-bcanalyzer -dump %t | FileCheck --check-prefix=BCA %s
 
 ; RUN: llvm-modextract -n 0 -o - %t | llvm-dis | FileCheck --check-prefix=IR1 %s
 ; RUN: llvm-modextract -n 1 -o - %t | llvm-dis | FileCheck --check-prefix=IR2 %s
 
 ; RUN: llvm-cat -b -o %t3 %t %t
-; RUN: not llvm-dis -o - %t3 2>&1 | FileCheck --check-prefix=ERROR %s
 ; RUN: llvm-bcanalyzer -dump %t3 | FileCheck --check-prefix=BCA4 %s
 
 ; RUN: llvm-modextract -n 0 -o - %t3 | llvm-dis | FileCheck --check-prefix=IR1 %s
 ; RUN: llvm-modextract -n 1 -o - %t3 | llvm-dis | FileCheck --check-prefix=IR2 %s
 ; RUN: llvm-modextract -n 2 -o - %t3 | llvm-dis | FileCheck --check-prefix=IR1 %s
 ; RUN: llvm-modextract -n 3 -o - %t3 | llvm-dis | FileCheck --check-prefix=IR2 %s
 
 ; BCA: <IDENTIFICATION_BLOCK

llvm/tools/llvm-dis/llvm-dis.cpp

int main(int argc, char **argv) {
 
   LLVMContext Context;
   Context.setDiagnosticHandler(
       std::make_unique<LLVMDisDiagnosticHandler>(argv[0]));
   cl::ParseCommandLineOptions(argc, argv, "llvm .bc -> .ll disassembler\n");
 
   std::unique_ptr<MemoryBuffer> MB =
       ExitOnErr(errorOrToExpected(MemoryBuffer::getFileOrSTDIN(InputFilename)));
-  std::unique_ptr<Module> M = ExitOnErr(getLazyBitcodeModule(
-      *MB, Context, /*ShouldLazyLoadMetadata=*/true, SetImporting));
+
+  BitcodeFileContents IF = ExitOnErr(llvm::getBitcodeFileContents(*MB));
+
+  const size_t N = IF.Mods.size();
+
+  if (OutputFilename == "-" && N > 1)
+      errs() << "only single module bitcode files can be written to stdout\n";
+
+  for (size_t i = 0; i < N; ++i) {
+    BitcodeModule MB = IF.Mods[i];
+    std::unique_ptr<Module> M = ExitOnErr(MB.getLazyModule(Context, MaterializeMetadata,
+                                          SetImporting));
     if (MaterializeMetadata)
       ExitOnErr(M->materializeMetadata());
     else
       ExitOnErr(M->materializeAll());
 
-  BitcodeLTOInfo LTOInfo = ExitOnErr(getBitcodeLTOInfo(*MB));
+    BitcodeLTOInfo LTOInfo = ExitOnErr(MB.getLTOInfo());
     std::unique_ptr<ModuleSummaryIndex> Index;
     if (LTOInfo.HasSummary)
-    Index = ExitOnErr(getModuleSummaryIndex(*MB));
+      Index = ExitOnErr(MB.getSummary());
+
+    std::string FinalFilename(OutputFilename);
 
     // Just use stdout.  We won't actually print anything on it.
     if (DontPrint)
-    OutputFilename = "-";
+      FinalFilename = "-";
 
     if (OutputFilename.empty()) { // Unspecified output, infer it.
       if (InputFilename == "-") {
-      OutputFilename = "-";
+        FinalFilename = "-";
       } else {
         StringRef IFN = InputFilename;
-      OutputFilename = (IFN.endswith(".bc") ? IFN.drop_back(3) : IFN).str();
-      OutputFilename += ".ll";
+        FinalFilename = (IFN.endswith(".bc") ? IFN.drop_back(3) : IFN).str();
+        if (N > 1)
+          FinalFilename += std::string(".") + std::to_string(i);
+        FinalFilename += ".ll";
       }
+    } else {
+      if (N > 1)
+        FinalFilename += std::string(".") + std::to_string(i);
     }
 
     std::error_code EC;
     std::unique_ptr<ToolOutputFile> Out(
-      new ToolOutputFile(OutputFilename, EC, sys::fs::OF_Text));
+        new ToolOutputFile(FinalFilename, EC, sys::fs::OF_Text));
     if (EC) {
       errs() << EC.message() << '\n';
       return 1;
     }
 
     std::unique_ptr<AssemblyAnnotationWriter> Annotator;
     if (ShowAnnotations)
       Annotator.reset(new CommentWriter());
 
     // All that llvm-dis does is write the assembly to a file.
     if (!DontPrint) {
       M->print(Out->os(), Annotator.get(), PreserveAssemblyUseListOrder);
       if (Index)
         Index->print(Out->os());
     }
 
     // Declare success.
     Out->keep();
+  }
 
   return 0;
 }