[llvm-reduce] Don't unset dso_local on implicitly dso_local GVs

[aeubanks]

Summary

This introduces a flag that aborts if we ever reduce to IR that fails
the verifier.

Depends on D101278.

[arichardson]

Supersedes D99943.
Maybe adding AbortOnInvalidReduction should be a separate commit, but the overall diff looks good to me.

[aeubanks]

don't use assert, that doesn't work in non-assert builds

llvm/test/tools/llvm-reduce/remove-dso-local.ll

 ; Test that llvm-reduce can remove dso_local.
 ;
-; RUN: llvm-reduce --test FileCheck --test-arg --check-prefixes=CHECK-INTERESTINGNESS --test-arg %s --test-arg --input-file %s -o %t
+; RUN: llvm-reduce --abort-on-invalid-reduction --delta-passes=global-values --test FileCheck --test-arg --check-prefixes=CHECK-INTERESTINGNESS --test-arg %s --test-arg --input-file %s -o %t
 ; RUN: FileCheck --check-prefix=CHECK-FINAL %s < %t
 
 ; CHECK-INTERESTINGNESS: declare
 ; CHECK-INTERESTINGNESS-SAME: void @f0
 ; CHECK-INTERESTINGNESS-SAME: i32
 ; CHECK-INTERESTINGNESS-SAME: i32
 
 ; CHECK-FINAL: declare void @f0(i32, i32)
 
 declare dso_local void @f0(i32, i32)
 
 ; CHECK-INTERESTINGNESS: declare
 ; CHECK-INTERESTINGNESS-SAME: dso_local
 ; CHECK-INTERESTINGNESS-SAME: void @f1
 ; CHECK-INTERESTINGNESS-SAME: i32
 ; CHECK-INTERESTINGNESS-SAME: i32
 
 ; CHECK-FINAL: declare dso_local void @f1(i32, i32)
 
 declare dso_local void @f1(i32, i32)
 
+; CHECK-INTERESTINGNESS: define {{.*}} @f2
+define private void @f2(i32, i32) {
+  ret void
+}

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

 // 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/CommandLine.h"
 #include "llvm/Support/ToolOutputFile.h"
 #include "llvm/Transforms/Utils/Cloning.h"
 #include <fstream>
 #include <set>
 
 using namespace llvm;
 
+static cl::opt<bool> AbortOnInvalidReduction(
+    "abort-on-invalid-reduction",
+    cl::desc("Abort if any reduction results in invalid IR"));
+
 void writeOutput(llvm::Module *M, llvm::StringRef Message);
 
 bool isReduced(Module &M, TestRunner &Test, SmallString<128> &CurrentFilepath) {
   // Write Module to tmp file
   int FD;
   std::error_code EC =
       sys::fs::createTemporaryFile("llvm-reduce", "ll", FD, CurrentFilepath);
   if (EC) {
for (Chunk &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())) {
+        if (AbortOnInvalidReduction) {
+          errs() << "Invalid reduction\n";
+          exit(1);
+        }
         errs() << " **** WARNING | reduction resulted in invalid module, "
                   "skipping\n";
         continue;
       }
 
       errs() << "Ignoring: ";
       ChunkToCheckForUninterestingness.print();
       for (const Chunk &C : UninterestingChunks)

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

 //===----------------------------------------------------------------------===//
 
 #include "ReduceGlobalValues.h"
 #include "llvm/IR/Constants.h"
 #include "llvm/IR/GlobalValue.h"
 
 using namespace llvm;
 
+static bool isValidDSOLocalReductionGV(GlobalValue &GV) {
+  return GV.isDSOLocal() && !GV.isImplicitDSOLocal();
+}
+
 /// Sets dso_local to false for all global values.
 static void extractGVsFromModule(std::vector<Chunk> ChunksToKeep,
                                  Module *Program) {
   Oracle O(ChunksToKeep);
 
   // remove dso_local from global values
   for (auto &GV : Program->global_values())
-    if (GV.isDSOLocal() && !O.shouldKeep()) {
+    if (isValidDSOLocalReductionGV(GV) && !O.shouldKeep()) {
       GV.setDSOLocal(false);
     }
 }
 
 /// Counts the amount of global values with dso_local and displays their
 /// respective name & index
 static int countGVs(Module *Program) {
   // TODO: Silence index with --quiet flag
   outs() << "----------------------------\n";
   outs() << "GlobalValue Index Reference:\n";
   int GVCount = 0;
   for (auto &GV : Program->global_values())
-    if (GV.isDSOLocal())
+    if (isValidDSOLocalReductionGV(GV))
       outs() << "\t" << ++GVCount << ": " << GV.getName() << "\n";
   outs() << "----------------------------\n";
   return GVCount;
 }
 
 void llvm::reduceGlobalValuesDeltaPass(TestRunner &Test) {
   outs() << "*** Reducing GlobalValues...\n";
   int GVCount = countGVs(Test.getProgram());
   runDeltaPass(Test, GVCount, extractGVsFromModule);
 }