LLVM  3.7.0
LegalizeTypesGeneric.cpp
Go to the documentation of this file.
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.
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 
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)) {
52  break;
54  llvm_unreachable("Bitcast of a promotion-needing float should never need"
55  "expansion");
57  // Convert the integer operand instead.
58  SplitInteger(GetSoftenedFloat(InOp), Lo, Hi);
59  Lo = DAG.getNode(ISD::BITCAST, dl, NOutVT, Lo);
60  Hi = DAG.getNode(ISD::BITCAST, dl, NOutVT, Hi);
61  return;
64  auto &DL = DAG.getDataLayout();
65  // Convert the expanded pieces of the input.
66  GetExpandedOp(InOp, Lo, Hi);
67  if (TLI.hasBigEndianPartOrdering(InVT, DL) !=
68  TLI.hasBigEndianPartOrdering(OutVT, DL))
69  std::swap(Lo, Hi);
70  Lo = DAG.getNode(ISD::BITCAST, dl, NOutVT, Lo);
71  Hi = DAG.getNode(ISD::BITCAST, dl, NOutVT, Hi);
72  return;
73  }
75  GetSplitVector(InOp, Lo, Hi);
76  if (TLI.hasBigEndianPartOrdering(OutVT, DAG.getDataLayout()))
77  std::swap(Lo, Hi);
78  Lo = DAG.getNode(ISD::BITCAST, dl, NOutVT, Lo);
79  Hi = DAG.getNode(ISD::BITCAST, dl, NOutVT, Hi);
80  return;
82  // Convert the element instead.
83  SplitInteger(BitConvertToInteger(GetScalarizedVector(InOp)), Lo, Hi);
84  Lo = DAG.getNode(ISD::BITCAST, dl, NOutVT, Lo);
85  Hi = DAG.getNode(ISD::BITCAST, dl, NOutVT, Hi);
86  return;
88  assert(!(InVT.getVectorNumElements() & 1) && "Unsupported BITCAST");
89  InOp = GetWidenedVector(InOp);
90  EVT LoVT, HiVT;
91  std::tie(LoVT, HiVT) = DAG.GetSplitDestVTs(InVT);
92  std::tie(Lo, Hi) = DAG.SplitVector(InOp, dl, LoVT, HiVT);
93  if (TLI.hasBigEndianPartOrdering(OutVT, DAG.getDataLayout()))
94  std::swap(Lo, Hi);
95  Lo = DAG.getNode(ISD::BITCAST, dl, NOutVT, Lo);
96  Hi = DAG.getNode(ISD::BITCAST, dl, NOutVT, Hi);
97  return;
98  }
99  }
100 
101  if (InVT.isVector() && OutVT.isInteger()) {
102  // Handle cases like i64 = BITCAST v1i64 on x86, where the operand
103  // is legal but the result is not.
104  unsigned NumElems = 2;
105  EVT ElemVT = NOutVT;
106  EVT NVT = EVT::getVectorVT(*DAG.getContext(), ElemVT, NumElems);
107 
108  // If <ElemVT * N> is not a legal type, try <ElemVT/2 * (N*2)>.
109  while (!isTypeLegal(NVT)) {
110  unsigned NewSizeInBits = ElemVT.getSizeInBits() / 2;
111  // If the element size is smaller than byte, bail.
112  if (NewSizeInBits < 8)
113  break;
114  NumElems *= 2;
115  ElemVT = EVT::getIntegerVT(*DAG.getContext(), NewSizeInBits);
116  NVT = EVT::getVectorVT(*DAG.getContext(), ElemVT, NumElems);
117  }
118 
119  if (isTypeLegal(NVT)) {
120  SDValue CastInOp = DAG.getNode(ISD::BITCAST, dl, NVT, InOp);
121 
123  for (unsigned i = 0; i < NumElems; ++i)
124  Vals.push_back(DAG.getNode(
125  ISD::EXTRACT_VECTOR_ELT, dl, ElemVT, CastInOp,
126  DAG.getConstant(i, dl, TLI.getVectorIdxTy(DAG.getDataLayout()))));
127 
128  // Build Lo, Hi pair by pairing extracted elements if needed.
129  unsigned Slot = 0;
130  for (unsigned e = Vals.size(); e - Slot > 2; Slot += 2, e += 1) {
131  // Each iteration will BUILD_PAIR two nodes and append the result until
132  // there are only two nodes left, i.e. Lo and Hi.
133  SDValue LHS = Vals[Slot];
134  SDValue RHS = Vals[Slot + 1];
135 
136  if (DAG.getDataLayout().isBigEndian())
137  std::swap(LHS, RHS);
138 
139  Vals.push_back(DAG.getNode(ISD::BUILD_PAIR, dl,
141  *DAG.getContext(),
142  LHS.getValueType().getSizeInBits() << 1),
143  LHS, RHS));
144  }
145  Lo = Vals[Slot++];
146  Hi = Vals[Slot++];
147 
148  if (DAG.getDataLayout().isBigEndian())
149  std::swap(Lo, Hi);
150 
151  return;
152  }
153  }
154 
155  // Lower the bit-convert to a store/load from the stack.
156  assert(NOutVT.isByteSized() && "Expanded type not byte sized!");
157 
158  // Create the stack frame object. Make sure it is aligned for both
159  // the source and expanded destination types.
160  unsigned Alignment = DAG.getDataLayout().getPrefTypeAlignment(
161  NOutVT.getTypeForEVT(*DAG.getContext()));
162  SDValue StackPtr = DAG.CreateStackTemporary(InVT, Alignment);
163  int SPFI = cast<FrameIndexSDNode>(StackPtr.getNode())->getIndex();
165 
166  // Emit a store to the stack slot.
167  SDValue Store = DAG.getStore(DAG.getEntryNode(), dl, InOp, StackPtr, PtrInfo,
168  false, false, 0);
169 
170  // Load the first half from the stack slot.
171  Lo = DAG.getLoad(NOutVT, dl, Store, StackPtr, PtrInfo,
172  false, false, false, 0);
173 
174  // Increment the pointer to the other half.
175  unsigned IncrementSize = NOutVT.getSizeInBits() / 8;
176  StackPtr = DAG.getNode(ISD::ADD, dl, StackPtr.getValueType(), StackPtr,
177  DAG.getConstant(IncrementSize, dl,
178  StackPtr.getValueType()));
179 
180  // Load the second half from the stack slot.
181  Hi = DAG.getLoad(NOutVT, dl, Store, StackPtr,
182  PtrInfo.getWithOffset(IncrementSize), false,
183  false, false, MinAlign(Alignment, IncrementSize));
184 
185  // Handle endianness of the load.
186  if (TLI.hasBigEndianPartOrdering(OutVT, DAG.getDataLayout()))
187  std::swap(Lo, Hi);
188 }
189 
190 void DAGTypeLegalizer::ExpandRes_BUILD_PAIR(SDNode *N, SDValue &Lo,
191  SDValue &Hi) {
192  // Return the operands.
193  Lo = N->getOperand(0);
194  Hi = N->getOperand(1);
195 }
196 
197 void DAGTypeLegalizer::ExpandRes_EXTRACT_ELEMENT(SDNode *N, SDValue &Lo,
198  SDValue &Hi) {
199  GetExpandedOp(N->getOperand(0), Lo, Hi);
200  SDValue Part = cast<ConstantSDNode>(N->getOperand(1))->getZExtValue() ?
201  Hi : Lo;
202 
203  assert(Part.getValueType() == N->getValueType(0) &&
204  "Type twice as big as expanded type not itself expanded!");
205 
206  GetPairElements(Part, Lo, Hi);
207 }
208 
209 void DAGTypeLegalizer::ExpandRes_EXTRACT_VECTOR_ELT(SDNode *N, SDValue &Lo,
210  SDValue &Hi) {
211  SDValue OldVec = N->getOperand(0);
212  unsigned OldElts = OldVec.getValueType().getVectorNumElements();
213  EVT OldEltVT = OldVec.getValueType().getVectorElementType();
214  SDLoc dl(N);
215 
216  // Convert to a vector of the expanded element type, for example
217  // <3 x i64> -> <6 x i32>.
218  EVT OldVT = N->getValueType(0);
219  EVT NewVT = TLI.getTypeToTransformTo(*DAG.getContext(), OldVT);
220 
221  if (OldVT != OldEltVT) {
222  // The result of EXTRACT_VECTOR_ELT may be larger than the element type of
223  // the input vector. If so, extend the elements of the input vector to the
224  // same bitwidth as the result before expanding.
225  assert(OldEltVT.bitsLT(OldVT) && "Result type smaller then element type!");
226  EVT NVecVT = EVT::getVectorVT(*DAG.getContext(), OldVT, OldElts);
227  OldVec = DAG.getNode(ISD::ANY_EXTEND, dl, NVecVT, N->getOperand(0));
228  }
229 
230  SDValue NewVec = DAG.getNode(ISD::BITCAST, dl,
232  NewVT, 2*OldElts),
233  OldVec);
234 
235  // Extract the elements at 2 * Idx and 2 * Idx + 1 from the new vector.
236  SDValue Idx = N->getOperand(1);
237 
238  Idx = DAG.getNode(ISD::ADD, dl, Idx.getValueType(), Idx, Idx);
239  Lo = DAG.getNode(ISD::EXTRACT_VECTOR_ELT, dl, NewVT, NewVec, Idx);
240 
241  Idx = DAG.getNode(ISD::ADD, dl, Idx.getValueType(), Idx,
242  DAG.getConstant(1, dl, Idx.getValueType()));
243  Hi = DAG.getNode(ISD::EXTRACT_VECTOR_ELT, dl, NewVT, NewVec, Idx);
244 
245  if (DAG.getDataLayout().isBigEndian())
246  std::swap(Lo, Hi);
247 }
248 
249 void DAGTypeLegalizer::ExpandRes_NormalLoad(SDNode *N, SDValue &Lo,
250  SDValue &Hi) {
251  assert(ISD::isNormalLoad(N) && "This routine only for normal loads!");
252  SDLoc dl(N);
253 
254  LoadSDNode *LD = cast<LoadSDNode>(N);
255  EVT ValueVT = LD->getValueType(0);
256  EVT NVT = TLI.getTypeToTransformTo(*DAG.getContext(), ValueVT);
257  SDValue Chain = LD->getChain();
258  SDValue Ptr = LD->getBasePtr();
259  unsigned Alignment = LD->getAlignment();
260  bool isVolatile = LD->isVolatile();
261  bool isNonTemporal = LD->isNonTemporal();
262  bool isInvariant = LD->isInvariant();
263  AAMDNodes AAInfo = LD->getAAInfo();
264 
265  assert(NVT.isByteSized() && "Expanded type not byte sized!");
266 
267  Lo = DAG.getLoad(NVT, dl, Chain, Ptr, LD->getPointerInfo(),
268  isVolatile, isNonTemporal, isInvariant, Alignment,
269  AAInfo);
270 
271  // Increment the pointer to the other half.
272  unsigned IncrementSize = NVT.getSizeInBits() / 8;
273  Ptr = DAG.getNode(ISD::ADD, dl, Ptr.getValueType(), Ptr,
274  DAG.getConstant(IncrementSize, dl, Ptr.getValueType()));
275  Hi = DAG.getLoad(NVT, dl, Chain, Ptr,
276  LD->getPointerInfo().getWithOffset(IncrementSize),
277  isVolatile, isNonTemporal, isInvariant,
278  MinAlign(Alignment, IncrementSize), AAInfo);
279 
280  // Build a factor node to remember that this load is independent of the
281  // other one.
282  Chain = DAG.getNode(ISD::TokenFactor, dl, MVT::Other, Lo.getValue(1),
283  Hi.getValue(1));
284 
285  // Handle endianness of the load.
286  if (TLI.hasBigEndianPartOrdering(ValueVT, DAG.getDataLayout()))
287  std::swap(Lo, Hi);
288 
289  // Modified the chain - switch anything that used the old chain to use
290  // the new one.
291  ReplaceValueWith(SDValue(N, 1), Chain);
292 }
293 
294 void DAGTypeLegalizer::ExpandRes_VAARG(SDNode *N, SDValue &Lo, SDValue &Hi) {
295  EVT OVT = N->getValueType(0);
296  EVT NVT = TLI.getTypeToTransformTo(*DAG.getContext(), OVT);
297  SDValue Chain = N->getOperand(0);
298  SDValue Ptr = N->getOperand(1);
299  SDLoc dl(N);
300  const unsigned Align = N->getConstantOperandVal(3);
301 
302  Lo = DAG.getVAArg(NVT, dl, Chain, Ptr, N->getOperand(2), Align);
303  Hi = DAG.getVAArg(NVT, dl, Lo.getValue(1), Ptr, N->getOperand(2), 0);
304 
305  // Handle endianness of the load.
306  if (TLI.hasBigEndianPartOrdering(OVT, DAG.getDataLayout()))
307  std::swap(Lo, Hi);
308 
309  // Modified the chain - switch anything that used the old chain to use
310  // the new one.
311  ReplaceValueWith(SDValue(N, 1), Hi.getValue(1));
312 }
313 
314 
315 //===--------------------------------------------------------------------===//
316 // Generic Operand Expansion.
317 //===--------------------------------------------------------------------===//
318 
319 void DAGTypeLegalizer::IntegerToVector(SDValue Op, unsigned NumElements,
321  EVT EltVT) {
322  assert(Op.getValueType().isInteger());
323  SDLoc DL(Op);
324  SDValue Parts[2];
325 
326  if (NumElements > 1) {
327  NumElements >>= 1;
328  SplitInteger(Op, Parts[0], Parts[1]);
329  if (DAG.getDataLayout().isBigEndian())
330  std::swap(Parts[0], Parts[1]);
331  IntegerToVector(Parts[0], NumElements, Ops, EltVT);
332  IntegerToVector(Parts[1], NumElements, Ops, EltVT);
333  } else {
334  Ops.push_back(DAG.getNode(ISD::BITCAST, DL, EltVT, Op));
335  }
336 }
337 
338 SDValue DAGTypeLegalizer::ExpandOp_BITCAST(SDNode *N) {
339  SDLoc dl(N);
340  if (N->getValueType(0).isVector()) {
341  // An illegal expanding type is being converted to a legal vector type.
342  // Make a two element vector out of the expanded parts and convert that
343  // instead, but only if the new vector type is legal (otherwise there
344  // is no point, and it might create expansion loops). For example, on
345  // x86 this turns v1i64 = BITCAST i64 into v1i64 = BITCAST v2i32.
346  //
347  // FIXME: I'm not sure why we are first trying to split the input into
348  // a 2 element vector, so I'm leaving it here to maintain the current
349  // behavior.
350  unsigned NumElts = 2;
351  EVT OVT = N->getOperand(0).getValueType();
352  EVT NVT = EVT::getVectorVT(*DAG.getContext(),
353  TLI.getTypeToTransformTo(*DAG.getContext(), OVT),
354  NumElts);
355  if (!isTypeLegal(NVT)) {
356  // If we can't find a legal type by splitting the integer in half,
357  // then we can use the node's value type.
358  NumElts = N->getValueType(0).getVectorNumElements();
359  NVT = N->getValueType(0);
360  }
361 
363  IntegerToVector(N->getOperand(0), NumElts, Ops, NVT.getVectorElementType());
364 
365  SDValue Vec = DAG.getNode(ISD::BUILD_VECTOR, dl, NVT,
366  makeArrayRef(Ops.data(), NumElts));
367  return DAG.getNode(ISD::BITCAST, dl, N->getValueType(0), Vec);
368  }
369 
370  // Otherwise, store to a temporary and load out again as the new type.
371  return CreateStackStoreLoad(N->getOperand(0), N->getValueType(0));
372 }
373 
374 SDValue DAGTypeLegalizer::ExpandOp_BUILD_VECTOR(SDNode *N) {
375  // The vector type is legal but the element type needs expansion.
376  EVT VecVT = N->getValueType(0);
377  unsigned NumElts = VecVT.getVectorNumElements();
378  EVT OldVT = N->getOperand(0).getValueType();
379  EVT NewVT = TLI.getTypeToTransformTo(*DAG.getContext(), OldVT);
380  SDLoc dl(N);
381 
382  assert(OldVT == VecVT.getVectorElementType() &&
383  "BUILD_VECTOR operand type doesn't match vector element type!");
384 
385  // Build a vector of twice the length out of the expanded elements.
386  // For example <3 x i64> -> <6 x i32>.
387  std::vector<SDValue> NewElts;
388  NewElts.reserve(NumElts*2);
389 
390  for (unsigned i = 0; i < NumElts; ++i) {
391  SDValue Lo, Hi;
392  GetExpandedOp(N->getOperand(i), Lo, Hi);
393  if (DAG.getDataLayout().isBigEndian())
394  std::swap(Lo, Hi);
395  NewElts.push_back(Lo);
396  NewElts.push_back(Hi);
397  }
398 
399  SDValue NewVec = DAG.getNode(ISD::BUILD_VECTOR, dl,
401  NewVT, NewElts.size()),
402  NewElts);
403 
404  // Convert the new vector to the old vector type.
405  return DAG.getNode(ISD::BITCAST, dl, VecVT, NewVec);
406 }
407 
408 SDValue DAGTypeLegalizer::ExpandOp_EXTRACT_ELEMENT(SDNode *N) {
409  SDValue Lo, Hi;
410  GetExpandedOp(N->getOperand(0), Lo, Hi);
411  return cast<ConstantSDNode>(N->getOperand(1))->getZExtValue() ? Hi : Lo;
412 }
413 
414 SDValue DAGTypeLegalizer::ExpandOp_INSERT_VECTOR_ELT(SDNode *N) {
415  // The vector type is legal but the element type needs expansion.
416  EVT VecVT = N->getValueType(0);
417  unsigned NumElts = VecVT.getVectorNumElements();
418  SDLoc dl(N);
419 
420  SDValue Val = N->getOperand(1);
421  EVT OldEVT = Val.getValueType();
422  EVT NewEVT = TLI.getTypeToTransformTo(*DAG.getContext(), OldEVT);
423 
424  assert(OldEVT == VecVT.getVectorElementType() &&
425  "Inserted element type doesn't match vector element type!");
426 
427  // Bitconvert to a vector of twice the length with elements of the expanded
428  // type, insert the expanded vector elements, and then convert back.
429  EVT NewVecVT = EVT::getVectorVT(*DAG.getContext(), NewEVT, NumElts*2);
430  SDValue NewVec = DAG.getNode(ISD::BITCAST, dl,
431  NewVecVT, N->getOperand(0));
432 
433  SDValue Lo, Hi;
434  GetExpandedOp(Val, Lo, Hi);
435  if (DAG.getDataLayout().isBigEndian())
436  std::swap(Lo, Hi);
437 
438  SDValue Idx = N->getOperand(2);
439  Idx = DAG.getNode(ISD::ADD, dl, Idx.getValueType(), Idx, Idx);
440  NewVec = DAG.getNode(ISD::INSERT_VECTOR_ELT, dl, NewVecVT, NewVec, Lo, Idx);
441  Idx = DAG.getNode(ISD::ADD, dl,
442  Idx.getValueType(), Idx,
443  DAG.getConstant(1, dl, Idx.getValueType()));
444  NewVec = DAG.getNode(ISD::INSERT_VECTOR_ELT, dl, NewVecVT, NewVec, Hi, Idx);
445 
446  // Convert the new vector to the old vector type.
447  return DAG.getNode(ISD::BITCAST, dl, VecVT, NewVec);
448 }
449 
450 SDValue DAGTypeLegalizer::ExpandOp_SCALAR_TO_VECTOR(SDNode *N) {
451  SDLoc dl(N);
452  EVT VT = N->getValueType(0);
453  assert(VT.getVectorElementType() == N->getOperand(0).getValueType() &&
454  "SCALAR_TO_VECTOR operand type doesn't match vector element type!");
455  unsigned NumElts = VT.getVectorNumElements();
456  SmallVector<SDValue, 16> Ops(NumElts);
457  Ops[0] = N->getOperand(0);
458  SDValue UndefVal = DAG.getUNDEF(Ops[0].getValueType());
459  for (unsigned i = 1; i < NumElts; ++i)
460  Ops[i] = UndefVal;
461  return DAG.getNode(ISD::BUILD_VECTOR, dl, VT, Ops);
462 }
463 
464 SDValue DAGTypeLegalizer::ExpandOp_NormalStore(SDNode *N, unsigned OpNo) {
465  assert(ISD::isNormalStore(N) && "This routine only for normal stores!");
466  assert(OpNo == 1 && "Can only expand the stored value so far");
467  SDLoc dl(N);
468 
469  StoreSDNode *St = cast<StoreSDNode>(N);
470  EVT ValueVT = St->getValue().getValueType();
471  EVT NVT = TLI.getTypeToTransformTo(*DAG.getContext(), ValueVT);
472  SDValue Chain = St->getChain();
473  SDValue Ptr = St->getBasePtr();
474  unsigned Alignment = St->getAlignment();
475  bool isVolatile = St->isVolatile();
476  bool isNonTemporal = St->isNonTemporal();
477  AAMDNodes AAInfo = St->getAAInfo();
478 
479  assert(NVT.isByteSized() && "Expanded type not byte sized!");
480  unsigned IncrementSize = NVT.getSizeInBits() / 8;
481 
482  SDValue Lo, Hi;
483  GetExpandedOp(St->getValue(), Lo, Hi);
484 
485  if (TLI.hasBigEndianPartOrdering(ValueVT, DAG.getDataLayout()))
486  std::swap(Lo, Hi);
487 
488  Lo = DAG.getStore(Chain, dl, Lo, Ptr, St->getPointerInfo(),
489  isVolatile, isNonTemporal, Alignment, AAInfo);
490 
491  Ptr = DAG.getNode(ISD::ADD, dl, Ptr.getValueType(), Ptr,
492  DAG.getConstant(IncrementSize, dl, Ptr.getValueType()));
493  Hi = DAG.getStore(Chain, dl, Hi, Ptr,
494  St->getPointerInfo().getWithOffset(IncrementSize),
495  isVolatile, isNonTemporal,
496  MinAlign(Alignment, IncrementSize), AAInfo);
497 
498  return DAG.getNode(ISD::TokenFactor, dl, MVT::Other, Lo, Hi);
499 }
500 
501 
502 //===--------------------------------------------------------------------===//
503 // Generic Result Splitting.
504 //===--------------------------------------------------------------------===//
505 
506 // Be careful to make no assumptions about which of Lo/Hi is stored first in
507 // memory (for vectors it is always Lo first followed by Hi in the following
508 // bytes; for integers and floats it is Lo first if and only if the machine is
509 // little-endian).
510 
511 void DAGTypeLegalizer::SplitRes_MERGE_VALUES(SDNode *N, unsigned ResNo,
512  SDValue &Lo, SDValue &Hi) {
513  SDValue Op = DisintegrateMERGE_VALUES(N, ResNo);
514  GetSplitOp(Op, Lo, Hi);
515 }
516 
517 void DAGTypeLegalizer::SplitRes_SELECT(SDNode *N, SDValue &Lo,
518  SDValue &Hi) {
519  SDValue LL, LH, RL, RH, CL, CH;
520  SDLoc dl(N);
521  GetSplitOp(N->getOperand(1), LL, LH);
522  GetSplitOp(N->getOperand(2), RL, RH);
523 
524  SDValue Cond = N->getOperand(0);
525  CL = CH = Cond;
526  if (Cond.getValueType().isVector()) {
527  // Check if there are already splitted versions of the vector available and
528  // use those instead of splitting the mask operand again.
529  if (getTypeAction(Cond.getValueType()) == TargetLowering::TypeSplitVector)
530  GetSplitVector(Cond, CL, CH);
531  else
532  std::tie(CL, CH) = DAG.SplitVector(Cond, dl);
533  }
534 
535  Lo = DAG.getNode(N->getOpcode(), dl, LL.getValueType(), CL, LL, RL);
536  Hi = DAG.getNode(N->getOpcode(), dl, LH.getValueType(), CH, LH, RH);
537 }
538 
539 void DAGTypeLegalizer::SplitRes_SELECT_CC(SDNode *N, SDValue &Lo,
540  SDValue &Hi) {
541  SDValue LL, LH, RL, RH;
542  SDLoc dl(N);
543  GetSplitOp(N->getOperand(2), LL, LH);
544  GetSplitOp(N->getOperand(3), RL, RH);
545 
546  Lo = DAG.getNode(ISD::SELECT_CC, dl, LL.getValueType(), N->getOperand(0),
547  N->getOperand(1), LL, RL, N->getOperand(4));
548  Hi = DAG.getNode(ISD::SELECT_CC, dl, LH.getValueType(), N->getOperand(0),
549  N->getOperand(1), LH, RH, N->getOperand(4));
550 }
551 
552 void DAGTypeLegalizer::SplitRes_UNDEF(SDNode *N, SDValue &Lo, SDValue &Hi) {
553  EVT LoVT, HiVT;
554  std::tie(LoVT, HiVT) = DAG.GetSplitDestVTs(N->getValueType(0));
555  Lo = DAG.getUNDEF(LoVT);
556  Hi = DAG.getUNDEF(HiVT);
557 }
BITCAST - This operator converts between integer, vector and FP values, as if the value was stored to...
Definition: ISDOpcodes.h:477
SDValue getValue(unsigned R) const
LLVMContext * getContext() const
Definition: SelectionDAG.h:289
SDValue getVAArg(EVT VT, SDLoc dl, SDValue Chain, SDValue Ptr, SDValue SV, unsigned Align)
VAArg produces a result and token chain, and takes a pointer and a source value as input...
unsigned getPrefTypeAlignment(Type *Ty) const
Returns the preferred stack/global alignment for the specified type.
Definition: DataLayout.cpp:684
std::pair< EVT, EVT > GetSplitDestVTs(const EVT &VT) const
Compute the VTs needed for the low/hi parts of a type which is split (or expanded) into two not neces...
unsigned getOpcode() const
Return the SelectionDAG opcode value for this node.
Type * getTypeForEVT(LLVMContext &Context) const
getTypeForEVT - This method returns an LLVM type corresponding to the specified EVT.
Definition: ValueTypes.cpp:181
SDValue getLoad(EVT VT, SDLoc dl, SDValue Chain, SDValue Ptr, MachinePointerInfo PtrInfo, bool isVolatile, bool isNonTemporal, bool isInvariant, unsigned Alignment, const AAMDNodes &AAInfo=AAMDNodes(), const MDNode *Ranges=nullptr)
Loads are not normal binary operators: their result type is not determined by their operands...
const SDValue & getOperand(unsigned Num) const
const SDValue & getBasePtr() const
Select with condition operator - This selects between a true value and a false value (ops #2 and #3) ...
Definition: ISDOpcodes.h:357
bool bitsLT(EVT VT) const
bitsLT - Return true if this has less bits than VT.
Definition: ValueTypes.h:189
static MachinePointerInfo getFixedStack(int FI, int64_t offset=0)
getFixedStack - Return a MachinePointerInfo record that refers to the the specified FrameIndex...
bool isVector() const
isVector - Return true if this is a vector value type.
Definition: ValueTypes.h:115
SDValue getStore(SDValue Chain, SDLoc dl, SDValue Val, SDValue Ptr, MachinePointerInfo PtrInfo, bool isVolatile, bool isNonTemporal, unsigned Alignment, const AAMDNodes &AAInfo=AAMDNodes())
Helper function to build ISD::STORE nodes.
ArrayRef< T > makeArrayRef(const T &OneElt)
Construct an ArrayRef from a single element.
Definition: ArrayRef.h:308
bool isNormalStore(const SDNode *N)
Returns true if the specified node is a non-truncating and unindexed store.
#define llvm_unreachable(msg)
Marks that the current location is not supposed to be reachable.
Definition: ErrorHandling.h:98
EVT getValueType(unsigned ResNo) const
Return the type of a specified result.
BUILD_PAIR - This is the opposite of EXTRACT_ELEMENT in some ways.
Definition: ISDOpcodes.h:181
This class consists of common code factored out of the SmallVector class to reduce code duplication b...
Definition: APInt.h:33
MachinePointerInfo getWithOffset(int64_t O) const
bool isInteger() const
isInteger - Return true if this is an integer, or a vector integer type.
Definition: ValueTypes.h:110
virtual MVT getVectorIdxTy(const DataLayout &DL) const
Returns the type to be used for the index operand of: ISD::INSERT_VECTOR_ELT, ISD::EXTRACT_VECTOR_ELT...
EVT getVectorElementType() const
getVectorElementType - Given a vector type, return the type of each element.
Definition: ValueTypes.h:216
bool hasBigEndianPartOrdering(EVT VT, const DataLayout &DL) const
When splitting a value of the specified type into parts, does the Lo or Hi part come first...
Simple integer binary arithmetic operators.
Definition: ISDOpcodes.h:191
const SDValue & getBasePtr() const
SDValue getUNDEF(EVT VT)
Return an UNDEF node. UNDEF does not have a useful SDLoc.
Definition: SelectionDAG.h:659
const DataLayout & getDataLayout() const
Definition: SelectionDAG.h:284
This class is used to represent ISD::STORE nodes.
BUILD_VECTOR(ELT0, ELT1, ELT2, ELT3,...) - Return a vector with the specified, possibly variable...
Definition: ISDOpcodes.h:262
SDNode * getNode() const
get the SDNode which holds the desired result
bool isNormalLoad(const SDNode *N)
Returns true if the specified node is a non-extending and unindexed load.
bool isNonTemporal() const
INSERT_VECTOR_ELT(VECTOR, VAL, IDX) - Returns VECTOR with the element at IDX replaced with VAL...
Definition: ISDOpcodes.h:267
bool isVolatile() const
const SDValue & getValue() const
EVT - Extended Value Type.
Definition: ValueTypes.h:31
static EVT getVectorVT(LLVMContext &Context, EVT VT, unsigned NumElements)
getVectorVT - Returns the EVT that represents a vector NumElements in length, where each element is o...
Definition: ValueTypes.h:70
MachinePointerInfo - This class contains a discriminated union of information about pointers in memor...
uint64_t getConstantOperandVal(unsigned Num) const
Helper method returns the integer value of a ConstantSDNode operand.
SDValue CreateStackTemporary(EVT VT, unsigned minAlign=1)
Create a stack temporary, suitable for holding the specified value type.
const MachinePointerInfo & getPointerInfo() const
TokenFactor - This node takes multiple tokens as input and produces a single token result...
Definition: ISDOpcodes.h:50
EXTRACT_VECTOR_ELT(VECTOR, IDX) - Returns a single element from VECTOR identified by the (potentially...
Definition: ISDOpcodes.h:273
bool isInvariant() const
std::pair< SDValue, SDValue > SplitVector(const SDValue &N, const SDLoc &DL, const EVT &LoVT, const EVT &HiVT)
Split the vector with EXTRACT_SUBVECTOR using the provides VTs and return the low/high part...
This is a 'vector' (really, a variable-sized array), optimized for the case when the array is small...
Definition: SmallVector.h:861
const SDValue & getChain() const
A collection of metadata nodes that might be associated with a memory access used by the alias-analys...
Definition: Metadata.h:548
Wrapper class for IR location info (IR ordering and DebugLoc) to be passed into SDNode creation funct...
Represents one node in the SelectionDAG.
static cl::opt< AlignMode > Align(cl::desc("Load/store alignment support"), cl::Hidden, cl::init(NoStrictAlign), cl::values(clEnumValN(StrictAlign,"aarch64-strict-align","Disallow all unaligned memory accesses"), clEnumValN(NoStrictAlign,"aarch64-no-strict-align","Allow unaligned memory accesses"), clEnumValEnd))
AAMDNodes getAAInfo() const
Returns the AA info that describes the dereference.
void swap(llvm::BitVector &LHS, llvm::BitVector &RHS)
Implement std::swap in terms of BitVector swap.
Definition: BitVector.h:576
SDValue getNode(unsigned Opcode, SDLoc DL, EVT VT, ArrayRef< SDUse > Ops)
Gets or creates the specified node.
ANY_EXTEND - Used for integer types. The high bits are undefined.
Definition: ISDOpcodes.h:386
uint64_t MinAlign(uint64_t A, uint64_t B)
MinAlign - A and B are either alignments or offsets.
Definition: MathExtras.h:552
unsigned getSizeInBits() const
getSizeInBits - Return the size of the specified value type in bits.
Definition: ValueTypes.h:233
#define N
EVT getValueType() const
Return the ValueType of the referenced return value.
SDValue getConstant(uint64_t Val, SDLoc DL, EVT VT, bool isTarget=false, bool isOpaque=false)
bool isByteSized() const
isByteSized - Return true if the bit size is a multiple of 8.
Definition: ValueTypes.h:160
EVT getTypeToTransformTo(LLVMContext &Context, EVT VT) const
For types supported by the target, this is an identity function.
static bool isVolatile(Instruction *Inst)
SDValue getEntryNode() const
Return the token chain corresponding to the entry of the function.
Definition: SelectionDAG.h:338
unsigned getAlignment() const
Unlike LLVM values, Selection DAG nodes may return multiple values as the result of a computation...
bool isBigEndian() const
Definition: DataLayout.h:218
static EVT getIntegerVT(LLVMContext &Context, unsigned BitWidth)
getIntegerVT - Returns the EVT that represents an integer with the given number of bits...
Definition: ValueTypes.h:61
unsigned getVectorNumElements() const
getVectorNumElements - Given a vector type, return the number of elements it contains.
Definition: ValueTypes.h:225
This class is used to represent ISD::LOAD nodes.