stop llvm-reduce from introducing undefs

[regehr]

Summary

this patch removes the operands-undef pass and also modifies several other passes that try to introduce undef to instead introduce a "default value" which at the moment is just the zero value.

it leaves an undef in ReduceRegisterUses.cpp, I leave fixing that as future work since I don't know much about MIR and don't to mess things up.

why do we want this patch? the major reason is because the client for reduced IR files is usually a human being, and we know that human beings are not that great about reasoning about undef. it's just really hard -- we'd often prefer a slightly bigger test case that doesn't contain undefs. the second reason is because undef is very difficult for alive2, and we're trying to develop an automated bugfinding workflow that relies on llvm-reduce, and getting gratuitous undefs is just a bad thing for that use case.

[aeubanks]

makes sense to me

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

20

PoisonValue?

20

looking at Constant::getNullValue, looks like labels also don't have a null value, but I guess we're not using this with labels

[regehr]

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

20

my take is it's not worth putting an assert on this since if a label goes into Constant::getNullValue() it'll hit the llvm_unreachable there, which is about as useful as hitting an assert

[regehr]

clang-format and address review

[arsenm]

I don't agree with this change. I definitely don't agree with changing the MIR reduction. I would say most of the value I've received from bugpoint and llvm-reduce is in finding bugs from mishandling undefs

[nlopes]

In D128317#3612910, @arsenm wrote:

I don't agree with this change. I definitely don't agree with changing the MIR reduction. I would say most of the value I've received from bugpoint and llvm-reduce is in finding bugs from mishandling undefs

If the original test case had undef, it is kept. This change just prevents introduction of more undefs.
llvm-reduce is not a fuzzer, so its job is not to create weird programs to find new bugs. I agree fuzzers should create programs with undef and everything else.

[regehr]

hi Matt, I wanted first to echo what Nuno said and second say that if this change is somehow detrimental to performing test case reductions that you care about, please send me the specific example (or maybe just post it on discourse and tag me) and let's figure out what to do about it. My hope and belief here are that this probably won't happen, but you never know.

[regehr]

Also, notice that this patch takes a bunch of program points that introduce undef and makes them all point to a getDefaultValue() function that we can trivially modify to start adding undefs again, perhaps protected by a command line argument, if that ended up being desirable. I'll make that change if it would benefit you. (But I still strongly believe that decreasing the number of undefs or at least leaving it unchanged is the correct default for basically any standard use case for llvm-reduce.)

llvm/test/tools/llvm-reduce/operands-to-args.ll

 ; REDUCED: store i32 0, i32* %Global, align 4
 ; REDUCED: store float 0.000000e+00, float* %0, align 4
 
 ; Do not add any arguments for %Keep and @GlobalKeep.
 ; INTERESTING: %[[KEEP:LocalKeep[0-9]*]] = add i32 %k, 21
 ; INTERESTING: store i32 %[[KEEP]], i32* @GlobalKeep, align 4
 
 ; INTERESTING-LABEL: define void @func_caller() {
-; REDUCED:             call void @func(i32 21, i32* undef, i32* undef, float* undef)
+; REDUCED:             call void @func(i32 21, i32* null, i32* null, float* null)
 
 
 @Global = global i32 42
 @GlobalKeep = global i32 42
 
 define void @func(i32 %k) {
 entry:
   %Local = alloca i32, align 4

llvm/test/tools/llvm-reduce/remove-all-of-multiple-args.ll

 ; 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
+; CHECK-FINAL: ret i32 0
 
   ret i32 %a1
 }

llvm/test/tools/llvm-reduce/remove-args-used-by-ret.ll

 ; 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
+; CHECK-FINAL: ret i32 0
 
   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 --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(i1 %c) {
 ; CHECK-LABEL: interesting:
 ; CHECK-NEXT:    br label %interesting2
 
 ; CHECK-LABEL: interesting2:
-; CHECK-NEXT:    ret i32 undef
+; CHECK-NEXT:    ret i32 0
 
 interesting:
   br label %interesting2
 
 interesting2:
   br i1 true, label %uninteresting1, label %uninteresting
 
 uninteresting:
   br label %uninteresting1
 
 uninteresting1:
   ret i32 10
 }

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

 bb1:
   landingpad { i8*, i32 } catch i8* null
   call void @thrown()
   br label %bb4
 
 ; CHECK-ALL: bb3:
 bb3:
 ; CHECK-INTERESTINGNESS: call void @did_not_throw(i32
-; CHECK-FINAL: call void @did_not_throw(i32 undef)
+; CHECK-FINAL: call void @did_not_throw(i32 0)
 ; CHECK-ALL: br label %bb4
   call void @did_not_throw(i32 %i0)
   br label %bb4
 
 ; CHECK-ALL: bb4:
 ; CHECK-ALL: ret void
 bb4:
   ret void
 }
 
 declare i32 @__gxx_personality_v0(...)

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').
+; their direct uses (which in turn are replaced with '0').
 
 ; 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

 @uninteresting = global i32 1, align 4
 @uninteresting2 = external global i32, align 4
 
 define i32 @main() {
 entry:
   %0 = load i32, i32* @uninteresting, align 4
 
   ; CHECK-INTERESTINGNESS: store i32 {{.*}}, i32* @interesting, align 4
-  ; CHECK-FINAL: store i32 undef, i32* @interesting, align 4
+  ; CHECK-FINAL: store i32 0, i32* @interesting, align 4
   store i32 %0, i32* @interesting, align 4
 
   ; CHECK-INTERESTINGNESS: store i32 {{.*}}, i32* @interesting3, align 4
-  ; CHECK-FINAL: store i32 undef, i32* @interesting3, align 4
+  ; CHECK-FINAL: store i32 0, i32* @interesting3, align 4
   store i32 %0, i32* @interesting3, align 4
 
   ; CHECK-ALL: load i32, i32* @interesting, align 4
   %1 = load i32, i32* @interesting, align 4
   store i32 %1, i32* @uninteresting, align 4
 
   ; CHECK-ALL: load i32, i32* @interesting3, align 4
   %2 = load i32, i32* @interesting3, align 4

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

 ; Test that llvm-reduce can reduce floating point operands
 ;
-; RUN: llvm-reduce --abort-on-invalid-reduction --delta-passes=operands-undef --test FileCheck --test-arg --check-prefixes=CHECK-INTERESTINGNESS --test-arg %s --test-arg --input-file %s -o %t
-; RUN: FileCheck --check-prefixes=CHECK,UNDEF %s < %t
-
 ; RUN: llvm-reduce --abort-on-invalid-reduction --delta-passes=operands-one --test FileCheck --test-arg --check-prefixes=CHECK-INTERESTINGNESS --test-arg %s --test-arg --input-file %s -o %t
 ; RUN: FileCheck --check-prefixes=CHECK,ONE %s < %t
 
 ; RUN: llvm-reduce --abort-on-invalid-reduction --delta-passes=operands-zero --test FileCheck --test-arg --check-prefixes=CHECK-INTERESTINGNESS --test-arg %s --test-arg --input-file %s -o %t
 ; RUN: FileCheck --check-prefixes=CHECK,ZERO %s < %t
 
 ; RUN: llvm-reduce --test FileCheck --test-arg --check-prefixes=CHECK-INTERESTINGNESS --test-arg %s --test-arg --input-file %s -o %t
 ; RUN: FileCheck --check-prefixes=CHECK,ZERO %s < %t

 ; 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(
 
-; UNDEF: %fadd0 = fadd float %arg0, undef
-; UNDEF: %fadd1 = fadd float undef, undef
-; UNDEF: %fadd2 = fadd float undef, 0.000000e+00
-; UNDEF: %fadd3 = fadd float undef, 1.000000e+00
-; UNDEF: %fadd4 = fadd float undef, 0x7FF8000000000000
-; UNDEF: %fadd5 = fadd float undef, undef
-; UNDEF: %fadd6 = fadd <2 x float> %arg2, undef
-; UNDEF: %fadd7 = fadd <2 x float> undef, undef
-; UNDEF: %fadd8 = fadd <2 x float> undef, zeroinitializer
-; UNDEF: %fadd9 = fadd <2 x float> undef, <float 1.000000e+00, float 1.000000e+00>
-; UNDEF: %fadd10 = fadd <2 x float> undef, undef
-; UNDEF: %fadd11 = fadd <2 x float> undef, <float 0x7FF8000000000000, float 0x7FF8000000000000>
-
 
 ; 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
 ; ONE: %fadd6 = fadd <2 x float> %arg2, <float 1.000000e+00, float 1.000000e+00>

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

 ; Test that llvm-reduce can reduce operands
 ;
-; RUN: llvm-reduce --abort-on-invalid-reduction --delta-passes=operands-undef --test FileCheck --test-arg --check-prefixes=CHECK-INTERESTINGNESS --test-arg %s --test-arg --input-file %s -o %t
-; RUN: cat %t | FileCheck %s --check-prefixes=CHECK,UNDEF
 ; RUN: llvm-reduce --abort-on-invalid-reduction --delta-passes=operands-one --test FileCheck --test-arg --check-prefixes=CHECK-INTERESTINGNESS --test-arg %s --test-arg --input-file %s -o %t
 ; RUN: cat %t | FileCheck %s --check-prefixes=CHECK,ONE
 ; RUN: llvm-reduce --abort-on-invalid-reduction --delta-passes=operands-zero --test FileCheck --test-arg --check-prefixes=CHECK-INTERESTINGNESS --test-arg %s --test-arg --input-file %s -o %t
 ; RUN: cat %t | FileCheck %s --check-prefixes=CHECK,ZERO
 ; RUN: llvm-reduce --test FileCheck --test-arg --check-prefixes=CHECK-INTERESTINGNESS --test-arg %s --test-arg --input-file %s -o %t
 ; RUN: cat %t | FileCheck %s --check-prefixes=CHECK,ZERO
 
 ; CHECK-INTERESTINGNESS: inttoptr
 ; CHECK-INTERESTINGNESS: inttoptr
 ; CHECK-INTERESTINGNESS: inttoptr
 ; 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
 define i32 @main(%t* %a, i32 %a2) {
 
 ; CHECK-LABEL: lb1:
-; UNDEF: inttoptr i16 0
-; UNDEF: inttoptr i16 1
-; UNDEF: inttoptr i16 2
-; UNDEF: inttoptr i16 undef
 ; ONE: inttoptr i16 0
 ; ONE: inttoptr i16 1
 ; ONE: inttoptr i16 1
 ; ONE: inttoptr i16 1
 ; ZERO: inttoptr i16 0
 ; ZERO: inttoptr i16 0
 ; ZERO: inttoptr i16 0
 ; ZERO: inttoptr i16 0
 ; CHECK: br label %lb2
 lb1:
   %b = getelementptr %t, %t* %a, i32 1, i32 0
   %i1 = inttoptr i16 0 to i8*
   %i2 = inttoptr i16 1 to i8*
   %i3 = inttoptr i16 2 to i8*
   %i4 = inttoptr i16 undef to i8*
   call void @llvm.foo(metadata %t* %a)
   br label %lb2
 
 ; CHECK-LABEL: lb2:
-; UNDEF: ret i32 undef
 ; ONE: ret i32 1
 ; ZERO: ret i32 0
 lb2:
   ret i32 %a2
 }

llvm/tools/llvm-reduce/CMakeLists.txt

set(LLVM_LINK_COMPONENTS
   TransformUtils
   )
 
 add_llvm_tool(llvm-reduce
   DeltaManager.cpp
   ReducerWorkItem.cpp
   TestRunner.cpp
   deltas/Delta.cpp
+  deltas/Utils.cpp
   deltas/ReduceAliases.cpp
   deltas/ReduceArguments.cpp
   deltas/ReduceAttributes.cpp
   deltas/ReduceBasicBlocks.cpp
   deltas/ReduceFunctionBodies.cpp
   deltas/ReduceFunctions.cpp
   deltas/ReduceGlobalObjects.cpp
   deltas/ReduceGlobalValues.cpp

llvm/tools/llvm-reduce/DeltaManager.cpp

#define DELTA_PASSES                                                           \
   DELTA_PASS("global-initializers", reduceGlobalsInitializersDeltaPass)        \
   DELTA_PASS("global-variables", reduceGlobalsDeltaPass)                       \
   DELTA_PASS("metadata", reduceMetadataDeltaPass)                              \
   DELTA_PASS("arguments", reduceArgumentsDeltaPass)                            \
   DELTA_PASS("instructions", reduceInstructionsDeltaPass)                      \
   DELTA_PASS("simplify-instructions", simplifyInstructionsDeltaPass)           \
   DELTA_PASS("operands-zero", reduceOperandsZeroDeltaPass)                     \
   DELTA_PASS("operands-one", reduceOperandsOneDeltaPass)                       \
-  DELTA_PASS("operands-undef", reduceOperandsUndefDeltaPass)                   \
   DELTA_PASS("operands-to-args", reduceOperandsToArgsDeltaPass)                \
   DELTA_PASS("operands-skip", reduceOperandsSkipDeltaPass)                     \
   DELTA_PASS("operand-bundles", reduceOperandBundesDeltaPass)                  \
   DELTA_PASS("attributes", reduceAttributesDeltaPass)                          \
   DELTA_PASS("module-data", reduceModuleDataDeltaPass)
 
 #define DELTA_PASSES_MIR                                                       \
   DELTA_PASS("instructions", reduceInstructionsMIRDeltaPass)                   \

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

 //===- ReduceArguments.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 Arguments from declared and defined functions.
 //
 //===----------------------------------------------------------------------===//
 
 #include "ReduceArguments.h"
 #include "Delta.h"
+#include "Utils.h"
 #include "llvm/ADT/SmallVector.h"
 #include "llvm/IR/Constants.h"
 #include "llvm/IR/Instructions.h"
 #include "llvm/IR/Intrinsics.h"
 #include <set>
 #include <vector>
 
 using namespace llvm;
static void extractArgumentsFromModule(Oracle &O, Module &Program) {
 
   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] = UndefValue::get(A.getType());
+        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(UndefValue::get(I->getType()));
+      I->replaceAllUsesWith(getDefaultValue(I->getType()));
       if (!I->isTerminator())
         I->eraseFromParent();
     }
 
     // No arguments to reduce
     if (VMap.empty())
       continue;
 

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

 //===- ReduceBasicBlocks.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 BasicBlocks from defined functions.
 //
 //===----------------------------------------------------------------------===//
 
 #include "ReduceBasicBlocks.h"
+#include "Utils.h"
 #include "llvm/ADT/DenseSet.h"
 #include "llvm/IR/BasicBlock.h"
 #include "llvm/IR/Constants.h"
 #include "llvm/IR/Instruction.h"
 #include "llvm/IR/Instructions.h"
 #include "llvm/IR/LLVMContext.h"
 #include "llvm/IR/Value.h"
 #include "llvm/Support/Casting.h"
static void replaceBranchTerminator(BasicBlock &BB,
   if (ChunkSuccessors.size() == Term->getNumSuccessors())
     return;
 
   bool IsBranch = isa<BranchInst>(Term) || isa<InvokeInst>(Term);
   Value *Address = nullptr;
   if (auto *IndBI = dyn_cast<IndirectBrInst>(Term))
     Address = IndBI->getAddress();
 
-  Term->replaceAllUsesWith(UndefValue::get(Term->getType()));
+  Term->replaceAllUsesWith(getDefaultValue(Term->getType()));
   Term->eraseFromParent();
 
   if (ChunkSuccessors.empty()) {
     // Scan forward in BB list to try find a block that is kept.
     Function &F = *BB.getParent();
     Function::iterator FI = BB.getIterator();
     FI++;
     while (FI != F.end()) {
       auto &FIB = *FI;
       if (BBsToKeep.count(&FIB) && !isa<PHINode>(FIB.begin())) {
         BranchInst::Create(&FIB, &BB);
         return;
       }
       FI++;
     }
     // If that fails then resort to replacing with a ret.
     auto *FnRetTy = BB.getParent()->getReturnType();
     ReturnInst::Create(BB.getContext(),
-                       FnRetTy->isVoidTy() ? nullptr : UndefValue::get(FnRetTy),
+                       FnRetTy->isVoidTy() ? nullptr : getDefaultValue(FnRetTy),
                        &BB);
     return;
   }
 
   if (IsBranch)
     BranchInst::Create(ChunkSuccessors[0], &BB);
 
   if (Address) {
     auto *NewIndBI =
         IndirectBrInst::Create(Address, ChunkSuccessors.size(), &BB);
     for (auto *Dest : ChunkSuccessors)
       NewIndBI->addDestination(Dest);
   }
 }
 
 /// Removes uninteresting BBs from switch, if the default case ends up being
 /// uninteresting, the switch is replaced with a void return (since it has to be
 /// replace with something)
 static void
 removeUninterestingBBsFromSwitch(SwitchInst &SwInst,
                                  const DenseSet<BasicBlock *> &BBsToKeep) {
   if (!BBsToKeep.count(SwInst.getDefaultDest())) {
     auto *FnRetTy = SwInst.getParent()->getParent()->getReturnType();
     ReturnInst::Create(SwInst.getContext(),
-                       FnRetTy->isVoidTy() ? nullptr : UndefValue::get(FnRetTy),
+                       FnRetTy->isVoidTy() ? nullptr : getDefaultValue(FnRetTy),
                        SwInst.getParent());
     SwInst.eraseFromParent();
   } else
     for (int I = 0, E = SwInst.getNumCases(); I != E; ++I) {
       auto Case = SwInst.case_begin() + I;
       if (!BBsToKeep.count(Case->getCaseSuccessor())) {
         SwInst.removeCase(Case);
         --I;
for (auto &BB : F) {
       else
         replaceBranchTerminator(BB, BBsToKeep);
     }
 
   // Replace out-of-chunk switch uses
   for (auto &BB : BBsToDelete) {
     // Instructions might be referenced in other BBs
     for (auto &I : *BB)
-      I.replaceAllUsesWith(UndefValue::get(I.getType()));
+      I.replaceAllUsesWith(getDefaultValue(I.getType()));
     if (BB->getParent()->size() == 1) {
       // this is the last basic block of the function, thus we must also make
       // sure to remove comdat and set linkage to external
       auto F = BB->getParent();
       F->deleteBody();
       F->setComdat(nullptr);
     } else {
       BB->eraseFromParent();
     }
   }
 }
 
 void llvm::reduceBasicBlocksDeltaPass(TestRunner &Test) {
   outs() << "*** Reducing Basic Blocks...\n";
   runDeltaPass(Test, extractBasicBlocksFromModule);
 }

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

 //===- ReduceFunctions.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 functions (and any instruction that calls it) in the provided
 // Module.
 //
 //===----------------------------------------------------------------------===//
 
 #include "ReduceFunctions.h"
 #include "Delta.h"
+#include "Utils.h"
 #include "llvm/ADT/STLExtras.h"
 #include "llvm/IR/Constants.h"
 #include "llvm/IR/Instructions.h"
 #include <iterator>
 #include <vector>
 
 using namespace llvm;
 
static void extractFunctionsFromModule(Oracle &O, Module &Program) {
 
   // Then, drop body of each of them. We want to batch this and do nothing else
   // here so that minimal number of remaining exteranal uses will remain.
   for (Function &F : FuncsToRemove)
     F.dropAllReferences();
 
   // And finally, we can actually delete them.
   for (Function &F : FuncsToRemove) {
-    // Replace all *still* remaining uses with undef.
-    F.replaceAllUsesWith(UndefValue::get(F.getType()));
+    // Replace all *still* remaining uses with the default value.
+    F.replaceAllUsesWith(getDefaultValue(F.getType()));
     // And finally, fully drop it.
     F.eraseFromParent();
   }
 }
 
 void llvm::reduceFunctionsDeltaPass(TestRunner &Test) {
   errs() << "*** Reducing Functions...\n";
   runDeltaPass(Test, extractFunctionsFromModule);
   errs() << "----------------------------\n";
 }

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

 //===- ReduceGlobalVars.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 Global Variables in the provided Module.
 //
 //===----------------------------------------------------------------------===//
 
 #include "ReduceGlobalVars.h"
+#include "Utils.h"
 #include "llvm/IR/Constants.h"
 #include <set>
 
 using namespace llvm;
 
 /// Removes all the GVs that aren't inside the desired Chunks.
 static void extractGVsFromModule(Oracle &O, Module &Program) {
   // Get GVs inside desired chunks
static void extractGVsFromModule(Oracle &O, Module &Program) {
   std::vector<GlobalVariable *> ToRemove;
   std::vector<WeakVH> InstToRemove;
   for (auto &GV : Program.globals())
     if (!GVsToKeep.count(&GV)) {
       for (auto *U : GV.users())
         if (auto *Inst = dyn_cast<Instruction>(U))
           InstToRemove.push_back(Inst);
 
-      GV.replaceAllUsesWith(UndefValue::get(GV.getType()));
+      GV.replaceAllUsesWith(getDefaultValue(GV.getType()));
       ToRemove.push_back(&GV);
     }
 
   // Delete (unique) Instruction uses of unwanted GVs
   for (Value *V : InstToRemove) {
     if (!V)
       continue;
     auto *Inst = cast<Instruction>(V);
-    Inst->replaceAllUsesWith(UndefValue::get(Inst->getType()));
+    Inst->replaceAllUsesWith(getDefaultValue(Inst->getType()));
     Inst->eraseFromParent();
   }
 
   for (auto *GV : ToRemove)
     GV->eraseFromParent();
 }
 
 void llvm::reduceGlobalsDeltaPass(TestRunner &Test) {
   outs() << "*** Reducing GVs...\n";
   runDeltaPass(Test, extractGVsFromModule);
 }

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

 //===- 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"
 
 using namespace llvm;
 
 /// 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, Module &Program) {
   std::vector<Instruction *> InitInstToKeep;
static void extractInstrFromModule(Oracle &O, Module &Program) {
   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(UndefValue::get(Inst.getType()));
+          Inst.replaceAllUsesWith(getDefaultValue(Inst.getType()));
           InstToDelete.push_back(&Inst);
         }
 
   for (auto &I : InstToDelete)
     I->eraseFromParent();
 }
 
 void llvm::reduceInstructionsDeltaPass(TestRunner &Test) {
   outs() << "*** Reducing Instructions...\n";
   runDeltaPass(Test, extractInstrFromModule);
 }

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

 //===----------------------------------------------------------------------===//
 //
 // 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
 //
 //===----------------------------------------------------------------------===//
 
 #ifndef LLVM_TOOLS_LLVM_REDUCE_DELTAS_REDUCEOPERANDS_H
 #define LLVM_TOOLS_LLVM_REDUCE_DELTAS_REDUCEOPERANDS_H
 
 #include "Delta.h"
 
 namespace llvm {
-void reduceOperandsUndefDeltaPass(TestRunner &Test);
 void reduceOperandsOneDeltaPass(TestRunner &Test);
 void reduceOperandsZeroDeltaPass(TestRunner &Test);
 } // namespace llvm
 
 #endif

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

if (isa<GEPOperator>(Op.getUser()))
     return false;
   if (auto *CB = dyn_cast<CallBase>(Op.getUser())) {
     if (&CB->getCalledOperandUse() == &Op)
       return false;
   }
   return true;
 }
 
-void llvm::reduceOperandsUndefDeltaPass(TestRunner &Test) {
-  errs() << "*** Reducing Operands to undef...\n";
-  auto ReduceValue = [](Use &Op) -> Value * {
-    if (!shouldReduceOperand(Op))
-      return nullptr;
-    // Don't replace existing ConstantData Uses.
-    return isa<ConstantData>(*Op) ? nullptr : UndefValue::get(Op->getType());
-  };
-  runDeltaPass(Test, [ReduceValue](Oracle &O, Module &Program) {
-    extractOperandsFromModule(O, Program, ReduceValue);
-  });
-}
-
 void llvm::reduceOperandsOneDeltaPass(TestRunner &Test) {
   errs() << "*** Reducing Operands to one...\n";
   auto ReduceValue = [](Use &Op) -> Value * {
     if (!shouldReduceOperand(Op))
       return nullptr;
 
     Type *Ty = Op->getType();
     if (auto *IntTy = dyn_cast<IntegerType>(Ty)) {

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

static bool shouldReduceOperand(Use &Op) {
   }
   return true;
 }
 
 /// Return a reduction priority for @p V. A higher values means "more reduced".
 static int classifyReductivePower(Value *V) {
   if (auto *C = dyn_cast<ConstantData>(V)) {
     if (isa<UndefValue>(V))
-      return 4;
+      return -2;
     if (C->isNullValue())
       return 7;
     if (C->isOneValue())
       return 6;
     return 5;
   }
 
   if (isa<Argument>(V))

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

 //===----------------------------------------------------------------------===//
 //
 // 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
 //
 //===----------------------------------------------------------------------===//
 
 #include "ReduceOperandsToArgs.h"
 #include "Delta.h"
+#include "Utils.h"
 #include "llvm/ADT/Sequence.h"
 #include "llvm/IR/Constants.h"
 #include "llvm/IR/InstIterator.h"
 #include "llvm/IR/InstrTypes.h"
 #include "llvm/IR/Instructions.h"
 #include "llvm/Transforms/Utils/BasicBlockUtils.h"
 #include "llvm/Transforms/Utils/Cloning.h"
 
for (Use &U : OldF->uses()) {
     assert(&U == &CI->getCalledOperandUse());
     assert(CI->getCalledFunction() == OldF);
     Callers.push_back(CI);
   }
 
   // Call arguments for NewF.
   SmallVector<Value *> Args(NewF->arg_size(), nullptr);
 
-  // Fill up the additional parameters with undef values.
+  // Fill up the additional parameters with default values.
   for (auto ArgIdx : llvm::seq<size_t>(OldF->arg_size(), NewF->arg_size())) {
     Type *NewArgTy = NewF->getArg(ArgIdx)->getType();
-    Args[ArgIdx] = UndefValue::get(NewArgTy);
+    Args[ArgIdx] = getDefaultValue(NewArgTy);
   }
 
   for (CallBase *CI : Callers) {
     // Preserve the original function arguments.
     for (auto Z : zip_first(CI->args(), Args))
       std::get<1>(Z) = std::get<0>(Z);
 
     // Also preserve operand bundles.

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

 //
 // For more details about special globals, see
 // https://llvm.org/docs/LangRef.html#intrinsic-global-variables
 //
 //===----------------------------------------------------------------------===//
 
 #include "ReduceSpecialGlobals.h"
 #include "Delta.h"
+#include "Utils.h"
 #include "llvm/ADT/StringRef.h"
 #include "llvm/IR/Constants.h"
 #include "llvm/IR/GlobalValue.h"
 
 using namespace llvm;
 
 static StringRef SpecialGlobalNames[] = {"llvm.used", "llvm.compiler.used"};
 
 /// Removes all special globals aren't inside any of the
 /// desired Chunks.
 static void extractSpecialGlobalsFromModule(Oracle &O, Module &Program) {
   for (StringRef Name : SpecialGlobalNames) {
     if (auto *Used = Program.getNamedGlobal(Name)) {
-      Used->replaceAllUsesWith(UndefValue::get(Used->getType()));
+      Used->replaceAllUsesWith(getDefaultValue(Used->getType()));
       Used->eraseFromParent();
     }
   }
 }
 
 void llvm::reduceSpecialGlobalsDeltaPass(TestRunner &Test) {
   errs() << "*** Reducing Special Globals ...\n";
   runDeltaPass(Test, extractSpecialGlobalsFromModule);
   errs() << "----------------------------\n";
 }

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

+//===- Utils.h - llvm-reduce utility functions ----------------------------===//
+//
+// 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 some utility functions supporting llvm-reduce.
+//
+//===----------------------------------------------------------------------===//
+
+#ifndef LLVM_TOOLS_LLVM_REDUCE_DELTAS_UTILS_H
+#define LLVM_TOOLS_LLVM_REDUCE_DELTAS_UTILS_H
+
+#include "llvm/IR/Value.h"
+
+namespace llvm {
+
+Value *getDefaultValue(Type *T);
+
+} // namespace llvm
+
+#endif

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

+//===- Utils.cpp - llvm-reduce utility functions --------------------------===//
+//
+// 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 some utility functions supporting llvm-reduce.
+//
+//===----------------------------------------------------------------------===//
+
+#include "Utils.h"
+#include "llvm/IR/Constants.h"
+
+using namespace llvm;
+
+Value *llvm::getDefaultValue(Type *T) {
+  return T->isVoidTy() ? PoisonValue::get(T) : Constant::getNullValue(T);
+}