[DebugInfo] Replace UndefValue with PoisonValue in setKillLocation

[Orlando]

Summary

This helps towards the effort to remove UndefValue from LLVM.

Related to https://discourse.llvm.org/t/auto-undef-debug-uses-of-a-deleted-value

[nlopes]

LGTM!

llvm/include/llvm/IR/IntrinsicInst.h

277

Maybe rename this var to Poison

[Orlando]

Thanks

llvm/include/llvm/IR/IntrinsicInst.h

277

Accidentally failed to amend the commit, done in follow up commit 48c68367d0320e0d6ec03bb9cf76a108f9202cad.

llvm/include/llvm/IR/IntrinsicInst.h

public:
 
   void setKillLocation() {
     // TODO: When/if we remove duplicate values from DIArgLists, we don't need
     // this set anymore.
     SmallPtrSet<Value *, 4> RemovedValues;
     for (Value *OldValue : location_ops()) {
       if (!RemovedValues.insert(OldValue).second)
         continue;
-      Value *Undef = UndefValue::get(OldValue->getType());
+      Value *Undef = PoisonValue::get(OldValue->getType());
       replaceVariableLocationOp(OldValue, Undef);
     }
   }
 
   bool isKillLocation() const {
     // Check for "kill" sentinel values.
     // Non-variadic: empty metadata.
     if (!hasArgList() && isa<MDNode>(getRawLocation()))

llvm/test/DebugInfo/Generic/assignment-tracking/loop-deletion/dead-loop.ll

 ;; $ clang++ -O2 -g -Xclang -fexperimental-assignment-tracking
 ;;
 ;; for.cond is a dead loop - the debug intrinsic inside will be moved to the
 ;; exit block (and made undef) and then the loop will be deleted. Ensure that
 ;; the dbg.assign intrinsic doesn't get transformed into a dbg.value by
 ;; mistake.
 
 ; CHECK: for.end:
-; CHECK-NEXT: call void @llvm.dbg.assign(metadata i32 undef,{{.+}}, metadata !DIExpression({{.+}}), metadata ![[ID:[0-9]+]], metadata ptr %Counter, metadata !DIExpression())
+; CHECK-NEXT: call void @llvm.dbg.assign(metadata i32 poison,{{.+}}, metadata !DIExpression({{.+}}), metadata ![[ID:[0-9]+]], metadata ptr %Counter, metadata !DIExpression())
 ; CHECK-NEXT: store i32 2, ptr %Counter, align 4,{{.*}}!DIAssignID ![[ID]]
 
 define dso_local void @_Z3funv() local_unnamed_addr #0 !dbg !7 {
 entry:
   %Counter = alloca i32, align 4, !DIAssignID !13
   call void @llvm.dbg.assign(metadata i1 undef, metadata !11, metadata !DIExpression(), metadata !13, metadata ptr %Counter, metadata !DIExpression()), !dbg !14
   call void @llvm.dbg.assign(metadata i32 0, metadata !11, metadata !DIExpression(), metadata !16, metadata ptr %Counter, metadata !DIExpression()), !dbg !14
   br label %for.cond, !dbg !17

llvm/test/DebugInfo/Generic/assignment-tracking/salvage-value.ll

entry:
   call void @llvm.dbg.assign(metadata i32 %add, metadata !14, metadata !DIExpression(), metadata !28, metadata ptr %p, metadata !DIExpression()), !dbg !16
 ;; %add is salvaged.
 ; CHECK: call void @llvm.dbg.assign(metadata i32 %x,{{.+}}metadata !DIExpression(DW_OP_plus_uconst, 1, DW_OP_stack_value),{{.+}}, metadata ptr %p, metadata !DIExpression())
 
  %add1 = add nsw i32 %x, %y, !dbg !29
  call void @llvm.dbg.assign(metadata i32 %add1, metadata !32, metadata !DIExpression(), metadata !31, metadata ptr %p, metadata !DIExpression()), !dbg !16
 ;; %add1 is not salvaged as it requires two values and DIArgList is
 ;; not (yet) supported for dbg.assigns.
-; CHECK-NEXT: call void @llvm.dbg.assign(metadata i32 undef,{{.+}}, metadata !DIExpression(),{{.+}}, metadata ptr %p, metadata !DIExpression())
+; CHECK-NEXT: call void @llvm.dbg.assign(metadata i32 poison,{{.+}}, metadata !DIExpression(),{{.+}}, metadata ptr %p, metadata !DIExpression())
 
   %arrayidx0 = getelementptr inbounds i32, ptr %p, i32 0
   call void @llvm.dbg.assign(metadata i32 %x, metadata !14, metadata !DIExpression(), metadata !17, metadata ptr %arrayidx0, metadata !DIExpression()), !dbg !16
 ;; %arrayidx0 is salvaged (zero offset, so the gep is just replaced with %p).
 ; CHECK-NEXT: call void @llvm.dbg.assign(metadata i32 %x,{{.+}}, metadata !DIExpression(),{{.+}}, metadata ptr %p, metadata !DIExpression())
 
   %arrayidx1 = getelementptr inbounds i32, ptr %p, i32 1
   call void @llvm.dbg.assign(metadata i32 %x, metadata !33, metadata !DIExpression(), metadata !18, metadata ptr %arrayidx1, metadata !DIExpression()), !dbg !16

llvm/test/DebugInfo/Generic/pr40628.ll

 ; RUN: opt -passes=early-cse -earlycse-debug-hash -S %s -o - | FileCheck %s
 
 ; PR40628: The first load below is determined to be redundant by EarlyCSE.
 ; During salvaging, the corresponding dbg.value could have a DW_OP_deref used
 ; in its DIExpression to represent the redundant operation -- however LLVM
 ; cannot currently determine that the subsequent store should terminate the
 ; variables location range. A debugger would display zero for the "redundant"
 ; variable after stepping onto the return instruction.
 
 ; Test that the load being removed results in the corresponding dbg.value
 ; being assigned the 'undef' value.
 
 ; CHECK:      @foo
-; CHECK-NEXT: dbg.value(metadata i32 undef, metadata ![[DEADVAR:[0-9]+]],
+; CHECK-NEXT: dbg.value(metadata i32 poison, metadata ![[DEADVAR:[0-9]+]],
 ; CHECK-NEXT: load
 ; CHECK-NEXT: dbg.value(metadata i32 %{{[0-9]+}}, metadata ![[LIVEVAR:[0-9]+]],
 ; CHECK-NEXT: store
 ; CHECK-NEXT: ret
 
 ; CHECK:      ![[DEADVAR]] = !DILocalVariable(name: "redundant",
 ; CHECK:      ![[LIVEVAR]] = !DILocalVariable(name: "loaded",
 

llvm/test/DebugInfo/X86/dead-store-elimination-marks-undef.ll

 ; RUN: opt -mtriple=x86_64-- -S -passes=dse %s  -o - | FileCheck %s
 ; Ensure that we can mark a value as undefined when performing dead
 ; store elimination.
 ; Bugzilla #45080
 
 @b = common dso_local local_unnamed_addr global i32 0, align 1
 
 define dso_local i32 @main() local_unnamed_addr !dbg !7 {
   %1 = alloca i32, align 4
   %2 = load i32, i32* @b, align 1, !dbg !13
-  ; CHECK: call void @llvm.dbg.value(metadata i32 undef
+  ; CHECK: call void @llvm.dbg.value(metadata i32 poison
   call void @llvm.dbg.value(metadata i32 %2, metadata !12, metadata !DIExpression()), !dbg !13
   store i32 %2, i32* %1, align 4, !dbg !13
   ret i32 0, !dbg !13
 }
 
 declare void @llvm.dbg.value(metadata, metadata, metadata)
 
 !llvm.dbg.cu = !{!0}

llvm/test/DebugInfo/X86/licm-undef-dbg-value.ll

 ; RUN: opt -passes=licm %s -S | FileCheck %s
 
 ; CHECK: for.body:
-; CHECK-NEXT: llvm.dbg.value(metadata i8 undef
+; CHECK-NEXT: llvm.dbg.value(metadata i8 poison
 
 ; The load is loop invariant. Check that we leave an undef dbg.value behind
 ; when licm sinks the instruction.
 
 ; clang reduce.cpp -g -O2 -Xclang -disable-llvm-passes -emit-llvm -o reduce.ll
 ; opt -passes=simplifycfg -sroa -passes=loop-rotate -o - -S reduce.ll
 ; cat reduce.cpp
 ; extern char a;

llvm/test/DebugInfo/limit-arglist-size.ll

 ; RUN: opt -S -passes=instcombine %s -o - | FileCheck %s
 
 ; For performance reasons, we currently limit the number of values that can be
 ; referenced by a dbg.value to 16. This test checks that we do not exceed this
 ; limit during salvaging.
 
-; CHECK: DIArgList(i32 undef
+; CHECK: DIArgList(i32 poison
 ; CHECK-NOT: DW_OP_LLVM_arg, 16
 
 target datalayout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128"
 target triple = "x86_64-unknown-linux-gnu"
 
 define i32 @_Z3foov() local_unnamed_addr !dbg !9 {
 entry:
   %call = call i32 @_Z3barv(), !dbg !14

llvm/test/DebugInfo/salvage-limit-expr-size.ll

 ; RUN: opt %s -passes=dce -S | FileCheck %s
 
 ;; Tests that a DIExpression will only be salvaged up to a certain length, and
 ;; will produce an undef value if an expression would need to exceed that length.
 
 define i32 @"?multiply@@YAHHH@Z"(i32 %a, i32 %b) !dbg !8 {
 entry:
   %add.1 = add nsw i32 %a, 5, !dbg !14
   %add.2 = add nsw i32 %a, %b, !dbg !14
   ;; These expressions should salvage successfully, up to exactly 128 elements.
   ; CHECK: call void @llvm.dbg.value(metadata i32 %a, metadata ![[VAR_C:[0-9]+]]
   ; CHECK-NEXT: call void @llvm.dbg.value(metadata !DIArgList(i32 %a, i32 %b), metadata ![[VAR_C]]
   call void @llvm.dbg.value(metadata i32 %add.1, metadata !12, metadata !DIExpression(DW_OP_constu, 1, DW_OP_plus, DW_OP_plus_uconst, 1, DW_OP_plus_uconst, 1, DW_OP_plus_uconst, 1, DW_OP_plus_uconst, 1, DW_OP_plus_uconst, 1, DW_OP_plus_uconst, 1, DW_OP_plus_uconst, 1, DW_OP_plus_uconst, 1, DW_OP_plus_uconst, 1, DW_OP_plus_uconst, 1, DW_OP_plus_uconst, 1, DW_OP_plus_uconst, 1, DW_OP_plus_uconst, 1, DW_OP_plus_uconst, 1, DW_OP_plus_uconst, 1, DW_OP_plus_uconst, 1, DW_OP_plus_uconst, 1, DW_OP_plus_uconst, 1, DW_OP_plus_uconst, 1, DW_OP_plus_uconst, 1, DW_OP_plus_uconst, 1, DW_OP_plus_uconst, 1, DW_OP_plus_uconst, 1, DW_OP_plus_uconst, 1, DW_OP_plus_uconst, 1, DW_OP_plus_uconst, 1, DW_OP_plus_uconst, 1, DW_OP_plus_uconst, 1, DW_OP_plus_uconst, 1, DW_OP_plus_uconst, 1, DW_OP_plus_uconst, 1, DW_OP_plus_uconst, 1, DW_OP_plus_uconst, 1, DW_OP_plus_uconst, 1, DW_OP_plus_uconst, 1, DW_OP_plus_uconst, 1, DW_OP_plus_uconst, 1, DW_OP_plus_uconst, 1, DW_OP_plus_uconst, 1, DW_OP_plus_uconst, 1, DW_OP_plus_uconst, 1, DW_OP_plus_uconst, 1, DW_OP_plus_uconst, 1, DW_OP_plus_uconst, 1, DW_OP_plus_uconst, 1, DW_OP_plus_uconst, 1, DW_OP_plus_uconst, 1, DW_OP_plus_uconst, 1, DW_OP_plus_uconst, 1, DW_OP_plus_uconst, 1, DW_OP_plus_uconst, 1, DW_OP_plus_uconst, 1, DW_OP_plus_uconst, 1, DW_OP_plus_uconst, 1, DW_OP_plus_uconst, 1, DW_OP_plus_uconst, 1, DW_OP_plus_uconst, 1, DW_OP_plus_uconst, 1, DW_OP_plus_uconst, 1, DW_OP_plus_uconst, 1, DW_OP_plus_uconst, 1, DW_OP_stack_value)), !dbg !13
   call void @llvm.dbg.value(metadata i32 %add.2, metadata !12, metadata !DIExpression(DW_OP_plus_uconst, 1, DW_OP_plus_uconst, 1, DW_OP_plus_uconst, 1, DW_OP_plus_uconst, 1, DW_OP_plus_uconst, 1, DW_OP_plus_uconst, 1, DW_OP_plus_uconst, 1, DW_OP_plus_uconst, 1, DW_OP_plus_uconst, 1, DW_OP_plus_uconst, 1, DW_OP_plus_uconst, 1, DW_OP_plus_uconst, 1, DW_OP_plus_uconst, 1, DW_OP_plus_uconst, 1, DW_OP_plus_uconst, 1, DW_OP_plus_uconst, 1, DW_OP_plus_uconst, 1, DW_OP_plus_uconst, 1, DW_OP_plus_uconst, 1, DW_OP_plus_uconst, 1, DW_OP_plus_uconst, 1, DW_OP_plus_uconst, 1, DW_OP_plus_uconst, 1, DW_OP_plus_uconst, 1, DW_OP_plus_uconst, 1, DW_OP_plus_uconst, 1, DW_OP_plus_uconst, 1, DW_OP_plus_uconst, 1, DW_OP_plus_uconst, 1, DW_OP_plus_uconst, 1, DW_OP_plus_uconst, 1, DW_OP_plus_uconst, 1, DW_OP_plus_uconst, 1, DW_OP_plus_uconst, 1, DW_OP_plus_uconst, 1, DW_OP_plus_uconst, 1, DW_OP_plus_uconst, 1, DW_OP_plus_uconst, 1, DW_OP_plus_uconst, 1, DW_OP_plus_uconst, 1, DW_OP_plus_uconst, 1, DW_OP_plus_uconst, 1, DW_OP_plus_uconst, 1, DW_OP_plus_uconst, 1, DW_OP_plus_uconst, 1, DW_OP_plus_uconst, 1, DW_OP_plus_uconst, 1, DW_OP_plus_uconst, 1, DW_OP_plus_uconst, 1, DW_OP_plus_uconst, 1, DW_OP_plus_uconst, 1, DW_OP_plus_uconst, 1, DW_OP_plus_uconst, 1, DW_OP_plus_uconst, 1, DW_OP_plus_uconst, 1, DW_OP_plus_uconst, 1, DW_OP_plus_uconst, 1, DW_OP_plus_uconst, 1, DW_OP_plus_uconst, 1, DW_OP_plus_uconst, 1, DW_OP_plus_uconst, 1, DW_OP_stack_value)), !dbg !13
   ;; These expressions should be set undef, as they would salvage up to exactly 129 elements.
-  ; CHECK-NEXT: call void @llvm.dbg.value(metadata i32 undef, metadata ![[VAR_C]]
-  ; CHECK-NEXT: call void @llvm.dbg.value(metadata i32 undef, metadata ![[VAR_C]]
+  ; CHECK-NEXT: call void @llvm.dbg.value(metadata i32 poison, metadata ![[VAR_C]]
+  ; CHECK-NEXT: call void @llvm.dbg.value(metadata i32 poison, metadata ![[VAR_C]]
   call void @llvm.dbg.value(metadata i32 %add.1, metadata !12, metadata !DIExpression(DW_OP_plus_uconst, 1, DW_OP_plus_uconst, 1, DW_OP_plus_uconst, 1, DW_OP_plus_uconst, 1, DW_OP_plus_uconst, 1, DW_OP_plus_uconst, 1, DW_OP_plus_uconst, 1, DW_OP_plus_uconst, 1, DW_OP_plus_uconst, 1, DW_OP_plus_uconst, 1, DW_OP_plus_uconst, 1, DW_OP_plus_uconst, 1, DW_OP_plus_uconst, 1, DW_OP_plus_uconst, 1, DW_OP_plus_uconst, 1, DW_OP_plus_uconst, 1, DW_OP_plus_uconst, 1, DW_OP_plus_uconst, 1, DW_OP_plus_uconst, 1, DW_OP_plus_uconst, 1, DW_OP_plus_uconst, 1, DW_OP_plus_uconst, 1, DW_OP_plus_uconst, 1, DW_OP_plus_uconst, 1, DW_OP_plus_uconst, 1, DW_OP_plus_uconst, 1, DW_OP_plus_uconst, 1, DW_OP_plus_uconst, 1, DW_OP_plus_uconst, 1, DW_OP_plus_uconst, 1, DW_OP_plus_uconst, 1, DW_OP_plus_uconst, 1, DW_OP_plus_uconst, 1, DW_OP_plus_uconst, 1, DW_OP_plus_uconst, 1, DW_OP_plus_uconst, 1, DW_OP_plus_uconst, 1, DW_OP_plus_uconst, 1, DW_OP_plus_uconst, 1, DW_OP_plus_uconst, 1, DW_OP_plus_uconst, 1, DW_OP_plus_uconst, 1, DW_OP_plus_uconst, 1, DW_OP_plus_uconst, 1, DW_OP_plus_uconst, 1, DW_OP_plus_uconst, 1, DW_OP_plus_uconst, 1, DW_OP_plus_uconst, 1, DW_OP_plus_uconst, 1, DW_OP_plus_uconst, 1, DW_OP_plus_uconst, 1, DW_OP_plus_uconst, 1, DW_OP_plus_uconst, 1, DW_OP_plus_uconst, 1, DW_OP_plus_uconst, 1, DW_OP_plus_uconst, 1, DW_OP_plus_uconst, 1, DW_OP_plus_uconst, 1, DW_OP_plus_uconst, 1, DW_OP_plus_uconst, 1, DW_OP_plus_uconst, 1, DW_OP_plus_uconst, 1, DW_OP_plus_uconst, 1, DW_OP_stack_value)), !dbg !13
   call void @llvm.dbg.value(metadata i32 %add.2, metadata !12, metadata !DIExpression(DW_OP_constu, 1, DW_OP_plus, DW_OP_plus_uconst, 1, DW_OP_plus_uconst, 1, DW_OP_plus_uconst, 1, DW_OP_plus_uconst, 1, DW_OP_plus_uconst, 1, DW_OP_plus_uconst, 1, DW_OP_plus_uconst, 1, DW_OP_plus_uconst, 1, DW_OP_plus_uconst, 1, DW_OP_plus_uconst, 1, DW_OP_plus_uconst, 1, DW_OP_plus_uconst, 1, DW_OP_plus_uconst, 1, DW_OP_plus_uconst, 1, DW_OP_plus_uconst, 1, DW_OP_plus_uconst, 1, DW_OP_plus_uconst, 1, DW_OP_plus_uconst, 1, DW_OP_plus_uconst, 1, DW_OP_plus_uconst, 1, DW_OP_plus_uconst, 1, DW_OP_plus_uconst, 1, DW_OP_plus_uconst, 1, DW_OP_plus_uconst, 1, DW_OP_plus_uconst, 1, DW_OP_plus_uconst, 1, DW_OP_plus_uconst, 1, DW_OP_plus_uconst, 1, DW_OP_plus_uconst, 1, DW_OP_plus_uconst, 1, DW_OP_plus_uconst, 1, DW_OP_plus_uconst, 1, DW_OP_plus_uconst, 1, DW_OP_plus_uconst, 1, DW_OP_plus_uconst, 1, DW_OP_plus_uconst, 1, DW_OP_plus_uconst, 1, DW_OP_plus_uconst, 1, DW_OP_plus_uconst, 1, DW_OP_plus_uconst, 1, DW_OP_plus_uconst, 1, DW_OP_plus_uconst, 1, DW_OP_plus_uconst, 1, DW_OP_plus_uconst, 1, DW_OP_plus_uconst, 1, DW_OP_plus_uconst, 1, DW_OP_plus_uconst, 1, DW_OP_plus_uconst, 1, DW_OP_plus_uconst, 1, DW_OP_plus_uconst, 1, DW_OP_plus_uconst, 1, DW_OP_plus_uconst, 1, DW_OP_plus_uconst, 1, DW_OP_plus_uconst, 1, DW_OP_plus_uconst, 1, DW_OP_plus_uconst, 1, DW_OP_plus_uconst, 1, DW_OP_plus_uconst, 1, DW_OP_plus_uconst, 1, DW_OP_plus_uconst, 1, DW_OP_stack_value)), !dbg !13
   %mul = mul nsw i32 %a, %b, !dbg !15
   ret i32 %mul, !dbg !15
 }
 
 ; CHECK: ![[VAR_C]] = !DILocalVariable(name: "c"
 

llvm/test/Transforms/BDCE/pr41925.ll

;CHECK: call void @llvm.dbg.value(metadata i8 2
   %.pr = load i8, i8* @b, align 1, !dbg !19
   call void @llvm.dbg.value(metadata i8 2, metadata !17, metadata !DIExpression()), !dbg !18
   %cmp5 = icmp slt i8 %.pr, 1, !dbg !22
   br i1 %cmp5, label %for.cond2thread-pre-split.preheader, label %for.end9, !dbg !23
 
 for.cond2thread-pre-split.preheader:              ; preds = %entry
   br label %for.cond2thread-pre-split, !dbg !23
 for.cond2thread-pre-split:                        ; preds = %for.cond2thread-pre-split.preheader, %for.inc7
-;CHECK: call void @llvm.dbg.value(metadata i8 undef
+;CHECK: call void @llvm.dbg.value(metadata i8 poison
   %l_177.06 = phi i8 [ %l_177.1.lcssa, %for.inc7 ], [ 2, %for.cond2thread-pre-split.preheader ]
   call void @llvm.dbg.value(metadata i8 %l_177.06, metadata !17, metadata !DIExpression()), !dbg !18
-;CHECK: call void @llvm.dbg.value(metadata i8 undef
+;CHECK: call void @llvm.dbg.value(metadata i8 poison
   %.pr1 = load i8, i8* @a, align 1, !dbg !24
   call void @llvm.dbg.value(metadata i8 %l_177.06, metadata !17, metadata !DIExpression()), !dbg !18
   %cmp42 = icmp sgt i8 %.pr1, -1, !dbg !27
   br i1 %cmp42, label %for.body6.preheader, label %for.inc7, !dbg !28
 
 for.body6.preheader:                              ; preds = %for.cond2thread-pre-split
   br label %for.body6, !dbg !28
 
 for.body6:                                        ; preds = %for.body6.preheader, %for.body6
-;CHECK: call void @llvm.dbg.value(metadata i8 undef
-;CHECK: call void @llvm.dbg.value(metadata i8 undef
+;CHECK: call void @llvm.dbg.value(metadata i8 poison
+;CHECK: call void @llvm.dbg.value(metadata i8 poison
   %l_177.13 = phi i8 [ %inc, %for.body6 ], [ %l_177.06, %for.body6.preheader ]
   call void @llvm.dbg.value(metadata i8 %l_177.13, metadata !17, metadata !DIExpression()), !dbg !18
   call void @llvm.dbg.value(metadata i8 %l_177.13, metadata !17, metadata !DIExpression(DW_OP_plus_uconst, 1, DW_OP_stack_value)), !dbg !18
   tail call void (...) @optimize_me_not(),  !dbg !29
   %inc = add i8 %l_177.13, 1, !dbg !31
   %0 = load i8, i8* @a, align 1, !dbg !32
   %dec = add i8 %0, -1, !dbg !32
   store i8 %dec, i8* @a, align 1, !dbg !32
   call void @llvm.dbg.value(metadata i8 %inc, metadata !17, metadata !DIExpression()), !dbg !18
   %cmp4 = icmp sgt i8 %dec, -1, !dbg !27
   br i1 %cmp4, label %for.body6, label %for.inc7.loopexit, !dbg !28, !llvm.loop !33
 
 for.inc7.loopexit:                                ; preds = %for.body6
   %inc.lcssa = phi i8 [ %inc, %for.body6 ], !dbg !31
   br label %for.inc7, !dbg !35
 
 for.inc7:                                         ; preds = %for.inc7.loopexit, %for.cond2thread-pre-split
-;CHECK: call void @llvm.dbg.value(metadata i8 undef
+;CHECK: call void @llvm.dbg.value(metadata i8 poison
   %l_177.1.lcssa = phi i8 [ %l_177.06, %for.cond2thread-pre-split ], [ %inc.lcssa, %for.inc7.loopexit ], !dbg !18
   %1 = load i8, i8* @b, align 1, !dbg !35
   %inc8 = add i8 %1, 1, !dbg !35
   store i8 %inc8, i8* @b, align 1, !dbg !35
   call void @llvm.dbg.value(metadata i8 %l_177.1.lcssa, metadata !17, metadata !DIExpression()), !dbg !18
   %cmp = icmp slt i8 %inc8, 1, !dbg !22
   br i1 %cmp, label %for.cond2thread-pre-split, label %for.end9.loopexit, !dbg !23, !llvm.loop !36
 

llvm/test/Transforms/InstCombine/debuginfo-dce.ll

 define void @salvage_load(%struct.entry** %queue) local_unnamed_addr #0 !dbg !14 {
 entry:
   %im_not_dead = alloca %struct.entry*
   %0 = load %struct.entry*, %struct.entry** %queue, align 8, !dbg !19
   %1 = load %struct.entry*, %struct.entry** %queue, align 8, !dbg !19
   call void @llvm.dbg.value(metadata %struct.entry* %1, metadata !18, metadata !20), !dbg !19
 ; CHECK: define void @salvage_load
 ; CHECK-NEXT: entry:
-; CHECK-NEXT: call void @llvm.dbg.value(metadata %struct.entry* undef
+; CHECK-NEXT: call void @llvm.dbg.value(metadata %struct.entry* poison
   store %struct.entry* %1, %struct.entry** %im_not_dead, align 8
   ret void, !dbg !21
 }
 
 define void @salvage_bitcast(%struct.entry* %queue) local_unnamed_addr #0 !dbg !22 {
 entry:
   %im_not_dead = alloca i8*
   %0 = bitcast %struct.entry* %queue to i8*, !dbg !23

llvm/test/Transforms/InstCombine/debuginfo-sink.ll

; CHECK-NEXT:  load
   ret i32 %0, !dbg !15
 }
 
 ; In this example the GEP cannot (yet) be salvaged. Check that not only is the
 ; dbg.value sunk, but an undef dbg.value is left to terminate any earlier
 ; value range.
 
 ; CHECK-LABEL: define i32 @bar(
-; CHECK:       call void @llvm.dbg.value(metadata ptr undef,
+; CHECK:       call void @llvm.dbg.value(metadata ptr poison,
 ; CHECK-NEXT:  br label %sink2
 
 define i32 @bar(ptr %a, i32 %b) !dbg !70 {
 entry:
   %gep = getelementptr <vscale x 4 x i32>, ptr %a, i32 %b
   call void @llvm.dbg.value(metadata ptr %gep, metadata !73, metadata !12), !dbg !74
   br label %sink2
 

llvm/test/Transforms/InstCombine/erase-dbg-values-at-dead-alloc-site.ll

 ; RUN: opt -S -passes=instcombine %s | FileCheck %s -check-prefix=RUN-ONCE
 
 ; This example was reduced from a test case in which InstCombine ran at least
 ; twice:
 ;   - The first InstCombine run converted dbg.declares to dbg.values using the
 ;     LowerDbgDeclare utility. This produced a dbg.value(ptr %2, DW_OP_deref)
 ;     (this happens when the contents of an alloca are passed by-value), and a
 ;     dbg.value(i32 %0) (due to the store of %0 into the alloca).
 ;   - The second InstCombine run deleted the alloca (%2).
 ; Check that the DW_OP_deref dbg.value is deleted, just like a dbg.declare would
 ; be.
 ;
 ; RUN-ONCE-LABEL: @t1(
 ; RUN-ONCE-NEXT: llvm.dbg.value(metadata i32 %0, metadata [[t1_arg0:![0-9]+]], metadata !DIExpression())
-; RUN-ONCE-NEXT: llvm.dbg.value(metadata ptr undef, metadata [[t1_fake_ptr:![0-9]+]], metadata !DIExpression())
+; RUN-ONCE-NEXT: llvm.dbg.value(metadata ptr poison, metadata [[t1_fake_ptr:![0-9]+]], metadata !DIExpression())
 ; RUN-ONCE-NEXT: ret void
 define void @t1(i32) !dbg !9 {
   %2 = alloca i32, align 4
   store i32 %0, ptr %2, align 4
   call void @llvm.dbg.value(metadata i32 %0, metadata !14, metadata !DIExpression()), !dbg !15
   call void @llvm.dbg.value(metadata ptr %2, metadata !14, metadata !DIExpression(DW_OP_deref)), !dbg !15
   call void @llvm.dbg.value(metadata ptr %2, metadata !20, metadata !DIExpression()), !dbg !15
   ret void

llvm/test/Transforms/InstCombine/pr43893.ll

 ; Check for setting dbg.value as undef which depends on trivially dead instructions.
 ; RUN: opt -passes=instcombine -S -o - %s | FileCheck %s
 
 @a = common dso_local global i8 0, align 1, !dbg !0
 @b = common dso_local global i8 0, align 1, !dbg !6
 
 define dso_local i32 @main() !dbg !13 {
 entry:
   %0 = load i8, ptr @a, align 1, !dbg !17
   %dec = add i8 %0, -1, !dbg !17
   store i8 %dec, ptr @a, align 1, !dbg !17
-;CHECK: call void @llvm.dbg.value(metadata i32 undef
+;CHECK: call void @llvm.dbg.value(metadata i32 poison
 ;CHECK: call void @llvm.dbg.value(metadata i32 -8
-;CHECK: call void @llvm.dbg.value(metadata i32 undef
+;CHECK: call void @llvm.dbg.value(metadata i32 poison
   %conv = sext i8 %dec to i32, !dbg !17
   %udiv = udiv i32 %conv, 4, !dbg !17
   call void @llvm.dbg.value(metadata i32 %udiv, metadata !18, metadata !DIExpression()), !dbg !19
   call void @llvm.dbg.value(metadata i32 -8, metadata !20, metadata !DIExpression()), !dbg !19
   call void @llvm.dbg.value(metadata i32 %udiv, metadata !20, metadata !DIExpression()), !dbg !19
   store i8 0, ptr @b, align 1, !dbg !21
   %cmp = icmp sgt i32 %conv, 0, !dbg !22
   %conv1 = zext i1 %cmp to i32, !dbg !22

llvm/test/Transforms/InstCombine/stacksave-debuginfo.ll

 ; NOTE: Assertions have been autogenerated by utils/update_test_checks.py
 ; dbg.value intrinsics should not affect peephole combining of stacksave/stackrestore.
 ; PR37713
 ; RUN: opt -passes=instcombine %s -S | FileCheck %s
 
 declare ptr @llvm.stacksave() #0
 declare void @llvm.stackrestore(ptr) #0
 
 define ptr @test1(i32 %P) !dbg !6 {
 ; CHECK-LABEL: @test1(
-; CHECK-NEXT:    call void @llvm.dbg.value(metadata ptr undef
+; CHECK-NEXT:    call void @llvm.dbg.value(metadata ptr poison
 ; CHECK-NEXT:    [[TMP1:%.*]] = zext i32 [[P:%.*]] to i64, !dbg !13
 ; CHECK-NEXT:    [[A:%.*]] = alloca i32, i64 [[TMP1]], align 4, !dbg !13
 ; CHECK-NEXT:    call void @llvm.dbg.value(metadata ptr [[A]]
 ; CHECK-NEXT:    ret ptr [[A]], !dbg !14
 ;
   %tmp = call ptr @llvm.stacksave(), !dbg !12
   call void @llvm.dbg.value(metadata ptr %tmp, metadata !9, metadata !DIExpression()), !dbg !12
   call void @llvm.stackrestore(ptr %tmp), !dbg !13

llvm/test/Transforms/LoopDeletion/diundef.ll

 for.cond:                                         ; preds = %for.cond, %entry
   %i.0 = phi i32 [ 0, %entry ], [ %inc, %for.cond ], !dbg !20
   call void @llvm.dbg.value(metadata i32 %i.0, metadata !16, metadata !DIExpression()), !dbg !17
   %inc = add nuw nsw i32 %i.0, 1, !dbg !21
   call void @llvm.dbg.value(metadata i32 %inc, metadata !16, metadata !DIExpression()), !dbg !17
   %exitcond = icmp ne i32 %inc, 3, !dbg !23
   br i1 %exitcond, label %for.cond, label %for.end, !dbg !24, !llvm.loop !25
 
-; CHECK: call void @llvm.dbg.value(metadata i32 undef, metadata !16, metadata !DIExpression()), !dbg !17
+; CHECK: call void @llvm.dbg.value(metadata i32 poison, metadata !16, metadata !DIExpression()), !dbg !17
 ; CHECK-NEXT: %call = tail call i32 {{.*}} @patatino()
 for.end:                                          ; preds = %for.cond
   %call = tail call i32 (...) @patatino() #3, !dbg !27
   %0 = load i32, i32* @a, align 4, !dbg !28
   ret i32 %0, !dbg !33
 }
 
 declare i32 @patatino(...) local_unnamed_addr

llvm/test/Transforms/LoopStrengthReduce/dbg-preserve-1.ll

 ; RUN: opt < %s -loop-reduce -S | FileCheck %s
 ;
 ; Test that LSR avoids crashing on very large integer inputs. It should
 ; discard the variable location by creating an undef dbg.value.
 ;
-; CHECK: call void @llvm.dbg.value(metadata i128 undef,
+; CHECK: call void @llvm.dbg.value(metadata i128 poison,
 
 source_filename = "<stdin>"
 target datalayout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128"
 target triple = "x86_64-unknown-linux-gnu"
 
 define dso_local void @qux() local_unnamed_addr !dbg !10 {
 entry:
   br label %for.body, !dbg !17

llvm/test/Transforms/Reassociate/reassociate_dbgvalue_discard.ll

 ; NOTE: Assertions have been autogenerated by utils/update_test_checks.py
 ; RUN: opt < %s -passes=reassociate -S -o - | FileCheck %s
 
 ; After reassociation m1 and m2 aren't calculated as m1=c*a and m2=c*b any longer.
 ; So let's verify that the dbg.value nodes for m1 and m3 are invalidated.
 
 source_filename = "reassociate_dbgvalue_discard.c"
 target datalayout = "e-m:e-i64:64-f80:128-n8:16:32:64-S128"
 target triple = "x86_64-unknown-linux-gnu"
 
 define dso_local i32 @test1(i32 %a, i32 %b, i32 %c, i32 %d) local_unnamed_addr #0 !dbg !7 {
 ; CHECK-LABEL: @test1(
 ; CHECK-NEXT:  entry:
-; CHECK-NEXT:    call void @llvm.dbg.value(metadata i32 undef, metadata !16, metadata !DIExpression()), !dbg !20
-; CHECK-NEXT:    call void @llvm.dbg.value(metadata i32 undef, metadata !17, metadata !DIExpression()), !dbg !21
+; CHECK-NEXT:    call void @llvm.dbg.value(metadata i32 poison, metadata !16, metadata !DIExpression()), !dbg !20
+; CHECK-NEXT:    call void @llvm.dbg.value(metadata i32 poison, metadata !17, metadata !DIExpression()), !dbg !21
 ; CHECK-NEXT:    [[M1:%.*]] = mul i32 [[D:%.*]], [[C:%.*]], !dbg !22
 ; CHECK-NEXT:    [[M3:%.*]] = mul i32 [[M1]], [[A:%.*]], !dbg !23
 ; CHECK-NEXT:    call void @llvm.dbg.value(metadata i32 [[M3]], metadata !18, metadata !DIExpression()), !dbg !24
 ; CHECK-NEXT:    [[M2:%.*]] = mul i32 [[D]], [[C]], !dbg !25
 ; CHECK-NEXT:    [[M4:%.*]] = mul i32 [[M2]], [[B:%.*]], !dbg !26
 ; CHECK-NEXT:    call void @llvm.dbg.value(metadata i32 [[M4]], metadata !19, metadata !DIExpression()), !dbg !27
 ; CHECK-NEXT:    [[RES:%.*]] = xor i32 [[M3]], [[M4]]
 ; CHECK-NEXT:    ret i32 [[RES]], !dbg !28

llvm/test/Transforms/Reassociate/undef_intrinsics_when_deleting_instructions.ll

 ; RUN: opt < %s -passes=reassociate -S | FileCheck %s
 
 ; Check that reassociate pass now undefs debug intrinsics that reference a value
 ; that gets dropped and cannot be salvaged.
 
 ; CHECK-NOT: %add = fadd fast float %a, %b
-; CHECK: call void @llvm.dbg.value(metadata float undef, metadata [[VAR_X:![0-9]+]], metadata !DIExpression())
+; CHECK: call void @llvm.dbg.value(metadata float poison, metadata [[VAR_X:![0-9]+]], metadata !DIExpression())
 
 ; CHECK-LABEL: if.then:
 ; CHECK-NOT: %add1 = fadd fast float %add, %c
-; CHECK: call void @llvm.dbg.value(metadata float undef, metadata [[VAR_Y:![0-9]+]], metadata !DIExpression())
+; CHECK: call void @llvm.dbg.value(metadata float poison, metadata [[VAR_Y:![0-9]+]], metadata !DIExpression())
 ; CHECK-LABEL: !0 =
 ; CHECK-DAG: [[VAR_Y]] = !DILocalVariable(name: "y"
 ; CHECK-DAG: [[VAR_X]] = !DILocalVariable(name: "x"
 
 define float @"?foo@@YAMMMMM@Z"(float %a, float %b, float %c, float %d) !dbg !8 {
 entry:
   call void @llvm.dbg.value(metadata float %d, metadata !12, metadata !DIExpression()), !dbg !13
   call void @llvm.dbg.value(metadata float %c, metadata !14, metadata !DIExpression()), !dbg !13