[llvm-reduce] Skip chunks that lead to broken modules.

[fhahn]

Summary

Some reduction passes may create invalid IR. I am not aware of any use
case where we would like to proceed reducing invalid IR. Various utils
used here, including CloneModule, assume the module to clone is valid
and crash otherwise.

Ideally, no reduction pass would create invalid IR, but some currently
do. ReduceInstructions can be fixed relatively easily (D86210), but
others are harder. For example, ReduceBasicBlocks may remove result in
invalid PHI nodes.

For now, skip the chunks. If we get to the point where all reduction
passes result in valid IR, we may want to turn this into an assertion.

[lebedev.ri]

I've been deliberating on this, but i guess this makes sense..
I personally always had opt -verify as the first interestingness check.

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

142

I think it may be better to say:

// Some reductions may result in invalid IR. Skip such reductions.

[fhahn]

In D86212#2232196, @lebedev.ri wrote:

I've been deliberating on this, but i guess this makes sense..
I personally always had opt -verify as the first interestingness check.

Great thanks! Discarding the invalid paths a bit earlier might be a bit faster and I think the behavior will save people some time with the result being always valid IR. If there are use-cases where we actually want invalid IR we can relax the check again.

llvm/test/Reduce/remove-function-bodies-used-in-globals.ll

 ; RUN: llvm-reduce --test FileCheck --test-arg --check-prefixes=CHECK-ALL,CHECK-INTERESTINGNESS --test-arg %s --test-arg --input-file %s -o %t
 ; RUN: cat %t | FileCheck --check-prefixes=CHECK-ALL,CHECK-FINAL %s
 
+; We cannot change the @alias to undef, because it would result in invalid IR
+; (Aliasee should be either GlobalValue or ConstantExpr).
+
 ; CHECK-INTERESTINGNESS: @alias =
-; CHECK-FINAL: @alias = alias void (i32), void (i32)* undef
+; CHECK-FINAL: @alias = alias void (i32), bitcast (void ()* @func to void (i32)*)
 
 @alias = alias void (i32), void (i32)* @func
 
-; CHECK-FINAL-NOT: @func()
+; CHECK-FINAL: @func()
 
 define void @func(i32 %arg) {
 entry:
   ret void
 }

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

 //===- Delta.cpp - Delta Debugging Algorithm Implementation ---------------===//
 //
 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
 // See https://llvm.org/LICENSE.txt for license information.
 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 //
 // This file contains the implementation for the Delta Debugging Algorithm:
 // it splits a given set of Targets (i.e. Functions, Instructions, BBs, etc.)
 // into chunks and tries to reduce the number chunks that are interesting.
 //
 //===----------------------------------------------------------------------===//
 
 #include "Delta.h"
 #include "llvm/ADT/STLExtras.h"
+#include "llvm/IR/Verifier.h"
 #include "llvm/Support/ToolOutputFile.h"
 #include "llvm/Transforms/Utils/Cloning.h"
 #include <fstream>
 #include <set>
 
 using namespace llvm;
 
 void writeOutput(llvm::Module *M, llvm::StringRef Message);
void llvm::runDeltaPass(
   }
 
   if (Module *Program = Test.getProgram()) {
     SmallString<128> CurrentFilepath;
     if (!IsReduced(*Program, Test, CurrentFilepath)) {
       errs() << "\nInput isn't interesting! Verify interesting-ness test\n";
       exit(1);
     }
+
+    assert(!verifyModule(*Program, &errs()) &&
+           "input module is broken before making changes");
   }
 
   std::vector<Chunk> ChunksStillConsideredInteresting = {{1, Targets}};
   std::unique_ptr<Module> ReducedProgram;
 
   bool FoundAtLeastOneNewUninterestingChunkWithCurrentGranularity;
   do {
     FoundAtLeastOneNewUninterestingChunkWithCurrentGranularity = false;
for (Chunk &ChunkToCheckForUninterestingness :
                        C != ChunkToCheckForUninterestingness;
               });
 
       // Clone module before hacking it up..
       std::unique_ptr<Module> Clone = CloneModule(*Test.getProgram());
       // Generate Module with only Targets inside Current Chunks
       ExtractChunksFromModule(CurrentChunks, Clone.get());
 
+      // Some reductions may result in invalid IR. Skip such reductions.
+      if (verifyModule(*Clone.get(), &errs())) {
+        errs() << " **** WARNING | reduction resulted in invalid module, "
+                  "skipping\n";
+        continue;
+      }
+
       errs() << "Ignoring: ";
       ChunkToCheckForUninterestingness.print();
       for (const Chunk &C : UninterestingChunks)
         C.print();
 
       SmallString<128> CurrentFilepath;
       if (!IsReduced(*Clone, Test, CurrentFilepath)) {
         // Program became non-reduced, so this chunk appears to be interesting.