1 //===-------- LegalizeTypesGeneric.cpp - Generic type legalization --------===//
2 //
3 // The LLVM Compiler Infrastructure
4 //
5 // This file is distributed under the University of Illinois Open Source
6 // License. See LICENSE.TXT for details.
7 //
8 //===----------------------------------------------------------------------===//
9 //
10 // This file implements generic type expansion and splitting for LegalizeTypes.
11 // The routines here perform legalization when the details of the type (such as
12 // whether it is an integer or a float) do not matter.
13 // Expansion is the act of changing a computation in an illegal type to be a
14 // computation in two identical registers of a smaller type. The Lo/Hi part
15 // is required to be stored first in memory on little/big-endian machines.
16 // Splitting is the act of changing a computation in an illegal type to be a
17 // computation in two not necessarily identical registers of a smaller type.
18 // There are no requirements on how the type is represented in memory.
19 //
20 //===----------------------------------------------------------------------===//
21
22 #include "LegalizeTypes.h"
23 #include "llvm/IR/DataLayout.h"
24 using namespace llvm;
25
26 #define DEBUG_TYPE "legalize-types"
27
28 //===----------------------------------------------------------------------===//
29 // Generic Result Expansion.
30 //===----------------------------------------------------------------------===//
31
32 // These routines assume that the Lo/Hi part is stored first in memory on
33 // little/big-endian machines, followed by the Hi/Lo part. This means that
34 // they cannot be used as is on vectors, for which Lo is always stored first.
ExpandRes_MERGE_VALUES(SDNode * N,unsigned ResNo,SDValue & Lo,SDValue & Hi)35 void DAGTypeLegalizer::ExpandRes_MERGE_VALUES(SDNode *N, unsigned ResNo,
36 SDValue &Lo, SDValue &Hi) {
37 SDValue Op = DisintegrateMERGE_VALUES(N, ResNo);
38 GetExpandedOp(Op, Lo, Hi);
39 }
40
ExpandRes_BITCAST(SDNode * N,SDValue & Lo,SDValue & Hi)41 void DAGTypeLegalizer::ExpandRes_BITCAST(SDNode *N, SDValue &Lo, SDValue &Hi) {
42 EVT OutVT = N->getValueType(0);
43 EVT NOutVT = TLI.getTypeToTransformTo(*DAG.getContext(), OutVT);
44 SDValue InOp = N->getOperand(0);
45 EVT InVT = InOp.getValueType();
46 SDLoc dl(N);
47
48 // Handle some special cases efficiently.
49 switch (getTypeAction(InVT)) {
50 case TargetLowering::TypeLegal:
51 case TargetLowering::TypePromoteInteger:
52 break;
53 case TargetLowering::TypePromoteFloat:
54 llvm_unreachable("Bitcast of a promotion-needing float should never need"
55 "expansion");
56 case TargetLowering::TypeSoftenFloat: {
57 // Expand the floating point operand only if it was converted to integers.
58 // Otherwise, it is a legal type like f128 that can be saved in a register.
59 auto SoftenedOp = GetSoftenedFloat(InOp);
60 if (SoftenedOp == InOp)
61 break;
62 SplitInteger(SoftenedOp, Lo, Hi);
63 Lo = DAG.getNode(ISD::BITCAST, dl, NOutVT, Lo);
64 Hi = DAG.getNode(ISD::BITCAST, dl, NOutVT, Hi);
65 return;
66 }
67 case TargetLowering::TypeExpandInteger:
68 case TargetLowering::TypeExpandFloat: {
69 auto &DL = DAG.getDataLayout();
70 // Convert the expanded pieces of the input.
71 GetExpandedOp(InOp, Lo, Hi);
72 if (TLI.hasBigEndianPartOrdering(InVT, DL) !=
73 TLI.hasBigEndianPartOrdering(OutVT, DL))
74 std::swap(Lo, Hi);
75 Lo = DAG.getNode(ISD::BITCAST, dl, NOutVT, Lo);
76 Hi = DAG.getNode(ISD::BITCAST, dl, NOutVT, Hi);
77 return;
78 }
79 case TargetLowering::TypeSplitVector:
80 GetSplitVector(InOp, Lo, Hi);
81 if (TLI.hasBigEndianPartOrdering(OutVT, DAG.getDataLayout()))
82 std::swap(Lo, Hi);
83 Lo = DAG.getNode(ISD::BITCAST, dl, NOutVT, Lo);
84 Hi = DAG.getNode(ISD::BITCAST, dl, NOutVT, Hi);
85 return;
86 case TargetLowering::TypeScalarizeVector:
87 // Convert the element instead.
88 SplitInteger(BitConvertToInteger(GetScalarizedVector(InOp)), Lo, Hi);
89 Lo = DAG.getNode(ISD::BITCAST, dl, NOutVT, Lo);
90 Hi = DAG.getNode(ISD::BITCAST, dl, NOutVT, Hi);
91 return;
92 case TargetLowering::TypeWidenVector: {
93 assert(!(InVT.getVectorNumElements() & 1) && "Unsupported BITCAST");
94 InOp = GetWidenedVector(InOp);
95 EVT LoVT, HiVT;
96 std::tie(LoVT, HiVT) = DAG.GetSplitDestVTs(InVT);
97 std::tie(Lo, Hi) = DAG.SplitVector(InOp, dl, LoVT, HiVT);
98 if (TLI.hasBigEndianPartOrdering(OutVT, DAG.getDataLayout()))
99 std::swap(Lo, Hi);
100 Lo = DAG.getNode(ISD::BITCAST, dl, NOutVT, Lo);
101 Hi = DAG.getNode(ISD::BITCAST, dl, NOutVT, Hi);
102 return;
103 }
104 }
105
106 if (InVT.isVector() && OutVT.isInteger()) {
107 // Handle cases like i64 = BITCAST v1i64 on x86, where the operand
108 // is legal but the result is not.
109 unsigned NumElems = 2;
110 EVT ElemVT = NOutVT;
111 EVT NVT = EVT::getVectorVT(*DAG.getContext(), ElemVT, NumElems);
112
113 // If <ElemVT * N> is not a legal type, try <ElemVT/2 * (N*2)>.
114 while (!isTypeLegal(NVT)) {
115 unsigned NewSizeInBits = ElemVT.getSizeInBits() / 2;
116 // If the element size is smaller than byte, bail.
117 if (NewSizeInBits < 8)
118 break;
119 NumElems *= 2;
120 ElemVT = EVT::getIntegerVT(*DAG.getContext(), NewSizeInBits);
121 NVT = EVT::getVectorVT(*DAG.getContext(), ElemVT, NumElems);
122 }
123
124 if (isTypeLegal(NVT)) {
125 SDValue CastInOp = DAG.getNode(ISD::BITCAST, dl, NVT, InOp);
126
127 SmallVector<SDValue, 8> Vals;
128 for (unsigned i = 0; i < NumElems; ++i)
129 Vals.push_back(DAG.getNode(
130 ISD::EXTRACT_VECTOR_ELT, dl, ElemVT, CastInOp,
131 DAG.getConstant(i, dl, TLI.getVectorIdxTy(DAG.getDataLayout()))));
132
133 // Build Lo, Hi pair by pairing extracted elements if needed.
134 unsigned Slot = 0;
135 for (unsigned e = Vals.size(); e - Slot > 2; Slot += 2, e += 1) {
136 // Each iteration will BUILD_PAIR two nodes and append the result until
137 // there are only two nodes left, i.e. Lo and Hi.
138 SDValue LHS = Vals[Slot];
139 SDValue RHS = Vals[Slot + 1];
140
141 if (DAG.getDataLayout().isBigEndian())
142 std::swap(LHS, RHS);
143
144 Vals.push_back(DAG.getNode(ISD::BUILD_PAIR, dl,
145 EVT::getIntegerVT(
146 *DAG.getContext(),
147 LHS.getValueType().getSizeInBits() << 1),
148 LHS, RHS));
149 }
150 Lo = Vals[Slot++];
151 Hi = Vals[Slot++];
152
153 if (DAG.getDataLayout().isBigEndian())
154 std::swap(Lo, Hi);
155
156 return;
157 }
158 }
159
160 // Lower the bit-convert to a store/load from the stack.
161 assert(NOutVT.isByteSized() && "Expanded type not byte sized!");
162
163 // Create the stack frame object. Make sure it is aligned for both
164 // the source and expanded destination types.
165 unsigned Alignment = DAG.getDataLayout().getPrefTypeAlignment(
166 NOutVT.getTypeForEVT(*DAG.getContext()));
167 SDValue StackPtr = DAG.CreateStackTemporary(InVT, Alignment);
168 int SPFI = cast<FrameIndexSDNode>(StackPtr.getNode())->getIndex();
169 MachinePointerInfo PtrInfo =
170 MachinePointerInfo::getFixedStack(DAG.getMachineFunction(), SPFI);
171
172 // Emit a store to the stack slot.
173 SDValue Store = DAG.getStore(DAG.getEntryNode(), dl, InOp, StackPtr, PtrInfo,
174 false, false, 0);
175
176 // Load the first half from the stack slot.
177 Lo = DAG.getLoad(NOutVT, dl, Store, StackPtr, PtrInfo,
178 false, false, false, 0);
179
180 // Increment the pointer to the other half.
181 unsigned IncrementSize = NOutVT.getSizeInBits() / 8;
182 StackPtr = DAG.getNode(ISD::ADD, dl, StackPtr.getValueType(), StackPtr,
183 DAG.getConstant(IncrementSize, dl,
184 StackPtr.getValueType()));
185
186 // Load the second half from the stack slot.
187 Hi = DAG.getLoad(NOutVT, dl, Store, StackPtr,
188 PtrInfo.getWithOffset(IncrementSize), false,
189 false, false, MinAlign(Alignment, IncrementSize));
190
191 // Handle endianness of the load.
192 if (TLI.hasBigEndianPartOrdering(OutVT, DAG.getDataLayout()))
193 std::swap(Lo, Hi);
194 }
195
ExpandRes_BUILD_PAIR(SDNode * N,SDValue & Lo,SDValue & Hi)196 void DAGTypeLegalizer::ExpandRes_BUILD_PAIR(SDNode *N, SDValue &Lo,
197 SDValue &Hi) {
198 // Return the operands.
199 Lo = N->getOperand(0);
200 Hi = N->getOperand(1);
201 }
202
ExpandRes_EXTRACT_ELEMENT(SDNode * N,SDValue & Lo,SDValue & Hi)203 void DAGTypeLegalizer::ExpandRes_EXTRACT_ELEMENT(SDNode *N, SDValue &Lo,
204 SDValue &Hi) {
205 GetExpandedOp(N->getOperand(0), Lo, Hi);
206 SDValue Part = cast<ConstantSDNode>(N->getOperand(1))->getZExtValue() ?
207 Hi : Lo;
208
209 assert(Part.getValueType() == N->getValueType(0) &&
210 "Type twice as big as expanded type not itself expanded!");
211
212 GetPairElements(Part, Lo, Hi);
213 }
214
ExpandRes_EXTRACT_VECTOR_ELT(SDNode * N,SDValue & Lo,SDValue & Hi)215 void DAGTypeLegalizer::ExpandRes_EXTRACT_VECTOR_ELT(SDNode *N, SDValue &Lo,
216 SDValue &Hi) {
217 SDValue OldVec = N->getOperand(0);
218 unsigned OldElts = OldVec.getValueType().getVectorNumElements();
219 EVT OldEltVT = OldVec.getValueType().getVectorElementType();
220 SDLoc dl(N);
221
222 // Convert to a vector of the expanded element type, for example
223 // <3 x i64> -> <6 x i32>.
224 EVT OldVT = N->getValueType(0);
225 EVT NewVT = TLI.getTypeToTransformTo(*DAG.getContext(), OldVT);
226
227 if (OldVT != OldEltVT) {
228 // The result of EXTRACT_VECTOR_ELT may be larger than the element type of
229 // the input vector. If so, extend the elements of the input vector to the
230 // same bitwidth as the result before expanding.
231 assert(OldEltVT.bitsLT(OldVT) && "Result type smaller then element type!");
232 EVT NVecVT = EVT::getVectorVT(*DAG.getContext(), OldVT, OldElts);
233 OldVec = DAG.getNode(ISD::ANY_EXTEND, dl, NVecVT, N->getOperand(0));
234 }
235
236 SDValue NewVec = DAG.getNode(ISD::BITCAST, dl,
237 EVT::getVectorVT(*DAG.getContext(),
238 NewVT, 2*OldElts),
239 OldVec);
240
241 // Extract the elements at 2 * Idx and 2 * Idx + 1 from the new vector.
242 SDValue Idx = N->getOperand(1);
243
244 Idx = DAG.getNode(ISD::ADD, dl, Idx.getValueType(), Idx, Idx);
245 Lo = DAG.getNode(ISD::EXTRACT_VECTOR_ELT, dl, NewVT, NewVec, Idx);
246
247 Idx = DAG.getNode(ISD::ADD, dl, Idx.getValueType(), Idx,
248 DAG.getConstant(1, dl, Idx.getValueType()));
249 Hi = DAG.getNode(ISD::EXTRACT_VECTOR_ELT, dl, NewVT, NewVec, Idx);
250
251 if (DAG.getDataLayout().isBigEndian())
252 std::swap(Lo, Hi);
253 }
254
ExpandRes_NormalLoad(SDNode * N,SDValue & Lo,SDValue & Hi)255 void DAGTypeLegalizer::ExpandRes_NormalLoad(SDNode *N, SDValue &Lo,
256 SDValue &Hi) {
257 assert(ISD::isNormalLoad(N) && "This routine only for normal loads!");
258 SDLoc dl(N);
259
260 LoadSDNode *LD = cast<LoadSDNode>(N);
261 EVT ValueVT = LD->getValueType(0);
262 EVT NVT = TLI.getTypeToTransformTo(*DAG.getContext(), ValueVT);
263 SDValue Chain = LD->getChain();
264 SDValue Ptr = LD->getBasePtr();
265 unsigned Alignment = LD->getAlignment();
266 bool isVolatile = LD->isVolatile();
267 bool isNonTemporal = LD->isNonTemporal();
268 bool isInvariant = LD->isInvariant();
269 AAMDNodes AAInfo = LD->getAAInfo();
270
271 assert(NVT.isByteSized() && "Expanded type not byte sized!");
272
273 Lo = DAG.getLoad(NVT, dl, Chain, Ptr, LD->getPointerInfo(),
274 isVolatile, isNonTemporal, isInvariant, Alignment,
275 AAInfo);
276
277 // Increment the pointer to the other half.
278 unsigned IncrementSize = NVT.getSizeInBits() / 8;
279 Ptr = DAG.getNode(ISD::ADD, dl, Ptr.getValueType(), Ptr,
280 DAG.getConstant(IncrementSize, dl, Ptr.getValueType()));
281 Hi = DAG.getLoad(NVT, dl, Chain, Ptr,
282 LD->getPointerInfo().getWithOffset(IncrementSize),
283 isVolatile, isNonTemporal, isInvariant,
284 MinAlign(Alignment, IncrementSize), AAInfo);
285
286 // Build a factor node to remember that this load is independent of the
287 // other one.
288 Chain = DAG.getNode(ISD::TokenFactor, dl, MVT::Other, Lo.getValue(1),
289 Hi.getValue(1));
290
291 // Handle endianness of the load.
292 if (TLI.hasBigEndianPartOrdering(ValueVT, DAG.getDataLayout()))
293 std::swap(Lo, Hi);
294
295 // Modified the chain - switch anything that used the old chain to use
296 // the new one.
297 ReplaceValueWith(SDValue(N, 1), Chain);
298 }
299
ExpandRes_VAARG(SDNode * N,SDValue & Lo,SDValue & Hi)300 void DAGTypeLegalizer::ExpandRes_VAARG(SDNode *N, SDValue &Lo, SDValue &Hi) {
301 EVT OVT = N->getValueType(0);
302 EVT NVT = TLI.getTypeToTransformTo(*DAG.getContext(), OVT);
303 SDValue Chain = N->getOperand(0);
304 SDValue Ptr = N->getOperand(1);
305 SDLoc dl(N);
306 const unsigned Align = N->getConstantOperandVal(3);
307
308 Lo = DAG.getVAArg(NVT, dl, Chain, Ptr, N->getOperand(2), Align);
309 Hi = DAG.getVAArg(NVT, dl, Lo.getValue(1), Ptr, N->getOperand(2), 0);
310
311 // Handle endianness of the load.
312 if (TLI.hasBigEndianPartOrdering(OVT, DAG.getDataLayout()))
313 std::swap(Lo, Hi);
314
315 // Modified the chain - switch anything that used the old chain to use
316 // the new one.
317 ReplaceValueWith(SDValue(N, 1), Hi.getValue(1));
318 }
319
320
321 //===--------------------------------------------------------------------===//
322 // Generic Operand Expansion.
323 //===--------------------------------------------------------------------===//
324
IntegerToVector(SDValue Op,unsigned NumElements,SmallVectorImpl<SDValue> & Ops,EVT EltVT)325 void DAGTypeLegalizer::IntegerToVector(SDValue Op, unsigned NumElements,
326 SmallVectorImpl<SDValue> &Ops,
327 EVT EltVT) {
328 assert(Op.getValueType().isInteger());
329 SDLoc DL(Op);
330 SDValue Parts[2];
331
332 if (NumElements > 1) {
333 NumElements >>= 1;
334 SplitInteger(Op, Parts[0], Parts[1]);
335 if (DAG.getDataLayout().isBigEndian())
336 std::swap(Parts[0], Parts[1]);
337 IntegerToVector(Parts[0], NumElements, Ops, EltVT);
338 IntegerToVector(Parts[1], NumElements, Ops, EltVT);
339 } else {
340 Ops.push_back(DAG.getNode(ISD::BITCAST, DL, EltVT, Op));
341 }
342 }
343
ExpandOp_BITCAST(SDNode * N)344 SDValue DAGTypeLegalizer::ExpandOp_BITCAST(SDNode *N) {
345 SDLoc dl(N);
346 if (N->getValueType(0).isVector()) {
347 // An illegal expanding type is being converted to a legal vector type.
348 // Make a two element vector out of the expanded parts and convert that
349 // instead, but only if the new vector type is legal (otherwise there
350 // is no point, and it might create expansion loops). For example, on
351 // x86 this turns v1i64 = BITCAST i64 into v1i64 = BITCAST v2i32.
352 //
353 // FIXME: I'm not sure why we are first trying to split the input into
354 // a 2 element vector, so I'm leaving it here to maintain the current
355 // behavior.
356 unsigned NumElts = 2;
357 EVT OVT = N->getOperand(0).getValueType();
358 EVT NVT = EVT::getVectorVT(*DAG.getContext(),
359 TLI.getTypeToTransformTo(*DAG.getContext(), OVT),
360 NumElts);
361 if (!isTypeLegal(NVT)) {
362 // If we can't find a legal type by splitting the integer in half,
363 // then we can use the node's value type.
364 NumElts = N->getValueType(0).getVectorNumElements();
365 NVT = N->getValueType(0);
366 }
367
368 SmallVector<SDValue, 8> Ops;
369 IntegerToVector(N->getOperand(0), NumElts, Ops, NVT.getVectorElementType());
370
371 SDValue Vec = DAG.getNode(ISD::BUILD_VECTOR, dl, NVT,
372 makeArrayRef(Ops.data(), NumElts));
373 return DAG.getNode(ISD::BITCAST, dl, N->getValueType(0), Vec);
374 }
375
376 // Otherwise, store to a temporary and load out again as the new type.
377 return CreateStackStoreLoad(N->getOperand(0), N->getValueType(0));
378 }
379
ExpandOp_BUILD_VECTOR(SDNode * N)380 SDValue DAGTypeLegalizer::ExpandOp_BUILD_VECTOR(SDNode *N) {
381 // The vector type is legal but the element type needs expansion.
382 EVT VecVT = N->getValueType(0);
383 unsigned NumElts = VecVT.getVectorNumElements();
384 EVT OldVT = N->getOperand(0).getValueType();
385 EVT NewVT = TLI.getTypeToTransformTo(*DAG.getContext(), OldVT);
386 SDLoc dl(N);
387
388 assert(OldVT == VecVT.getVectorElementType() &&
389 "BUILD_VECTOR operand type doesn't match vector element type!");
390
391 // Build a vector of twice the length out of the expanded elements.
392 // For example <3 x i64> -> <6 x i32>.
393 std::vector<SDValue> NewElts;
394 NewElts.reserve(NumElts*2);
395
396 for (unsigned i = 0; i < NumElts; ++i) {
397 SDValue Lo, Hi;
398 GetExpandedOp(N->getOperand(i), Lo, Hi);
399 if (DAG.getDataLayout().isBigEndian())
400 std::swap(Lo, Hi);
401 NewElts.push_back(Lo);
402 NewElts.push_back(Hi);
403 }
404
405 SDValue NewVec = DAG.getNode(ISD::BUILD_VECTOR, dl,
406 EVT::getVectorVT(*DAG.getContext(),
407 NewVT, NewElts.size()),
408 NewElts);
409
410 // Convert the new vector to the old vector type.
411 return DAG.getNode(ISD::BITCAST, dl, VecVT, NewVec);
412 }
413
ExpandOp_EXTRACT_ELEMENT(SDNode * N)414 SDValue DAGTypeLegalizer::ExpandOp_EXTRACT_ELEMENT(SDNode *N) {
415 SDValue Lo, Hi;
416 GetExpandedOp(N->getOperand(0), Lo, Hi);
417 return cast<ConstantSDNode>(N->getOperand(1))->getZExtValue() ? Hi : Lo;
418 }
419
ExpandOp_INSERT_VECTOR_ELT(SDNode * N)420 SDValue DAGTypeLegalizer::ExpandOp_INSERT_VECTOR_ELT(SDNode *N) {
421 // The vector type is legal but the element type needs expansion.
422 EVT VecVT = N->getValueType(0);
423 unsigned NumElts = VecVT.getVectorNumElements();
424 SDLoc dl(N);
425
426 SDValue Val = N->getOperand(1);
427 EVT OldEVT = Val.getValueType();
428 EVT NewEVT = TLI.getTypeToTransformTo(*DAG.getContext(), OldEVT);
429
430 assert(OldEVT == VecVT.getVectorElementType() &&
431 "Inserted element type doesn't match vector element type!");
432
433 // Bitconvert to a vector of twice the length with elements of the expanded
434 // type, insert the expanded vector elements, and then convert back.
435 EVT NewVecVT = EVT::getVectorVT(*DAG.getContext(), NewEVT, NumElts*2);
436 SDValue NewVec = DAG.getNode(ISD::BITCAST, dl,
437 NewVecVT, N->getOperand(0));
438
439 SDValue Lo, Hi;
440 GetExpandedOp(Val, Lo, Hi);
441 if (DAG.getDataLayout().isBigEndian())
442 std::swap(Lo, Hi);
443
444 SDValue Idx = N->getOperand(2);
445 Idx = DAG.getNode(ISD::ADD, dl, Idx.getValueType(), Idx, Idx);
446 NewVec = DAG.getNode(ISD::INSERT_VECTOR_ELT, dl, NewVecVT, NewVec, Lo, Idx);
447 Idx = DAG.getNode(ISD::ADD, dl,
448 Idx.getValueType(), Idx,
449 DAG.getConstant(1, dl, Idx.getValueType()));
450 NewVec = DAG.getNode(ISD::INSERT_VECTOR_ELT, dl, NewVecVT, NewVec, Hi, Idx);
451
452 // Convert the new vector to the old vector type.
453 return DAG.getNode(ISD::BITCAST, dl, VecVT, NewVec);
454 }
455
ExpandOp_SCALAR_TO_VECTOR(SDNode * N)456 SDValue DAGTypeLegalizer::ExpandOp_SCALAR_TO_VECTOR(SDNode *N) {
457 SDLoc dl(N);
458 EVT VT = N->getValueType(0);
459 assert(VT.getVectorElementType() == N->getOperand(0).getValueType() &&
460 "SCALAR_TO_VECTOR operand type doesn't match vector element type!");
461 unsigned NumElts = VT.getVectorNumElements();
462 SmallVector<SDValue, 16> Ops(NumElts);
463 Ops[0] = N->getOperand(0);
464 SDValue UndefVal = DAG.getUNDEF(Ops[0].getValueType());
465 for (unsigned i = 1; i < NumElts; ++i)
466 Ops[i] = UndefVal;
467 return DAG.getNode(ISD::BUILD_VECTOR, dl, VT, Ops);
468 }
469
ExpandOp_NormalStore(SDNode * N,unsigned OpNo)470 SDValue DAGTypeLegalizer::ExpandOp_NormalStore(SDNode *N, unsigned OpNo) {
471 assert(ISD::isNormalStore(N) && "This routine only for normal stores!");
472 assert(OpNo == 1 && "Can only expand the stored value so far");
473 SDLoc dl(N);
474
475 StoreSDNode *St = cast<StoreSDNode>(N);
476 EVT ValueVT = St->getValue().getValueType();
477 EVT NVT = TLI.getTypeToTransformTo(*DAG.getContext(), ValueVT);
478 SDValue Chain = St->getChain();
479 SDValue Ptr = St->getBasePtr();
480 unsigned Alignment = St->getAlignment();
481 bool isVolatile = St->isVolatile();
482 bool isNonTemporal = St->isNonTemporal();
483 AAMDNodes AAInfo = St->getAAInfo();
484
485 assert(NVT.isByteSized() && "Expanded type not byte sized!");
486 unsigned IncrementSize = NVT.getSizeInBits() / 8;
487
488 SDValue Lo, Hi;
489 GetExpandedOp(St->getValue(), Lo, Hi);
490
491 if (TLI.hasBigEndianPartOrdering(ValueVT, DAG.getDataLayout()))
492 std::swap(Lo, Hi);
493
494 Lo = DAG.getStore(Chain, dl, Lo, Ptr, St->getPointerInfo(),
495 isVolatile, isNonTemporal, Alignment, AAInfo);
496
497 Ptr = DAG.getNode(ISD::ADD, dl, Ptr.getValueType(), Ptr,
498 DAG.getConstant(IncrementSize, dl, Ptr.getValueType()));
499 Hi = DAG.getStore(Chain, dl, Hi, Ptr,
500 St->getPointerInfo().getWithOffset(IncrementSize),
501 isVolatile, isNonTemporal,
502 MinAlign(Alignment, IncrementSize), AAInfo);
503
504 return DAG.getNode(ISD::TokenFactor, dl, MVT::Other, Lo, Hi);
505 }
506
507
508 //===--------------------------------------------------------------------===//
509 // Generic Result Splitting.
510 //===--------------------------------------------------------------------===//
511
512 // Be careful to make no assumptions about which of Lo/Hi is stored first in
513 // memory (for vectors it is always Lo first followed by Hi in the following
514 // bytes; for integers and floats it is Lo first if and only if the machine is
515 // little-endian).
516
SplitRes_MERGE_VALUES(SDNode * N,unsigned ResNo,SDValue & Lo,SDValue & Hi)517 void DAGTypeLegalizer::SplitRes_MERGE_VALUES(SDNode *N, unsigned ResNo,
518 SDValue &Lo, SDValue &Hi) {
519 SDValue Op = DisintegrateMERGE_VALUES(N, ResNo);
520 GetSplitOp(Op, Lo, Hi);
521 }
522
SplitRes_SELECT(SDNode * N,SDValue & Lo,SDValue & Hi)523 void DAGTypeLegalizer::SplitRes_SELECT(SDNode *N, SDValue &Lo,
524 SDValue &Hi) {
525 SDValue LL, LH, RL, RH, CL, CH;
526 SDLoc dl(N);
527 GetSplitOp(N->getOperand(1), LL, LH);
528 GetSplitOp(N->getOperand(2), RL, RH);
529
530 SDValue Cond = N->getOperand(0);
531 CL = CH = Cond;
532 if (Cond.getValueType().isVector()) {
533 // Check if there are already splitted versions of the vector available and
534 // use those instead of splitting the mask operand again.
535 if (getTypeAction(Cond.getValueType()) == TargetLowering::TypeSplitVector)
536 GetSplitVector(Cond, CL, CH);
537 else
538 std::tie(CL, CH) = DAG.SplitVector(Cond, dl);
539 }
540
541 Lo = DAG.getNode(N->getOpcode(), dl, LL.getValueType(), CL, LL, RL);
542 Hi = DAG.getNode(N->getOpcode(), dl, LH.getValueType(), CH, LH, RH);
543 }
544
SplitRes_SELECT_CC(SDNode * N,SDValue & Lo,SDValue & Hi)545 void DAGTypeLegalizer::SplitRes_SELECT_CC(SDNode *N, SDValue &Lo,
546 SDValue &Hi) {
547 SDValue LL, LH, RL, RH;
548 SDLoc dl(N);
549 GetSplitOp(N->getOperand(2), LL, LH);
550 GetSplitOp(N->getOperand(3), RL, RH);
551
552 Lo = DAG.getNode(ISD::SELECT_CC, dl, LL.getValueType(), N->getOperand(0),
553 N->getOperand(1), LL, RL, N->getOperand(4));
554 Hi = DAG.getNode(ISD::SELECT_CC, dl, LH.getValueType(), N->getOperand(0),
555 N->getOperand(1), LH, RH, N->getOperand(4));
556 }
557
SplitRes_UNDEF(SDNode * N,SDValue & Lo,SDValue & Hi)558 void DAGTypeLegalizer::SplitRes_UNDEF(SDNode *N, SDValue &Lo, SDValue &Hi) {
559 EVT LoVT, HiVT;
560 std::tie(LoVT, HiVT) = DAG.GetSplitDestVTs(N->getValueType(0));
561 Lo = DAG.getUNDEF(LoVT);
562 Hi = DAG.getUNDEF(HiVT);
563 }
564