Add -disable-verify flag to llvm-link.

[nickwasmer]

Summary

This flag allows the developer to see the result of linking even if it fails the verifier, as a step in debugging cases where the linked module fails the verifier. Same as opt -disable-verify.

No test is introduced. I don't want to write a test that relies on any manner of producing an invalid output that is a bug that should be fixed, as then the test would break if a bug is fixed.

There's an alternative that I considered but did not implement. Unlike opt, llvm-link has many intermediate outputs as it links more files and runs the verifier on each one. We could instead have a flag that outputs a module and stop after running the verifier and seeing a failure. This would allow us to find issues closer to the source, but it also requires that the verifier not crash on the invalid input in question.

[nickwasmer]

Apply clang-format suggestion.

[tejohnson]

How about a test like llvm/test/LTO/X86/strip-debug-info.ll? Could something similar be done to test llvm-link?

[nickwasmer]

In D99382#2652212, @tejohnson wrote:

How about a test like llvm/test/LTO/X86/strip-debug-info.ll? Could something similar be done to test llvm-link?

I wasn't quite able to get that trick to work. With llvm-link I just get a "warning: ignoring invalid debug info in <stdin>" whether the input is assembled by llvm-link or by llvm-as -disable-verify, or opt -disable-verify -disable-upgrade-debug-info (the .bc file is the same).

The case where it would behave differently is checked by a CHECK-ERR which is never set as any check-prefix. I also don't see any documentation or code in FileCheck that makes -ERR a special suffix like -LABEL and -DAG are.

Looking into the history, I think this test is no longer testing that -disable-verify works that way as of git commit a8b2ddbde453fab0db90be21b9a1ff961a7770e0 which removed the CHECK-ERR run.

[tejohnson]

Ok thanks for trying. Someone should remove that orphaned CHECK-ERR in the other test - could you commit that as well?

lgtm

llvm/tools/llvm-link/llvm-link.cpp

static cl::opt<bool> PreserveBitcodeUseListOrder(
     cl::desc("Preserve use-list order when writing LLVM bitcode."),
     cl::init(true), cl::Hidden);
 
 static cl::opt<bool> PreserveAssemblyUseListOrder(
     "preserve-ll-uselistorder",
     cl::desc("Preserve use-list order when writing LLVM assembly."),
     cl::init(false), cl::Hidden);
 
+static cl::opt<bool> NoVerify("disable-verify",
+                              cl::desc("Do not run the verifier"), cl::Hidden);
+
 static ExitOnError ExitOnErr;
 
 // Read the specified bitcode file in and return it. This routine searches the
 // link path for the specified file to try to find it...
 //
 static std::unique_ptr<Module> loadFile(const char *argv0,
                                         std::unique_ptr<MemoryBuffer> Buffer,
                                         LLVMContext &Context,
if (Idx == std::string::npos) {
       return false;
     }
     std::string FunctionName = Import.substr(0, Idx);
     std::string FileName = Import.substr(Idx + 1, std::string::npos);
 
     // Load the specified source module.
     auto &SrcModule = ModuleLoaderCache(argv0, FileName);
 
-    if (verifyModule(SrcModule, &errs())) {
+    if (!NoVerify && verifyModule(SrcModule, &errs())) {
       errs() << argv0 << ": " << FileName;
       WithColor::error() << "input module is broken!\n";
       return false;
     }
 
     Function *F = SrcModule.getFunction(FunctionName);
     if (!F) {
       errs() << "Ignoring import request for non-existent function "
if (!M.get()) {
       errs() << argv0 << ": ";
       WithColor::error() << " loading file '" << File << "'\n";
       return false;
     }
 
     // Note that when ODR merging types cannot verify input files in here When
     // doing that debug metadata in the src module might already be pointing to
     // the destination.
-    if (DisableDITypeMap && verifyModule(*M, &errs())) {
+    if (DisableDITypeMap && !NoVerify && verifyModule(*M, &errs())) {
       errs() << argv0 << ": " << File << ": ";
       WithColor::error() << "input module is broken!\n";
       return false;
     }
 
     // If a module summary index is supplied, load it so linkInModule can treat
     // local functions/variables as exported and promote if necessary.
     if (!SummaryIndex.empty()) {
int main(int argc, char **argv) {
   std::error_code EC;
   ToolOutputFile Out(OutputFilename, EC,
                      OutputAssembly ? sys::fs::OF_Text : sys::fs::OF_None);
   if (EC) {
     WithColor::error() << EC.message() << '\n';
     return 1;
   }
 
-  if (verifyModule(*Composite, &errs())) {
+  if (!NoVerify && verifyModule(*Composite, &errs())) {
     errs() << argv[0] << ": ";
     WithColor::error() << "linked module is broken!\n";
     return 1;
   }
 
   if (Verbose)
     errs() << "Writing bitcode...\n";
   if (OutputAssembly) {