[DeadArgElim] Use poison instead of undef as placeholder for dead arguments

[nlopes]

Summary

DeadArgElim uses undef values as placeholder for dead arguments. Let's switch that to poison as it doesn't matter which value we use and we get one step closer of getting rid of undef.

[fhahn]

LGTM, thanks!

llvm/test/Transforms/DeadArgElim/NoundefAttrs.ll

2–3

undef -> poison?

clang/test/CodeGen/debug-info-block-vars.c

 // RUN: %clang_cc1 -no-opaque-pointers -x c -std=c89 -fblocks -debug-info-kind=standalone -emit-llvm -O0 \
 // RUN:   -triple x86_64-apple-darwin -o - %s | FileCheck %s
 // RUN: %clang_cc1 -no-opaque-pointers -x c -std=c89 -fblocks -debug-info-kind=standalone -emit-llvm -O1 \
 // RUN:   -triple x86_64-apple-darwin -o - %s \
 // RUN:   | FileCheck --check-prefix=CHECK-OPT %s
 
 // CHECK: define internal void @__f_block_invoke(i8* noundef %.block_descriptor)
 // CHECK: %.block_descriptor.addr = alloca i8*, align 8
 // CHECK: %block.addr = alloca <{ i8*, i32, i32, i8*, %struct.__block_descriptor* }>*, align 8
 // CHECK: store i8* %.block_descriptor, i8** %.block_descriptor.addr, align 8
 // CHECK: call void @llvm.dbg.declare(metadata i8** %.block_descriptor.addr,
 // CHECK-SAME:                        metadata !DIExpression())
 // CHECK-OPT-NOT: alloca
 // Since the block address is not used anywhere in this function,
 // the optimizer (DeadArgElim) has replaced all the false uses
-// (i.e., metadata users) with undef.
-// CHECK-OPT: call void @llvm.dbg.value(metadata i8* undef,
+// (i.e., metadata users) with poison.
+// CHECK-OPT: call void @llvm.dbg.value(metadata i8* poison,
 // CHECK-OPT-SAME:                      metadata !DIExpression())
 void f(void) {
   a(^{
     b();
   });
 }

clang/test/CodeGen/mips-unsigned-ext-var.c

unsigned foo(int x, ...) {
   return a;
 }
 
 void foo1(void) {
   unsigned f = 0xffffffe0;
   foo(1,f);
 }
 
-//N64: call signext i32 (i32, ...) @foo(i32 signext undef, i32 noundef signext -32)
-//N32: call signext i32 (i32, ...) @foo(i32 signext undef, i32 noundef signext -32)
-//O32: call i32 (i32, ...) @foo(i32 signext undef, i32 noundef signext -32)
+//N64: call signext i32 (i32, ...) @foo(i32 signext poison, i32 noundef signext -32)
+//N32: call signext i32 (i32, ...) @foo(i32 signext poison, i32 noundef signext -32)
+//O32: call i32 (i32, ...) @foo(i32 signext poison, i32 noundef signext -32)

llvm/lib/Transforms/IPO/DeadArgumentElimination.cpp

 #include <vector>
 
 using namespace llvm;
 
 #define DEBUG_TYPE "deadargelim"
 
 STATISTIC(NumArgumentsEliminated, "Number of unread args removed");
 STATISTIC(NumRetValsEliminated  , "Number of unused return values removed");
-STATISTIC(NumArgumentsReplacedWithUndef,
-          "Number of unread args replaced with undef");
+STATISTIC(NumArgumentsReplacedWithPoison,
+          "Number of unread args replaced with poison");
 
 namespace {
 
   /// DAE - The dead argument elimination pass.
   class DAE : public ModulePass {
   protected:
     // DAH uses this to specify a different ID.
     explicit DAE(char &ID) : ModulePass(ID) {}
bool DeadArgumentEliminationPass::DeleteDeadVarargs(Function &Fn) {
   // appear to be address-taken.
   NF->removeDeadConstantUsers();
   // Finally, nuke the old function.
   Fn.eraseFromParent();
   return true;
 }
 
 /// RemoveDeadArgumentsFromCallers - Checks if the given function has any
-/// arguments that are unused, and changes the caller parameters to be undefined
+/// arguments that are unused, and changes the caller parameters to be poison
 /// instead.
 bool DeadArgumentEliminationPass::RemoveDeadArgumentsFromCallers(Function &Fn) {
   // We cannot change the arguments if this TU does not define the function or
   // if the linker may choose a function body from another TU, even if the
   // nominal linkage indicates that other copies of the function have the same
   // semantics. In the below example, the dead load from %p may not have been
-  // eliminated from the linker-chosen copy of f, so replacing %p with undef
+  // eliminated from the linker-chosen copy of f, so replacing %p with poison
   // in callers may introduce undefined behavior.
   //
   // define linkonce_odr void @f(i32* %p) {
   //   %v = load i32 %p
   //   ret void
   // }
   if (!Fn.hasExactDefinition())
     return false;
bool DeadArgumentEliminationPass::RemoveDeadArgumentsFromCallers(Function &Fn) {
   bool Changed = false;
 
   AttributeMask UBImplyingAttributes =
       AttributeFuncs::getUBImplyingAttributes();
   for (Argument &Arg : Fn.args()) {
     if (!Arg.hasSwiftErrorAttr() && Arg.use_empty() &&
         !Arg.hasPassPointeeByValueCopyAttr()) {
       if (Arg.isUsedByMetadata()) {
-        Arg.replaceAllUsesWith(UndefValue::get(Arg.getType()));
+        Arg.replaceAllUsesWith(PoisonValue::get(Arg.getType()));
         Changed = true;
       }
       UnusedArgs.push_back(Arg.getArgNo());
       Fn.removeParamAttrs(Arg.getArgNo(), UBImplyingAttributes);
     }
   }
 
   if (UnusedArgs.empty())
     return false;
 
   for (Use &U : Fn.uses()) {
     CallBase *CB = dyn_cast<CallBase>(U.getUser());
     if (!CB || !CB->isCallee(&U) ||
         CB->getFunctionType() != Fn.getFunctionType())
       continue;
 
-    // Now go through all unused args and replace them with "undef".
+    // Now go through all unused args and replace them with poison.
     for (unsigned I = 0, E = UnusedArgs.size(); I != E; ++I) {
       unsigned ArgNo = UnusedArgs[I];
 
       Value *Arg = CB->getArgOperand(ArgNo);
-      CB->setArgOperand(ArgNo, UndefValue::get(Arg->getType()));
+      CB->setArgOperand(ArgNo, PoisonValue::get(Arg->getType()));
       CB->removeParamAttrs(ArgNo, UBImplyingAttributes);
 
-      ++NumArgumentsReplacedWithUndef;
+      ++NumArgumentsReplacedWithPoison;
       Changed = true;
     }
   }
 
   return Changed;
 }
 
 /// Convenience function that returns the number of return values. It returns 0
while (!F->use_empty()) {
     ArgAttrVec.clear();
 
     if (!CB.use_empty() || CB.isUsedByMetadata()) {
       if (NewCB->getType() == CB.getType()) {
         // Return type not changed? Just replace users then.
         CB.replaceAllUsesWith(NewCB);
         NewCB->takeName(&CB);
       } else if (NewCB->getType()->isVoidTy()) {
-        // If the return value is dead, replace any uses of it with undef
+        // If the return value is dead, replace any uses of it with poison
         // (any non-debug value uses will get removed later on).
         if (!CB.getType()->isX86_MMXTy())
-          CB.replaceAllUsesWith(UndefValue::get(CB.getType()));
+          CB.replaceAllUsesWith(PoisonValue::get(CB.getType()));
       } else {
         assert((RetTy->isStructTy() || RetTy->isArrayTy()) &&
                "Return type changed, but not into a void. The old return type"
                " must have been a struct or an array!");
         Instruction *InsertPt = &CB;
         if (InvokeInst *II = dyn_cast<InvokeInst>(&CB)) {
           BasicBlock *NewEdge =
               SplitEdge(NewCB->getParent(), II->getNormalDest());
           InsertPt = &*NewEdge->getFirstInsertionPt();
         }
 
         // We used to return a struct or array. Instead of doing smart stuff
         // with all the uses, we will just rebuild it using extract/insertvalue
         // chaining and let instcombine clean that up.
         //
-        // Start out building up our return value from undef
-        Value *RetVal = UndefValue::get(RetTy);
+        // Start out building up our return value from poison
+        Value *RetVal = PoisonValue::get(RetTy);
         for (unsigned Ri = 0; Ri != RetCount; ++Ri)
           if (NewRetIdxs[Ri] != -1) {
             Value *V;
             IRBuilder<NoFolder> IRB(InsertPt);
             if (RetTypes.size() > 1)
               // We are still returning a struct, so extract the value from our
               // return value
               V = IRB.CreateExtractValue(NewCB, NewRetIdxs[Ri], "newret");
for (Function::arg_iterator I = F->arg_begin(), E = F->arg_end(),
        I != E; ++I, ++ArgI)
     if (ArgAlive[ArgI]) {
       // If this is a live argument, move the name and users over to the new
       // version.
       I->replaceAllUsesWith(&*I2);
       I2->takeName(&*I);
       ++I2;
     } else {
-      // If this argument is dead, replace any uses of it with undef
+      // If this argument is dead, replace any uses of it with poison
       // (any non-debug value uses will get removed later on).
       if (!I->getType()->isX86_MMXTy())
-        I->replaceAllUsesWith(UndefValue::get(I->getType()));
+        I->replaceAllUsesWith(PoisonValue::get(I->getType()));
     }
 
   // If we change the return value of the function we must rewrite any return
   // instructions.  Check this now.
   if (F->getReturnType() != NF->getReturnType())
     for (BasicBlock &BB : *NF)
       if (ReturnInst *RI = dyn_cast<ReturnInst>(BB.getTerminator())) {
         IRBuilder<NoFolder> IRB(RI);
         Value *RetVal = nullptr;
 
         if (!NFTy->getReturnType()->isVoidTy()) {
           assert(RetTy->isStructTy() || RetTy->isArrayTy());
           // The original return value was a struct or array, insert
           // extractvalue/insertvalue chains to extract only the values we need
           // to return and insert them into our new result.
           // This does generate messy code, but we'll let it to instcombine to
           // clean that up.
           Value *OldRet = RI->getOperand(0);
-          // Start out building up our return value from undef
-          RetVal = UndefValue::get(NRetTy);
+          // Start out building up our return value from poison
+          RetVal = PoisonValue::get(NRetTy);
           for (unsigned RetI = 0; RetI != RetCount; ++RetI)
             if (NewRetIdxs[RetI] != -1) {
               Value *EV = IRB.CreateExtractValue(OldRet, RetI, "oldret");
 
               if (RetTypes.size() > 1) {
                 // We're still returning a struct, so reinsert the value into
                 // our new return value at the new index
 
PreservedAnalyses DeadArgumentEliminationPass::run(Module &M,
 
   // Now, remove all dead arguments and return values from each function in
   // turn.  We use make_early_inc_range here because functions will probably get
   // removed (i.e. replaced by new ones).
   for (Function &F : llvm::make_early_inc_range(M))
     Changed |= RemoveDeadStuffFromFunction(&F);
 
   // Finally, look for any unused parameters in functions with non-local
-  // linkage and replace the passed in parameters with undef.
+  // linkage and replace the passed in parameters with poison.
   for (auto &F : M)
     Changed |= RemoveDeadArgumentsFromCallers(F);
 
   if (!Changed)
     return PreservedAnalyses::all();
   return PreservedAnalyses::none();
 }

llvm/test/DebugInfo/X86/dbgloc-insert-extract-val-instrs.ll

 ;; Check that every instruction inserted by -deadargelim has a debug location.
 ;; The test was generated by using -debugify option.
 
 ; RUN: opt < %s -deadargelim -S 2>&1 | FileCheck %s
 
 ; CHECK-LABEL: fn
 ; CHECK: %oldret = extractvalue { i32, i32, i16 } %z, 0, !dbg ![[LOC:.*]]
-; CHECK: %newret = insertvalue { i32, i32 } undef, i32 %oldret, 0, !dbg ![[LOC:.*]]
+; CHECK: %newret = insertvalue { i32, i32 } poison, i32 %oldret, 0, !dbg ![[LOC:.*]]
 ; CHECK: %oldret1 = extractvalue { i32, i32, i16 } %z, 1, !dbg ![[LOC:.*]]
 ; CHECK: %newret2 = insertvalue { i32, i32 } %newret, i32 %oldret1, 1, !dbg ![[LOC:.*]]
 
 ; CHECK-LABEL: fn1
 ; CHECK: %newret = extractvalue { i32, i32 } %ret, 0, !dbg ![[LOC2:.*]]
-; CHECK: %oldret = insertvalue { i32, i32, i16 } undef, i32 %newret, 0, !dbg ![[LOC2:.*]]
+; CHECK: %oldret = insertvalue { i32, i32, i16 } poison, i32 %newret, 0, !dbg ![[LOC2:.*]]
 ; CHECK: %newret1 = extractvalue { i32, i32 } %ret, 1, !dbg ![[LOC2:.*]]
 ; CHECK: %oldret2 = insertvalue { i32, i32, i16 } %oldret, i32 %newret1, 1, !dbg ![[LOC2:.*]]
 
 ; ModuleID = 'test.ll'
 source_filename = "test.ll"
 
 define internal { i32, i32, i16 } @fn() !dbg !6 {
-  %x = insertvalue { i32, i32, i16 } undef, i32 1, 0, !dbg !8
+  %x = insertvalue { i32, i32, i16 } poison, i32 1, 0, !dbg !8
   %y = insertvalue { i32, i32, i16 } %x, i32 2, 1, !dbg !9
   %z = insertvalue { i32, i32, i16 } %y, i16 3, 2, !dbg !10
   ret { i32, i32, i16 } %z, !dbg !11
 }
 
 define i32 @fn1() !dbg !12 {
   %ret = call { i32, i32, i16 } @fn(), !dbg !13
   %b = extractvalue { i32, i32, i16 } %ret, 0, !dbg !14

llvm/test/Transforms/DeadArgElim/NoundefAttrs.ll

 ; RUN: opt -passes=deadargelim -S < %s | FileCheck %s
 
-; If caller is changed to pass in undef, noundef, dereferenceable and other
-; attributes that imply immediate undefined behavior should be delete.
+; If caller is changed to pass in poison, noundef, dereferenceable and other
+; attributes that imply immediate undefined behavior must be deleted.
 ; Other attributes like nonnull, which only imply poison, can be safely kept.
 
 ; CHECK:   define i64 @bar(i64* nonnull %0, i64 %1)
 define i64 @bar(i64* nonnull dereferenceable(8) %0, i64 %1) {
 entry:
   %2 = add i64 %1, 8
   ret i64 %2
 }
 
 define i64 @foo(i64* %p, i64 %v) {
-; CHECK:   %retval = call i64 @bar(i64* nonnull undef, i64 %v)
+; CHECK:   %retval = call i64 @bar(i64* nonnull poison, i64 %v)
   %retval = call i64 @bar(i64* nonnull dereferenceable(8) %p, i64 %v)
   ret i64 %retval
 }

llvm/test/Transforms/DeadArgElim/aggregates.ll

 define internal { i32, i32 } @test_rets_independent_if_agguse_dead(i1 %tst) {
   %val = call { i32, i32 } @rets_independent_if_agguse_dead()
   br i1 %tst, label %use_1, label %use_aggregate
 
 use_1:
   ; This use can be classified as applying only to ret 1.
   %val0 = extractvalue { i32, i32 } %val, 1
   call void @callee(i32 %val0)
-  ret { i32, i32 } undef
+  ret { i32, i32 } poison
 
 use_aggregate:
   ; This use is assumed to apply to both 0 and 1.
   ret { i32, i32 } %val
 }
 
 ; Case 2: an opaque use of the aggregate exists (in this case *live*). Other
 ; uses shouldn't matter.
 
 ; CHECK-LABEL: define internal { i32, i32 } @rets_live_agguse()
 ; CHECK: ret { i32, i32 } { i32 0, i32 1 }
 
 define internal { i32, i32 } @rets_live_agguse() {
   ret { i32, i32} { i32 0, i32 1 }
 }
 
 define { i32, i32 } @test_rets_live_aggues(i1 %tst) {
   %val = call { i32, i32 } @rets_live_agguse()
   br i1 %tst, label %use_1, label %use_aggregate
 
 use_1:
   ; This use can be classified as applying only to ret 1.
   %val0 = extractvalue { i32, i32 } %val, 1
   call void @callee(i32 %val0)
-  ret { i32, i32 } undef
+  ret { i32, i32 } poison
 
 use_aggregate:
   ; This use is assumed to apply to both 0 and 1.
   ret { i32, i32 } %val
 }
 
 declare void @callee(i32)
 
 ; Case 3: the insertvalue meant %in was live if ret-slot-1 was, but we were only
 ; tracking multiple ret-slots for struct types. So %in was eliminated
 ; incorrectly.
 
 ; CHECK-LABEL: define internal [2 x i32] @array_rets_have_multiple_slots(i32 %in)
 
 define internal [2 x i32] @array_rets_have_multiple_slots(i32 %in) {
-  %ret = insertvalue [2 x i32] undef, i32 %in, 1
+  %ret = insertvalue [2 x i32] poison, i32 %in, 1
   ret [2 x i32] %ret
 }
 
 define [2 x i32] @test_array_rets_have_multiple_slots() {
   %res = call [2 x i32] @array_rets_have_multiple_slots(i32 42)
   ret [2 x i32] %res
 }
 
 ; Case 4: we can remove some retvals from the array. It's nice to produce an
 ; array again having done so (rather than converting it to a struct).
 
 ; CHECK-LABEL: define internal [2 x i32] @can_shrink_arrays()
 ; CHECK: [[VAL0:%.*]] = extractvalue [3 x i32] [i32 42, i32 43, i32 44], 0
-; CHECK: [[RESTMP:%.*]] = insertvalue [2 x i32] undef, i32 [[VAL0]], 0
+; CHECK: [[RESTMP:%.*]] = insertvalue [2 x i32] poison, i32 [[VAL0]], 0
 ; CHECK: [[VAL2:%.*]] = extractvalue [3 x i32] [i32 42, i32 43, i32 44], 2
 ; CHECK: [[RES:%.*]] = insertvalue [2 x i32] [[RESTMP]], i32 [[VAL2]], 1
 ; CHECK: ret [2 x i32] [[RES]]
 
 ; CHECK-LABEL: define void @test_can_shrink_arrays()
 
 define internal [3 x i32] @can_shrink_arrays() {
   ret [3 x i32] [i32 42, i32 43, i32 44]

 
 define internal { i32 } @agg_ret() {
 entry:
   unreachable
 }
 
 ; CHECK-LABEL: define void @PR24906
 ; CHECK: %[[invoke:.*]] = invoke i32 @agg_ret()
-; CHECK: %[[oldret:.*]] = insertvalue { i32 } undef, i32 %[[invoke]], 0
+; CHECK: %[[oldret:.*]] = insertvalue { i32 } poison, i32 %[[invoke]], 0
 ; CHECK: phi { i32 } [ %[[oldret]],
-define void @PR24906() personality i32 (i32)* undef {
+define void @PR24906() personality i32 (i32)* poison {
 entry:
   %tmp2 = invoke { i32 } @agg_ret()
           to label %bb3 unwind label %bb4
 
 bb3:
   %tmp3 = phi { i32 } [ %tmp2, %entry ]
   unreachable
 
 bb4:
   %tmp4 = landingpad { i8*, i32 }
           cleanup
   unreachable
 }

llvm/test/Transforms/DeadArgElim/byref.ll

 ; NOTE: Assertions have been autogenerated by utils/update_test_checks.py
 ; RUN: opt < %s -passes=deadargelim -S | FileCheck %s
 
 declare void @sideeffect()
 
 define void @unused_byref_arg(i32* byref(i32) %dead_arg) {
 ; CHECK-LABEL: @unused_byref_arg(
 ; CHECK-NEXT:    tail call void @sideeffect()
 ; CHECK-NEXT:    ret void
 ;
   tail call void @sideeffect()
   ret void
 }
 
-define void @dont_replace_by_undef(i32* %ptr) {
-; CHECK-LABEL: @dont_replace_by_undef(
-; CHECK-NEXT:    call void @unused_byref_arg(i32* byref(i32) undef)
+define void @dont_replace_by_poison(i32* %ptr) {
+; CHECK-LABEL: @dont_replace_by_poison(
+; CHECK-NEXT:    call void @unused_byref_arg(i32* byref(i32) poison)
 ; CHECK-NEXT:    ret void
 ;
   call void @unused_byref_arg(i32* byref(i32) %ptr)
   ret void
 }

llvm/test/Transforms/DeadArgElim/dbginfo-update-dbgval-local.ll

 ; RUN: opt -passes=deadargelim -S < %s | FileCheck %s
 
 ; Verify that the dbg.value intrinsics that use the dead argument and return
-; value are marked as undef to indicate that the values are optimized out.
+; value are marked as poison to indicate that the values are optimized out.
 
 ; Reproducer for PR23260.
 
 ; CHECK-LABEL: define internal void @bar()
-; CHECK: call void @llvm.dbg.value(metadata i32 undef, metadata ![[LOCAL1:[0-9]+]]
+; CHECK: call void @llvm.dbg.value(metadata i32 poison, metadata ![[LOCAL1:[0-9]+]]
 ; CHECK: call void @sink()
 
 ; Function Attrs: alwaysinline nounwind uwtable
 define internal i32 @bar(i32 %deadarg) #1 !dbg !10 {
 entry:
   call void @llvm.dbg.value(metadata i32 %deadarg, metadata !15, metadata !DIExpression()), !dbg !17
   call void @sink(), !dbg !17
   ret i32 123, !dbg !17
 }
 
 ; CHECK-LABEL: define void @foo()
 ; CHECK: call void @bar()
-; CHECK: call void @llvm.dbg.value(metadata i32 undef, metadata ![[LOCAL2:[0-9]+]]
+; CHECK: call void @llvm.dbg.value(metadata i32 poison, metadata ![[LOCAL2:[0-9]+]]
 ; CHECK: call void @bar()
 
 ; Function Attrs: nounwind uwtable
 define void @foo() #0 !dbg !6 {
 entry:
   %deadret = call i32 @bar(i32 0), !dbg !9
   call void @llvm.dbg.value(metadata i32 %deadret, metadata !16, metadata !DIExpression()), !dbg !9
   call i32 @bar(i32 1), !dbg !9

llvm/test/Transforms/DeadArgElim/dbginfo-update-dbgval.ll

 
 target datalayout = "e-m:e-i64:64-f80:128-n8:16:32:64-S128"
 
 @s = common dso_local local_unnamed_addr global i32 0, align 4, !dbg !0
 
 ; Function Attrs: noinline nounwind uwtable
 define dso_local void @f2(i32 %k) local_unnamed_addr !dbg !11 {
 entry:
-; CHECK: call void @llvm.dbg.value(metadata i32 undef, metadata !15, metadata !DIExpression()), !dbg !16
+; CHECK: call void @llvm.dbg.value(metadata i32 poison, metadata !15, metadata !DIExpression()), !dbg !16
   call void @llvm.dbg.value(metadata i32 %k, metadata !15, metadata !DIExpression()), !dbg !16
   %0 = load i32, i32* @s, align 4, !dbg !17
   %inc = add nsw i32 %0, 1, !dbg !17
   store i32 %inc, i32* @s, align 4, !dbg !17
   call void @llvm.dbg.value(metadata i32* @s, metadata !15, metadata !DIExpression(DW_OP_deref)), !dbg !16
   ret void, !dbg !18
 }
 
 ; Function Attrs: noinline nounwind uwtable
 define dso_local void @f() local_unnamed_addr !dbg !19 {
 entry:
-; CHECK: tail call void @f2(i32 undef), !dbg !22
+; CHECK: tail call void @f2(i32 poison), !dbg !22
   tail call void @f2(i32 4), !dbg !22
   ret void, !dbg !23
 }
 
 ; Function Attrs: nounwind uwtable
 define dso_local i32 @main() local_unnamed_addr !dbg !24 {
 entry:
   tail call void @f(), !dbg !27

llvm/test/Transforms/DeadArgElim/deadexternal.ll

 ; RUN: opt -passes=deadargelim -S < %s | FileCheck %s
 
 define void @test(i32) {
   ret void
 }
 
 define void @foo() {
   call void @test(i32 0)
   ret void
 ; CHECK-LABEL: @foo(
-; CHECK: i32 undef
+; CHECK: i32 poison
 }
 
 define void @f(i32 %X) {
 entry:
   tail call void @sideeffect() nounwind
   ret void
 }
 
 declare void @sideeffect()
 
 define void @g(i32 %n) {
 entry:
   %add = add nsw i32 %n, 1
-; CHECK: tail call void @f(i32 undef)
+; CHECK: tail call void @f(i32 poison)
   tail call void @f(i32 %add)
   ret void
 }
 
 define void @h() {
 entry:
   %i = alloca i32, align 4
   store volatile i32 10, i32* %i, align 4
 ; CHECK: %tmp = load volatile i32, i32* %i, align 4
-; CHECK-NEXT: call void @f(i32 undef)
+; CHECK-NEXT: call void @f(i32 poison)
   %tmp = load volatile i32, i32* %i, align 4
   call void @f(i32 %tmp)
   ret void
 }
 
 ; Check that callers are not transformed for weak definitions.
 define weak i32 @weak_f(i32 %x) nounwind {
 entry:
   ret i32 0
 }
 define void @weak_f_caller() nounwind {
 entry:
 ; CHECK: call i32 @weak_f(i32 10)
   %call = tail call i32 @weak_f(i32 10)
   ret void
 }
 
 %swift_error = type opaque
 
 define void @unused_swifterror_arg(%swift_error** swifterror %dead_arg) {
   tail call void @sideeffect() nounwind
   ret void
 }
 
-; CHECK-LABEL: @dont_replace_by_undef
-; CHECK-NOT: call void @unused_swifterror_arg({{.*}}undef)
-define void @dont_replace_by_undef() {
+; CHECK-LABEL: @dont_replace_by_poison
+; CHECK-NOT: call void @unused_swifterror_arg({{.*}}poison)
+define void @dont_replace_by_poison() {
   %error_ptr_ref = alloca swifterror %swift_error*
   store %swift_error* null, %swift_error** %error_ptr_ref
   call void @unused_swifterror_arg(%swift_error** %error_ptr_ref)
   ret void
 }

llvm/test/Transforms/DeadArgElim/fct_ptr.ll

 ; RUN: opt -S %s -deadargelim -o - | FileCheck %s
 ; In that test @internal_fct is used by an instruction
 ; we don't know how to rewrite (the comparison that produces
 ; %cmp1).
 ; Because of that use, we used to bail out on removing the
 ; unused arguments for this function.
 ; Yet, we should still be able to rewrite the direct calls that are
-; statically known, by replacing the related arguments with undef.
+; statically known, by replacing the related arguments with poison.
 ; This is what we check on the call that produces %res2.
 
 define i32 @call_indirect(i32 (i32, i32, i32)* readnone %fct_ptr, i32 %arg1, i32 %arg2, i32 %arg3) {
 ; CHECK-LABEL: @call_indirect(
 ; CHECK-NEXT:    [[CMP0:%.*]] = icmp eq i32 (i32, i32, i32)* [[FCT_PTR:%.*]], @external_fct
 ; CHECK-NEXT:    br i1 [[CMP0]], label [[CALL_EXT:%.*]], label [[CHK2:%.*]]
 ; CHECK:       call_ext:
-; CHECK-NEXT:    [[RES1:%.*]] = tail call i32 @external_fct(i32 undef, i32 [[ARG2:%.*]], i32 undef)
+; CHECK-NEXT:    [[RES1:%.*]] = tail call i32 @external_fct(i32 poison, i32 [[ARG2:%.*]], i32 poison)
 ; CHECK-NEXT:    br label [[END:%.*]]
 ; CHECK:       chk2:
 ; CHECK-NEXT:    [[CMP1:%.*]] = icmp eq i32 (i32, i32, i32)* [[FCT_PTR]], @internal_fct
 ; CHECK-NEXT:    br i1 [[CMP1]], label [[CALL_INT:%.*]], label [[CALL_OTHER:%.*]]
 ; CHECK:       call_int:
-; CHECK-NEXT:    [[RES2:%.*]] = tail call i32 @internal_fct(i32 undef, i32 [[ARG2]], i32 undef)
+; CHECK-NEXT:    [[RES2:%.*]] = tail call i32 @internal_fct(i32 poison, i32 [[ARG2]], i32 poison)
 ; CHECK-NEXT:    br label [[END]]
 ; CHECK:       call_other:
 ; CHECK-NEXT:    [[RES3:%.*]] = tail call i32 @other_fct(i32 [[ARG2]])
 ; CHECK-NEXT:    br label [[END]]
 ; CHECK:       end:
 ; CHECK-NEXT:    [[FINAL_RES:%.*]] = phi i32 [ [[RES1]], [[CALL_EXT]] ], [ [[RES2]], [[CALL_INT]] ], [ [[RES3]], [[CALL_OTHER]] ]
 ; CHECK-NEXT:    ret i32 [[FINAL_RES]]
 ;

llvm/test/Transforms/DeadArgElim/opaque-ptr.ll

 ; NOTE: Assertions have been autogenerated by utils/update_test_checks.py UTC_ARGS: --function-signature
 ; RUN: opt -S -passes=deadargelim -opaque-pointers < %s | FileCheck %s
 
 define void @callee(i32 %unused) {
 ; CHECK-LABEL: define {{[^@]+}}@callee
 ; CHECK-SAME: (i32 [[UNUSED:%.*]]) {
 ; CHECK-NEXT:    ret void
 ;
   ret void
 }
 
 define void @caller() {
 ; CHECK-LABEL: define {{[^@]+}}@caller() {
-; CHECK-NEXT:    call void @callee(i32 undef)
+; CHECK-NEXT:    call void @callee(i32 poison)
 ; CHECK-NEXT:    call void @callee()
 ; CHECK-NEXT:    call void @callee(i32 42, i32 24)
 ; CHECK-NEXT:    ret void
 ;
   call void @callee(i32 42)
   call void @callee()
   call void @callee(i32 42, i32 24)
   ret void

llvm/test/Transforms/DeadArgElim/variadic_safety.ll

 ; Function derived from AArch64 ABI, where 8 integer arguments go in
 ; registers but the 9th goes on the stack. We really don't want to put
 ; just 7 args in registers and then start on the stack since any
 ; va_arg implementation already present in va_func won't be expecting
 ; it.
 define i32 @call_va(i32 %in) {
   %stacked = alloca i32
   store i32 42, i32* %stacked
-  %res = call i32(i32, i32, ...) @va_func(i32 %in, i32 %in, [6 x i32] undef, i32* byval(i32) %stacked)
+  %res = call i32(i32, i32, ...) @va_func(i32 %in, i32 %in, [6 x i32] poison, i32* byval(i32) %stacked)
   ret i32 %res
-; CHECK: call i32 (i32, i32, ...) @va_func(i32 undef, i32 %in, [6 x i32] undef, i32* byval(i32) %stacked)
+; CHECK: call i32 (i32, i32, ...) @va_func(i32 poison, i32 %in, [6 x i32] poison, i32* byval(i32) %stacked)
 }
 
 define internal i32 @va_deadret_func(i32 %a, i32 %b, ...) {
   %valist = alloca i8
   call void @llvm.va_start(i8* %valist)
 
   ret i32 %a
 }
 
 define void @call_deadret(i32 %in) {
   %stacked = alloca i32
   store i32 42, i32* %stacked
-  call i32 (i32, i32, ...) @va_deadret_func(i32 undef, i32 %in, [6 x i32] undef, i32* byval(i32) %stacked)
+  call i32 (i32, i32, ...) @va_deadret_func(i32 poison, i32 %in, [6 x i32] poison, i32* byval(i32) %stacked)
   ret void
-; CHECK: call void (i32, i32, ...) @va_deadret_func(i32 undef, i32 undef, [6 x i32] undef, i32* byval(i32) %stacked)
+; CHECK: call void (i32, i32, ...) @va_deadret_func(i32 poison, i32 poison, [6 x i32] poison, i32* byval(i32) %stacked)
 }