[llvm-reduce] Add reduce operands pass

[swamulism]

Summary

Add reduction to set operands to default null values

[aeubanks]

I'm not sure if we should be using undef, poison, or the null value for reductions. I'll ask llvm-dev for opinions.

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

2

we should add tests for things like making sure we don't crash on a br since basic blocks don't have a null value

llvm/tools/llvm-reduce/DeltaManager.cpp

53

reduceOperandsDeltaPass for consistency

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

32

can we list types that don't have a null value instead? seems better than the current approach since the list is much smaller

I'll run this patch over a larger file to see if we're missing some types in this check (as in we're trying to get the null value of some type that doesn't have a null value)

63

these are always used together, can we create something like canReduceOperand()?

[swamulism]

[llvm-reduce] Update reduce operand test and fix pass name

[swamulism]

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

32

I would rather keep it a list of types that work rather than types that don't work. Since if a new type is added that is not nullable in the future this pass would crash.

But it would probably bet better for this logic to live in the same place as Constant::getNullValue

[aeubanks]

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

32

yeah, can you add a Constant::hasNullValue?

83

VariableCount doesn't really make sense, maybe just Count is good enough

[lebedev.ri]

Wouldn't it be better to leave the question of with what to replace to a separate patch, and stick to the current consistent practice here?

[aeubanks]

In D108903#2987942, @lebedev.ri wrote:

Wouldn't it be better to leave the question of with what to replace to a separate patch, and stick to the current consistent practice here?

I don't think it matters too much if we've agreed in the thread that null is better, and we do a followup patch soon where we add a flag and consolidate what we replace things with into a helper method controlled by the flag.

[lebedev.ri]

In D108903#2988032, @aeubanks wrote:

In D108903#2987942, @lebedev.ri wrote:

Wouldn't it be better to leave the question of with what to replace to a separate patch, and stick to the current consistent practice here?

I don't think it matters too much if we've agreed in the thread that null is better, and we do a followup patch soon where we add a flag and consolidate what we replace things with into a helper method controlled by the flag.

But did we agree on null?
And i'm not really sure what "I don't think it matters too much" means - this either does introduce inconsistency or it does not.

[aeubanks]

In D108903#2988047, @lebedev.ri wrote:

In D108903#2988032, @aeubanks wrote:

In D108903#2987942, @lebedev.ri wrote:

Wouldn't it be better to leave the question of with what to replace to a separate patch, and stick to the current consistent practice here?

I don't think it matters too much if we've agreed in the thread that null is better, and we do a followup patch soon where we add a flag and consolidate what we replace things with into a helper method controlled by the flag.

But did we agree on null?

Reading through the thread, there was a vague consensus that using undef was not ideal and null is probably better in most cases. https://groups.google.com/g/llvm-dev/c/ofvHCsXrLN8

And i'm not really sure what "I don't think it matters too much" means - this either does introduce inconsistency or it does not.

It does introduce inconsistency, but I don't think the inconsistency matters. We'll end up either having undef or null in the reduced repro, either one is probably for most cases.

[lebedev.ri]

May i propose that we do that either after this patch, or before this patch, but not overlap the two?
I am not seeing quite seeing from where the motivation for the latter comes from.

[aeubanks]

Sure I suppose we can split up this patch
@swamulism can you do that?

[swamulism]

In D108903#2988082, @aeubanks wrote:

Sure I suppose we can split up this patch
@swamulism can you do that?

Sure I can add Constant::hasNullValue and remove ReduceOperands::typeIsNullable in a separate patch

[aeubanks]

In D108903#2988164, @swamulism wrote:

In D108903#2988082, @aeubanks wrote:

Sure I suppose we can split up this patch
@swamulism can you do that?

Sure I can add Constant::hasNullValue and remove ReduceOperands::typeIsNullable in a separate patch

I meant the part about reducing to undef vs null. Constant::hasNullValue() should be in this patch

[lebedev.ri]

In D108903#2988165, @aeubanks wrote:

In D108903#2988164, @swamulism wrote:

In D108903#2988082, @aeubanks wrote:

Sure I suppose we can split up this patch
@swamulism can you do that?

Sure I can add Constant::hasNullValue and remove ReduceOperands::typeIsNullable in a separate patch

I meant the part about reducing to undef vs null. Constant::hasNullValue() should be in this patch

Also no, that can be separated - place it before Constant::getNullValue() / base it on that function,
and change Constant::getNullValue() to first assert that said new function says there is such a constant.

But, i'm still not sold on null everywhere. E.g. div-by-zero is ub, gep inbounds of null w/ non-zero offset is null, etc.

[aeubanks]

In D108903#2988173, @lebedev.ri wrote:

In D108903#2988165, @aeubanks wrote:

In D108903#2988164, @swamulism wrote:

In D108903#2988082, @aeubanks wrote:

Sure I suppose we can split up this patch
@swamulism can you do that?

Sure I can add Constant::hasNullValue and remove ReduceOperands::typeIsNullable in a separate patch

I meant the part about reducing to undef vs null. Constant::hasNullValue() should be in this patch

Also no, that can be separated - place it before Constant::getNullValue() / base it on that function,
and change Constant::getNullValue() to first assert that said new function says there is such a constant.

But, i'm still not sold on null everywhere. E.g. div-by-zero is ub, gep inbounds of null w/ non-zero offset is null, etc.

Isn't it the same for undef? Since we could arbitrarily decide to replace all undefs with null. Using undef should always be at least the same amount of ub as using null.

[swamulism]

In D108903#2988173, @lebedev.ri wrote:

Also no, that can be separated - place it before Constant::getNullValue() / base it on that function,
and change Constant::getNullValue() to first assert that said new function says there is such a constant.

But, i'm still not sold on null everywhere. E.g. div-by-zero is ub, gep inbounds of null w/ non-zero offset is null, etc.

I was thinking to change getNullValue to return nullptr when there is no null value instead of crashing.
Then make hasNullValue to something like the following so the code only needs to be updated in one place when future types are added.

bool Constant::hasNullValue(Type *Ty) {
  return getNullValue(Ty) != nullptr;
}

Also for the null vs undef discussion, llvm-reduce should not reduce using this delta pass if it doesn't pass the interestingness test.
Is the worry that this pass will make the the reduction worse (longer or harder to read)?

[swamulism]

Add Constant::hasNullValue

[aeubanks]

llvm/lib/IR/Constants.cpp

32

remove

388

if we're going to return nullptr here there's no need for Constant::hasNullValue
also can you update the documentation saying that it'll return null for not supported types, and move it into Constant.h

[swamulism]

Add documentation to getNullValue and remove hasNullValue

[swamulism]

Add missing newline

[lebedev.ri]

My point is either not being heard, or is being intentionally ignored.

[aeubanks]

I honestly don't understand what you're trying to say. I thought your point was that making everything null instead of undef would be bad because some operations may have UB when using null (e.g. your null GEP example). But that argument doesn't make sense since undef is more undefined than null. div by undef is still UB.

Or are you trying to say that we should be doing the operand reduction pass in the first place on some instructions?

[nikic]

@aeubanks I believe @lebedev.ri is asking you to use undef for the initial patch and then switch undef to 0 consistently for all reductions in llvm-reduce. Right now everything else uses undef, and this place is going to use 0.

[aeubanks]

In D108903#2992079, @nikic wrote:

@aeubanks I believe @lebedev.ri is asking you to use undef for the initial patch and then switch undef to 0 consistently for all reductions in llvm-reduce. Right now everything else uses undef, and this place is going to use 0.

When I said

In D108903#2988082, @aeubanks wrote:

Sure I suppose we can split up this patch
@swamulism can you do that?

I was expecting a separate patch to add a helper method to choose what value to replace things with given a type.
Since replacing most operands with undef seems not ideal when it comes to reducing, I'd rather that patch come first, but I wouldn't object to making this patch use undef first then having the patch to choose what value to reduce to coming after.

Separately, after rereading @lebedev.ri 's comments, I was getting the impression that maybe I misunderstood the comments about not wanting to replace every operand of every instruction with null (or undef). Perhaps you meant that we should skip replacing the pointer operand of a GEP or the second operand of a div with null/undef?

[lebedev.ri]

In D108903#2992079, @nikic wrote:

@aeubanks I believe @lebedev.ri is asking you to use undef for the initial patch and then switch undef to 0 consistently for all reductions in llvm-reduce. Right now everything else uses undef, and this place is going to use 0.

Precisely. I have no clue how else i need to reword my message to get my thought across,

[aeubanks]

Sorry for my bad communication, I was fine with doing what you wanted. That's what I meant with

In D108903#2988165, @aeubanks wrote:

In D108903#2988164, @swamulism wrote:

In D108903#2988082, @aeubanks wrote:

Sure I suppose we can split up this patch
@swamulism can you do that?

Sure I can add Constant::hasNullValue and remove ReduceOperands::typeIsNullable in a separate patch

I meant the part about reducing to undef vs null. Constant::hasNullValue() should be in this patch

[swamulism]

Change from reducing to null to reducing to undef

[swamulism]

Update incorrect docs

[aeubanks]

almost there

llvm/test/tools/llvm-reduce/no-replace-intrinsic-callee-with-undef.ll

6

this doesn't contain any operand bundles, so the pass shouldn't be necessary

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

1

I think the following is cleaner:

diff --git a/llvm/test/tools/llvm-reduce/remove-invoked-functions.ll b/llvm/test/tools/llvm-reduce/remove-invoked-functions.ll
index e1224b99e176..0d3f8f87fd4a 100644
--- a/llvm/test/tools/llvm-reduce/remove-invoked-functions.ll
+++ b/llvm/test/tools/llvm-reduce/remove-invoked-functions.ll
@@ -1,4 +1,4 @@
-; RUN: llvm-reduce --delta-passes=functions,function-bodies,arguments,attributes --test FileCheck --test-arg --check-prefixes=CHECK-ALL,CHECK-INTERESTINGNESS --test-arg %s --test-arg --input-file %s -o %t
+; 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
 
 ; CHECK-INTERESTINGNESS: define i32 @maybe_throwing_callee(
@@ -22,8 +22,8 @@ declare void @thrown()
 define void @caller(i32 %arg) personality i8* bitcast (i32 (...)* @__gxx_personality_v0 to i8*) {
 ; CHECK-ALL: bb:
 bb:
-; CHECK-INTERESTINGNESS: %i0 = invoke i32
-; CHECK-FINAL: %i0 = invoke i32 bitcast (i32 ()* @maybe_throwing_callee to i32 (i32)*)(i32 %arg)
+; CHECK-INTERESTINGNESS: %i0 = invoke i32 {{.*}}@maybe_throwing_callee
+; CHECK-FINAL: %i0 = invoke i32 bitcast (i32 ()* @maybe_throwing_callee to i32 (i32)*)
 ; CHECK-ALL: to label %bb3 unwind label %bb1
   %i0 = invoke i32 @maybe_throwing_callee(i32 %arg)
           to label %bb3 unwind label %bb1

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

17

do we need this?

19

do we need this?

23

undef

37

we actually can replace token values with an undef

e.g.

declare void @llvm.foo(token)

define void @f() {
  call void @llvm.foo(token undef)
  ret void
}

verifies

[swamulism]

Address comments

[swamulism]

Thanks for looking through this!

llvm/include/llvm/IR/Constant.h

public:
   /// From replaced with uses of To.  After this construction is completed, all
   /// of the users of 'this' are replaced to use the new constant, and then
   /// 'this' is deleted.  In general, you should not call this method, instead,
   /// use Value::replaceAllUsesWith, which automatically dispatches to this
   /// method as needed.
   ///
   void handleOperandChange(Value *, Value *);
 
+  static bool hasNullValue(Type* Ty);
   static Constant *getNullValue(Type* Ty);
 
   /// @returns the value for an integer or vector of integer constant of the
   /// given type that has all its bits set to true.
   /// Get the all ones value
   static Constant *getAllOnesValue(Type* Ty);
 
   /// Return the value for an integer or pointer constant, or a vector thereof,

llvm/lib/IR/Constants.cpp

 #include "llvm/IR/Operator.h"
 #include "llvm/IR/PatternMatch.h"
 #include "llvm/Support/Debug.h"
 #include "llvm/Support/ErrorHandling.h"
 #include "llvm/Support/ManagedStatic.h"
 #include "llvm/Support/MathExtras.h"
 #include "llvm/Support/raw_ostream.h"
 #include <algorithm>
+#include <system_error>
 
 using namespace llvm;
 using namespace PatternMatch;
 
 //===----------------------------------------------------------------------===//
 //                              Constant Class
 //===----------------------------------------------------------------------===//
 
bool Constant::containsConstantExpression() const {
   if (auto *VTy = dyn_cast<FixedVectorType>(getType())) {
     for (unsigned i = 0, e = VTy->getNumElements(); i != e; ++i)
       if (isa<ConstantExpr>(getAggregateElement(i)))
         return true;
   }
   return false;
 }
 
+bool Constant::hasNullValue(Type *Ty) {
+  return getNullValue(Ty) != nullptr;
+}
+
 /// Constructor to create a '0' constant of arbitrary type.
 Constant *Constant::getNullValue(Type *Ty) {
   switch (Ty->getTypeID()) {
   case Type::IntegerTyID:
     return ConstantInt::get(Ty, 0);
   case Type::HalfTyID:
     return ConstantFP::get(Ty->getContext(),
                            APFloat::getZero(APFloat::IEEEhalf()));
Constant *Constant::getNullValue(Type *Ty) {
   case Type::ArrayTyID:
   case Type::FixedVectorTyID:
   case Type::ScalableVectorTyID:
     return ConstantAggregateZero::get(Ty);
   case Type::TokenTyID:
     return ConstantTokenNone::get(Ty->getContext());
   default:
     // Function, Label, or Opaque type?
-    llvm_unreachable("Cannot create a null constant of that type!");
+    return nullptr;
   }
 }
 
 Constant *Constant::getIntegerValue(Type *Ty, const APInt &V) {
   Type *ScalarTy = Ty->getScalarType();
 
   // Create the base integer constant.
   Constant *C = ConstantInt::get(Ty->getContext(), V);

llvm/test/tools/llvm-reduce/no-replace-intrinsic-callee-with-undef.ll

 ; Intrinsic calls can't be uniformly replaced with undef without invalidating
 ; IR (eg: only intrinsic calls can have metadata arguments), so ensure they are
 ; not replaced. The whole call instruction can be removed by instruction
 ; reduction instead.
 
-; RUN: llvm-reduce --test FileCheck --test-arg --check-prefixes=ALL,CHECK-INTERESTINGNESS --test-arg %s --test-arg --input-file %s -o %t 2> %t.log
+; RUN: llvm-reduce --delta-passes=functions,instructions,operand-bundles --test FileCheck --test-arg --check-prefixes=ALL,CHECK-INTERESTINGNESS --test-arg %s --test-arg --input-file %s -o %t 2> %t.log
 ; RUN: FileCheck -implicit-check-not=uninteresting --check-prefixes=ALL,CHECK-FINAL %s < %t
 
 ; Check that the call is removed by instruction reduction passes
-; RUN: llvm-reduce --test FileCheck --test-arg --check-prefix=ALL --test-arg %s --test-arg --input-file %s -o %t
+; RUN: llvm-reduce --delta-passes=functions,instructions,operand-bundles --test FileCheck --test-arg --check-prefix=ALL --test-arg %s --test-arg --input-file %s -o %t
 ; RUN: FileCheck -implicit-check-not=uninteresting --check-prefixes=ALL,CHECK-NOCALL %s < %t
 
 
 declare i8* @llvm.sponentry.p0i8()
 declare void @uninteresting()
 
 ; ALL-LABEL: define i8* @interesting(
 define i8* @interesting() {

llvm/test/tools/llvm-reduce/remove-all-of-multiple-args.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: llvm-reduce --delta-passes=arguments --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
 
 define i32 @t(i32 %a0, i32 %a1, i32 %a2) {
 ; CHECK-ALL-LABEL: @t
 ; CHECK-FINAL: () {
 ;
 ; CHECK-INTERESTINGNESS: ret i32
 ; CHECK-FINAL: ret i32 undef
 
   ret i32 %a1
 }

llvm/test/tools/llvm-reduce/remove-args-used-by-ret.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: llvm-reduce --delta-passes=arguments --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 can't drop arguments if they are used by terminator instructions.
 
 define i32 @t(i32 %a0, i32 %a1, i32 %a2) {
 ; CHECK-ALL-LABEL: @t
 ; CHECK-FINAL-NOT: %a1
 ;
 ; CHECK-INTERESTINGNESS: ret i32
 ; CHECK-FINAL: ret i32 undef
 
   ret i32 %a1
 }

llvm/test/tools/llvm-reduce/remove-bbs-ret-nonvoid.ll

 ; Test that llvm-reduce inserts valid return instructions for functions with
 ; on-void return types.
 ;
-; RUN: llvm-reduce --test FileCheck --test-arg --check-prefixes=CHECK-INTERESTINGNESS --test-arg %s --test-arg --input-file %s -o %t
+; RUN: llvm-reduce --delta-passes=basic-blocks --test FileCheck --test-arg --check-prefixes=CHECK-INTERESTINGNESS --test-arg %s --test-arg --input-file %s -o %t
 ; RUN: cat %t | FileCheck %s
 
 ; CHECK-INTERESTINGNESS: interesting:
 ; CHECK-INTERESTINGNESS: interesting2:
 
 define i32 @main(i1 %c) {
-; CHECK-LABEL: define i32 @main() {
+; CHECK-LABEL: define i32 @main(i1 %c) {
 ; CHECK-LABEL: interesting:
 ; CHECK-NEXT:    br label %interesting2
 
 ; CHECK-LABEL: interesting2:
 ; CHECK-NEXT:    ret i32 undef
 
 interesting:
   br label %interesting2

llvm/test/tools/llvm-reduce/remove-bbs-unwinded-to.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: llvm-reduce --delta-passes=basic-blocks --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
 
 declare i32 @maybe_throwing_callee()
 
 ; CHECK-ALL: declare void @did_not_throw(i32)
 declare void @did_not_throw(i32)
 
 declare void @thrown()

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

 ; Test that llvm-reduce can remove uninteresting Basic Blocks, and remove them from instructions (i.e. SwitchInst, BranchInst and IndirectBrInst)
 ; Note: if an uninteresting BB is the default case for a switch, the instruction is removed altogether (since the default case cannot be replaced)
 ;
-; RUN: llvm-reduce --test %python --test-arg %p/Inputs/remove-bbs.py %s -o %t
+; RUN: llvm-reduce --delta-passes=basic-blocks --test %python --test-arg %p/Inputs/remove-bbs.py %s -o %t
 ; RUN: cat %t | FileCheck -implicit-check-not=uninteresting %s
 
 define void @main() {
 interesting:
   ; CHECK-NOT: switch i32 0, label %uninteresting
   switch i32 0, label %uninteresting [
     i32 0, label %uninteresting
   ]

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

 ; Test that llvm-reduce can remove uninteresting functions as well as
 ; their InstCalls.
 ;
-; RUN: llvm-reduce --test FileCheck --test-arg --check-prefixes=CHECK-ALL,CHECK-INTERESTINGNESS --test-arg %s --test-arg --input-file %s -o %t
+; RUN: llvm-reduce --delta-passes=functions,instructions --test FileCheck --test-arg --check-prefixes=CHECK-ALL,CHECK-INTERESTINGNESS --test-arg %s --test-arg --input-file %s -o %t
 ; RUN: cat %t | FileCheck -implicit-check-not=uninteresting --check-prefixes=CHECK-ALL,CHECK-FINAL %s
 
 define i32 @uninteresting1() {
 entry:
   ret i32 0
 }
 
 ; CHECK-ALL-LABEL: interesting()

llvm/test/tools/llvm-reduce/remove-global-vars.ll

 ; Test that llvm-reduce can remove uninteresting Global Variables as well as
 ; their direct uses (which in turn are replaced with 'undef').
 
-; RUN: llvm-reduce --test FileCheck --test-arg --check-prefixes=CHECK-ALL,CHECK-INTERESTINGNESS --test-arg %s --test-arg --input-file %s -o %t
+; RUN: llvm-reduce --delta-passes=global-variables,global-initializers --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 --implicit-check-not=uninteresting %s
 
 $interesting5 = comdat any
 
 ; CHECK-INTERESTINGNESS: @interesting = {{.*}}global i32{{.*}}, align 4
 ; CHECK-INTERESTINGNESS: @interesting2 = global i32 0, align 4
 ; CHECK-INTERESTINGNESS: @interesting3 = {{.*}}global i32{{.*}}, align 4
 ; CHECK-INTERESTINGNESS: @interesting4 = {{.*}}constant i32{{.*}}, align 4

llvm/test/tools/llvm-reduce/remove-invoked-functions.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
 
 ; CHECK-INTERESTINGNESS: define i32 @maybe_throwing_callee(
 ; CHECK-FINAL: define i32 @maybe_throwing_callee()
 define i32 @maybe_throwing_callee(i32 %arg) {
 ; CHECK-ALL: call void @thrown()
 ; CHECK-INTERESTINGNESS: ret i32
-; CHECK-FINAL: ret i32 undef
+; CHECK-FINAL: ret i32 0
   call void @thrown()
   ret i32 %arg
 }
 
 ; CHECK-ALL: declare void @did_not_throw(i32)
 declare void @did_not_throw(i32)
 
 ; CHECK-ALL: declare void @thrown()
 declare void @thrown()
 
 ; CHECK-INTERESTINGNESS: define void @caller(
 ; CHECK-FINAL: define void @caller(i32 %arg)
 define void @caller(i32 %arg) personality i8* bitcast (i32 (...)* @__gxx_personality_v0 to i8*) {
 ; CHECK-ALL: bb:
 bb:
 ; CHECK-INTERESTINGNESS: %i0 = invoke i32
-; CHECK-FINAL: %i0 = invoke i32 bitcast (i32 ()* @maybe_throwing_callee to i32 (i32)*)(i32 %arg)
+; CHECK-FINAL: %i0 = invoke i32 null(i32 0)
 ; 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.ll

+; Test that llvm-reduce can reduce operands to their respective null values.
+;
+; RUN: llvm-reduce --delta-passes=operands --test FileCheck --test-arg --check-prefixes=CHECK-INTERESTINGNESS --test-arg %s --test-arg --input-file %s -o %t
+; RUN: cat %t | FileCheck %s
+
+; CHECK-INTERESTINGNESS: ret i32
+
+; CHECK-LABEL: define i32 @main() {
+define i32 @main() {
+
+; CHECK-LABEL: lb1:
+; CHECK-LABEL: br label %lb2
+lb1:
+  br label %lb2
+
+; CHECK-LABEL: lb2:
+; CHECK-NEXT: ret i32 0
+lb2:
+  ret i32 10
+}
 No newline at end of file

llvm/test/tools/llvm-reduce/remove-single-arg.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: llvm-reduce --delta-passes=arguments --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
 
 define i32 @t(i32 %a0) {
 ; CHECK-ALL-LABEL: @t
 ; CHECK-FINAL: () {
 ;
 ; CHECK-INTERESTINGNESS: ret i32
 ; CHECK-FINAL: ret i32 42
 
   ret i32 42
 }

llvm/tools/llvm-reduce/CMakeLists.txt

add_llvm_tool(llvm-reduce
   deltas/ReduceGlobalValues.cpp
   deltas/ReduceGlobalVarInitializers.cpp
   deltas/ReduceGlobalVars.cpp
   deltas/ReduceInstructions.cpp
   deltas/ReduceMetadata.cpp
   deltas/ReduceModuleData.cpp
   deltas/ReduceOperandBundles.cpp
   deltas/ReduceSpecialGlobals.cpp
+  deltas/ReduceOperands.cpp
   llvm-reduce.cpp
 
   DEPENDS
   intrinsics_gen
   )

llvm/tools/llvm-reduce/DeltaManager.cpp

 #include "deltas/ReduceFunctions.h"
 #include "deltas/ReduceGlobalValues.h"
 #include "deltas/ReduceGlobalVarInitializers.h"
 #include "deltas/ReduceGlobalVars.h"
 #include "deltas/ReduceInstructions.h"
 #include "deltas/ReduceMetadata.h"
 #include "deltas/ReduceModuleData.h"
 #include "deltas/ReduceOperandBundles.h"
+#include "deltas/ReduceOperands.h"
 #include "deltas/ReduceSpecialGlobals.h"
 #include "llvm/Support/CommandLine.h"
 
 using namespace llvm;
 
 static cl::opt<std::string>
     DeltaPasses("delta-passes",
                 cl::desc("Delta passes to run, separated by commas. By "
                          "default, run all delta passes."));
 
 #define DELTA_PASSES                                                           \
   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-initializers", reduceGlobalsInitializersDeltaPass)        \
   DELTA_PASS("global-variables", reduceGlobalsDeltaPass)                       \
   DELTA_PASS("metadata", reduceMetadataDeltaPass)                              \
   DELTA_PASS("arguments", reduceArgumentsDeltaPass)                            \
   DELTA_PASS("instructions", reduceInstructionsDeltaPass)                      \
+  DELTA_PASS("operands", reduceOperandsDeltaPass)                              \
   DELTA_PASS("operand-bundles", reduceOperandBundesDeltaPass)                  \
   DELTA_PASS("attributes", reduceAttributesDeltaPass)                          \
   DELTA_PASS("module-data", reduceModuleDataDeltaPass)
 
 static void runAllDeltaPasses(TestRunner &Tester) {
 #define DELTA_PASS(NAME, FUNC) FUNC(Tester);
   DELTA_PASSES
 #undef DELTA_PASS

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

+//===- ReduceOperands.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 to reduce operands to their null value.
+//
+//===----------------------------------------------------------------------===//
+
+#ifndef LLVM_TOOLS_LLVM_REDUCE_DELTAS_REDUCEOPERANDS_H
+#define LLVM_TOOLS_LLVM_REDUCE_DELTAS_REDUCEOPERANDS_H
+
+#include "Delta.h"
+
+namespace llvm {
+void reduceOperandsDeltaPass(TestRunner &Test);
+} // namespace llvm
+
+#endif

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

+//===- ReduceOperands.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 to reduce operands to their null value.
+//
+//===----------------------------------------------------------------------===//
+
+#include "ReduceOperands.h"
+#include "llvm/IR/Constant.h"
+#include "llvm/IR/Constants.h"
+#include "llvm/IR/GlobalValue.h"
+#include "llvm/IR/InstIterator.h"
+#include "llvm/IR/ValueSymbolTable.h"
+
+using namespace llvm;
+
+/// Returns if the given operand is null.
+static bool operandIsNullValue(Use &Op) {
+  if (auto *C = dyn_cast<Constant>(Op))
+    return C->isNullValue();
+  return false;
+}
+
+static bool canReduceOperand(Use &Op) {
+  auto *Ty = Op->getType();
+  return !operandIsNullValue(Op) && Constant::hasNullValue(Ty);
+}
+
+/// Sets Operands to their null value.
+static void extractOperandsFromModule(std::vector<Chunk> ChunksToKeep,
+                                      Module *Program) {
+  Oracle O(ChunksToKeep);
+
+  // Extract Operands from the module.
+  for (auto &F : Program->functions()) {
+    for (auto &I : instructions(&F)) {
+      for (auto &Op : I.operands()) {
+        // Filter Operands then set to default values.
+        if (canReduceOperand(Op) && !O.shouldKeep()) {
+          auto *Ty = Op->getType();
+          Op.set(Constant::getNullValue(Ty));
+        }
+      }
+    }
+  }
+}
+
+/// Counts the amount of operands in the module that are not null.
+static int countOperands(Module *Program) {
+  int Count = 0;
+  for (auto &F : Program->functions()) {
+    for (auto &I : instructions(&F)) {
+      for (auto &Op : I.operands()) {
+        if (canReduceOperand(Op)) {
+          Count++;
+        }
+      }
+    }
+  }
+  return Count;
+}
+
+void llvm::reduceOperandsDeltaPass(TestRunner &Test) {
+  outs() << "*** Reducing Operands...\n";
+  int Count = countOperands(Test.getProgram());
+  runDeltaPass(Test, Count, extractOperandsFromModule);
+}

llvm/utils/gn/secondary/llvm/tools/llvm-reduce/BUILD.gn

sources = [
     "deltas/ReduceGlobalValues.cpp",
     "deltas/ReduceGlobalVarInitializers.cpp",
     "deltas/ReduceGlobalVars.cpp",
     "deltas/ReduceInstructions.cpp",
     "deltas/ReduceMetadata.cpp",
     "deltas/ReduceModuleData.cpp",
     "deltas/ReduceOperandBundles.cpp",
     "deltas/ReduceSpecialGlobals.cpp",
+    "deltas/ReduceOperands.cpp",
     "llvm-reduce.cpp",
   ]
 }