[llvm] DAG: Use poison in getLoad/getStore for offsets (PR #212066)
Matt Arsenault via llvm-commits
llvm-commits at lists.llvm.org
Wed Jul 29 03:09:03 PDT 2026
https://github.com/arsenm updated https://github.com/llvm/llvm-project/pull/212066
>From 7c20e1d885cda69097cc8c9374889a865c599d78 Mon Sep 17 00:00:00 2001
From: Matt Arsenault <Matthew.Arsenault at amd.com>
Date: Sun, 16 Nov 2025 12:54:11 -0800
Subject: [PATCH] DAG: Use poison in getLoad/getStore for offsets
The painful part of this is due to a few unfortunate things.
1. poison is legalized to undef
2. Non-indexed load/store encode the offset as an undef (which is
not like a TargetConstant, and does get legalized)
3. 2 asserts in DAGCombiner expect identical load/store nodes,
which assumes the offset will be preserved and not converted
between poison and undef
4. The getLoad/getStore overloads are a mess, and a path was missing
to recreate the store case with the original offset.
---
llvm/include/llvm/CodeGen/SelectionDAG.h | 12 ++++
llvm/lib/CodeGen/SelectionDAG/DAGCombiner.cpp | 21 +++----
.../SelectionDAG/LegalizeVectorTypes.cpp | 4 +-
.../lib/CodeGen/SelectionDAG/SelectionDAG.cpp | 56 ++++++++++++-------
llvm/lib/Target/AMDGPU/R600ISelLowering.cpp | 14 ++---
.../AArch64/ragreedy-local-interval-cost.ll | 2 +-
.../X86/merge-store-partially-alias-loads.ll | 8 +--
.../CodeGen/SelectionDAGPatternMatchTest.cpp | 2 +-
8 files changed, 74 insertions(+), 45 deletions(-)
diff --git a/llvm/include/llvm/CodeGen/SelectionDAG.h b/llvm/include/llvm/CodeGen/SelectionDAG.h
index 3e2bb19da5135..8467d49c72140 100644
--- a/llvm/include/llvm/CodeGen/SelectionDAG.h
+++ b/llvm/include/llvm/CodeGen/SelectionDAG.h
@@ -1590,11 +1590,23 @@ class SelectionDAG {
}
LLVM_ABI SDValue getStore(SDValue Chain, const SDLoc &dl, SDValue Val,
SDValue Ptr, MachineMemOperand *MMO);
+ LLVM_ABI SDValue getStore(SDValue Chain, const SDLoc &dl, SDValue Val,
+ SDValue Ptr, SDValue Offset,
+ MachineMemOperand *MMO);
+ LLVM_ABI SDValue getTruncStore(
+ SDValue Chain, const SDLoc &dl, SDValue Val, SDValue Ptr, SDValue Offset,
+ MachinePointerInfo PtrInfo, EVT SVT, Align Alignment,
+ MachineMemOperand::Flags MMOFlags = MachineMemOperand::MONone,
+ const AAMDNodes &AAInfo = AAMDNodes());
LLVM_ABI SDValue
getTruncStore(SDValue Chain, const SDLoc &dl, SDValue Val, SDValue Ptr,
MachinePointerInfo PtrInfo, EVT SVT, Align Alignment,
MachineMemOperand::Flags MMOFlags = MachineMemOperand::MONone,
const AAMDNodes &AAInfo = AAMDNodes());
+ LLVM_ABI SDValue getTruncStore(SDValue Chain, const SDLoc &dl, SDValue Val,
+ SDValue Ptr, SDValue Offset, EVT SVT,
+ MachineMemOperand *MMO);
+
inline SDValue
getTruncStore(SDValue Chain, const SDLoc &dl, SDValue Val, SDValue Ptr,
MachinePointerInfo PtrInfo, EVT SVT,
diff --git a/llvm/lib/CodeGen/SelectionDAG/DAGCombiner.cpp b/llvm/lib/CodeGen/SelectionDAG/DAGCombiner.cpp
index ff54965b64a75..7a183a53f3761 100644
--- a/llvm/lib/CodeGen/SelectionDAG/DAGCombiner.cpp
+++ b/llvm/lib/CodeGen/SelectionDAG/DAGCombiner.cpp
@@ -21905,7 +21905,7 @@ SDValue DAGCombiner::visitLOAD(SDNode *N) {
bool CanSplitIdx = canSplitIdx(LD);
if (!N->hasAnyUseOfValue(0) && (CanSplitIdx || !N->hasAnyUseOfValue(1))) {
- SDValue Undef = DAG.getUNDEF(N->getValueType(0));
+ SDValue Poison = DAG.getPOISON(N->getValueType(0));
SDValue Index;
if (N->hasAnyUseOfValue(1) && CanSplitIdx) {
Index = SplitIndexingFromLoad(LD);
@@ -21913,12 +21913,12 @@ SDValue DAGCombiner::visitLOAD(SDNode *N) {
// stores.
AddUsersToWorklist(N);
} else
- Index = DAG.getUNDEF(N->getValueType(1));
+ Index = DAG.getPOISON(N->getValueType(1));
LLVM_DEBUG(dbgs() << "\nReplacing.7 "; N->dump(&DAG);
- dbgs() << "\nWith: "; Undef.dump(&DAG);
+ dbgs() << "\nWith: "; Poison.dump(&DAG);
dbgs() << " and 2 other values\n");
WorklistRemover DeadNodes(*this);
- DAG.ReplaceAllUsesOfValueWith(SDValue(N, 0), Undef);
+ DAG.ReplaceAllUsesOfValueWith(SDValue(N, 0), Poison);
DAG.ReplaceAllUsesOfValueWith(SDValue(N, 1), Index);
DAG.ReplaceAllUsesOfValueWith(SDValue(N, 2), Chain);
deleteAndRecombine(N);
@@ -21938,8 +21938,9 @@ SDValue DAGCombiner::visitLOAD(SDNode *N) {
if (MaybeAlign Alignment = DAG.InferPtrAlign(Ptr)) {
if (*Alignment > LD->getAlign() &&
isAligned(*Alignment, LD->getSrcValueOffset())) {
- SDValue NewLoad = DAG.getExtLoad(
- LD->getExtensionType(), SDLoc(N), LD->getValueType(0), Chain, Ptr,
+ SDValue NewLoad = DAG.getLoad(
+ LD->getAddressingMode(), LD->getExtensionType(),
+ LD->getValueType(0), SDLoc(N), Chain, Ptr, LD->getOffset(),
LD->getPointerInfo(), LD->getMemoryVT(), *Alignment,
LD->getMemOperand()->getFlags(), LD->getAAInfo());
// NewLoad will always be N as we are only refining the alignment
@@ -24470,10 +24471,10 @@ SDValue DAGCombiner::visitSTORE(SDNode *N) {
if (MaybeAlign Alignment = DAG.InferPtrAlign(Ptr)) {
if (*Alignment > ST->getAlign() &&
isAligned(*Alignment, ST->getSrcValueOffset())) {
- SDValue NewStore =
- DAG.getTruncStore(Chain, SDLoc(N), Value, Ptr, ST->getPointerInfo(),
- ST->getMemoryVT(), *Alignment,
- ST->getMemOperand()->getFlags(), ST->getAAInfo());
+ SDValue NewStore = DAG.getTruncStore(
+ Chain, SDLoc(N), Value, Ptr, ST->getOffset(), ST->getPointerInfo(),
+ ST->getMemoryVT(), *Alignment, ST->getMemOperand()->getFlags(),
+ ST->getAAInfo());
// NewStore will always be N as we are only refining the alignment
assert(NewStore.getNode() == N);
(void)NewStore;
diff --git a/llvm/lib/CodeGen/SelectionDAG/LegalizeVectorTypes.cpp b/llvm/lib/CodeGen/SelectionDAG/LegalizeVectorTypes.cpp
index c71352fb20817..3ac59831e7d5a 100644
--- a/llvm/lib/CodeGen/SelectionDAG/LegalizeVectorTypes.cpp
+++ b/llvm/lib/CodeGen/SelectionDAG/LegalizeVectorTypes.cpp
@@ -569,7 +569,7 @@ SDValue DAGTypeLegalizer::ScalarizeVecRes_LOAD(LoadSDNode *N) {
SDValue Result = DAG.getLoad(
ISD::UNINDEXED, N->getExtensionType(),
N->getValueType(0).getVectorElementType(), SDLoc(N), N->getChain(),
- N->getBasePtr(), DAG.getUNDEF(N->getBasePtr().getValueType()),
+ N->getBasePtr(), DAG.getPOISON(N->getBasePtr().getValueType()),
N->getPointerInfo(), N->getMemoryVT().getVectorElementType(),
N->getBaseAlign(), N->getMemOperand()->getFlags(), N->getAAInfo());
@@ -2425,7 +2425,7 @@ void DAGTypeLegalizer::SplitVecRes_LOAD(LoadSDNode *LD, SDValue &Lo,
ISD::LoadExtType ExtType = LD->getExtensionType();
SDValue Ch = LD->getChain();
SDValue Ptr = LD->getBasePtr();
- SDValue Offset = DAG.getUNDEF(Ptr.getValueType());
+ SDValue Offset = DAG.getPOISON(Ptr.getValueType());
EVT MemoryVT = LD->getMemoryVT();
MachineMemOperand::Flags MMOFlags = LD->getMemOperand()->getFlags();
AAMDNodes AAInfo = LD->getAAInfo();
diff --git a/llvm/lib/CodeGen/SelectionDAG/SelectionDAG.cpp b/llvm/lib/CodeGen/SelectionDAG/SelectionDAG.cpp
index db40d2d31e363..405ae80671d71 100644
--- a/llvm/lib/CodeGen/SelectionDAG/SelectionDAG.cpp
+++ b/llvm/lib/CodeGen/SelectionDAG/SelectionDAG.cpp
@@ -10744,14 +10744,14 @@ SDValue SelectionDAG::getLoad(EVT VT, const SDLoc &dl, SDValue Chain,
MaybeAlign Alignment,
MachineMemOperand::Flags MMOFlags,
const AAMDNodes &AAInfo, const MDNode *Ranges) {
- SDValue Undef = getUNDEF(Ptr.getValueType());
+ SDValue Undef = getPOISON(Ptr.getValueType());
return getLoad(ISD::UNINDEXED, ISD::NON_EXTLOAD, VT, dl, Chain, Ptr, Undef,
PtrInfo, VT, Alignment, MMOFlags, AAInfo, Ranges);
}
SDValue SelectionDAG::getLoad(EVT VT, const SDLoc &dl, SDValue Chain,
SDValue Ptr, MachineMemOperand *MMO) {
- SDValue Undef = getUNDEF(Ptr.getValueType());
+ SDValue Undef = getPOISON(Ptr.getValueType());
return getLoad(ISD::UNINDEXED, ISD::NON_EXTLOAD, VT, dl, Chain, Ptr, Undef,
VT, MMO);
}
@@ -10762,7 +10762,7 @@ SDValue SelectionDAG::getExtLoad(ISD::LoadExtType ExtType, const SDLoc &dl,
MaybeAlign Alignment,
MachineMemOperand::Flags MMOFlags,
const AAMDNodes &AAInfo) {
- SDValue Undef = getUNDEF(Ptr.getValueType());
+ SDValue Undef = getPOISON(Ptr.getValueType());
return getLoad(ISD::UNINDEXED, ExtType, VT, dl, Chain, Ptr, Undef, PtrInfo,
MemVT, Alignment, MMOFlags, AAInfo);
}
@@ -10770,7 +10770,7 @@ SDValue SelectionDAG::getExtLoad(ISD::LoadExtType ExtType, const SDLoc &dl,
SDValue SelectionDAG::getExtLoad(ISD::LoadExtType ExtType, const SDLoc &dl,
EVT VT, SDValue Chain, SDValue Ptr, EVT MemVT,
MachineMemOperand *MMO) {
- SDValue Undef = getUNDEF(Ptr.getValueType());
+ SDValue Undef = getPOISON(Ptr.getValueType());
return getLoad(ISD::UNINDEXED, ExtType, VT, dl, Chain, Ptr, Undef,
MemVT, MMO);
}
@@ -10811,7 +10811,7 @@ SDValue SelectionDAG::getStore(SDValue Chain, const SDLoc &dl, SDValue Val,
SDValue SelectionDAG::getStore(SDValue Chain, const SDLoc &dl, SDValue Val,
SDValue Ptr, MachineMemOperand *MMO) {
- SDValue Undef = getUNDEF(Ptr.getValueType());
+ SDValue Undef = getPOISON(Ptr.getValueType());
return getStore(Chain, dl, Val, Ptr, Undef, Val.getValueType(), MMO,
ISD::UNINDEXED);
}
@@ -10866,8 +10866,9 @@ SDValue SelectionDAG::getStore(SDValue Chain, const SDLoc &dl, SDValue Val,
}
SDValue SelectionDAG::getTruncStore(SDValue Chain, const SDLoc &dl, SDValue Val,
- SDValue Ptr, MachinePointerInfo PtrInfo,
- EVT SVT, Align Alignment,
+ SDValue Ptr, SDValue Offset,
+ MachinePointerInfo PtrInfo, EVT SVT,
+ Align Alignment,
MachineMemOperand::Flags MMOFlags,
const AAMDNodes &AAInfo) {
assert(Chain.getValueType() == MVT::Other &&
@@ -10882,14 +10883,29 @@ SDValue SelectionDAG::getTruncStore(SDValue Chain, const SDLoc &dl, SDValue Val,
MachineFunction &MF = getMachineFunction();
MachineMemOperand *MMO = MF.getMachineMemOperand(
PtrInfo, MMOFlags, SVT.getStoreSize(), Alignment, AAInfo);
- return getTruncStore(Chain, dl, Val, Ptr, SVT, MMO);
+ return getTruncStore(Chain, dl, Val, Ptr, Offset, SVT, MMO);
+}
+
+SDValue SelectionDAG::getTruncStore(SDValue Chain, const SDLoc &dl, SDValue Val,
+ SDValue Ptr, MachinePointerInfo PtrInfo,
+ EVT SVT, Align Alignment,
+ MachineMemOperand::Flags MMOFlags,
+ const AAMDNodes &AAInfo) {
+ return getTruncStore(Chain, dl, Val, Ptr, getPOISON(Ptr.getValueType()),
+ PtrInfo, SVT, Alignment, MMOFlags, AAInfo);
+}
+
+SDValue SelectionDAG::getTruncStore(SDValue Chain, const SDLoc &dl, SDValue Val,
+ SDValue Ptr, SDValue Offset, EVT SVT,
+ MachineMemOperand *MMO) {
+ return getStore(Chain, dl, Val, Ptr, Offset, SVT, MMO, ISD::UNINDEXED, true);
}
SDValue SelectionDAG::getTruncStore(SDValue Chain, const SDLoc &dl, SDValue Val,
SDValue Ptr, EVT SVT,
MachineMemOperand *MMO) {
- SDValue Undef = getUNDEF(Ptr.getValueType());
- return getStore(Chain, dl, Val, Ptr, Undef, SVT, MMO, ISD::UNINDEXED, true);
+ return getStore(Chain, dl, Val, Ptr, getPOISON(Ptr.getValueType()), SVT, MMO,
+ ISD::UNINDEXED, true);
}
SDValue SelectionDAG::getIndexedStore(SDValue OrigStore, const SDLoc &dl,
@@ -10971,7 +10987,7 @@ SDValue SelectionDAG::getLoadVP(EVT VT, const SDLoc &dl, SDValue Chain,
MachineMemOperand::Flags MMOFlags,
const AAMDNodes &AAInfo, const MDNode *Ranges,
bool IsExpanding) {
- SDValue Undef = getUNDEF(Ptr.getValueType());
+ SDValue Undef = getPOISON(Ptr.getValueType());
return getLoadVP(ISD::UNINDEXED, ISD::NON_EXTLOAD, VT, dl, Chain, Ptr, Undef,
Mask, EVL, PtrInfo, VT, Alignment, MMOFlags, AAInfo, Ranges,
IsExpanding);
@@ -10980,7 +10996,7 @@ SDValue SelectionDAG::getLoadVP(EVT VT, const SDLoc &dl, SDValue Chain,
SDValue SelectionDAG::getLoadVP(EVT VT, const SDLoc &dl, SDValue Chain,
SDValue Ptr, SDValue Mask, SDValue EVL,
MachineMemOperand *MMO, bool IsExpanding) {
- SDValue Undef = getUNDEF(Ptr.getValueType());
+ SDValue Undef = getPOISON(Ptr.getValueType());
return getLoadVP(ISD::UNINDEXED, ISD::NON_EXTLOAD, VT, dl, Chain, Ptr, Undef,
Mask, EVL, VT, MMO, IsExpanding);
}
@@ -10992,7 +11008,7 @@ SDValue SelectionDAG::getExtLoadVP(ISD::LoadExtType ExtType, const SDLoc &dl,
MaybeAlign Alignment,
MachineMemOperand::Flags MMOFlags,
const AAMDNodes &AAInfo, bool IsExpanding) {
- SDValue Undef = getUNDEF(Ptr.getValueType());
+ SDValue Undef = getPOISON(Ptr.getValueType());
return getLoadVP(ISD::UNINDEXED, ExtType, VT, dl, Chain, Ptr, Undef, Mask,
EVL, PtrInfo, MemVT, Alignment, MMOFlags, AAInfo, nullptr,
IsExpanding);
@@ -11002,7 +11018,7 @@ SDValue SelectionDAG::getExtLoadVP(ISD::LoadExtType ExtType, const SDLoc &dl,
EVT VT, SDValue Chain, SDValue Ptr,
SDValue Mask, SDValue EVL, EVT MemVT,
MachineMemOperand *MMO, bool IsExpanding) {
- SDValue Undef = getUNDEF(Ptr.getValueType());
+ SDValue Undef = getPOISON(Ptr.getValueType());
return getLoadVP(ISD::UNINDEXED, ExtType, VT, dl, Chain, Ptr, Undef, Mask,
EVL, MemVT, MMO, IsExpanding);
}
@@ -11092,7 +11108,7 @@ SDValue SelectionDAG::getTruncStoreVP(SDValue Chain, const SDLoc &dl,
assert(Chain.getValueType() == MVT::Other && "Invalid chain type");
if (VT == SVT)
- return getStoreVP(Chain, dl, Val, Ptr, getUNDEF(Ptr.getValueType()), Mask,
+ return getStoreVP(Chain, dl, Val, Ptr, getPOISON(Ptr.getValueType()), Mask,
EVL, VT, MMO, ISD::UNINDEXED,
/*IsTruncating*/ false, IsCompressing);
@@ -11106,7 +11122,7 @@ SDValue SelectionDAG::getTruncStoreVP(SDValue Chain, const SDLoc &dl,
"Cannot use trunc store to change the number of vector elements!");
SDVTList VTs = getVTList(MVT::Other);
- SDValue Undef = getUNDEF(Ptr.getValueType());
+ SDValue Undef = getPOISON(Ptr.getValueType());
SDValue Ops[] = {Chain, Val, Ptr, Undef, Mask, EVL};
FoldingSetNodeID ID;
AddNodeIDNode(ID, ISD::VP_STORE, VTs, Ops);
@@ -11201,7 +11217,7 @@ SDValue SelectionDAG::getStridedLoadVP(EVT VT, const SDLoc &DL, SDValue Chain,
SDValue Mask, SDValue EVL,
MachineMemOperand *MMO,
bool IsExpanding) {
- SDValue Undef = getUNDEF(Ptr.getValueType());
+ SDValue Undef = getPOISON(Ptr.getValueType());
return getStridedLoadVP(ISD::UNINDEXED, ISD::NON_EXTLOAD, VT, DL, Chain, Ptr,
Undef, Stride, Mask, EVL, VT, MMO, IsExpanding);
}
@@ -11210,7 +11226,7 @@ SDValue SelectionDAG::getExtStridedLoadVP(
ISD::LoadExtType ExtType, const SDLoc &DL, EVT VT, SDValue Chain,
SDValue Ptr, SDValue Stride, SDValue Mask, SDValue EVL, EVT MemVT,
MachineMemOperand *MMO, bool IsExpanding) {
- SDValue Undef = getUNDEF(Ptr.getValueType());
+ SDValue Undef = getPOISON(Ptr.getValueType());
return getStridedLoadVP(ISD::UNINDEXED, ExtType, VT, DL, Chain, Ptr, Undef,
Stride, Mask, EVL, MemVT, MMO, IsExpanding);
}
@@ -11261,7 +11277,7 @@ SDValue SelectionDAG::getTruncStridedStoreVP(SDValue Chain, const SDLoc &DL,
assert(Chain.getValueType() == MVT::Other && "Invalid chain type");
if (VT == SVT)
- return getStridedStoreVP(Chain, DL, Val, Ptr, getUNDEF(Ptr.getValueType()),
+ return getStridedStoreVP(Chain, DL, Val, Ptr, getPOISON(Ptr.getValueType()),
Stride, Mask, EVL, VT, MMO, ISD::UNINDEXED,
/*IsTruncating*/ false, IsCompressing);
@@ -11275,7 +11291,7 @@ SDValue SelectionDAG::getTruncStridedStoreVP(SDValue Chain, const SDLoc &DL,
"Cannot use trunc store to change the number of vector elements!");
SDVTList VTs = getVTList(MVT::Other);
- SDValue Undef = getUNDEF(Ptr.getValueType());
+ SDValue Undef = getPOISON(Ptr.getValueType());
SDValue Ops[] = {Chain, Val, Ptr, Undef, Stride, Mask, EVL};
FoldingSetNodeID ID;
AddNodeIDNode(ID, ISD::EXPERIMENTAL_VP_STRIDED_STORE, VTs, Ops);
diff --git a/llvm/lib/Target/AMDGPU/R600ISelLowering.cpp b/llvm/lib/Target/AMDGPU/R600ISelLowering.cpp
index b413bd4d53cc2..642962e954ea2 100644
--- a/llvm/lib/Target/AMDGPU/R600ISelLowering.cpp
+++ b/llvm/lib/Target/AMDGPU/R600ISelLowering.cpp
@@ -1511,13 +1511,13 @@ SDValue R600TargetLowering::LowerFormalArguments(
Align Alignment = commonAlignment(Align(VT.getStoreSize()), PartOffset);
MachinePointerInfo PtrInfo(AMDGPUAS::PARAM_I_ADDRESS);
- SDValue Arg = DAG.getLoad(
- ISD::UNINDEXED, Ext, VT, DL, Chain,
- DAG.getConstant(PartOffset, DL, MVT::i32), DAG.getUNDEF(MVT::i32),
- PtrInfo,
- MemVT, Alignment, MachineMemOperand::MONonTemporal |
- MachineMemOperand::MODereferenceable |
- MachineMemOperand::MOInvariant);
+ SDValue Arg =
+ DAG.getLoad(ISD::UNINDEXED, Ext, VT, DL, Chain,
+ DAG.getConstant(PartOffset, DL, MVT::i32),
+ DAG.getPOISON(MVT::i32), PtrInfo, MemVT, Alignment,
+ MachineMemOperand::MONonTemporal |
+ MachineMemOperand::MODereferenceable |
+ MachineMemOperand::MOInvariant);
InVals.push_back(Arg);
}
diff --git a/llvm/test/CodeGen/AArch64/ragreedy-local-interval-cost.ll b/llvm/test/CodeGen/AArch64/ragreedy-local-interval-cost.ll
index b94a26fd0e80b..9f513a940015e 100644
--- a/llvm/test/CodeGen/AArch64/ragreedy-local-interval-cost.ll
+++ b/llvm/test/CodeGen/AArch64/ragreedy-local-interval-cost.ll
@@ -75,7 +75,7 @@ define dso_local void @run_test() local_unnamed_addr uwtable {
; CHECK-NEXT: ldr x16, [x9]
; CHECK-NEXT: stp q15, q4, [sp] // 32-byte Folded Spill
; CHECK-NEXT: add x5, x10, x11
-; CHECK-NEXT: mul x1, x15, x18
+; CHECK-NEXT: mul x1, x18, x15
; CHECK-NEXT: ldr x2, [x13], #64
; CHECK-NEXT: stp q6, q23, [sp, #32] // 32-byte Folded Spill
; CHECK-NEXT: ldr q23, [sp, #80] // 16-byte Reload
diff --git a/llvm/test/CodeGen/X86/merge-store-partially-alias-loads.ll b/llvm/test/CodeGen/X86/merge-store-partially-alias-loads.ll
index c1fdd71c04948..e4471c6ca9081 100644
--- a/llvm/test/CodeGen/X86/merge-store-partially-alias-loads.ll
+++ b/llvm/test/CodeGen/X86/merge-store-partially-alias-loads.ll
@@ -18,12 +18,12 @@
; DBGDAG-DAG: [[BASEPTR:t[0-9]+]]: i64,ch = CopyFromReg [[ENTRYTOKEN]],
; DBGDAG-DAG: [[ADDPTR:t[0-9]+]]: i64 = add {{(nuw )?}}[[BASEPTR]], Constant:i64<2>
-; DBGDAG-DAG: [[LD2:t[0-9]+]]: i16,ch = load<(load (s16) from %ir.tmp81, align 1)> [[ENTRYTOKEN]], [[BASEPTR]], undef:i64
-; DBGDAG-DAG: [[LD1:t[0-9]+]]: i8,ch = load<(load (s8) from %ir.tmp12)> [[ENTRYTOKEN]], [[ADDPTR]], undef:i64
+; DBGDAG-DAG: [[LD2:t[0-9]+]]: i16,ch = load<(load (s16) from %ir.tmp81, align 1)> [[ENTRYTOKEN]], [[BASEPTR]], poison:i64
+; DBGDAG-DAG: [[LD1:t[0-9]+]]: i8,ch = load<(load (s8) from %ir.tmp12)> [[ENTRYTOKEN]], [[ADDPTR]], poison:i64
-; DBGDAG-DAG: [[ST1:t[0-9]+]]: ch = store<(store (s8) into %ir.tmp14)> [[ENTRYTOKEN]], [[LD1]], t{{[0-9]+}}, undef:i64
+; DBGDAG-DAG: [[ST1:t[0-9]+]]: ch = store<(store (s8) into %ir.tmp14)> [[ENTRYTOKEN]], [[LD1]], t{{[0-9]+}}, poison:i64
; DBGDAG-DAG: [[LOADTOKEN:t[0-9]+]]: ch = TokenFactor [[LD2]]:1, [[LD1]]:1
-; DBGDAG-DAG: [[ST2:t[0-9]+]]: ch = store<(store (s16) into %ir.tmp10, align 1)> [[LOADTOKEN]], [[LD2]], t{{[0-9]+}}, undef:i64
+; DBGDAG-DAG: [[ST2:t[0-9]+]]: ch = store<(store (s16) into %ir.tmp10, align 1)> [[LOADTOKEN]], [[LD2]], t{{[0-9]+}}, poison:i64
; DBGDAG: X86ISD::RET_GLUE t{{[0-9]+}},
diff --git a/llvm/unittests/CodeGen/SelectionDAGPatternMatchTest.cpp b/llvm/unittests/CodeGen/SelectionDAGPatternMatchTest.cpp
index 1073d67ff68e6..6687308bda8cc 100644
--- a/llvm/unittests/CodeGen/SelectionDAGPatternMatchTest.cpp
+++ b/llvm/unittests/CodeGen/SelectionDAGPatternMatchTest.cpp
@@ -118,7 +118,7 @@ TEST_F(SelectionDAGPatternMatchTest, matchTernaryOp) {
SDValue Ch = DAG->getEntryNode();
SDValue BasePtr = DAG->getRegister(1, MVT::i64);
- SDValue Offset = DAG->getUNDEF(MVT::i64);
+ SDValue Offset = DAG->getPOISON(MVT::i64);
MachinePointerInfo PtrInfo;
SDValue Load = DAG->getLoad(MVT::i32, DL, Ch, BasePtr, PtrInfo);
More information about the llvm-commits
mailing list