[clang] Allow disassembly of multi-module bitcode files

[ormris]

Summary

Clang currently exits with an error message if asked to disassemble a
multi-module bitcode file which is used by ThinLTO to allow for Whole
Program Devirtualization and CFI. This might be confusing to some who are not
familiar with bitcode formats. In addition, multi-module bitcode files
are reasonably common. This patch makes clang's behavior consistent for
all common bitcode files.

Example usage:

clang -c -flto=thin -fwhole-program-vtables -fvisibility=hidden virtual.cpp
clang -x ir -S -emit-llvm virtual.o
# Writes virtual.0.ll and virtual.1.ll

[ormris]

clang-format

[aaron.ballman]

FWIW, the precommit CI Windows bot found an issue with the newly added test case. Maybe test the Itanium and MS ABIs separately? (Uncertain if an Itanium-only test is appropriate but that's another option.)

[ormris]

Yes, I'm working on a new test that's less target dependent.

[ormris]

Attempt to fix pre-merge checks.

[MaskRay]

clang/test/Frontend/split-lto-ir-support.cpp

1

Without -fsanitize=cfi or -fwhole-program-vtables, -fsplit-lto-unit is not the default. You need to specify this option explicitly.

%clang is normally used for test/Driver tests. For other tests, prefer %clang_cc1.

15

[MaskRay]

[clang] Allow disassembly of multi-module bitcode files

The subject confused me as I did not recognize what disassembly means :)

Clang currently exits with an error message if asked to disassemble a multi-module bitcode file. [...]

The description is hand-waving on how Clang uses multi-module bitcode files.
You can be more specific that multi-module bitcode files are for -fsanitize=cfi and -fwhole-program-vtables. And it will be more useful to include an example in the summary.

It seems that you want to do this:

myclang -Xclang -flto-unit -fsplit-lto-unit -flto=thin a.c -c -o a.bc
myclang -S -emit-llvm a.bc -o b.ll
ls b.0.ll b.1.ll

This is a bit odd as the -o file may no longer an output. This could be fixed, but is this functionality really useful?

% rm -f a.0.ll a.1.ll; myclang -c a.bc -o a.o ; ls a.[01].ll
a.0.ll  a.1.ll

We can just disassemble a bitcode with llvm-dis a.bc -o -. The nicer thing is that llvm-dis additionally calls ModuleSummaryIndex::print to print the module summary index (if present).
clang -S -emit-llvm -x ir a.bc output doesn't have this information.

clang/test/Frontend/split-lto-ir-support.cpp

1

We need to hard code a target triple as many targets don't support LTO.

[ormris]

This comment was removed by ormris.

[ormris]

You can be more specific that multi-module bitcode files are for -fsanitize=cfi and -fwhole-program-vtables. And it will be more useful to include an example in the summary.

Fixed.

This is a bit odd as the -o file may no longer an output. This could be fixed, but is this functionality really useful?

I think it's useful to allow this kind of disassembly. Users who want to quickly inspect a bitcode files produced by the compiler could run them through clang first. While llvm-dis is the normal tool to do this, but some users don't know or have access to llvm-dis.

The nicer thing is that llvm-dis additionally calls ModuleSummaryIndex::print to print the module summary index (if present).

True, though this functionality could be added. I think users are more likely to be concerned about how their code was optimized by the LTO pre-link pipeline, say, then what the summary contains.

[MaskRay]

Is a simpler change like D154923 sufficient? It also handles the case when we don't emit .ll, but .o or .s.

[steven_wu]

I don't like this doesn't write to the output file by -o too. I also think the output should just match llvm-dis output, instead of splitting into multiple files.

clang/include/clang/CodeGen/CodeGenAction.h

private:
   unsigned Act;
   std::unique_ptr<llvm::Module> TheModule;
 
   /// Bitcode modules to link in to our module.
   SmallVector<LinkModule, 4> LinkModules;
   llvm::LLVMContext *VMContext;
   bool OwnsVMContext;
 
-  std::unique_ptr<llvm::Module> loadModule(llvm::MemoryBufferRef MBRef);
+  std::vector<std::unique_ptr<llvm::Module>>
+  loadModule(llvm::MemoryBufferRef MBRef);
 
   /// Load bitcode modules to link into our module from the options.
   bool loadLinkModules(CompilerInstance &CI);
 
 protected:
   /// Create a new code generation action.  If the optional \p _VMContext
   /// parameter is supplied, the action uses it without taking ownership,
   /// otherwise it creates a fresh LLVM context and takes ownership.

clang/lib/CodeGen/CodeGenAction.cpp

std::unique_ptr<PPCallbacks> Callbacks =
         std::make_unique<MacroPPCallbacks>(BEConsumer->getCodeGenerator(),
                                             CI.getPreprocessor());
     CI.getPreprocessor().addPPCallbacks(std::move(Callbacks));
   }
 
   return std::move(Result);
 }
 
-std::unique_ptr<llvm::Module>
+std::vector<std::unique_ptr<llvm::Module>>
 CodeGenAction::loadModule(MemoryBufferRef MBRef) {
   CompilerInstance &CI = getCompilerInstance();
   SourceManager &SM = CI.getSourceManager();
 
-  // For ThinLTO backend invocations, ensure that the context
-  // merges types based on ODR identifiers. We also need to read
-  // the correct module out of a multi-module bitcode file.
-  if (!CI.getCodeGenOpts().ThinLTOIndexFile.empty()) {
-    VMContext->enableDebugTypeODRUniquing();
+  std::vector<std::unique_ptr<llvm::Module>> Result;
+
+  if (!llvm::isBitcode((const unsigned char *)MBRef.getBufferStart(),
+                       (const unsigned char *)MBRef.getBufferEnd())) {
+    llvm::SMDiagnostic Err;
+    std::unique_ptr<llvm::Module> M = parseIR(MBRef, Err, *VMContext);
+    if (!M) {
+      // Translate from the diagnostic info to the SourceManager location if
+      // available.
+      // TODO: Unify this with ConvertBackendLocation()
+      SourceLocation Loc;
+      if (Err.getLineNo() > 0) {
+        assert(Err.getColumnNo() >= 0);
+        Loc = SM.translateFileLineCol(SM.getFileEntryForID(SM.getMainFileID()),
+                                      Err.getLineNo(), Err.getColumnNo() + 1);
+      }
+
+      // Strip off a leading diagnostic code if there is one.
+      StringRef Msg = Err.getMessage();
+      if (Msg.startswith("error: "))
+        Msg = Msg.substr(7);
 
-    auto DiagErrors = [&](Error E) -> std::unique_ptr<llvm::Module> {
-      unsigned DiagID =
-          CI.getDiagnostics().getCustomDiagID(DiagnosticsEngine::Error, "%0");
-      handleAllErrors(std::move(E), [&](ErrorInfoBase &EIB) {
-        CI.getDiagnostics().Report(DiagID) << EIB.message();
-      });
-      return {};
-    };
+      unsigned DiagID =
+          CI.getDiagnostics().getCustomDiagID(DiagnosticsEngine::Error, "%0");
+
+      CI.getDiagnostics().Report(Loc, DiagID) << Msg;
+      return {};
+    }
+
+    Result.push_back(std::move(M));
+    return Result;
+  }
+
+  auto DiagErrors = [&](Error E) -> std::vector<std::unique_ptr<llvm::Module>> {
 
+  // For ThinLTO backend invocations, ensure that the context
+  // merges types based on ODR identifiers. We also need to read
+  // the correct module out of a multi-module bitcode file.
+  if (!CI.getCodeGenOpts().ThinLTOIndexFile.empty()) {
+    VMContext->enableDebugTypeODRUniquing();
+
     Expected<std::vector<BitcodeModule>> BMsOrErr = getBitcodeModuleList(MBRef);
     if (!BMsOrErr)
       return DiagErrors(BMsOrErr.takeError());
     BitcodeModule *Bm = llvm::lto::findThinLTOModule(*BMsOrErr);
     // We have nothing to do if the file contains no ThinLTO module. This is
     // possible if ThinLTO compilation was not able to split module. Content of
     // the file was already processed by indexing and will be passed to the
     // linker using merged object file.
     if (!Bm) {
       auto M = std::make_unique<llvm::Module>("empty", *VMContext);
       M->setTargetTriple(CI.getTargetOpts().Triple);
-      return M;
+      Result.push_back(std::move(M));
+      return Result;
     }
     Expected<std::unique_ptr<llvm::Module>> MOrErr =
         Bm->parseModule(*VMContext);
     if (!MOrErr)
       return DiagErrors(MOrErr.takeError());
-    return std::move(*MOrErr);
+    Result.push_back(std::move(MOrErr.get()));
+    return Result;
   }
 
   // Load bitcode modules to link with, if we need to.
   if (loadLinkModules(CI))
-    return nullptr;
+    return {};
 
-  llvm::SMDiagnostic Err;
-  if (std::unique_ptr<llvm::Module> M = parseIR(MBRef, Err, *VMContext))
-    return M;
+  Expected<std::vector<BitcodeModule>> BMsOrErr = getBitcodeModuleList(MBRef);
+  if (!BMsOrErr)
+    return DiagErrors(BMsOrErr.takeError());
 
-  // Translate from the diagnostic info to the SourceManager location if
-  // available.
-  // TODO: Unify this with ConvertBackendLocation()
-  SourceLocation Loc;
-  if (Err.getLineNo() > 0) {
-    assert(Err.getColumnNo() >= 0);
-    Loc = SM.translateFileLineCol(SM.getFileEntryForID(SM.getMainFileID()),
-                                  Err.getLineNo(), Err.getColumnNo() + 1);
+  for (auto BM : BMsOrErr.get()) {
+    auto M = BM.parseModule(*VMContext);
+    if (!M)
+      return DiagErrors(M.takeError());
+    Result.push_back(std::move(M.get()));
   }
 
-  // Strip off a leading diagnostic code if there is one.
-  StringRef Msg = Err.getMessage();
-  if (Msg.startswith("error: "))
-    Msg = Msg.substr(7);
-
-  unsigned DiagID =
-      CI.getDiagnostics().getCustomDiagID(DiagnosticsEngine::Error, "%0");
-
-  CI.getDiagnostics().Report(Loc, DiagID) << Msg;
-  return {};
+  return Result;
 }
 
 void CodeGenAction::ExecuteAction() {
   if (getCurrentFileKind().getLanguage() != Language::LLVM_IR) {
     this->ASTFrontendAction::ExecuteAction();
     return;
   }
 
   // If this is an IR file, we have to treat it specially.
   BackendAction BA = static_cast<BackendAction>(Act);
   CompilerInstance &CI = getCompilerInstance();
   auto &CodeGenOpts = CI.getCodeGenOpts();
   auto &Diagnostics = CI.getDiagnostics();
-  std::unique_ptr<raw_pwrite_stream> OS =
-      GetOutputStream(CI, getCurrentFileOrBufferName(), BA);
-  if (BA != Backend_EmitNothing && !OS)
-    return;
+  const TargetOptions &TargetOpts = CI.getTargetOpts();
 
   SourceManager &SM = CI.getSourceManager();
   FileID FID = SM.getMainFileID();
   std::optional<MemoryBufferRef> MainFile = SM.getBufferOrNone(FID);
   if (!MainFile)
     return;
 
-  TheModule = loadModule(*MainFile);
-  if (!TheModule)
-    return;
+  std::vector<std::unique_ptr<llvm::Module>> Modules = loadModule(*MainFile);
 
-  const TargetOptions &TargetOpts = CI.getTargetOpts();
-  if (TheModule->getTargetTriple() != TargetOpts.Triple) {
-    Diagnostics.Report(SourceLocation(), diag::warn_fe_override_module)
-        << TargetOpts.Triple;
-    TheModule->setTargetTriple(TargetOpts.Triple);
+  for (size_t I = 0; I < Modules.size(); ++I) {
+    llvm::Module *TheModule = Modules[I].get();
+    llvm::StringRef OutputPath = getCurrentFileOrBufferName();
+    std::unique_ptr<raw_pwrite_stream> OS = nullptr;
+    if (Modules.size() > 1) {
+      std::string FrontendPath = CI.getFrontendOpts().OutputFile;
+      if (!FrontendPath.empty())
+        OutputPath = FrontendPath;
+      llvm::SmallString<16> Ext = llvm::sys::path::extension(OutputPath);
+      llvm::SmallString<128> TmpName = OutputPath.drop_back(Ext.size());
+      TmpName += ".";
+      TmpName += std::to_string(I);
+      TmpName += ".ll";
+      OS = CI.createOutputFile(TmpName, false, false,
+                               CI.getFrontendOpts().UseTemporary);
+    } else {
+      OS = GetOutputStream(CI, OutputPath, BA);
     }
 
-  EmbedObject(TheModule.get(), CodeGenOpts, Diagnostics);
-  EmbedBitcode(TheModule.get(), CodeGenOpts, *MainFile);
+    if (BA == Backend_EmitNothing || !OS)
+      return;
+    EmbedObject(TheModule, CodeGenOpts, Diagnostics);
+    EmbedBitcode(TheModule, CodeGenOpts, *MainFile);
 
     LLVMContext &Ctx = TheModule->getContext();
 
     // Restore any diagnostic handler previously set before returning from this
     // function.
     struct RAII {
       LLVMContext &Ctx;
-    std::unique_ptr<DiagnosticHandler> PrevHandler = Ctx.getDiagnosticHandler();
+      std::unique_ptr<DiagnosticHandler> PrevHandler =
+          Ctx.getDiagnosticHandler();
       ~RAII() { Ctx.setDiagnosticHandler(std::move(PrevHandler)); }
     } _{Ctx};
 
     // Set clang diagnostic handler. To do this we need to create a fake
     // BackendConsumer.
     BackendConsumer Result(BA, CI.getDiagnostics(), &CI.getVirtualFileSystem(),
                            CI.getHeaderSearchOpts(), CI.getPreprocessorOpts(),
                            CI.getCodeGenOpts(), CI.getTargetOpts(),
-                         CI.getLangOpts(), TheModule.get(),
-                         std::move(LinkModules), *VMContext, nullptr);
-
+                           CI.getLangOpts(), TheModule, std::move(LinkModules),
+                           *VMContext, nullptr);
     // Link in each pending link module.
     if (Result.LinkInModules(&*TheModule))
       return;
 
     // PR44896: Force DiscardValueNames as false. DiscardValueNames cannot be
     // true here because the valued names are needed for reading textual IR.
     Ctx.setDiscardValueNames(false);
     Ctx.setDiagnosticHandler(
         std::make_unique<ClangDiagnosticHandler>(CodeGenOpts, &Result));
 
     Expected<std::unique_ptr<llvm::ToolOutputFile>> OptRecordFileOrErr =
         setupLLVMOptimizationRemarks(
             Ctx, CodeGenOpts.OptRecordFile, CodeGenOpts.OptRecordPasses,
             CodeGenOpts.OptRecordFormat, CodeGenOpts.DiagnosticsWithHotness,
             CodeGenOpts.DiagnosticsHotnessThreshold);
 
     if (Error E = OptRecordFileOrErr.takeError()) {
       reportOptRecordError(std::move(E), Diagnostics, CodeGenOpts);
       return;
     }
     std::unique_ptr<llvm::ToolOutputFile> OptRecordFile =
         std::move(*OptRecordFileOrErr);
 
     EmitBackendOutput(
         Diagnostics, CI.getHeaderSearchOpts(), CodeGenOpts, TargetOpts,
-      CI.getLangOpts(), CI.getTarget().getDataLayoutString(), TheModule.get(),
-      BA, CI.getFileManager().getVirtualFileSystemPtr(), std::move(OS));
+        CI.getLangOpts(), CI.getTarget().getDataLayoutString(), TheModule, BA,
+        CI.getFileManager().getVirtualFileSystemPtr(), std::move(OS));
     if (OptRecordFile)
       OptRecordFile->keep();
   }
+}
 
 //
 
 void EmitAssemblyAction::anchor() { }
 EmitAssemblyAction::EmitAssemblyAction(llvm::LLVMContext *_VMContext)
   : CodeGenAction(Backend_EmitAssembly, _VMContext) {}
 
 void EmitBCAction::anchor() { }

clang/test/Frontend/split-lto-ir-support.cpp

+// RUN: %clang -c -flto=thin %s -o %t0.bc
+// RUN: mkdir %t1.d
+// RUN: %clang -S -emit-llvm %t0.bc -o %t1.d/split-lto-ir-support.ll
+// RUN: FileCheck <%t1.d/split-lto-ir-support.0.ll --check-prefix M0 %s
+// RUN: FileCheck <%t1.d/split-lto-ir-support.1.ll --check-prefix M1 %s
+// RUN: rm -rf %t1.d
+// M0: @main
+// M1: anon.
+
+struct A {
+  virtual int c(int i) = 0;
+};
+
+struct B : A {
+  virtual int c(int i) {
+    return i + 3;
+  }
+};
+
+int
+main(void)
+{
+  A *a = new B();
+
+  return a->c(0);
+}