llvm-reduce: Support running passes unconditionally and add useful manual reductions

[Zoxc]

Summary

This adds a --reduce command line options which just runs the specified passes without using a test program or the delta algorithm.

A noise pass is added which runs other passes intended to make the LLVM IR more readable is added by removing less important details. It also runs a demangling pass.

A to-call-list pass is added which runs other passes reducing functions to only calls of non-intrinsic functions. It also removes arguments and runs the noise pass. This is useful to investigate inlining behavior.

The reduce arguments pass is changed to no longer delete instructions so that it can be reused in the to-call-list pass. I'm not sure why it previously did so, as there is a separate pass to remove instructions.

[arsenm]

All of the different points you mentioned should be split into separate patches. Also needs tests

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

2

Broken first line comment

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

100

Typo Instrinsics

llvm/tools/llvm-reduce/CMakeLists.txt

 set(LLVM_LINK_COMPONENTS
   AllTargetsAsmParsers
   AllTargetsCodeGens
   AllTargetsDescs
   AllTargetsInfos
   Analysis
   BitReader
   BitWriter
   CodeGen
   Core
+  Demangle
   IRReader
   MC
   MIRParser
   Passes
   Support
   Target
   TargetParser
   TransformUtils
   IPO
   )
 
 add_llvm_tool(llvm-reduce
   DeltaManager.cpp
   ReducerWorkItem.cpp
   TestRunner.cpp
   deltas/Delta.cpp
+  deltas/Demangle.cpp
+  deltas/MoveToEntry.cpp
   deltas/Utils.cpp
   deltas/ReduceAliases.cpp
   deltas/ReduceArguments.cpp
   deltas/ReduceAttributes.cpp
   deltas/ReduceBasicBlocks.cpp
   deltas/ReduceDIMetadata.cpp
   deltas/ReduceFunctionBodies.cpp
   deltas/ReduceFunctions.cpp

llvm/tools/llvm-reduce/DeltaManager.h

 //===- DeltaManager.h - Runs Delta Passes to reduce Input -------*- C++ -*-===//
 //
 // 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 calls each specialized Delta pass in order to reduce the input IR
 // file.
 //
 //===----------------------------------------------------------------------===//
 
 #ifndef LLVM_TOOLS_LLVM_REDUCE_DELTAMANAGER_H
 #define LLVM_TOOLS_LLVM_REDUCE_DELTAMANAGER_H
 
+#include "llvm/Support/CommandLine.h"
+
 namespace llvm {
 class raw_ostream;
 class TestRunner;
 
 void printDeltaPasses(raw_ostream &OS);
 void runDeltaPasses(TestRunner &Tester, int MaxPassIterations);
+void runUnconditionalPasses(TestRunner &Tester,
+                            const cl::list<std::string> &PassList);
 } // namespace llvm
 
 #endif

llvm/tools/llvm-reduce/DeltaManager.cpp

 // file.
 //
 //===----------------------------------------------------------------------===//
 
 #include "DeltaManager.h"
 #include "ReducerWorkItem.h"
 #include "TestRunner.h"
 #include "deltas/Delta.h"
+#include "deltas/Demangle.h"
+#include "deltas/MoveToEntry.h"
 #include "deltas/ReduceAliases.h"
 #include "deltas/ReduceArguments.h"
 #include "deltas/ReduceAttributes.h"
 #include "deltas/ReduceBasicBlocks.h"
 #include "deltas/ReduceDIMetadata.h"
 #include "deltas/ReduceFunctionBodies.h"
 #include "deltas/ReduceFunctions.h"
 #include "deltas/ReduceGlobalObjects.h"
DeltaPasses("delta-passes",
                 cl::cat(LLVMReduceOptions), cl::CommaSeparated);
 
 static cl::list<std::string>
     SkipDeltaPasses("skip-delta-passes",
                     cl::desc("Delta passes to not run, separated by commas. By "
                              "default, run all delta passes."),
                     cl::cat(LLVMReduceOptions), cl::CommaSeparated);
 
+#define UNCONDITIONAL_PASSES                                                   \
+  do {                                                                         \
+    DELTA_PASS("intrinsics", reduceInstrinsicsPass)                            \
+    DELTA_PASS("noisy-intrinsics", reduceNoisyInstrinsicsPass)                 \
+    DELTA_PASS("to-calls", reduceToCallsPass)                                  \
+    DELTA_PASS("move-to-entry", moveToEntryPass)                               \
+    DELTA_PASS("mangling", demanglePass)                                       \
+    DELTA_PASS("noise", reduceNoisePass)                                       \
+    DELTA_PASS("to-call-list", reduceToCallListPass)                           \
+  } while (false)
+
 #define DELTA_PASSES                                                           \
   do {                                                                         \
     DELTA_PASS("strip-debug-info", stripDebugInfoDeltaPass)                    \
     DELTA_PASS("functions", reduceFunctionsDeltaPass)                          \
     DELTA_PASS("function-bodies", reduceFunctionBodiesDeltaPass)               \
     DELTA_PASS("special-globals", reduceSpecialGlobalsDeltaPass)               \
     DELTA_PASS("aliases", reduceAliasesDeltaPass)                              \
     DELTA_PASS("ifuncs", reduceIFuncsDeltaPass)                                \
     DELTA_PASS("simplify-conditionals-true", reduceConditionalsTrueDeltaPass)  \
-    DELTA_PASS("simplify-conditionals-false", reduceConditionalsFalseDeltaPass)\
+    DELTA_PASS("simplify-conditionals-false",                                  \
+               reduceConditionalsFalseDeltaPass)                               \
     DELTA_PASS("invokes", reduceInvokesDeltaPass)                              \
-    DELTA_PASS("unreachable-basic-blocks", reduceUnreachableBasicBlocksDeltaPass) \
+    DELTA_PASS("unreachable-basic-blocks",                                     \
+               reduceUnreachableBasicBlocksDeltaPass)                          \
     DELTA_PASS("basic-blocks", reduceBasicBlocksDeltaPass)                     \
     DELTA_PASS("simplify-cfg", reduceUsingSimplifyCFGDeltaPass)                \
     DELTA_PASS("function-data", reduceFunctionDataDeltaPass)                   \
     DELTA_PASS("global-values", reduceGlobalValuesDeltaPass)                   \
     DELTA_PASS("global-objects", reduceGlobalObjectsDeltaPass)                 \
     DELTA_PASS("global-initializers", reduceGlobalsInitializersDeltaPass)      \
     DELTA_PASS("global-variables", reduceGlobalsDeltaPass)                     \
     DELTA_PASS("di-metadata", reduceDIMetadataDeltaPass)                       \
do {                                                                         \
     DELTA_PASS("operand-bundles", reduceOperandBundesDeltaPass)                \
     DELTA_PASS("attributes", reduceAttributesDeltaPass)                        \
     DELTA_PASS("module-data", reduceModuleDataDeltaPass)                       \
     DELTA_PASS("opcodes", reduceOpcodesDeltaPass)                              \
     DELTA_PASS("volatile", reduceVolatileInstructionsDeltaPass)                \
     DELTA_PASS("atomic-ordering", reduceAtomicOrderingDeltaPass)               \
     DELTA_PASS("syncscopes", reduceAtomicSyncScopesDeltaPass)                  \
     DELTA_PASS("instruction-flags", reduceInstructionFlagsDeltaPass)           \
   } while (false)
 
 #define DELTA_PASSES_MIR                                                       \
   do {                                                                         \
     DELTA_PASS("instructions", reduceInstructionsMIRDeltaPass)                 \
     DELTA_PASS("ir-instruction-references",                                    \
                reduceIRInstructionReferencesDeltaPass)                         \
     DELTA_PASS("ir-block-references", reduceIRBlockReferencesDeltaPass)        \
     DELTA_PASS("ir-function-references", reduceIRFunctionReferencesDeltaPass)  \
     DELTA_PASS("instruction-flags", reduceInstructionFlagsMIRDeltaPass)        \
     DELTA_PASS("register-uses", reduceRegisterUsesMIRDeltaPass)                \
     DELTA_PASS("register-defs", reduceRegisterDefsMIRDeltaPass)                \
     DELTA_PASS("register-hints", reduceVirtualRegisterHintsDeltaPass)          \
     DELTA_PASS("register-masks", reduceRegisterMasksMIRDeltaPass)              \
   } while (false)
 
+static void reduceNoisePass(TestRunner &Test) {
+  demanglePass(Test);
+  reduceNoisyInstrinsicsPass(Test);
+  reduceAttributesDeltaPass(Test);
+  stripDebugInfoDeltaPass(Test);
+  reduceDIMetadataDeltaPass(Test);
+  reduceMetadataDeltaPass(Test);
+  reduceNamedMetadataDeltaPass(Test);
+
+  // Simplify CFG in case `invoke` was used as a previous pass, to remove the
+  // unwind paths.
+  reduceUsingSimplifyCFGDeltaPass(Test);
+  reduceUnreachableBasicBlocksDeltaPass(Test);
+}
+
+static void reduceToCallListPass(TestRunner &Test) {
+  // Remove noise to start
+  reduceNoisePass(Test);
+
+  // Strip intrinsics as we're interested in user defined calls only.
+  reduceInstrinsicsPass(Test);
+
+  // Reduce invokes to calls so reducing arguments and reducing non-call
+  // instructions work as expected.
+  reduceInvokesDeltaPass(Test);
+
+  reduceArgumentsDeltaPass(Test);
+  reduceToCallsPass(Test);
+
+  // Move everything to the entry block.
+  moveToEntryPass(Test);
+
+  // Then prune everything else
+  reduceUsingSimplifyCFGDeltaPass(Test);
+  reduceUnreachableBasicBlocksDeltaPass(Test);
+}
+
 static void runAllDeltaPasses(TestRunner &Tester,
                               const SmallStringSet &SkipPass) {
 #define DELTA_PASS(NAME, FUNC)                                                 \
   if (!SkipPass.count(NAME)) {                                                 \
     FUNC(Tester);                                                              \
   }
   if (Tester.getProgram().isMIR()) {
     DELTA_PASSES_MIR;
   } else {
     DELTA_PASSES;
   }
 #undef DELTA_PASS
 }
 
 static void runDeltaPassName(TestRunner &Tester, StringRef PassName) {
 #define DELTA_PASS(NAME, FUNC)                                                 \
   if (PassName == NAME) {                                                      \
     FUNC(Tester);                                                              \
     return;                                                                    \
   }
   if (Tester.getProgram().isMIR()) {
     DELTA_PASSES_MIR;
   } else {
     DELTA_PASSES;
+    UNCONDITIONAL_PASSES;
   }
 #undef DELTA_PASS
 
   // We should have errored on unrecognized passes before trying to run
   // anything.
   llvm_unreachable("unknown delta pass");
 }
 
 void llvm::printDeltaPasses(raw_ostream &OS) {
   OS << "Delta passes (pass to `--delta-passes=` as a comma separated list):\n";
 #define DELTA_PASS(NAME, FUNC) OS << "  " << NAME << "\n";
   OS << " IR:\n";
   DELTA_PASSES;
+  UNCONDITIONAL_PASSES;
   OS << " MIR:\n";
   DELTA_PASSES_MIR;
 #undef DELTA_PASS
 }
 
 // Built a set of available delta passes.
 static void collectPassNames(const TestRunner &Tester,
                              SmallStringSet &NameSet) {
 #define DELTA_PASS(NAME, FUNC) NameSet.insert(NAME);
   if (Tester.getProgram().isMIR()) {
     DELTA_PASSES_MIR;
   } else {
     DELTA_PASSES;
+    UNCONDITIONAL_PASSES;
   }
 #undef DELTA_PASS
 }
 
 /// Verify all requested or skipped passes are valid names, and return them in a
 /// set.
 static SmallStringSet handlePassList(const TestRunner &Tester,
                                      const cl::list<std::string> &PassList) {
for (int Iter = 0; Iter < MaxPassIterations; ++Iter) {
     }
 
     uint64_t NewComplexity = Tester.getProgram().getComplexityScore();
     if (NewComplexity >= OldComplexity)
       break;
     OldComplexity = NewComplexity;
   }
 }
+
+void llvm::runUnconditionalPasses(TestRunner &Tester,
+                                  const cl::list<std::string> &PassList) {
+  auto PassSet = handlePassList(Tester, PassList);
+
+  for (StringRef PassName : PassList) {
+    runDeltaPassName(Tester, PassName);
+  }
+}

llvm/tools/llvm-reduce/TestRunner.h

 // This class contains all the info necessary for running the provided
 // interesting-ness test, as well as the most reduced module and its
 // respective filename.
 class TestRunner {
 public:
   TestRunner(StringRef TestName, const std::vector<std::string> &TestArgs,
              std::unique_ptr<ReducerWorkItem> Program,
              std::unique_ptr<TargetMachine> TM, StringRef ToolName,
-             StringRef OutputFilename, bool InputIsBitcode, bool OutputBitcode);
+             StringRef OutputFilename, bool InputIsBitcode, bool OutputBitcode,
+             bool Unconditional);
+
+  bool unconditional() const { return Unconditional; }
 
   /// Runs the interesting-ness test for the specified file
   /// @returns 0 if test was successful, 1 if otherwise
   int run(StringRef Filename) const;
 
   /// Returns the most reduced version of the original testcase
   ReducerWorkItem &getProgram() const { return *Program; }
 
   void setProgram(std::unique_ptr<ReducerWorkItem> &&P) {
     assert(P && "Setting null program?");
     Program = std::move(P);
   }
 
   const TargetMachine *getTargetMachine() const { return TM.get(); }
 
   StringRef getToolName() const { return ToolName; }
 
   void writeOutput(StringRef Message);
 
-  bool inputIsBitcode() const {
-    return InputIsBitcode;
-  }
+  bool inputIsBitcode() const { return InputIsBitcode; }
 
 private:
+  const bool Unconditional;
   StringRef TestName;
   StringRef ToolName;
   const std::vector<std::string> &TestArgs;
   std::unique_ptr<ReducerWorkItem> Program;
   std::unique_ptr<TargetMachine> TM;
   StringRef OutputFilename;
   const bool InputIsBitcode;
   bool EmitBitcode;
 };
 
 } // namespace llvm
 
 #endif

llvm/tools/llvm-reduce/TestRunner.cpp

 
 using namespace llvm;
 
 TestRunner::TestRunner(StringRef TestName,
                        const std::vector<std::string> &TestArgs,
                        std::unique_ptr<ReducerWorkItem> Program,
                        std::unique_ptr<TargetMachine> TM, StringRef ToolName,
                        StringRef OutputName, bool InputIsBitcode,
-                       bool OutputBitcode)
-    : TestName(TestName), ToolName(ToolName), TestArgs(TestArgs),
-      Program(std::move(Program)), TM(std::move(TM)),
+                       bool OutputBitcode, bool Unconditional)
+    : Unconditional(Unconditional), TestName(TestName), ToolName(ToolName),
+      TestArgs(TestArgs), Program(std::move(Program)), TM(std::move(TM)),
       OutputFilename(OutputName), InputIsBitcode(InputIsBitcode),
       EmitBitcode(OutputBitcode) {
   assert(this->Program && "Initialized with null program?");
 }
 
 static constexpr std::array<std::optional<StringRef>, 3> DefaultRedirects = {
     StringRef()};
 static constexpr std::array<std::optional<StringRef>, 3> NullRedirects;

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

if (std::unique_ptr<ReducerWorkItem> ChunkResult =
     // Communicate that the task reduced a chunk.
     AnyReduced = true;
   }
   return Result;
 }
 
 using SharedTaskQueue = std::deque<std::shared_future<SmallString<0>>>;
 
+static void runUnconditionalPass(TestRunner &Test,
+                                 ReductionFunc ExtractChunksFromModule,
+                                 StringRef Message) {
+  errs() << "*** " << Message << "...\n";
+
+  // Run the function with no chunks so all possible changes get made.
+  std::vector<Chunk> NoChunks = {};
+  Oracle Counter(NoChunks);
+  ExtractChunksFromModule(Counter, Test.getProgram());
+}
+
 /// Runs the Delta Debugging algorithm, splits the code into chunks and
 /// reduces the amount of chunks that are considered interesting by the
 /// given test. The number of chunks is determined by a preliminary run of the
 /// reduction pass where no change must be made to the module.
 void llvm::runDeltaPass(TestRunner &Test, ReductionFunc ExtractChunksFromModule,
                         StringRef Message) {
+  if (Test.unconditional()) {
+    return runUnconditionalPass(Test, ExtractChunksFromModule, Message);
+  }
   assert(!Test.getProgram().verify(&errs()) &&
          "input module is broken before making changes");
   errs() << "*** " << Message << "...\n";
 
   int Targets;
   {
     // Count the number of chunks by counting the number of calls to
     // Oracle::shouldKeep() but always returning true so no changes are
     // made.
     std::vector<Chunk> AllChunks = {{0, INT_MAX}};
     Oracle Counter(AllChunks);
     ExtractChunksFromModule(Counter, Test.getProgram());
     Targets = Counter.count();
 
     assert(!Test.getProgram().verify(&errs()) &&
            "input module is broken after counting chunks");
     assert(Test.getProgram().isReduced(Test) &&
            "input module no longer interesting after counting chunks");
 
 #ifndef NDEBUG
     // Make sure that the number of chunks does not change as we reduce.
     std::vector<Chunk> NoChunks = {{0, INT_MAX}};
     Oracle NoChunksCounter(NoChunks);
     std::unique_ptr<ReducerWorkItem> Clone =
         Test.getProgram().clone(Test.getTargetMachine());
     ExtractChunksFromModule(NoChunksCounter, *Clone);
     assert(Targets == NoChunksCounter.count() &&
            "number of chunks changes when reducing");
 #endif
   }
   if (!Targets) {
     if (Verbose)
       errs() << "\nNothing to reduce\n";

llvm/tools/llvm-reduce/deltas/Demangle.h

+//===- Demangle.h -------------------------------------*- C++ -*-===//
+//
+// 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 implements a function which calls the Generic Delta pass in order
+// to demangle function names.
+//
+//===----------------------------------------------------------------------===//
+
+#ifndef LLVM_TOOLS_LLVM_REDUCE_DEMANGLE_H
+#define LLVM_TOOLS_LLVM_REDUCE_DEMANGLE_H
+
+#include "Delta.h"
+
+namespace llvm {
+void demanglePass(TestRunner &Test);
+} // namespace llvm
+
+#endif

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

+//===- Demangle.cpp - Specialized Delta Pass
+//---------------------===//
+//
+// 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 implements a function which calls the Generic Delta pass in order
+// to demangle function names.
+//
+//===----------------------------------------------------------------------===//
+
+#include "Demangle.h"
+#include "llvm/Demangle/Demangle.h"
+
+using namespace llvm;
+
+static void demangleModule(Oracle &O, ReducerWorkItem &WorkItem) {
+  Module &Program = WorkItem.getModule();
+
+  if (O.shouldKeep())
+    return;
+
+  for (auto &F : Program) {
+    F.setName(llvm::demangle(F.getName().str()));
+  }
+}
+
+void llvm::demanglePass(TestRunner &Test) {
+  runDeltaPass(Test, demangleModule, "Demangling names");
+}

llvm/tools/llvm-reduce/deltas/MoveToEntry.h

+//===- MoveToEntry.h -------------------------------------*- C++ -*-===//
+//
+// 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 implements a function which calls the Generic Delta pass in order
+// to move instructions to the entry basic block.
+//
+//===----------------------------------------------------------------------===//
+
+#ifndef LLVM_TOOLS_LLVM_REDUCE_DELTAS_MOVETOENTRY_H
+#define LLVM_TOOLS_LLVM_REDUCE_DELTAS_MOVETOENTRY_H
+
+#include "Delta.h"
+
+namespace llvm {
+void moveToEntryPass(TestRunner &Test);
+} // namespace llvm
+
+#endif

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

+//===- MoveToEntry.cpp - Specialized Delta Pass
+//---------------------===//
+//
+// 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 implements a function which calls the Generic Delta pass in order
+// to move instructions to the entry basic block.
+//
+//===----------------------------------------------------------------------===//
+
+#include "MoveToEntry.h"
+#include "Utils.h"
+#include "llvm/IR/Constants.h"
+#include "llvm/IR/Instructions.h"
+#include "llvm/Transforms/Utils/BasicBlockUtils.h"
+#include "llvm/Transforms/Utils/Cloning.h"
+
+using namespace llvm;
+
+/// Filter out cases where deleting the instruction will likely cause the
+/// user/def of the instruction to fail the verifier.
+//
+// TODO: Technically the verifier only enforces preallocated token usage and
+// there is a none token.
+static bool shouldAlwaysKeep(const Instruction &I) {
+  return I.isEHPad() || I.getType()->isTokenTy() || I.isSwiftError();
+}
+
+static void moveToEntryModule(Oracle &O, ReducerWorkItem &WorkItem) {
+  Module &Program = WorkItem.getModule();
+
+  if (O.shouldKeep())
+    return;
+
+  for (auto &F : Program) {
+    std::vector<Instruction *> ToMove;
+
+    for (auto &BB : make_range(std::next(F.begin()), F.end())) {
+      for (auto &Inst : make_range(BB.begin(), std::prev(BB.end()))) {
+        if (!shouldAlwaysKeep(Inst)) {
+          Inst.replaceAllUsesWith(getDefaultValue(Inst.getType()));
+          ToMove.push_back(&Inst);
+        }
+      }
+    }
+    auto &Entry = *F.begin();
+
+    for (auto &Inst : ToMove) {
+      Inst->removeFromParent();
+      Inst->insertBefore(&*std::prev(Entry.end()));
+    }
+  }
+}
+
+void llvm::moveToEntryPass(TestRunner &Test) {
+  runDeltaPass(Test, moveToEntryModule, "Moving instructions to entry block");
+}

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

 #include <vector>
 
 using namespace llvm;
 
 /// Goes over OldF calls and replaces them with a call to NewF
 static void replaceFunctionCalls(Function &OldF, Function &NewF,
                                  const std::set<int> &ArgIndexesToKeep) {
   const auto &Users = OldF.users();
-  for (auto I = Users.begin(), E = Users.end(); I != E; )
+  for (auto I = Users.begin(), E = Users.end(); I != E;)
     if (auto *CI = dyn_cast<CallInst>(*I++)) {
       // Skip uses in call instructions where OldF isn't the called function
       // (e.g. if OldF is an argument of the call).
       if (CI->getCalledFunction() != &OldF)
         continue;
       SmallVector<Value *, 8> Args;
       for (auto ArgI = CI->arg_begin(), E = CI->arg_end(); ArgI != E; ++ArgI)
         if (ArgIndexesToKeep.count(ArgI - CI->arg_begin()))
static void extractArgumentsFromModule(Oracle &O, ReducerWorkItem &WorkItem) {
 
   // We create a vector first, then convert it to a set, so that we don't have
   // to pay the cost of rebalancing the set frequently if the order we insert
   // the elements doesn't match the order they should appear inside the set.
   std::set<Argument *> ArgsToKeep(InitArgsToKeep.begin(), InitArgsToKeep.end());
 
   for (auto *F : Funcs) {
     ValueToValueMapTy VMap;
-    std::vector<WeakVH> InstToDelete;
     for (auto &A : F->args())
       if (!ArgsToKeep.count(&A)) {
         // By adding undesired arguments to the VMap, CloneFunction will remove
         // them from the resulting Function
         VMap[&A] = getDefaultValue(A.getType());
-        for (auto *U : A.users())
-          if (auto *I = dyn_cast<Instruction>(*&U))
-            InstToDelete.push_back(I);
-      }
-    // Delete any (unique) instruction that uses the argument
-    for (Value *V : InstToDelete) {
-      if (!V)
-        continue;
-      auto *I = cast<Instruction>(V);
-      I->replaceAllUsesWith(getDefaultValue(I->getType()));
-      if (!I->isTerminator())
-        I->eraseFromParent();
       }
 
     // No arguments to reduce
     if (VMap.empty())
       continue;
 
     std::set<int> ArgIndexesToKeep;
     for (auto &Arg : enumerate(F->args()))
       if (ArgsToKeep.count(&Arg.value()))

llvm/tools/llvm-reduce/deltas/ReduceInstructions.h

 #define LLVM_TOOLS_LLVM_REDUCE_DELTAS_REDUCEINSTRUCTIONS_H
 
 #include "Delta.h"
 #include "llvm/Transforms/Utils/BasicBlockUtils.h"
 #include "llvm/Transforms/Utils/Cloning.h"
 
 namespace llvm {
 void reduceInstructionsDeltaPass(TestRunner &Test);
+void reduceToCallsPass(TestRunner &Test);
+void reduceInstrinsicsPass(TestRunner &Test);
+void reduceNoisyInstrinsicsPass(TestRunner &Test);
 } // namespace llvm
 
 #endif

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

-//===- ReduceInstructions.cpp - Specialized Delta Pass ---------------------===//
+//===- ReduceInstructions.cpp - Specialized Delta Pass --------------------===//
 //
 // 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 implements a function which calls the Generic Delta pass in order
 // to reduce uninteresting Instructions from defined functions.
 //
 //===----------------------------------------------------------------------===//
 
 #include "ReduceInstructions.h"
 #include "Utils.h"
 #include "llvm/IR/Constants.h"
+#include "llvm/IR/Instructions.h"
+#include "llvm/IR/IntrinsicInst.h"
 
 using namespace llvm;
 
+using FilterFunc = function_ref<bool(const Instruction &I)>;
+
 /// Filter out cases where deleting the instruction will likely cause the
 /// user/def of the instruction to fail the verifier.
 //
 // TODO: Technically the verifier only enforces preallocated token usage and
 // there is a none token.
-static bool shouldAlwaysKeep(const Instruction &I) {
-  return I.isEHPad() || I.getType()->isTokenTy() || I.isSwiftError();
+static bool shouldAlwaysKeep(const Instruction &I, FilterFunc Filter) {
+  return I.isEHPad() || I.getType()->isTokenTy() || I.isSwiftError() ||
+         Filter(I);
 }
 
 /// Removes out-of-chunk arguments from functions, and modifies their calls
 /// accordingly. It also removes allocations of out-of-chunk arguments.
-static void extractInstrFromModule(Oracle &O, ReducerWorkItem &WorkItem) {
+static void extractInstrFromModule(Oracle &O, ReducerWorkItem &WorkItem,
+                                   FilterFunc Filter) {
   Module &Program = WorkItem.getModule();
   std::vector<Instruction *> InitInstToKeep;
 
   for (auto &F : Program)
     for (auto &BB : F) {
       // Removing the terminator would make the block invalid. Only iterate over
       // instructions before the terminator.
       InitInstToKeep.push_back(BB.getTerminator());
       for (auto &Inst : make_range(BB.begin(), std::prev(BB.end()))) {
-        if (shouldAlwaysKeep(Inst) || O.shouldKeep())
+        if (shouldAlwaysKeep(Inst, Filter) || O.shouldKeep())
           InitInstToKeep.push_back(&Inst);
       }
     }
 
   // We create a vector first, then convert it to a set, so that we don't have
   // to pay the cost of rebalancing the set frequently if the order we insert
   // the elements doesn't match the order they should appear inside the set.
   std::set<Instruction *> InstToKeep(InitInstToKeep.begin(),
                                      InitInstToKeep.end());
 
   std::vector<Instruction *> InstToDelete;
   for (auto &F : Program)
     for (auto &BB : F)
       for (auto &Inst : BB)
         if (!InstToKeep.count(&Inst)) {
           Inst.replaceAllUsesWith(getDefaultValue(Inst.getType()));
           InstToDelete.push_back(&Inst);
         }
 
   for (auto &I : InstToDelete)
     I->eraseFromParent();
 }
 
 void llvm::reduceInstructionsDeltaPass(TestRunner &Test) {
-  runDeltaPass(Test, extractInstrFromModule, "Reducing Instructions");
+  runDeltaPass(
+      Test,
+      [](Oracle &O, ReducerWorkItem &WorkItem) {
+        extractInstrFromModule(
+            O, WorkItem, [](const Instruction &I) -> bool { return false; });
+      },
+      "Reducing Instructions");
+}
+
+void llvm::reduceToCallsPass(TestRunner &Test) {
+  runDeltaPass(
+      Test,
+      [](Oracle &O, ReducerWorkItem &WorkItem) {
+        extractInstrFromModule(O, WorkItem, [](const Instruction &I) -> bool {
+          return isa<CallBase>(I);
+        });
+      },
+      "Reducing Non-Call Instructions");
+}
+
+void llvm::reduceInstrinsicsPass(TestRunner &Test) {
+  runDeltaPass(
+      Test,
+      [](Oracle &O, ReducerWorkItem &WorkItem) {
+        extractInstrFromModule(O, WorkItem, [](const Instruction &I) -> bool {
+          return !isa<IntrinsicInst>(I);
+        });
+      },
+      "Reducing Instrinsics");
+}
+
+static llvm::Intrinsic::ID Noisy[] = {
+    Intrinsic::assume, Intrinsic::lifetime_start, Intrinsic::lifetime_end};
+
+void llvm::reduceNoisyInstrinsicsPass(TestRunner &Test) {
+  runDeltaPass(
+      Test,
+      [](Oracle &O, ReducerWorkItem &WorkItem) {
+        extractInstrFromModule(O, WorkItem, [](const Instruction &I) -> bool {
+          if (const IntrinsicInst *II = dyn_cast<const IntrinsicInst>(&I)) {
+            auto ID = II->getIntrinsicID();
+            for (auto I : Noisy) {
+              if (ID == I) {
+                return false;
+              }
+            }
+          }
+          return true;
+        });
+      },
+      "Reducing Noisy Instrinsics");
 }

llvm/tools/llvm-reduce/llvm-reduce.cpp

 
 cl::OptionCategory LLVMReduceOptions("llvm-reduce options");
 
 static cl::opt<bool> Help("h", cl::desc("Alias for -help"), cl::Hidden,
                           cl::cat(LLVMReduceOptions));
 static cl::opt<bool> Version("v", cl::desc("Alias for -version"), cl::Hidden,
                              cl::cat(LLVMReduceOptions));
 
+static cl::list<std::string> UnconditionalPasses(
+    "reduce",
+    cl::desc("Passes to unconditionally run, disables the delta algorithm"),
+    cl::cat(LLVMReduceOptions), cl::CommaSeparated);
+
 static cl::opt<bool> PreserveDebugEnvironment(
     "preserve-debug-environment",
     cl::desc("Don't disable features used for crash "
              "debugging (crash reports, llvm-symbolizer and core dumps)"),
     cl::cat(LLVMReduceOptions));
 
 static cl::opt<bool>
     PrintDeltaPasses("print-delta-passes",
int main(int Argc, char **Argv) {
   }
 
   if (InputFilename.empty()) {
     WithColor::error(errs(), ToolName)
         << "reduction testcase positional argument must be specified\n";
     return 1;
   }
 
-  if (TestFilename.empty()) {
-    WithColor::error(errs(), ToolName) << "--test option must be specified\n";
-    return 1;
-  }
-
   if (!PreserveDebugEnvironment)
     disableEnvironmentDebugFeatures();
 
   LLVMContext Context;
   std::unique_ptr<TargetMachine> TM;
 
   auto [OriginalProgram, InputIsBitcode] =
       parseReducerWorkItem(ToolName, InputFilename, Context, TM, ReduceModeMIR);
   if (!OriginalProgram) {
     return 1;
   }
 
   StringRef OutputFilename;
   bool OutputBitcode;
   std::tie(OutputFilename, OutputBitcode) =
       determineOutputType(ReduceModeMIR, InputIsBitcode);
 
+  if (UnconditionalPasses.empty() && TestFilename.empty()) {
+    WithColor::error(errs(), ToolName) << "--test option must be specified\n";
+    return 1;
+  }
+
   // Initialize test environment
   TestRunner Tester(TestFilename, TestArguments, std::move(OriginalProgram),
                     std::move(TM), ToolName, OutputFilename, InputIsBitcode,
-                    OutputBitcode);
+                    OutputBitcode, !UnconditionalPasses.empty());
 
-  // This parses and writes out the testcase into a temporary file copy for the
-  // test, rather than evaluating the source IR directly. This is for the
+  if (UnconditionalPasses.empty()) {
+    // This parses and writes out the testcase into a temporary file copy for
+    // the test, rather than evaluating the source IR directly. This is for the
     // convenience of lit tests; the stripped out comments may have broken the
     // interestingness checks.
     if (!Tester.getProgram().isReduced(Tester)) {
       errs() << "\nInput isn't interesting! Verify interesting-ness test\n";
       return 1;
     }
 
     // Try to reduce code
     runDeltaPasses(Tester, MaxPassIterations);
+  } else {
+    runUnconditionalPasses(Tester, UnconditionalPasses);
+  }
 
   // Print reduced file to STDOUT
   if (OutputFilename == "-")
     Tester.getProgram().print(outs(), nullptr);
   else
     Tester.writeOutput("Done reducing! Reduced testcase: ");
 
   return 0;
 }