LLVM 24.0.0git
SystemZSelectionDAGInfo.cpp
Go to the documentation of this file.
1//===-- SystemZSelectionDAGInfo.cpp - SystemZ SelectionDAG Info -----------===//
2//
3// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
4// See https://llvm.org/LICENSE.txt for license information.
5// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
6//
7//===----------------------------------------------------------------------===//
8//
9// This file implements the SystemZSelectionDAGInfo class.
10//
11//===----------------------------------------------------------------------===//
12
16
17#define GET_SDNODE_DESC
18#include "SystemZGenSDNodeInfo.inc"
19
20using namespace llvm;
21
22#define DEBUG_TYPE "systemz-selectiondag-info"
23
26
27const char *SystemZSelectionDAGInfo::getTargetNodeName(unsigned Opcode) const {
28 switch (static_cast<SystemZISD::NodeType>(Opcode)) {
30 return "SystemZISD::GET_CCMASK";
31 }
32
34}
35
36static unsigned getMemMemLenAdj(unsigned Op) {
37 return Op == SystemZISD::MEMSET_MVC ? 2 : 1;
38}
39
40static SDValue createMemMemNode(SelectionDAG &DAG, const SDLoc &DL, unsigned Op,
41 SDValue Chain, SDValue Dst, SDValue Src,
42 SDValue LenAdj, SDValue Byte) {
43 SDVTList VTs = Op == SystemZISD::CLC ? DAG.getVTList(MVT::i32, MVT::Other)
44 : DAG.getVTList(MVT::Other);
46 if (Op == SystemZISD::MEMSET_MVC)
47 Ops = { Chain, Dst, LenAdj, Byte };
48 else
49 Ops = { Chain, Dst, Src, LenAdj };
50 return DAG.getNode(Op, DL, VTs, Ops);
51}
52
53// Emit a mem-mem operation after subtracting one (or two for memset) from
54// size, which will be added back during pseudo expansion. As the Reg case
55// emitted here may be converted by DAGCombiner into having an Imm length,
56// they are both emitted the same way.
57static SDValue emitMemMemImm(SelectionDAG &DAG, const SDLoc &DL, unsigned Op,
58 SDValue Chain, SDValue Dst, SDValue Src,
59 uint64_t Size, SDValue Byte = SDValue()) {
60 unsigned Adj = getMemMemLenAdj(Op);
61 assert(Size >= Adj && "Adjusted length overflow.");
62 SDValue LenAdj = DAG.getConstant(Size - Adj, DL, Dst.getValueType());
63 return createMemMemNode(DAG, DL, Op, Chain, Dst, Src, LenAdj, Byte);
64}
65
66static SDValue emitMemMemReg(SelectionDAG &DAG, const SDLoc &DL, unsigned Op,
67 SDValue Chain, SDValue Dst, SDValue Src,
68 SDValue Size, SDValue Byte = SDValue()) {
69 int64_t Adj = getMemMemLenAdj(Op);
70 SDValue LenAdj = DAG.getNode(ISD::ADD, DL, MVT::i64,
71 DAG.getZExtOrTrunc(Size, DL, MVT::i64),
72 DAG.getSignedConstant(0 - Adj, DL, MVT::i64));
73 return createMemMemNode(DAG, DL, Op, Chain, Dst, Src, LenAdj, Byte);
74}
75
77 SelectionDAG &DAG, const SDLoc &DL, SDValue Chain, SDValue Dst, SDValue Src,
78 SDValue Size, Align DstAlign, Align SrcAlign, bool IsVolatile,
79 bool AlwaysInline, bool &IsTailCall, MachinePointerInfo DstPtrInfo,
80 MachinePointerInfo SrcPtrInfo) const {
81 IsTailCall = false;
82 if (IsVolatile)
83 return SDValue();
84
85 if (auto *CSize = dyn_cast<ConstantSDNode>(Size))
86 return emitMemMemImm(DAG, DL, SystemZISD::MVC, Chain, Dst, Src,
87 CSize->getZExtValue());
88
89 return emitMemMemReg(DAG, DL, SystemZISD::MVC, Chain, Dst, Src, Size);
90}
91
93 SelectionDAG &DAG, const SDLoc &DL, SDValue Chain, SDValue Dst, SDValue Src,
94 SDValue Size, Align DstAlign, Align SrcAlign, bool IsVolatile,
95 bool &IsTailCall, MachinePointerInfo DstPtrInfo,
96 MachinePointerInfo SrcPtrInfo) const {
97 IsTailCall = false;
98 if (IsVolatile)
99 return SDValue();
100
103
104 if (auto *CSize = dyn_cast<ConstantSDNode>(Size))
105 if (Subtarget.hasMiscellaneousExtensions3() && CSize->getZExtValue() > 0 &&
106 CSize->getZExtValue() <= 256) {
107 SDValue Size64 = DAG.getZExtOrTrunc(Size, DL, MVT::i64);
108 return DAG.getNode(SystemZISD::MEMMOVE, DL, MVT::Other,
109 {Chain, Dst, Src, Size64});
110 }
111
112 return SDValue();
113}
114
115// Handle a memset of 1, 2, 4 or 8 bytes with the operands given by
116// Chain, Dst, ByteVal and Size. These cases are expected to use
117// MVI, MVHHI, MVHI and MVGHI respectively.
118static SDValue memsetStore(SelectionDAG &DAG, const SDLoc &DL, SDValue Chain,
119 SDValue Dst, uint64_t ByteVal, uint64_t Size,
120 Align Alignment, MachinePointerInfo DstPtrInfo) {
121 uint64_t StoreVal = ByteVal;
122 for (unsigned I = 1; I < Size; ++I)
123 StoreVal |= ByteVal << (I * 8);
124 return DAG.getStore(
125 Chain, DL, DAG.getConstant(StoreVal, DL, MVT::getIntegerVT(Size * 8)),
126 Dst, DstPtrInfo, Alignment);
127}
128
130 SelectionDAG &DAG, const SDLoc &DL, SDValue Chain, SDValue Dst,
131 SDValue Byte, SDValue Size, Align Alignment, bool IsVolatile,
132 bool AlwaysInline, bool &IsTailCall, MachinePointerInfo DstPtrInfo) const {
133 IsTailCall = false;
134 EVT PtrVT = Dst.getValueType();
135
136 if (IsVolatile)
137 return SDValue();
138
139 auto *CByte = dyn_cast<ConstantSDNode>(Byte);
140 if (auto *CSize = dyn_cast<ConstantSDNode>(Size)) {
141 uint64_t Bytes = CSize->getZExtValue();
142 if (Bytes == 0)
143 return SDValue();
144 if (CByte) {
145 // Handle cases that can be done using at most two of
146 // MVI, MVHI, MVHHI and MVGHI. The latter two can only be
147 // used if ByteVal is all zeros or all ones; in other cases,
148 // we can move at most 2 halfwords.
149 uint64_t ByteVal = CByte->getZExtValue();
150 if (ByteVal == 0 || ByteVal == 255
151 ? Bytes <= 16 && llvm::popcount(Bytes) <= 2
152 : Bytes <= 4) {
153 unsigned Size1 = Bytes == 16 ? 8 : llvm::bit_floor(Bytes);
154 unsigned Size2 = Bytes - Size1;
155 SDValue Chain1 = memsetStore(DAG, DL, Chain, Dst, ByteVal, Size1,
156 Alignment, DstPtrInfo);
157 if (Size2 == 0)
158 return Chain1;
159 Dst = DAG.getNode(ISD::ADD, DL, PtrVT, Dst,
160 DAG.getConstant(Size1, DL, PtrVT));
161 DstPtrInfo = DstPtrInfo.getWithOffset(Size1);
162 SDValue Chain2 =
163 memsetStore(DAG, DL, Chain, Dst, ByteVal, Size2,
164 std::min(Alignment, Align(Size1)), DstPtrInfo);
165 return DAG.getNode(ISD::TokenFactor, DL, MVT::Other, Chain1, Chain2);
166 }
167 } else {
168 // Handle one and two bytes using STC.
169 if (Bytes <= 2) {
170 SDValue Chain1 =
171 DAG.getStore(Chain, DL, Byte, Dst, DstPtrInfo, Alignment);
172 if (Bytes == 1)
173 return Chain1;
174 SDValue Dst2 = DAG.getNode(ISD::ADD, DL, PtrVT, Dst,
175 DAG.getConstant(1, DL, PtrVT));
176 SDValue Chain2 = DAG.getStore(Chain, DL, Byte, Dst2,
177 DstPtrInfo.getWithOffset(1), Align(1));
178 return DAG.getNode(ISD::TokenFactor, DL, MVT::Other, Chain1, Chain2);
179 }
180 }
181 assert(Bytes >= 2 && "Should have dealt with 0- and 1-byte cases already");
182
183 // Handle the special case of a memset of 0, which can use XC.
184 if (CByte && CByte->getZExtValue() == 0)
185 return emitMemMemImm(DAG, DL, SystemZISD::XC, Chain, Dst, Dst, Bytes);
186
187 return emitMemMemImm(DAG, DL, SystemZISD::MEMSET_MVC, Chain, Dst, SDValue(),
188 Bytes, DAG.getAnyExtOrTrunc(Byte, DL, MVT::i32));
189 }
190
191 // Variable length
192 if (CByte && CByte->getZExtValue() == 0)
193 // Handle the special case of a variable length memset of 0 with XC.
194 return emitMemMemReg(DAG, DL, SystemZISD::XC, Chain, Dst, Dst, Size);
195
196 return emitMemMemReg(DAG, DL, SystemZISD::MEMSET_MVC, Chain, Dst, SDValue(),
197 Size, DAG.getAnyExtOrTrunc(Byte, DL, MVT::i32));
198}
199
200// Convert the current CC value into an integer that is 0 if CC == 0,
201// greater than zero if CC == 1 and less than zero if CC >= 2.
202// The sequence starts with IPM, which puts CC into bits 29 and 28
203// of an integer and clears bits 30 and 31.
204static SDValue addIPMSequence(const SDLoc &DL, SDValue CCReg,
205 SelectionDAG &DAG) {
206 SDValue IPM = DAG.getNode(SystemZISD::IPM, DL, MVT::i32, CCReg);
207 SDValue SHL = DAG.getNode(ISD::SHL, DL, MVT::i32, IPM,
208 DAG.getConstant(30 - SystemZ::IPM_CC, DL, MVT::i32));
209 SDValue SRA = DAG.getNode(ISD::SRA, DL, MVT::i32, SHL,
210 DAG.getConstant(30, DL, MVT::i32));
211 return SRA;
212}
213
215 SelectionDAG &DAG, const SDLoc &DL, SDValue Chain, SDValue Src1,
216 SDValue Src2, SDValue Size, const CallInst *CI) const {
217 SDValue CCReg;
218 // Swap operands to invert CC == 1 vs. CC == 2 cases.
219 if (auto *CSize = dyn_cast<ConstantSDNode>(Size)) {
220 uint64_t Bytes = CSize->getZExtValue();
221 assert(Bytes > 0 && "Caller should have handled 0-size case");
222 CCReg = emitMemMemImm(DAG, DL, SystemZISD::CLC, Chain, Src2, Src1, Bytes);
223 } else
224 CCReg = emitMemMemReg(DAG, DL, SystemZISD::CLC, Chain, Src2, Src1, Size);
225 Chain = CCReg.getValue(1);
226 return std::make_pair(addIPMSequence(DL, CCReg, DAG), Chain);
227}
228
230 SelectionDAG &DAG, const SDLoc &DL, SDValue Chain, SDValue Src,
231 SDValue Char, SDValue Length, MachinePointerInfo SrcPtrInfo) const {
232 // Use SRST to find the character. End is its address on success.
233 EVT PtrVT = Src.getValueType();
234 SDVTList VTs = DAG.getVTList(PtrVT, MVT::i32, MVT::Other);
235 Length = DAG.getZExtOrTrunc(Length, DL, PtrVT);
236 Char = DAG.getZExtOrTrunc(Char, DL, MVT::i32);
237 Char = DAG.getNode(ISD::AND, DL, MVT::i32, Char,
238 DAG.getConstant(255, DL, MVT::i32));
239 SDValue Limit = DAG.getNode(ISD::ADD, DL, PtrVT, Src, Length);
240 SDValue End = DAG.getNode(SystemZISD::SEARCH_STRING, DL, VTs, Chain,
241 Limit, Src, Char);
242 SDValue CCReg = End.getValue(1);
243 Chain = End.getValue(2);
244
245 // Now select between End and null, depending on whether the character
246 // was found.
247 SDValue Ops[] = {
248 End, DAG.getConstant(0, DL, PtrVT),
250 DAG.getTargetConstant(SystemZ::CCMASK_SRST_FOUND, DL, MVT::i32), CCReg};
251 End = DAG.getNode(SystemZISD::SELECT_CCMASK, DL, PtrVT, Ops);
252 return std::make_pair(End, Chain);
253}
254
256 SelectionDAG &DAG, const SDLoc &DL, SDValue Chain, SDValue Dest,
257 SDValue Src, MachinePointerInfo DestPtrInfo, MachinePointerInfo SrcPtrInfo,
258 bool isStpcpy, const CallInst *CI) const {
259 SDVTList VTs = DAG.getVTList(Dest.getValueType(), MVT::Other);
260 SDValue EndDest = DAG.getNode(SystemZISD::STPCPY, DL, VTs, Chain, Dest, Src,
261 DAG.getConstant(0, DL, MVT::i32));
262 return std::make_pair(isStpcpy ? EndDest : Dest, EndDest.getValue(1));
263}
264
266 SelectionDAG &DAG, const SDLoc &DL, SDValue Chain, SDValue Src1,
267 SDValue Src2, MachinePointerInfo Op1PtrInfo, MachinePointerInfo Op2PtrInfo,
268 const CallInst *CI) const {
269 SDVTList VTs = DAG.getVTList(Src1.getValueType(), MVT::i32, MVT::Other);
270 // Swap operands to invert CC == 1 vs. CC == 2 cases.
271 SDValue Unused = DAG.getNode(SystemZISD::STRCMP, DL, VTs, Chain, Src2, Src1,
272 DAG.getConstant(0, DL, MVT::i32));
273 SDValue CCReg = Unused.getValue(1);
274 Chain = Unused.getValue(2);
275 return std::make_pair(addIPMSequence(DL, CCReg, DAG), Chain);
276}
277
278// Search from Src for a null character, stopping once Src reaches Limit.
279// Return a pair of values, the first being the number of nonnull characters
280// and the second being the out chain.
281//
282// This can be used for strlen by setting Limit to 0.
283static std::pair<SDValue, SDValue> getBoundedStrlen(SelectionDAG &DAG,
284 const SDLoc &DL,
285 SDValue Chain, SDValue Src,
286 SDValue Limit) {
287 EVT PtrVT = Src.getValueType();
288 SDVTList VTs = DAG.getVTList(PtrVT, MVT::i32, MVT::Other);
289 SDValue End = DAG.getNode(SystemZISD::SEARCH_STRING, DL, VTs, Chain,
290 Limit, Src, DAG.getConstant(0, DL, MVT::i32));
291 Chain = End.getValue(2);
292 SDValue Len = DAG.getNode(ISD::SUB, DL, PtrVT, End, Src);
293 return std::make_pair(Len, Chain);
294}
295
297 SelectionDAG &DAG, const SDLoc &DL, SDValue Chain, SDValue Src,
298 const CallInst *CI) const {
299 EVT PtrVT = Src.getValueType();
300 return getBoundedStrlen(DAG, DL, Chain, Src, DAG.getConstant(0, DL, PtrVT));
301}
302
304 SelectionDAG &DAG, const SDLoc &DL, SDValue Chain, SDValue Src,
305 SDValue MaxLength, MachinePointerInfo SrcPtrInfo) const {
306 EVT PtrVT = Src.getValueType();
307 MaxLength = DAG.getZExtOrTrunc(MaxLength, DL, PtrVT);
308 SDValue Limit = DAG.getNode(ISD::ADD, DL, PtrVT, Src, MaxLength);
309 return getBoundedStrlen(DAG, DL, Chain, Src, Limit);
310}
return SDValue()
const AArch64Subtarget & Subtarget
assert(UImm &&(UImm !=~static_cast< T >(0)) &&"Invalid immediate!")
uint64_t uint64_t
MachineBasicBlock MachineBasicBlock::iterator DebugLoc DL
const AbstractManglingParser< Derived, Alloc >::OperatorInfo AbstractManglingParser< Derived, Alloc >::Ops[]
#define I(x, y, z)
Definition MD5.cpp:57
static SDValue emitMemMemReg(SelectionDAG &DAG, const SDLoc &DL, unsigned Op, SDValue Chain, SDValue Dst, SDValue Src, SDValue Size, SDValue Byte=SDValue())
static std::pair< SDValue, SDValue > getBoundedStrlen(SelectionDAG &DAG, const SDLoc &DL, SDValue Chain, SDValue Src, SDValue Limit)
static unsigned getMemMemLenAdj(unsigned Op)
static SDValue addIPMSequence(const SDLoc &DL, SDValue CCReg, SelectionDAG &DAG)
static SDValue memsetStore(SelectionDAG &DAG, const SDLoc &DL, SDValue Chain, SDValue Dst, uint64_t ByteVal, uint64_t Size, Align Alignment, MachinePointerInfo DstPtrInfo)
static SDValue createMemMemNode(SelectionDAG &DAG, const SDLoc &DL, unsigned Op, SDValue Chain, SDValue Dst, SDValue Src, SDValue LenAdj, SDValue Byte)
static SDValue emitMemMemImm(SelectionDAG &DAG, const SDLoc &DL, unsigned Op, SDValue Chain, SDValue Dst, SDValue Src, uint64_t Size, SDValue Byte=SDValue())
This class represents a function call, abstracting a target machine's calling convention.
static MVT getIntegerVT(unsigned BitWidth)
const TargetSubtargetInfo & getSubtarget() const
getSubtarget - Return the subtarget for which this machine code is being compiled.
Wrapper class for IR location info (IR ordering and DebugLoc) to be passed into SDNode creation funct...
Unlike LLVM values, Selection DAG nodes may return multiple values as the result of a computation.
SDValue getValue(unsigned R) const
EVT getValueType() const
Return the ValueType of the referenced return value.
const char * getTargetNodeName(unsigned Opcode) const override
Returns the name of the given target-specific opcode, suitable for debug printing.
SelectionDAGGenTargetInfo(const SDNodeInfo &GenNodeInfo)
This is used to represent a portion of an LLVM function in a low-level Data Dependence DAG representa...
LLVM_ABI SDVTList getVTList(EVT VT)
Return an SDVTList that represents the list of values specified.
LLVM_ABI SDValue getStore(SDValue Chain, const SDLoc &dl, SDValue Val, SDValue Ptr, MachinePointerInfo PtrInfo, Align Alignment, MachineMemOperand::Flags MMOFlags=MachineMemOperand::MONone, const MMOMetadata &Metadata=MMOMetadata())
Helper function to build ISD::STORE nodes.
LLVM_ABI SDValue getConstant(uint64_t Val, const SDLoc &DL, EVT VT, bool isTarget=false, bool isOpaque=false)
Create a ConstantSDNode wrapping a constant value.
LLVM_ABI SDValue getSignedConstant(int64_t Val, const SDLoc &DL, EVT VT, bool isTarget=false, bool isOpaque=false)
LLVM_ABI SDValue getAnyExtOrTrunc(SDValue Op, const SDLoc &DL, EVT VT)
Convert Op, which must be of integer type, to the integer type VT, by either any-extending or truncat...
LLVM_ABI SDValue getNode(unsigned Opcode, const SDLoc &DL, EVT VT, ArrayRef< SDUse > Ops)
Gets or creates the specified node.
SDValue getTargetConstant(uint64_t Val, const SDLoc &DL, EVT VT, bool isOpaque=false)
MachineFunction & getMachineFunction() const
LLVM_ABI SDValue getZExtOrTrunc(SDValue Op, const SDLoc &DL, EVT VT)
Convert Op, which must be of integer type, to the integer type VT, by either zero-extending or trunca...
This is a 'vector' (really, a variable-sized array), optimized for the case when the array is small.
const char * getTargetNodeName(unsigned Opcode) const override
Returns the name of the given target-specific opcode, suitable for debug printing.
std::pair< SDValue, SDValue > EmitTargetCodeForMemchr(SelectionDAG &DAG, const SDLoc &DL, SDValue Chain, SDValue Src, SDValue Char, SDValue Length, MachinePointerInfo SrcPtrInfo) const override
Emit target-specific code that performs a memchr, in cases where that is faster than a libcall.
std::pair< SDValue, SDValue > EmitTargetCodeForMemcmp(SelectionDAG &DAG, const SDLoc &DL, SDValue Chain, SDValue Src1, SDValue Src2, SDValue Size, const CallInst *CI) const override
Emit target-specific code that performs a memcmp/bcmp, in cases where that is faster than a libcall.
SDValue EmitTargetCodeForMemcpy(SelectionDAG &DAG, const SDLoc &DL, SDValue Chain, SDValue Dst, SDValue Src, SDValue Size, Align DstAlign, Align SrcAlign, bool IsVolatile, bool AlwaysInline, bool &IsTailCall, MachinePointerInfo DstPtrInfo, MachinePointerInfo SrcPtrInfo) const override
Emit target-specific code that performs a memcpy.
std::pair< SDValue, SDValue > EmitTargetCodeForStrnlen(SelectionDAG &DAG, const SDLoc &DL, SDValue Chain, SDValue Src, SDValue MaxLength, MachinePointerInfo SrcPtrInfo) const override
std::pair< SDValue, SDValue > EmitTargetCodeForStrlen(SelectionDAG &DAG, const SDLoc &DL, SDValue Chain, SDValue Src, const CallInst *CI) const override
std::pair< SDValue, SDValue > EmitTargetCodeForStrcpy(SelectionDAG &DAG, const SDLoc &DL, SDValue Chain, SDValue Dest, SDValue Src, MachinePointerInfo DestPtrInfo, MachinePointerInfo SrcPtrInfo, bool isStpcpy, const CallInst *CI) const override
Emit target-specific code that performs a strcpy or stpcpy, in cases where that is faster than a libc...
std::pair< SDValue, SDValue > EmitTargetCodeForStrcmp(SelectionDAG &DAG, const SDLoc &DL, SDValue Chain, SDValue Src1, SDValue Src2, MachinePointerInfo Op1PtrInfo, MachinePointerInfo Op2PtrInfo, const CallInst *CI) const override
Emit target-specific code that performs a strcmp, in cases where that is faster than a libcall.
SDValue EmitTargetCodeForMemmove(SelectionDAG &DAG, const SDLoc &DL, SDValue Chain, SDValue Dst, SDValue Src, SDValue Size, Align DstAlign, Align SrcAlign, bool IsVolatile, bool &IsTailCall, MachinePointerInfo DstPtrInfo, MachinePointerInfo SrcPtrInfo) const override
Emit target-specific code that performs a memmove.
SDValue EmitTargetCodeForMemset(SelectionDAG &DAG, const SDLoc &DL, SDValue Chain, SDValue Dst, SDValue Byte, SDValue Size, Align Alignment, bool IsVolatile, bool AlwaysInline, bool &IsTailCall, MachinePointerInfo DstPtrInfo) const override
Emit target-specific code that performs a memset.
@ ADD
Simple integer binary arithmetic operators.
Definition ISDOpcodes.h:266
@ SHL
Shift and rotation operations.
Definition ISDOpcodes.h:793
@ AND
Bitwise operators - logical and, logical or, logical xor.
Definition ISDOpcodes.h:763
@ TokenFactor
TokenFactor - This node takes multiple tokens as input and produces a single token result.
Definition ISDOpcodes.h:55
const unsigned CCMASK_SRST
Definition SystemZ.h:80
const unsigned CCMASK_SRST_FOUND
Definition SystemZ.h:78
const unsigned IPM_CC
Definition SystemZ.h:118
This is an optimization pass for GlobalISel generic memory operations.
@ Length
Definition DWP.cpp:577
decltype(auto) dyn_cast(const From &Val)
dyn_cast<X> - Return the argument parameter cast to the specified type.
Definition Casting.h:643
constexpr int popcount(T Value) noexcept
Count the number of set bits in a value.
Definition bit.h:156
DWARFExpression::Operation Op
T bit_floor(T Value)
Returns the largest integral power of two no greater than Value if Value is nonzero.
Definition bit.h:347
@ End
Run the machine verifier once, at the end of the pipeline.
Definition CodeGen.h:320
This struct is a compact representation of a valid (non-zero power of two) alignment.
Definition Alignment.h:39
Extended Value Type.
Definition ValueTypes.h:35
This class contains a discriminated union of information about pointers in memory operands,...
MachinePointerInfo getWithOffset(int64_t O) const
This represents a list of ValueType's that has been intern'd by a SelectionDAG.