llvm-reduce: reduce using opt passes

[regehr]

Summary

This patch teaches llvm-reduce to run opt passes. The rationale for this comes in three parts:

1. opt passes have the potential to usefully shrink test cases in ways that are more powerful than the existing delta passes that we have. for example, SROA cleans up a lot of allocas, InstCombine does lots of other simplifications, etc.
2. running opt passes can bring the test case closer to the actual input that gets miscompiled. consider an example where we're reducing some unoptimized IR that gets miscompiled 25 passes into the phase ordering. by running some of these earlier passes, we make the test case into something that is more directly miscompiled, making it easier to understand what's going on and also making it easier to tell if the bug trigger is a duplicate.
3. opt passes try to canonicalize the code, and we like canonicalization because for those of us who read a lot of canonical IR it's easier to understand. if there are non-canonical aspects to our test case that are inessential for triggering a bug, we should eliminate them.

A drawback of this patch is that it makes llvm-reduce run slower -- on my machine, this patch makes my machine take 2.4 seconds instead of 1.6 seconds to run all of the llvm-reduce test cases. The other drawback that I can think of is that if we're trying to reduce a file that crashes one of the passes we're trying to run, llvm-reduce will also crash (I have a solution to this, but was hoping to land this patch first).

One thing to discuss is the set of passes that we run here, I've just gone and picked some by hand that seem like they are mostly going to simplify the code, but am open to discussion about which passes make the most sense.

Another thing we could discuss is when to run the opt passes. Here I have them running right at the beginning, when there should be lots of opportunities for them to clean things up, but we could also make an argument for running them at the end of the llvm-reduce phase ordering so that they'll canonicalize the IR as much as possible before it gets dumped out for human consumption.

[regehr]

this patch is currently failing some tests but I can fix that up quickly. I just benchmarked it and it reduces final file size by 7% on my test cases. not earthshattering, but the reduced files end up being somewhat more pleasant to look at, since the passes leave things looking nice and canonical. anyone have time to look this over?

[aeubanks]

sorry, forgot to review this the first time around

do we really need this many passes? I'd think that just SROA/InstCombine/SimplifyCFG would be enough

llvm/test/tools/llvm-reduce/remove-operands-fp.ll

26

I'd actually prefer not to have internal as the canonical reduced output, it's more likely to get thrown away by accident and also increases the amount of text in the output. ditto with tail calls

llvm/tools/llvm-reduce/DeltaManager.cpp

55

we should run this after some of the other passes that remove lots of stuff quickly since this is fairly expensive

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

21

this isn't running opt, it's just running passes. something like reduceUsingIRPassesDeltaPass seems more appropriate

[arsenm]

Overlap with D123749?

[arsenm]

In D128470#3701102, @aeubanks wrote:

sorry, forgot to review this the first time around

do we really need this many passes? I'd think that just SROA/InstCombine/SimplifyCFG would be enough

I get a lot of value out of manually running InferAddressSpaces and GVN when reducing

[regehr]

In D128470#3701107, @arsenm wrote:

Overlap with D123749?

aieee!!! I wish I'd seen that earlier. I'm totally happy to go with that one instead of this it if looks better to y'all.

I agree my list of passes is overkill, and also that gvn sounds super useful to run (I have no objection to InferAddressSpaces)

[regehr]

here's a proposal: if we decide to go forward with my patch instead of Arthur's, I'll do a bit of work to remove the passes one by one in order to help us make a more informed decision about which passes we should be running here.

I'm not saying we should include every pass that reduces size, but rather that that data is a better starting point for this discussion than our intuition is.

[arsenm]

In D128470#3701200, @regehr wrote:

here's a proposal: if we decide to go forward with my patch instead of Arthur's, I'll do a bit of work to remove the passes one by one in order to help us make a more informed decision about which passes we should be running here.

I'm not saying we should include every pass that reduces size, but rather that that data is a better starting point for this discussion than our intuition is.

I do think restricting this is more useful. Just running opt -O3 kills most failures I look at

llvm/test/tools/llvm-reduce/reduce-using-passes.ll

+; the function below can be simplified by InstCombine + DSE to "ret
+; 0".  here we'll test the ability of reduceUsingOpt to run only
+; InstCombine and not also DSE.
+
+; RUN: llvm-reduce --delta-passes=using-opt --abort-on-invalid-reduction --test FileCheck --test-arg --check-prefixes=INTERESTINGNESS --test-arg %s --test-arg --input-file %s -o %t
+; RUN: FileCheck %s --input-file=%t
+
+; INTERESTINGNESS: store i32
+
+; CHECK: ret i32 0
+
+%struct.foo = type { [2 x i32] }
+
+@g = dso_local global %struct.foo zeroinitializer, align 4
+
+define dso_local i32 @test(i32 noundef %0, i32 noundef %1) {
+  %3 = alloca i32, align 4
+  %4 = alloca i32, align 4
+  %5 = alloca %struct.foo, align 4
+  %6 = alloca i32, align 4
+  %7 = alloca i32, align 4
+  %8 = alloca i32, align 4
+  store i32 %0, ptr %3, align 4
+  store i32 %1, ptr %4, align 4
+  call void @llvm.memcpy.p0.p0.i64(ptr align 4 %5, ptr align 4 @g, i64 8, i1 false)
+  %9 = load i32, ptr %3, align 4
+  store i32 %9, ptr @g, align 4
+  %10 = load i32, ptr %4, align 4
+  store i32 %10, ptr getelementptr inbounds ([2 x i32], ptr @g, i64 0, i64 1), align 4
+  %11 = load i32, ptr @g, align 4
+  %12 = xor i32 %11, -1
+  %13 = load i32, ptr getelementptr inbounds ([2 x i32], ptr @g, i64 0, i64 1), align 4
+  %14 = xor i32 %13, -1
+  %15 = or i32 %12, %14
+  store i32 %15, ptr %6, align 4
+  %16 = load i32, ptr @g, align 4
+  %17 = xor i32 %16, -1
+  %18 = load i32, ptr getelementptr inbounds ([2 x i32], ptr @g, i64 0, i64 1), align 4
+  %19 = xor i32 %18, -1
+  %20 = and i32 %17, %19
+  store i32 %20, ptr %7, align 4
+  %21 = load i32, ptr %6, align 4
+  %22 = load i32, ptr %7, align 4
+  %23 = and i32 %21, %22
+  %24 = load i32, ptr @g, align 4
+  %25 = and i32 %23, %24
+  store i32 %25, ptr %8, align 4
+  call void @llvm.memcpy.p0.p0.i64(ptr align 4 @g, ptr align 4 %5, i64 8, i1 false)
+  %26 = load i32, ptr %8, align 4
+  ret i32 %26
+}
+
+declare void @llvm.memcpy.p0.p0.i64(ptr noalias nocapture writeonly, ptr noalias nocapture readonly, i64, i1 immarg) #1

llvm/test/tools/llvm-reduce/remove-attributes-from-intrinsic-like-functions.ll

 ; CHECK-INTERESTINGNESS-SAME: "arg0"
 ; CHECK-INTERESTINGNESS-SAME: i32 @llvm.not.really.an.intrinsic(i32
 ; CHECK-INTERESTINGNESS-SAME: "arg3"
 ; CHECK-INTERESTINGNESS-SAME: %a
 ; CHECK-INTERESTINGNESS-SAME: i32
 ; CHECK-INTERESTINGNESS-SAME: %a
 ; CHECK-INTERESTINGNESS-SAME: #1
 
-; CHECK-FINAL: %r = call "arg0" i32 @llvm.not.really.an.intrinsic(i32 "arg3" %a, i32 %a) #1
+; CHECK-FINAL: %r = tail call "arg0" i32 @llvm.not.really.an.intrinsic(i32 "arg3" %a, i32 %a) #1
 ; CHECK-ALL: ret i32 %r
 
   %r = call "arg0" "arg1" i32 @llvm.not.really.an.intrinsic(i32 "arg2" "arg3" %a, i32 %a) "arg4" "arg5"
   ret i32 %r
 }
 
 ; CHECK-INTERESTINGNESS: attributes #0 = {
 ; CHECK-INTERESTINGNESS-SAME: "arg6"

llvm/test/tools/llvm-reduce/remove-attributes-from-intrinsics.ll

 ; CHECK-INTERESTINGNESS-SAME: "arg0"
 ; CHECK-INTERESTINGNESS-SAME: i32 @llvm.uadd.sat.i32(i32
 ; CHECK-INTERESTINGNESS-SAME: "arg3"
 ; CHECK-INTERESTINGNESS-SAME: %a
 ; CHECK-INTERESTINGNESS-SAME: i32
 ; CHECK-INTERESTINGNESS-SAME: %a
 ; CHECK-INTERESTINGNESS-SAME: #1
 
-; CHECK-FINAL: %r = call "arg0" i32 @llvm.uadd.sat.i32(i32 "arg3" %a, i32 %a) #1
+; CHECK-FINAL: %r = tail call "arg0" i32 @llvm.uadd.sat.i32(i32 "arg3" %a, i32 %a) #1
 ; CHECK-ALL: ret i32 %r
 
   %r = call "arg0" "arg1" i32 @llvm.uadd.sat.i32(i32 "arg2" "arg3" %a, i32 %a) "arg4" "arg5"
   ret i32 %r
 }
 
 ; CHECK-ALL: declare i32 @llvm.uadd.sat.i32(i32, i32) #0
 declare i32 @llvm.uadd.sat.i32(i32, i32) #0

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

 ; RUN: llvm-reduce --test FileCheck --test-arg --check-prefix=CHECK-INTERESTINGNESS --test-arg %s --test-arg --input-file %s -o %t
 ; RUN: FileCheck --check-prefix=CHECK-FINAL %s < %t
 
 ; 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), bitcast (void ()* @func to void (i32)*)
+; CHECK-FINAL: @alias = internal alias void (i32), bitcast (void ()* @func to void (i32)*)
 
 @alias = alias void (i32), void (i32)* @func
 
 ; CHECK-FINAL: @func()
 
 define void @func(i32 %arg) {
 entry:
   ret void
 }

llvm/test/tools/llvm-reduce/remove-invoked-functions.ll

 declare void @thrown()
 
 ; CHECK-INTERESTINGNESS: define void @caller(
 ; CHECK-FINAL: define void @caller()
 define void @caller(i32 %arg) personality i8* bitcast (i32 (...)* @__gxx_personality_v0 to i8*) {
 ; CHECK-ALL: bb:
 bb:
 ; CHECK-INTERESTINGNESS: %i0 = invoke i32 {{.*}}@maybe_throwing_callee
-; CHECK-FINAL: %i0 = invoke i32 bitcast (i32 ()* @maybe_throwing_callee to i32 (i32)*)
+; CHECK-FINAL: %i0 = invoke i32 @maybe_throwing_callee()
 ; CHECK-ALL: to label %bb3 unwind label %bb1
   %i0 = invoke i32 @maybe_throwing_callee(i32 %arg)
           to label %bb3 unwind label %bb1
 
 ; CHECK-ALL: bb1:
 bb1:
 ; CHECK-ALL: landingpad { i8*, i32 }
 ; CHECK-ALL: catch i8* null

llvm/test/tools/llvm-reduce/remove-operands-fp.ll

 
 ; CHECK-INTERESTINGNESS: = fadd <2 x float> %
 ; CHECK-INTERESTINGNESS: = fadd <2 x float>
 ; CHECK-INTERESTINGNESS: = fadd <2 x float>
 ; CHECK-INTERESTINGNESS: = fadd <2 x float>
 ; CHECK-INTERESTINGNESS: = fadd <2 x float>
 ; CHECK-INTERESTINGNESS: = fadd <2 x float>
 
-; CHECK-LABEL: define void @foo(
+; CHECK-LABEL: define {{(internal )?}}void @foo(
 
 
 ; ONE: %fadd0 = fadd float %arg0, 1.000000e+00
 ; ONE: %fadd1 = fadd float 1.000000e+00, 1.000000e+00
 ; ONE: %fadd2 = fadd float 1.000000e+00, 0.000000e+00
 ; ONE: %fadd3 = fadd float 1.000000e+00, 1.000000e+00
 ; ONE: %fadd4 = fadd float 1.000000e+00, 1.000000e+00
 ; ONE: %fadd5 = fadd float 1.000000e+00, 1.000000e+00

llvm/test/tools/llvm-reduce/remove-operands.ll

 ; CHECK-INTERESTINGNESS: inttoptr
 ; CHECK-INTERESTINGNESS: br label
 ; CHECK-INTERESTINGNESS: ret i32
 
 %t = type { i32, i8 }
 
 declare void @llvm.foo(metadata)
 
-; CHECK-LABEL: define i32 @main
+; CHECK-LABEL: define {{(internal )?}}i32 @main
 define i32 @main(%t* %a, i32 %a2) {
 
 ; CHECK-LABEL: lb1:
 ; ONE: inttoptr i16 0
 ; ONE: inttoptr i16 1
 ; ONE: inttoptr i16 1
 ; ONE: inttoptr i16 1
 ; ZERO: inttoptr i16 0

llvm/tools/llvm-reduce/CMakeLists.txt

 set(LLVM_LINK_COMPONENTS
+  AggressiveInstCombine
   AllTargetsAsmParsers
   AllTargetsCodeGens
   AllTargetsDescs
   AllTargetsInfos
   Analysis
   BitReader
   BitWriter
   CodeGen
   Core
+  InstCombine
+  IPO
   IRReader
   MC
   MIRParser
+  Passes
+  ScalarOpts
   Support
   Target
   TransformUtils
   )
 
 add_llvm_tool(llvm-reduce
   DeltaManager.cpp
   ReducerWorkItem.cpp
add_llvm_tool(llvm-reduce
   deltas/ReduceMetadata.cpp
   deltas/ReduceModuleData.cpp
   deltas/ReduceOperandBundles.cpp
   deltas/ReduceSpecialGlobals.cpp
   deltas/ReduceOperands.cpp
   deltas/ReduceOperandsSkip.cpp
   deltas/ReduceOperandsToArgs.cpp
   deltas/ReduceInstructionsMIR.cpp
+  deltas/ReduceUsingOpt.cpp
   deltas/ReduceInstructionFlagsMIR.cpp
   deltas/ReduceIRReferences.cpp
   deltas/ReduceVirtualRegisters.cpp
   deltas/ReduceRegisterUses.cpp
   deltas/SimplifyInstructions.cpp
   llvm-reduce.cpp
 
   DEPENDS
   intrinsics_gen
   )

llvm/tools/llvm-reduce/DeltaManager.cpp

 #include "deltas/ReduceMetadata.h"
 #include "deltas/ReduceModuleData.h"
 #include "deltas/ReduceOperandBundles.h"
 #include "deltas/ReduceOperands.h"
 #include "deltas/ReduceOperandsSkip.h"
 #include "deltas/ReduceOperandsToArgs.h"
 #include "deltas/ReduceRegisterUses.h"
 #include "deltas/ReduceSpecialGlobals.h"
+#include "deltas/ReduceUsingOpt.h"
 #include "deltas/ReduceVirtualRegisters.h"
 #include "deltas/SimplifyInstructions.h"
 #include "llvm/Support/CommandLine.h"
 
 using namespace llvm;
 
 extern cl::OptionCategory LLVMReduceOptions;
 static cl::opt<std::string>
     DeltaPasses("delta-passes",
                 cl::desc("Delta passes to run, separated by commas. By "
                          "default, run all delta passes."),
                 cl::cat(LLVMReduceOptions));
 
 #define DELTA_PASSES                                                           \
+  DELTA_PASS("using-opt", reduceUsingOptDeltaPass)                             \
   DELTA_PASS("special-globals", reduceSpecialGlobalsDeltaPass)                 \
   DELTA_PASS("aliases", reduceAliasesDeltaPass)                                \
   DELTA_PASS("function-bodies", reduceFunctionBodiesDeltaPass)                 \
   DELTA_PASS("functions", reduceFunctionsDeltaPass)                            \
   DELTA_PASS("basic-blocks", reduceBasicBlocksDeltaPass)                       \
   DELTA_PASS("global-values", reduceGlobalValuesDeltaPass)                     \
   DELTA_PASS("global-objects", reduceGlobalObjectsDeltaPass)                   \
   DELTA_PASS("global-initializers", reduceGlobalsInitializersDeltaPass)        \

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

+//===- ReduceUsingOpt.h - 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 call various optimization passes in order to simplify
+// and canonicalize the code being reduced.
+//
+//===----------------------------------------------------------------------===//
+
+#ifndef LLVM_TOOLS_LLVM_REDUCE_DELTAS_REDUCEUSINGOPT_H
+#define LLVM_TOOLS_LLVM_REDUCE_DELTAS_REDUCEUSINGOPT_H
+
+#include "Delta.h"
+
+namespace llvm {
+void reduceUsingOptDeltaPass(TestRunner &Test);
+} // namespace llvm
+
+#endif

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

+//===- ReduceUsingOpt.h - 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 call various optimization passes in order to simplify
+// and canonicalize the code being reduced.
+//
+//===----------------------------------------------------------------------===//
+
+#include "ReduceUsingOpt.h"
+#include "Delta.h"
+#include "llvm/IR/PassManager.h"
+#include "llvm/Passes/PassBuilder.h"
+#include "llvm/Transforms/AggressiveInstCombine/AggressiveInstCombine.h"
+#include "llvm/Transforms/IPO.h"
+#include "llvm/Transforms/IPO/DeadArgumentElimination.h"
+#include "llvm/Transforms/IPO/GlobalDCE.h"
+#include "llvm/Transforms/IPO/GlobalOpt.h"
+#include "llvm/Transforms/IPO/Internalize.h"
+#include "llvm/Transforms/IPO/SCCP.h"
+#include "llvm/Transforms/InstCombine/InstCombine.h"
+#include "llvm/Transforms/Scalar/ADCE.h"
+#include "llvm/Transforms/Scalar/BDCE.h"
+#include "llvm/Transforms/Scalar/CorrelatedValuePropagation.h"
+#include "llvm/Transforms/Scalar/DCE.h"
+#include "llvm/Transforms/Scalar/DeadStoreElimination.h"
+#include "llvm/Transforms/Scalar/EarlyCSE.h"
+#include "llvm/Transforms/Scalar/GVN.h"
+#include "llvm/Transforms/Scalar/IndVarSimplify.h"
+#include "llvm/Transforms/Scalar/InstSimplifyPass.h"
+#include "llvm/Transforms/Scalar/JumpThreading.h"
+#include "llvm/Transforms/Scalar/LICM.h"
+#include "llvm/Transforms/Scalar/LoopDeletion.h"
+#include "llvm/Transforms/Scalar/LoopIdiomRecognize.h"
+#include "llvm/Transforms/Scalar/LoopInstSimplify.h"
+#include "llvm/Transforms/Scalar/LoopSimplifyCFG.h"
+#include "llvm/Transforms/Scalar/MemCpyOptimizer.h"
+#include "llvm/Transforms/Scalar/NewGVN.h"
+#include "llvm/Transforms/Scalar/Reassociate.h"
+#include "llvm/Transforms/Scalar/SCCP.h"
+#include "llvm/Transforms/Scalar/SROA.h"
+#include "llvm/Transforms/Scalar/SimpleLoopUnswitch.h"
+#include "llvm/Transforms/Scalar/SimplifyCFG.h"
+#include "llvm/Transforms/Scalar/TailRecursionElimination.h"
+
+using namespace llvm;
+
+static std::vector<std::function<void(FunctionPassManager &)>> FunctionPasses =
+    {
+        [](FunctionPassManager &FPM) -> void {
+          FPM.addPass(InstSimplifyPass());
+        },
+        [](FunctionPassManager &FPM) -> void { FPM.addPass(DCEPass()); },
+        [](FunctionPassManager &FPM) -> void { FPM.addPass(ADCEPass()); },
+        [](FunctionPassManager &FPM) -> void { FPM.addPass(BDCEPass()); },
+        [](FunctionPassManager &FPM) -> void { FPM.addPass(DSEPass()); },
+        [](FunctionPassManager &FPM) -> void { FPM.addPass(GVNPass()); },
+        [](FunctionPassManager &FPM) -> void { FPM.addPass(NewGVNPass()); },
+        [](FunctionPassManager &FPM) -> void {
+          FPM.addPass(InstCombinePass());
+        },
+        [](FunctionPassManager &FPM) -> void {
+          FPM.addPass(AggressiveInstCombinePass());
+        },
+        [](FunctionPassManager &FPM) -> void {
+          FPM.addPass(JumpThreadingPass());
+        },
+        [](FunctionPassManager &FPM) -> void { FPM.addPass(MemCpyOptPass()); },
+        [](FunctionPassManager &FPM) -> void { FPM.addPass(SROAPass()); },
+        [](FunctionPassManager &FPM) -> void { FPM.addPass(SCCPPass()); },
+        [](FunctionPassManager &FPM) -> void {
+          FPM.addPass(SimplifyCFGPass());
+        },
+        [](FunctionPassManager &FPM) -> void { FPM.addPass(EarlyCSEPass()); },
+        [](FunctionPassManager &FPM) -> void {
+          FPM.addPass(ReassociatePass());
+        },
+        [](FunctionPassManager &FPM) -> void {
+          FPM.addPass(CorrelatedValuePropagationPass());
+        },
+        [](FunctionPassManager &FPM) -> void {
+          FPM.addPass(TailCallElimPass());
+        },
+};
+
+static std::vector<std::function<void(LoopPassManager &)>> LoopPasses = {
+    // MssaOptCap = 100 and MssaNoAccForPromotionCap = 250 are the
+    // default values found in LICM.cpp
+    [](LoopPassManager &LPM) -> void { LPM.addPass(LICMPass(100, 250, true)); },
+    [](LoopPassManager &LPM) -> void { LPM.addPass(LoopDeletionPass()); },
+    [](LoopPassManager &LPM) -> void { LPM.addPass(LoopInstSimplifyPass()); },
+    [](LoopPassManager &LPM) -> void { LPM.addPass(LoopSimplifyCFGPass()); },
+    [](LoopPassManager &LPM) -> void { LPM.addPass(SimpleLoopUnswitchPass()); },
+    [](LoopPassManager &LPM) -> void { LPM.addPass(LoopIdiomRecognizePass()); },
+    [](LoopPassManager &LPM) -> void { LPM.addPass(IndVarSimplifyPass()); },
+};
+
+static std::vector<std::function<void(ModulePassManager &)>> ModulePasses = {
+    [](ModulePassManager &MPM) -> void { MPM.addPass(GlobalDCEPass()); },
+    [](ModulePassManager &MPM) -> void {
+      MPM.addPass(DeadArgumentEliminationPass());
+    },
+    [](ModulePassManager &MPM) -> void { MPM.addPass(GlobalOptPass()); },
+    [](ModulePassManager &MPM) -> void {
+      MPM.addPass(ModuleInlinerWrapperPass());
+    },
+    [](ModulePassManager &MPM) -> void { MPM.addPass(InternalizePass()); },
+    [](ModulePassManager &MPM) -> void { MPM.addPass(IPSCCPPass()); },
+};
+
+static void runOptPasses(Oracle &O, Module &Program) {
+  PassBuilder PB;
+
+  LoopAnalysisManager LAM;
+  FunctionAnalysisManager FAM;
+  CGSCCAnalysisManager CGAM;
+  ModulePassManager MPM;
+  ModuleAnalysisManager MAM;
+
+  PB.registerModuleAnalyses(MAM);
+  PB.registerCGSCCAnalyses(CGAM);
+  PB.registerFunctionAnalyses(FAM);
+  PB.registerLoopAnalyses(LAM);
+  PB.crossRegisterProxies(LAM, FAM, CGAM, MAM);
+
+  FunctionPassManager FPM;
+  for (auto FP : FunctionPasses)
+    if (!O.shouldKeep())
+      FP(FPM);
+  MPM.addPass(createModuleToFunctionPassAdaptor(std::move(FPM)));
+
+  LoopPassManager LPM;
+  for (auto LP : LoopPasses)
+    if (!O.shouldKeep())
+      LP(LPM);
+  MPM.addPass(createModuleToFunctionPassAdaptor(
+      createFunctionToLoopPassAdaptor(std::move(LPM))));
+
+  for (auto MP : ModulePasses)
+    if (!O.shouldKeep())
+      MP(MPM);
+
+  MPM.run(Program, MAM);
+}
+
+void llvm::reduceUsingOptDeltaPass(TestRunner &Test) {
+  outs() << "*** Reducing with Optimization Passes...\n";
+  runDeltaPass(Test, runOptPasses);
+}