[llvm] [SelectionDAG] Pass SDVTList instead of VTs to *SDNode constructors. NFC (PR #89880)
via llvm-commits
llvm-commits at lists.llvm.org
Tue Apr 23 23:42:07 PDT 2024
llvmbot wrote:
<!--LLVM PR SUMMARY COMMENT-->
@llvm/pr-subscribers-llvm-selectiondag
Author: Craig Topper (topperc)
<details>
<summary>Changes</summary>
All of these constructors were creating a SDVTList using an EVT* created by SDNode::getValueTypeList. This EVT needs to live at least as long as the SDNode that uses it. To do this, SDNode::getValueTypeList contains several function scoped static variables that hold the memory for the EVT. So the EVT lives until global destructors run.
This is problematic since an EVT contains a Type* that points to memory allocated by an LLVMContext. If multiple LLVMContexts are used that don't have overlapping lifetimes, we can end up with stale or or incorrect pointers cached in the EVTs owned by SDNode::getValueTypeList.
I want to try to make the EVTs be owned by SelectionDAG instead. This is already done for SDVTLists with more than 1 VT. The single value case is a very old optimizaton that should be re-evaluated. In order to do this, I need the SDVTLists to be created by SelectionDAG rather than by the SDNode itself.
This patch doesn't change how the allocation is done yet. It just moves the code around.
This patch does reduce the number of calls to getVTList since we now share with the call needed for the SDNode FoldingSet.
Part of fixing #<!-- -->88233.
---
Patch is 20.66 KiB, truncated to 20.00 KiB below, full version: https://github.com/llvm/llvm-project/pull/89880.diff
2 Files Affected:
- (modified) llvm/include/llvm/CodeGen/SelectionDAGNodes.h (+38-35)
- (modified) llvm/lib/CodeGen/SelectionDAG/SelectionDAG.cpp (+52-38)
``````````diff
diff --git a/llvm/include/llvm/CodeGen/SelectionDAGNodes.h b/llvm/include/llvm/CodeGen/SelectionDAGNodes.h
index 261f7e49e5c8ca..6dd16ef0e1e958 100644
--- a/llvm/include/llvm/CodeGen/SelectionDAGNodes.h
+++ b/llvm/include/llvm/CodeGen/SelectionDAGNodes.h
@@ -1283,7 +1283,7 @@ class AddrSpaceCastSDNode : public SDNode {
unsigned DestAddrSpace;
public:
- AddrSpaceCastSDNode(unsigned Order, const DebugLoc &dl, EVT VT,
+ AddrSpaceCastSDNode(unsigned Order, const DebugLoc &dl, SDVTList VTs,
unsigned SrcAS, unsigned DestAS);
unsigned getSrcAddressSpace() const { return SrcAddrSpace; }
@@ -1573,8 +1573,9 @@ class ShuffleVectorSDNode : public SDNode {
protected:
friend class SelectionDAG;
- ShuffleVectorSDNode(EVT VT, unsigned Order, const DebugLoc &dl, const int *M)
- : SDNode(ISD::VECTOR_SHUFFLE, Order, dl, getSDVTList(VT)), Mask(M) {}
+ ShuffleVectorSDNode(SDVTList VTs, unsigned Order, const DebugLoc &dl,
+ const int *M)
+ : SDNode(ISD::VECTOR_SHUFFLE, Order, dl, VTs), Mask(M) {}
public:
ArrayRef<int> getMask() const {
@@ -1628,9 +1629,10 @@ class ConstantSDNode : public SDNode {
const ConstantInt *Value;
- ConstantSDNode(bool isTarget, bool isOpaque, const ConstantInt *val, EVT VT)
+ ConstantSDNode(bool isTarget, bool isOpaque, const ConstantInt *val,
+ SDVTList VTs)
: SDNode(isTarget ? ISD::TargetConstant : ISD::Constant, 0, DebugLoc(),
- getSDVTList(VT)),
+ VTs),
Value(val) {
ConstantSDNodeBits.IsOpaque = isOpaque;
}
@@ -1681,9 +1683,9 @@ class ConstantFPSDNode : public SDNode {
const ConstantFP *Value;
- ConstantFPSDNode(bool isTarget, const ConstantFP *val, EVT VT)
+ ConstantFPSDNode(bool isTarget, const ConstantFP *val, SDVTList VTs)
: SDNode(isTarget ? ISD::TargetConstantFP : ISD::ConstantFP, 0,
- DebugLoc(), getSDVTList(VT)),
+ DebugLoc(), VTs),
Value(val) {}
public:
@@ -1816,7 +1818,7 @@ class GlobalAddressSDNode : public SDNode {
unsigned TargetFlags;
GlobalAddressSDNode(unsigned Opc, unsigned Order, const DebugLoc &DL,
- const GlobalValue *GA, EVT VT, int64_t o,
+ const GlobalValue *GA, SDVTList VTs, int64_t o,
unsigned TF);
public:
@@ -1839,10 +1841,10 @@ class FrameIndexSDNode : public SDNode {
int FI;
- FrameIndexSDNode(int fi, EVT VT, bool isTarg)
- : SDNode(isTarg ? ISD::TargetFrameIndex : ISD::FrameIndex,
- 0, DebugLoc(), getSDVTList(VT)), FI(fi) {
- }
+ FrameIndexSDNode(int fi, SDVTList VTs, bool isTarg)
+ : SDNode(isTarg ? ISD::TargetFrameIndex : ISD::FrameIndex, 0, DebugLoc(),
+ VTs),
+ FI(fi) {}
public:
int getIndex() const { return FI; }
@@ -1917,10 +1919,10 @@ class JumpTableSDNode : public SDNode {
int JTI;
unsigned TargetFlags;
- JumpTableSDNode(int jti, EVT VT, bool isTarg, unsigned TF)
- : SDNode(isTarg ? ISD::TargetJumpTable : ISD::JumpTable,
- 0, DebugLoc(), getSDVTList(VT)), JTI(jti), TargetFlags(TF) {
- }
+ JumpTableSDNode(int jti, SDVTList VTs, bool isTarg, unsigned TF)
+ : SDNode(isTarg ? ISD::TargetJumpTable : ISD::JumpTable, 0, DebugLoc(),
+ VTs),
+ JTI(jti), TargetFlags(TF) {}
public:
int getIndex() const { return JTI; }
@@ -1943,19 +1945,19 @@ class ConstantPoolSDNode : public SDNode {
Align Alignment; // Minimum alignment requirement of CP.
unsigned TargetFlags;
- ConstantPoolSDNode(bool isTarget, const Constant *c, EVT VT, int o,
+ ConstantPoolSDNode(bool isTarget, const Constant *c, SDVTList VTs, int o,
Align Alignment, unsigned TF)
: SDNode(isTarget ? ISD::TargetConstantPool : ISD::ConstantPool, 0,
- DebugLoc(), getSDVTList(VT)),
+ DebugLoc(), VTs),
Offset(o), Alignment(Alignment), TargetFlags(TF) {
assert(Offset >= 0 && "Offset is too large");
Val.ConstVal = c;
}
- ConstantPoolSDNode(bool isTarget, MachineConstantPoolValue *v, EVT VT, int o,
- Align Alignment, unsigned TF)
+ ConstantPoolSDNode(bool isTarget, MachineConstantPoolValue *v, SDVTList VTs,
+ int o, Align Alignment, unsigned TF)
: SDNode(isTarget ? ISD::TargetConstantPool : ISD::ConstantPool, 0,
- DebugLoc(), getSDVTList(VT)),
+ DebugLoc(), VTs),
Offset(o), Alignment(Alignment), TargetFlags(TF) {
assert(Offset >= 0 && "Offset is too large");
Val.MachineCPVal = v;
@@ -2003,9 +2005,9 @@ class TargetIndexSDNode : public SDNode {
int64_t Offset;
public:
- TargetIndexSDNode(int Idx, EVT VT, int64_t Ofs, unsigned TF)
- : SDNode(ISD::TargetIndex, 0, DebugLoc(), getSDVTList(VT)),
- TargetFlags(TF), Index(Idx), Offset(Ofs) {}
+ TargetIndexSDNode(int Idx, SDVTList VTs, int64_t Ofs, unsigned TF)
+ : SDNode(ISD::TargetIndex, 0, DebugLoc(), VTs), TargetFlags(TF),
+ Index(Idx), Offset(Ofs) {}
unsigned getTargetFlags() const { return TargetFlags; }
int getIndex() const { return Index; }
@@ -2215,8 +2217,8 @@ class RegisterSDNode : public SDNode {
Register Reg;
- RegisterSDNode(Register reg, EVT VT)
- : SDNode(ISD::Register, 0, DebugLoc(), getSDVTList(VT)), Reg(reg) {}
+ RegisterSDNode(Register reg, SDVTList VTs)
+ : SDNode(ISD::Register, 0, DebugLoc(), VTs), Reg(reg) {}
public:
Register getReg() const { return Reg; }
@@ -2251,10 +2253,10 @@ class BlockAddressSDNode : public SDNode {
int64_t Offset;
unsigned TargetFlags;
- BlockAddressSDNode(unsigned NodeTy, EVT VT, const BlockAddress *ba,
+ BlockAddressSDNode(unsigned NodeTy, SDVTList VTs, const BlockAddress *ba,
int64_t o, unsigned Flags)
- : SDNode(NodeTy, 0, DebugLoc(), getSDVTList(VT)),
- BA(ba), Offset(o), TargetFlags(Flags) {}
+ : SDNode(NodeTy, 0, DebugLoc(), VTs), BA(ba), Offset(o),
+ TargetFlags(Flags) {}
public:
const BlockAddress *getBlockAddress() const { return BA; }
@@ -2292,9 +2294,10 @@ class ExternalSymbolSDNode : public SDNode {
const char *Symbol;
unsigned TargetFlags;
- ExternalSymbolSDNode(bool isTarget, const char *Sym, unsigned TF, EVT VT)
+ ExternalSymbolSDNode(bool isTarget, const char *Sym, unsigned TF,
+ SDVTList VTs)
: SDNode(isTarget ? ISD::TargetExternalSymbol : ISD::ExternalSymbol, 0,
- DebugLoc(), getSDVTList(VT)),
+ DebugLoc(), VTs),
Symbol(Sym), TargetFlags(TF) {}
public:
@@ -2312,8 +2315,8 @@ class MCSymbolSDNode : public SDNode {
MCSymbol *Symbol;
- MCSymbolSDNode(MCSymbol *Symbol, EVT VT)
- : SDNode(ISD::MCSymbol, 0, DebugLoc(), getSDVTList(VT)), Symbol(Symbol) {}
+ MCSymbolSDNode(MCSymbol *Symbol, SDVTList VTs)
+ : SDNode(ISD::MCSymbol, 0, DebugLoc(), VTs), Symbol(Symbol) {}
public:
MCSymbol *getMCSymbol() const { return Symbol; }
@@ -3026,8 +3029,8 @@ class AssertAlignSDNode : public SDNode {
Align Alignment;
public:
- AssertAlignSDNode(unsigned Order, const DebugLoc &DL, EVT VT, Align A)
- : SDNode(ISD::AssertAlign, Order, DL, getSDVTList(VT)), Alignment(A) {}
+ AssertAlignSDNode(unsigned Order, const DebugLoc &DL, SDVTList VTs, Align A)
+ : SDNode(ISD::AssertAlign, Order, DL, VTs), Alignment(A) {}
Align getAlign() const { return Alignment; }
diff --git a/llvm/lib/CodeGen/SelectionDAG/SelectionDAG.cpp b/llvm/lib/CodeGen/SelectionDAG/SelectionDAG.cpp
index b63b8b893fdbf1..7aaec9973e74c7 100644
--- a/llvm/lib/CodeGen/SelectionDAG/SelectionDAG.cpp
+++ b/llvm/lib/CodeGen/SelectionDAG/SelectionDAG.cpp
@@ -1703,8 +1703,9 @@ SDValue SelectionDAG::getConstant(const ConstantInt &Val, const SDLoc &DL,
assert(Elt->getBitWidth() == EltVT.getSizeInBits() &&
"APInt size does not match type size!");
unsigned Opc = isT ? ISD::TargetConstant : ISD::Constant;
+ SDVTList VTs = getVTList(EltVT);
FoldingSetNodeID ID;
- AddNodeIDNode(ID, Opc, getVTList(EltVT), std::nullopt);
+ AddNodeIDNode(ID, Opc, VTs, std::nullopt);
ID.AddPointer(Elt);
ID.AddBoolean(isO);
void *IP = nullptr;
@@ -1714,7 +1715,7 @@ SDValue SelectionDAG::getConstant(const ConstantInt &Val, const SDLoc &DL,
return SDValue(N, 0);
if (!N) {
- N = newSDNode<ConstantSDNode>(isT, isO, Elt, EltVT);
+ N = newSDNode<ConstantSDNode>(isT, isO, Elt, VTs);
CSEMap.InsertNode(N, IP);
InsertNode(N);
NewSDValueDbgMsg(SDValue(N, 0), "Creating constant: ", this);
@@ -1764,8 +1765,9 @@ SDValue SelectionDAG::getConstantFP(const ConstantFP &V, const SDLoc &DL,
// value, so that we don't have problems with 0.0 comparing equal to -0.0, and
// we don't have issues with SNANs.
unsigned Opc = isTarget ? ISD::TargetConstantFP : ISD::ConstantFP;
+ SDVTList VTs = getVTList(EltVT);
FoldingSetNodeID ID;
- AddNodeIDNode(ID, Opc, getVTList(EltVT), std::nullopt);
+ AddNodeIDNode(ID, Opc, VTs, std::nullopt);
ID.AddPointer(&V);
void *IP = nullptr;
SDNode *N = nullptr;
@@ -1774,7 +1776,7 @@ SDValue SelectionDAG::getConstantFP(const ConstantFP &V, const SDLoc &DL,
return SDValue(N, 0);
if (!N) {
- N = newSDNode<ConstantFPSDNode>(isTarget, &V, EltVT);
+ N = newSDNode<ConstantFPSDNode>(isTarget, &V, VTs);
CSEMap.InsertNode(N, IP);
InsertNode(N);
}
@@ -1821,8 +1823,9 @@ SDValue SelectionDAG::getGlobalAddress(const GlobalValue *GV, const SDLoc &DL,
else
Opc = isTargetGA ? ISD::TargetGlobalAddress : ISD::GlobalAddress;
+ SDVTList VTs = getVTList(VT);
FoldingSetNodeID ID;
- AddNodeIDNode(ID, Opc, getVTList(VT), std::nullopt);
+ AddNodeIDNode(ID, Opc, VTs, std::nullopt);
ID.AddPointer(GV);
ID.AddInteger(Offset);
ID.AddInteger(TargetFlags);
@@ -1830,8 +1833,9 @@ SDValue SelectionDAG::getGlobalAddress(const GlobalValue *GV, const SDLoc &DL,
if (SDNode *E = FindNodeOrInsertPos(ID, DL, IP))
return SDValue(E, 0);
- auto *N = newSDNode<GlobalAddressSDNode>(
- Opc, DL.getIROrder(), DL.getDebugLoc(), GV, VT, Offset, TargetFlags);
+ auto *N =
+ newSDNode<GlobalAddressSDNode>(Opc, DL.getIROrder(), DL.getDebugLoc(), GV,
+ VTs, Offset, TargetFlags);
CSEMap.InsertNode(N, IP);
InsertNode(N);
return SDValue(N, 0);
@@ -1839,14 +1843,15 @@ SDValue SelectionDAG::getGlobalAddress(const GlobalValue *GV, const SDLoc &DL,
SDValue SelectionDAG::getFrameIndex(int FI, EVT VT, bool isTarget) {
unsigned Opc = isTarget ? ISD::TargetFrameIndex : ISD::FrameIndex;
+ SDVTList VTs = getVTList(VT);
FoldingSetNodeID ID;
- AddNodeIDNode(ID, Opc, getVTList(VT), std::nullopt);
+ AddNodeIDNode(ID, Opc, VTs, std::nullopt);
ID.AddInteger(FI);
void *IP = nullptr;
if (SDNode *E = FindNodeOrInsertPos(ID, IP))
return SDValue(E, 0);
- auto *N = newSDNode<FrameIndexSDNode>(FI, VT, isTarget);
+ auto *N = newSDNode<FrameIndexSDNode>(FI, VTs, isTarget);
CSEMap.InsertNode(N, IP);
InsertNode(N);
return SDValue(N, 0);
@@ -1857,15 +1862,17 @@ SDValue SelectionDAG::getJumpTable(int JTI, EVT VT, bool isTarget,
assert((TargetFlags == 0 || isTarget) &&
"Cannot set target flags on target-independent jump tables");
unsigned Opc = isTarget ? ISD::TargetJumpTable : ISD::JumpTable;
+ SDVTList VTs = getVTList(VT);
FoldingSetNodeID ID;
- AddNodeIDNode(ID, Opc, getVTList(VT), std::nullopt);
+ AddNodeIDNode(ID, Opc, VTs, std::nullopt);
ID.AddInteger(JTI);
ID.AddInteger(TargetFlags);
void *IP = nullptr;
if (SDNode *E = FindNodeOrInsertPos(ID, IP))
return SDValue(E, 0);
- auto *N = newSDNode<JumpTableSDNode>(JTI, VT, isTarget, TargetFlags);
+ auto *N =
+ newSDNode<JumpTableSDNode>(JTI, VTs, isTarget, TargetFlags);
CSEMap.InsertNode(N, IP);
InsertNode(N);
return SDValue(N, 0);
@@ -1888,8 +1895,9 @@ SDValue SelectionDAG::getConstantPool(const Constant *C, EVT VT,
? getDataLayout().getABITypeAlign(C->getType())
: getDataLayout().getPrefTypeAlign(C->getType());
unsigned Opc = isTarget ? ISD::TargetConstantPool : ISD::ConstantPool;
+ SDVTList VTs = getVTList(VT);
FoldingSetNodeID ID;
- AddNodeIDNode(ID, Opc, getVTList(VT), std::nullopt);
+ AddNodeIDNode(ID, Opc, VTs, std::nullopt);
ID.AddInteger(Alignment->value());
ID.AddInteger(Offset);
ID.AddPointer(C);
@@ -1898,8 +1906,8 @@ SDValue SelectionDAG::getConstantPool(const Constant *C, EVT VT,
if (SDNode *E = FindNodeOrInsertPos(ID, IP))
return SDValue(E, 0);
- auto *N = newSDNode<ConstantPoolSDNode>(isTarget, C, VT, Offset, *Alignment,
- TargetFlags);
+ auto *N = newSDNode<ConstantPoolSDNode>(isTarget, C, VTs, Offset,
+ *Alignment, TargetFlags);
CSEMap.InsertNode(N, IP);
InsertNode(N);
SDValue V = SDValue(N, 0);
@@ -1915,8 +1923,9 @@ SDValue SelectionDAG::getConstantPool(MachineConstantPoolValue *C, EVT VT,
if (!Alignment)
Alignment = getDataLayout().getPrefTypeAlign(C->getType());
unsigned Opc = isTarget ? ISD::TargetConstantPool : ISD::ConstantPool;
+ SDVTList VTs = getVTList(VT);
FoldingSetNodeID ID;
- AddNodeIDNode(ID, Opc, getVTList(VT), std::nullopt);
+ AddNodeIDNode(ID, Opc, VTs, std::nullopt);
ID.AddInteger(Alignment->value());
ID.AddInteger(Offset);
C->addSelectionDAGCSEId(ID);
@@ -1925,8 +1934,8 @@ SDValue SelectionDAG::getConstantPool(MachineConstantPoolValue *C, EVT VT,
if (SDNode *E = FindNodeOrInsertPos(ID, IP))
return SDValue(E, 0);
- auto *N = newSDNode<ConstantPoolSDNode>(isTarget, C, VT, Offset, *Alignment,
- TargetFlags);
+ auto *N = newSDNode<ConstantPoolSDNode>(isTarget, C, VTs, Offset,
+ *Alignment, TargetFlags);
CSEMap.InsertNode(N, IP);
InsertNode(N);
return SDValue(N, 0);
@@ -1963,7 +1972,7 @@ SDValue SelectionDAG::getValueType(EVT VT) {
SDValue SelectionDAG::getExternalSymbol(const char *Sym, EVT VT) {
SDNode *&N = ExternalSymbols[Sym];
if (N) return SDValue(N, 0);
- N = newSDNode<ExternalSymbolSDNode>(false, Sym, 0, VT);
+ N = newSDNode<ExternalSymbolSDNode>(false, Sym, 0, getVTList(VT));
InsertNode(N);
return SDValue(N, 0);
}
@@ -1972,7 +1981,7 @@ SDValue SelectionDAG::getMCSymbol(MCSymbol *Sym, EVT VT) {
SDNode *&N = MCSymbols[Sym];
if (N)
return SDValue(N, 0);
- N = newSDNode<MCSymbolSDNode>(Sym, VT);
+ N = newSDNode<MCSymbolSDNode>(Sym, getVTList(VT));
InsertNode(N);
return SDValue(N, 0);
}
@@ -1982,7 +1991,7 @@ SDValue SelectionDAG::getTargetExternalSymbol(const char *Sym, EVT VT,
SDNode *&N =
TargetExternalSymbols[std::pair<std::string, unsigned>(Sym, TargetFlags)];
if (N) return SDValue(N, 0);
- N = newSDNode<ExternalSymbolSDNode>(true, Sym, TargetFlags, VT);
+ N = newSDNode<ExternalSymbolSDNode>(true, Sym, TargetFlags, getVTList(VT));
InsertNode(N);
return SDValue(N, 0);
}
@@ -2198,9 +2207,10 @@ SDValue SelectionDAG::getVectorShuffle(EVT VT, const SDLoc &dl, SDValue N1,
}
}
+ SDVTList VTs = getVTList(VT);
FoldingSetNodeID ID;
SDValue Ops[2] = { N1, N2 };
- AddNodeIDNode(ID, ISD::VECTOR_SHUFFLE, getVTList(VT), Ops);
+ AddNodeIDNode(ID, ISD::VECTOR_SHUFFLE, VTs, Ops);
for (int i = 0; i != NElts; ++i)
ID.AddInteger(MaskVec[i]);
@@ -2214,7 +2224,7 @@ SDValue SelectionDAG::getVectorShuffle(EVT VT, const SDLoc &dl, SDValue N1,
int *MaskAlloc = OperandAllocator.Allocate<int>(NElts);
llvm::copy(MaskVec, MaskAlloc);
- auto *N = newSDNode<ShuffleVectorSDNode>(VT, dl.getIROrder(),
+ auto *N = newSDNode<ShuffleVectorSDNode>(VTs, dl.getIROrder(),
dl.getDebugLoc(), MaskAlloc);
createOperands(N, Ops);
@@ -2236,14 +2246,15 @@ SDValue SelectionDAG::getCommutedVectorShuffle(const ShuffleVectorSDNode &SV) {
}
SDValue SelectionDAG::getRegister(unsigned RegNo, EVT VT) {
+ SDVTList VTs = getVTList(VT);
FoldingSetNodeID ID;
- AddNodeIDNode(ID, ISD::Register, getVTList(VT), std::nullopt);
+ AddNodeIDNode(ID, ISD::Register, VTs, std::nullopt);
ID.AddInteger(RegNo);
void *IP = nullptr;
if (SDNode *E = FindNodeOrInsertPos(ID, IP))
return SDValue(E, 0);
- auto *N = newSDNode<RegisterSDNode>(RegNo, VT);
+ auto *N = newSDNode<RegisterSDNode>(RegNo, VTs);
N->SDNodeBits.IsDivergent = TLI->isSDNodeSourceOfDivergence(N, FLI, UA);
CSEMap.InsertNode(N, IP);
InsertNode(N);
@@ -2292,9 +2303,10 @@ SDValue SelectionDAG::getBlockAddress(const BlockAddress *BA, EVT VT,
int64_t Offset, bool isTarget,
unsigned TargetFlags) {
unsigned Opc = isTarget ? ISD::TargetBlockAddress : ISD::BlockAddress;
+ SDVTList VTs = getVTList(VT);
FoldingSetNodeID ID;
- AddNodeIDNode(ID, Opc, getVTList(VT), std::nullopt);
+ AddNodeIDNode(ID, Opc, VTs, std::nullopt);
ID.AddPointer(BA);
ID.AddInteger(Offset);
ID.AddInteger(TargetFlags);
@@ -2302,7 +2314,7 @@ SDValue SelectionDAG::getBlockAddress(const BlockAddress *BA, EVT VT,
if (SDNode *E = FindNodeOrInsertPos(ID, IP))
return SDValue(E, 0);
- auto *N = newSDNode<BlockAddressSDNode>(Opc, VT, BA, Offset, TargetFlags);
+ auto *N = newSDNode<BlockAddressSDNode>(Opc, VTs, BA, Offset, TargetFlags);
CSEMap.InsertNode(N, IP);
InsertNode(N);
return SDValue(N, 0);
@@ -2347,9 +2359,10 @@ SDValue SelectionDAG::getBitcast(EVT VT, SDValue V) {
SDValue SelectionDAG::getAddrSpaceCast(const SDLoc &dl, EVT VT, SDValue Ptr,
unsigned SrcAS, unsigned DestAS) {
+ SDVTList VTs = getVTList(VT);
SDValue Ops[] = {Ptr};
FoldingSetNodeID ID;
- AddNodeIDNode(ID, ISD::ADDRSPACECAST, getVTList(VT), Ops);
+ AddNodeIDNode(ID, ISD::ADDRSPACECAST, VTs, Ops);
ID.AddInteger(SrcAS);
ID.AddInteger(DestAS);
@@ -2358,7 +2371,7 @@ SDValue SelectionDAG::getAddrSpaceCast(const SDLoc &dl, EVT VT, SDValue Ptr,
return SDValue(E, 0);
auto *N = newSDNode<AddrSpaceCastSDNode>(dl.getIROrder(), dl.getDebugLoc(),
- VT, SrcAS, DestAS);
+ VTs, SrcAS, DestAS);
createOperands(N, Ops);
CSEMap.InsertNode(N, IP);
@@ -5691,14 +5704,14 @@ static SDValue foldCONCAT_VECTORS(const SDLoc &DL, EVT VT,
/// Gets or creates the specified node.
SDValue SelectionDAG::getNode(unsigned Opcode, const SDLoc &DL, EVT VT) {
+ SDVTList VTs = getVTList(VT);
FoldingSetNodeID ID;
- AddNodeIDNode(ID, Opcode, getVTList(VT), std::nullopt);
+ AddNodeIDNode(ID, Opcode, VTs, std::nullopt);
void *IP = nullptr;
if (SDNode *E = FindNodeOrInsertPos(ID, DL, IP))
return SDValue(E, 0);
- auto *N = newSDNode<SDNode>(Opcode, DL.getIROrder(), DL.getDebugLoc(),
- getVTList(VT));
+ auto *N = newSDNode<SDNode>(Opcode, DL.getIROrder(), DL.getDebugLoc(), VTs);
CSEMap.InsertNode(N, IP);
InsertNode(N);
@@ -6645,8 +6658,9 @@ SDValue SelectionDAG::getAssertAlign(const SDLoc &DL, SDValue Val, Align A) {
if (A == Align(1))
return Val;
+ SDVTList VTs = getVTList(Val.getValueType());
FoldingSetNodeID ID;
- AddNodeIDNode(ID, ISD::AssertAlign, getVTList(Val.getValueType()), {Val});
+ AddNodeIDNode(ID, ISD::AssertAlign, VTs, {Val});
ID.AddInteger(A.value());
void *IP = nullptr;
@@ -6654,7 +6668,7 @@ SDValue SelectionDAG::getAssertAlign(const SDLoc &DL, SDValue Val, Align A) {
return SDValue(E, 0);
auto *N = newSDNode<AssertAlignSDNode>(DL.getIROrder(), DL.getDebugLoc(),
- Val.getValueType(), A);
+ VTs, A);
createOperands(N, {Val});
CSEMap.InsertNode(N, IP);
@@ -11775,17 +11789,17 @@ HandleSDNode::~HandleSDNode() {
GlobalAddressSDNode::GlobalAddressSDNode(unsigned Opc, unsigned Order,
const DebugLoc &DL,
- const GlobalValue *GA, EVT VT,
+ const GlobalValue *GA, SDVTList VTs,
int64_t o, unsigned TF)
- : SDNode(Opc, Order, DL, getSDVTList(VT)), Offset(o), TargetFlags(TF) {
+ : SDNode(Opc, Order, DL, VTs), Offset(o), Ta...
[truncated]
``````````
</details>
https://github.com/llvm/llvm-project/pull/89880
More information about the llvm-commits
mailing list