LLVM  3.7.0
LegalizeTypes.h
Go to the documentation of this file.
1 //===-- LegalizeTypes.h - DAG Type Legalizer class definition ---*- C++ -*-===//
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 defines the DAGTypeLegalizer class. This is a private interface
11 // shared between the code that implements the SelectionDAG::LegalizeTypes
12 // method.
13 //
14 //===----------------------------------------------------------------------===//
15 
16 #ifndef LLVM_LIB_CODEGEN_SELECTIONDAG_LEGALIZETYPES_H
17 #define LLVM_LIB_CODEGEN_SELECTIONDAG_LEGALIZETYPES_H
18 
19 #include "llvm/ADT/DenseMap.h"
20 #include "llvm/ADT/DenseSet.h"
22 #include "llvm/Support/Compiler.h"
23 #include "llvm/Support/Debug.h"
25 
26 namespace llvm {
27 
28 //===----------------------------------------------------------------------===//
29 /// DAGTypeLegalizer - This takes an arbitrary SelectionDAG as input and hacks
30 /// on it until only value types the target machine can handle are left. This
31 /// involves promoting small sizes to large sizes or splitting up large values
32 /// into small values.
33 ///
35  const TargetLowering &TLI;
36  SelectionDAG &DAG;
37 public:
38  // NodeIdFlags - This pass uses the NodeId on the SDNodes to hold information
39  // about the state of the node. The enum has all the values.
40  enum NodeIdFlags {
41  /// ReadyToProcess - All operands have been processed, so this node is ready
42  /// to be handled.
43  ReadyToProcess = 0,
44 
45  /// NewNode - This is a new node, not before seen, that was created in the
46  /// process of legalizing some other node.
47  NewNode = -1,
48 
49  /// Unanalyzed - This node's ID needs to be set to the number of its
50  /// unprocessed operands.
51  Unanalyzed = -2,
52 
53  /// Processed - This is a node that has already been processed.
54  Processed = -3
55 
56  // 1+ - This is a node which has this many unprocessed operands.
57  };
58 private:
59 
60  /// ValueTypeActions - This is a bitvector that contains two bits for each
61  /// simple value type, where the two bits correspond to the LegalizeAction
62  /// enum from TargetLowering. This can be queried with "getTypeAction(VT)".
63  TargetLowering::ValueTypeActionImpl ValueTypeActions;
64 
65  /// getTypeAction - Return how we should legalize values of this type.
66  TargetLowering::LegalizeTypeAction getTypeAction(EVT VT) const {
67  return TLI.getTypeAction(*DAG.getContext(), VT);
68  }
69 
70  /// isTypeLegal - Return true if this type is legal on this target.
71  bool isTypeLegal(EVT VT) const {
72  return TLI.getTypeAction(*DAG.getContext(), VT) == TargetLowering::TypeLegal;
73  }
74 
75  EVT getSetCCResultType(EVT VT) const {
76  return TLI.getSetCCResultType(DAG.getDataLayout(), *DAG.getContext(), VT);
77  }
78 
79  /// IgnoreNodeResults - Pretend all of this node's results are legal.
80  bool IgnoreNodeResults(SDNode *N) const {
81  return N->getOpcode() == ISD::TargetConstant;
82  }
83 
84  /// PromotedIntegers - For integer nodes that are below legal width, this map
85  /// indicates what promoted value to use.
86  SmallDenseMap<SDValue, SDValue, 8> PromotedIntegers;
87 
88  /// ExpandedIntegers - For integer nodes that need to be expanded this map
89  /// indicates which operands are the expanded version of the input.
90  SmallDenseMap<SDValue, std::pair<SDValue, SDValue>, 8> ExpandedIntegers;
91 
92  /// SoftenedFloats - For floating point nodes converted to integers of
93  /// the same size, this map indicates the converted value to use.
94  SmallDenseMap<SDValue, SDValue, 8> SoftenedFloats;
95 
96  /// PromotedFloats - For floating point nodes that have a smaller precision
97  /// than the smallest supported precision, this map indicates what promoted
98  /// value to use.
99  SmallDenseMap<SDValue, SDValue, 8> PromotedFloats;
100 
101  /// ExpandedFloats - For float nodes that need to be expanded this map
102  /// indicates which operands are the expanded version of the input.
103  SmallDenseMap<SDValue, std::pair<SDValue, SDValue>, 8> ExpandedFloats;
104 
105  /// ScalarizedVectors - For nodes that are <1 x ty>, this map indicates the
106  /// scalar value of type 'ty' to use.
107  SmallDenseMap<SDValue, SDValue, 8> ScalarizedVectors;
108 
109  /// SplitVectors - For nodes that need to be split this map indicates
110  /// which operands are the expanded version of the input.
111  SmallDenseMap<SDValue, std::pair<SDValue, SDValue>, 8> SplitVectors;
112 
113  /// WidenedVectors - For vector nodes that need to be widened, indicates
114  /// the widened value to use.
115  SmallDenseMap<SDValue, SDValue, 8> WidenedVectors;
116 
117  /// ReplacedValues - For values that have been replaced with another,
118  /// indicates the replacement value to use.
119  SmallDenseMap<SDValue, SDValue, 8> ReplacedValues;
120 
121  /// Worklist - This defines a worklist of nodes to process. In order to be
122  /// pushed onto this worklist, all operands of a node must have already been
123  /// processed.
124  SmallVector<SDNode*, 128> Worklist;
125 
126 public:
128  : TLI(dag.getTargetLoweringInfo()), DAG(dag),
129  ValueTypeActions(TLI.getValueTypeActions()) {
131  "Too many value types for ValueTypeActions to hold!");
132  }
133 
134  /// run - This is the main entry point for the type legalizer. This does a
135  /// top-down traversal of the dag, legalizing types as it goes. Returns
136  /// "true" if it made any changes.
137  bool run();
138 
139  void NoteDeletion(SDNode *Old, SDNode *New) {
140  ExpungeNode(Old);
141  ExpungeNode(New);
142  for (unsigned i = 0, e = Old->getNumValues(); i != e; ++i)
143  ReplacedValues[SDValue(Old, i)] = SDValue(New, i);
144  }
145 
146  SelectionDAG &getDAG() const { return DAG; }
147 
148 private:
149  SDNode *AnalyzeNewNode(SDNode *N);
150  void AnalyzeNewValue(SDValue &Val);
151  void ExpungeNode(SDNode *N);
152  void PerformExpensiveChecks();
153  void RemapValue(SDValue &N);
154 
155  // Common routines.
156  SDValue BitConvertToInteger(SDValue Op);
157  SDValue BitConvertVectorToIntegerVector(SDValue Op);
158  SDValue CreateStackStoreLoad(SDValue Op, EVT DestVT);
159  bool CustomLowerNode(SDNode *N, EVT VT, bool LegalizeResult);
160  bool CustomWidenLowerNode(SDNode *N, EVT VT);
161 
162  /// DisintegrateMERGE_VALUES - Replace each result of the given MERGE_VALUES
163  /// node with the corresponding input operand, except for the result 'ResNo',
164  /// for which the corresponding input operand is returned.
165  SDValue DisintegrateMERGE_VALUES(SDNode *N, unsigned ResNo);
166 
167  SDValue GetVectorElementPointer(SDValue VecPtr, EVT EltVT, SDValue Index);
168  SDValue JoinIntegers(SDValue Lo, SDValue Hi);
169  SDValue LibCallify(RTLIB::Libcall LC, SDNode *N, bool isSigned);
170 
171  std::pair<SDValue, SDValue> ExpandChainLibCall(RTLIB::Libcall LC,
172  SDNode *Node, bool isSigned);
173  std::pair<SDValue, SDValue> ExpandAtomic(SDNode *Node);
174 
175  SDValue PromoteTargetBoolean(SDValue Bool, EVT ValVT);
176  void ReplaceValueWith(SDValue From, SDValue To);
177  void SplitInteger(SDValue Op, SDValue &Lo, SDValue &Hi);
178  void SplitInteger(SDValue Op, EVT LoVT, EVT HiVT,
179  SDValue &Lo, SDValue &Hi);
180 
181  //===--------------------------------------------------------------------===//
182  // Integer Promotion Support: LegalizeIntegerTypes.cpp
183  //===--------------------------------------------------------------------===//
184 
185  /// GetPromotedInteger - Given a processed operand Op which was promoted to a
186  /// larger integer type, this returns the promoted value. The low bits of the
187  /// promoted value corresponding to the original type are exactly equal to Op.
188  /// The extra bits contain rubbish, so the promoted value may need to be zero-
189  /// or sign-extended from the original type before it is usable (the helpers
190  /// SExtPromotedInteger and ZExtPromotedInteger can do this for you).
191  /// For example, if Op is an i16 and was promoted to an i32, then this method
192  /// returns an i32, the lower 16 bits of which coincide with Op, and the upper
193  /// 16 bits of which contain rubbish.
194  SDValue GetPromotedInteger(SDValue Op) {
195  SDValue &PromotedOp = PromotedIntegers[Op];
196  RemapValue(PromotedOp);
197  assert(PromotedOp.getNode() && "Operand wasn't promoted?");
198  return PromotedOp;
199  }
200  void SetPromotedInteger(SDValue Op, SDValue Result);
201 
202  /// SExtPromotedInteger - Get a promoted operand and sign extend it to the
203  /// final size.
204  SDValue SExtPromotedInteger(SDValue Op) {
205  EVT OldVT = Op.getValueType();
206  SDLoc dl(Op);
207  Op = GetPromotedInteger(Op);
208  return DAG.getNode(ISD::SIGN_EXTEND_INREG, dl, Op.getValueType(), Op,
209  DAG.getValueType(OldVT));
210  }
211 
212  /// ZExtPromotedInteger - Get a promoted operand and zero extend it to the
213  /// final size.
214  SDValue ZExtPromotedInteger(SDValue Op) {
215  EVT OldVT = Op.getValueType();
216  SDLoc dl(Op);
217  Op = GetPromotedInteger(Op);
218  return DAG.getZeroExtendInReg(Op, dl, OldVT.getScalarType());
219  }
220 
221  // Integer Result Promotion.
222  void PromoteIntegerResult(SDNode *N, unsigned ResNo);
223  SDValue PromoteIntRes_MERGE_VALUES(SDNode *N, unsigned ResNo);
224  SDValue PromoteIntRes_AssertSext(SDNode *N);
225  SDValue PromoteIntRes_AssertZext(SDNode *N);
226  SDValue PromoteIntRes_Atomic0(AtomicSDNode *N);
227  SDValue PromoteIntRes_Atomic1(AtomicSDNode *N);
228  SDValue PromoteIntRes_AtomicCmpSwap(AtomicSDNode *N, unsigned ResNo);
229  SDValue PromoteIntRes_EXTRACT_SUBVECTOR(SDNode *N);
230  SDValue PromoteIntRes_VECTOR_SHUFFLE(SDNode *N);
231  SDValue PromoteIntRes_BUILD_VECTOR(SDNode *N);
232  SDValue PromoteIntRes_SCALAR_TO_VECTOR(SDNode *N);
233  SDValue PromoteIntRes_INSERT_VECTOR_ELT(SDNode *N);
234  SDValue PromoteIntRes_CONCAT_VECTORS(SDNode *N);
235  SDValue PromoteIntRes_BITCAST(SDNode *N);
236  SDValue PromoteIntRes_BSWAP(SDNode *N);
237  SDValue PromoteIntRes_BUILD_PAIR(SDNode *N);
238  SDValue PromoteIntRes_Constant(SDNode *N);
239  SDValue PromoteIntRes_CONVERT_RNDSAT(SDNode *N);
240  SDValue PromoteIntRes_CTLZ(SDNode *N);
241  SDValue PromoteIntRes_CTPOP(SDNode *N);
242  SDValue PromoteIntRes_CTTZ(SDNode *N);
243  SDValue PromoteIntRes_EXTRACT_VECTOR_ELT(SDNode *N);
244  SDValue PromoteIntRes_FP_TO_XINT(SDNode *N);
245  SDValue PromoteIntRes_FP_TO_FP16(SDNode *N);
246  SDValue PromoteIntRes_INT_EXTEND(SDNode *N);
247  SDValue PromoteIntRes_LOAD(LoadSDNode *N);
248  SDValue PromoteIntRes_MLOAD(MaskedLoadSDNode *N);
249  SDValue PromoteIntRes_Overflow(SDNode *N);
250  SDValue PromoteIntRes_SADDSUBO(SDNode *N, unsigned ResNo);
251  SDValue PromoteIntRes_SDIV(SDNode *N);
252  SDValue PromoteIntRes_SELECT(SDNode *N);
253  SDValue PromoteIntRes_VSELECT(SDNode *N);
254  SDValue PromoteIntRes_SELECT_CC(SDNode *N);
255  SDValue PromoteIntRes_SETCC(SDNode *N);
256  SDValue PromoteIntRes_SHL(SDNode *N);
257  SDValue PromoteIntRes_SimpleIntBinOp(SDNode *N);
258  SDValue PromoteIntRes_SIGN_EXTEND_INREG(SDNode *N);
259  SDValue PromoteIntRes_SRA(SDNode *N);
260  SDValue PromoteIntRes_SRL(SDNode *N);
261  SDValue PromoteIntRes_TRUNCATE(SDNode *N);
262  SDValue PromoteIntRes_UADDSUBO(SDNode *N, unsigned ResNo);
263  SDValue PromoteIntRes_UDIV(SDNode *N);
264  SDValue PromoteIntRes_UNDEF(SDNode *N);
265  SDValue PromoteIntRes_VAARG(SDNode *N);
266  SDValue PromoteIntRes_XMULO(SDNode *N, unsigned ResNo);
267 
268  // Integer Operand Promotion.
269  bool PromoteIntegerOperand(SDNode *N, unsigned OperandNo);
270  SDValue PromoteIntOp_ANY_EXTEND(SDNode *N);
271  SDValue PromoteIntOp_ATOMIC_STORE(AtomicSDNode *N);
272  SDValue PromoteIntOp_BITCAST(SDNode *N);
273  SDValue PromoteIntOp_BUILD_PAIR(SDNode *N);
274  SDValue PromoteIntOp_BR_CC(SDNode *N, unsigned OpNo);
275  SDValue PromoteIntOp_BRCOND(SDNode *N, unsigned OpNo);
276  SDValue PromoteIntOp_BUILD_VECTOR(SDNode *N);
277  SDValue PromoteIntOp_CONVERT_RNDSAT(SDNode *N);
278  SDValue PromoteIntOp_INSERT_VECTOR_ELT(SDNode *N, unsigned OpNo);
279  SDValue PromoteIntOp_EXTRACT_ELEMENT(SDNode *N);
280  SDValue PromoteIntOp_EXTRACT_VECTOR_ELT(SDNode *N);
281  SDValue PromoteIntOp_EXTRACT_SUBVECTOR(SDNode *N);
282  SDValue PromoteIntOp_CONCAT_VECTORS(SDNode *N);
283  SDValue PromoteIntOp_SCALAR_TO_VECTOR(SDNode *N);
284  SDValue PromoteIntOp_SELECT(SDNode *N, unsigned OpNo);
285  SDValue PromoteIntOp_SELECT_CC(SDNode *N, unsigned OpNo);
286  SDValue PromoteIntOp_SETCC(SDNode *N, unsigned OpNo);
287  SDValue PromoteIntOp_VSETCC(SDNode *N, unsigned OpNo);
288  SDValue PromoteIntOp_Shift(SDNode *N);
289  SDValue PromoteIntOp_SIGN_EXTEND(SDNode *N);
290  SDValue PromoteIntOp_SINT_TO_FP(SDNode *N);
291  SDValue PromoteIntOp_STORE(StoreSDNode *N, unsigned OpNo);
292  SDValue PromoteIntOp_TRUNCATE(SDNode *N);
293  SDValue PromoteIntOp_UINT_TO_FP(SDNode *N);
294  SDValue PromoteIntOp_ZERO_EXTEND(SDNode *N);
295  SDValue PromoteIntOp_MSTORE(MaskedStoreSDNode *N, unsigned OpNo);
296  SDValue PromoteIntOp_MLOAD(MaskedLoadSDNode *N, unsigned OpNo);
297 
298  void PromoteSetCCOperands(SDValue &LHS,SDValue &RHS, ISD::CondCode Code);
299 
300  //===--------------------------------------------------------------------===//
301  // Integer Expansion Support: LegalizeIntegerTypes.cpp
302  //===--------------------------------------------------------------------===//
303 
304  /// GetExpandedInteger - Given a processed operand Op which was expanded into
305  /// two integers of half the size, this returns the two halves. The low bits
306  /// of Op are exactly equal to the bits of Lo; the high bits exactly equal Hi.
307  /// For example, if Op is an i64 which was expanded into two i32's, then this
308  /// method returns the two i32's, with Lo being equal to the lower 32 bits of
309  /// Op, and Hi being equal to the upper 32 bits.
310  void GetExpandedInteger(SDValue Op, SDValue &Lo, SDValue &Hi);
311  void SetExpandedInteger(SDValue Op, SDValue Lo, SDValue Hi);
312 
313  // Integer Result Expansion.
314  void ExpandIntegerResult(SDNode *N, unsigned ResNo);
315  void ExpandIntRes_MERGE_VALUES (SDNode *N, unsigned ResNo,
316  SDValue &Lo, SDValue &Hi);
317  void ExpandIntRes_ANY_EXTEND (SDNode *N, SDValue &Lo, SDValue &Hi);
318  void ExpandIntRes_AssertSext (SDNode *N, SDValue &Lo, SDValue &Hi);
319  void ExpandIntRes_AssertZext (SDNode *N, SDValue &Lo, SDValue &Hi);
320  void ExpandIntRes_Constant (SDNode *N, SDValue &Lo, SDValue &Hi);
321  void ExpandIntRes_CTLZ (SDNode *N, SDValue &Lo, SDValue &Hi);
322  void ExpandIntRes_CTPOP (SDNode *N, SDValue &Lo, SDValue &Hi);
323  void ExpandIntRes_CTTZ (SDNode *N, SDValue &Lo, SDValue &Hi);
324  void ExpandIntRes_LOAD (LoadSDNode *N, SDValue &Lo, SDValue &Hi);
325  void ExpandIntRes_SIGN_EXTEND (SDNode *N, SDValue &Lo, SDValue &Hi);
326  void ExpandIntRes_SIGN_EXTEND_INREG (SDNode *N, SDValue &Lo, SDValue &Hi);
327  void ExpandIntRes_TRUNCATE (SDNode *N, SDValue &Lo, SDValue &Hi);
328  void ExpandIntRes_ZERO_EXTEND (SDNode *N, SDValue &Lo, SDValue &Hi);
329  void ExpandIntRes_FP_TO_SINT (SDNode *N, SDValue &Lo, SDValue &Hi);
330  void ExpandIntRes_FP_TO_UINT (SDNode *N, SDValue &Lo, SDValue &Hi);
331 
332  void ExpandIntRes_Logical (SDNode *N, SDValue &Lo, SDValue &Hi);
333  void ExpandIntRes_ADDSUB (SDNode *N, SDValue &Lo, SDValue &Hi);
334  void ExpandIntRes_ADDSUBC (SDNode *N, SDValue &Lo, SDValue &Hi);
335  void ExpandIntRes_ADDSUBE (SDNode *N, SDValue &Lo, SDValue &Hi);
336  void ExpandIntRes_BSWAP (SDNode *N, SDValue &Lo, SDValue &Hi);
337  void ExpandIntRes_MUL (SDNode *N, SDValue &Lo, SDValue &Hi);
338  void ExpandIntRes_SDIV (SDNode *N, SDValue &Lo, SDValue &Hi);
339  void ExpandIntRes_SREM (SDNode *N, SDValue &Lo, SDValue &Hi);
340  void ExpandIntRes_UDIV (SDNode *N, SDValue &Lo, SDValue &Hi);
341  void ExpandIntRes_UREM (SDNode *N, SDValue &Lo, SDValue &Hi);
342  void ExpandIntRes_Shift (SDNode *N, SDValue &Lo, SDValue &Hi);
343 
344  void ExpandIntRes_SADDSUBO (SDNode *N, SDValue &Lo, SDValue &Hi);
345  void ExpandIntRes_UADDSUBO (SDNode *N, SDValue &Lo, SDValue &Hi);
346  void ExpandIntRes_XMULO (SDNode *N, SDValue &Lo, SDValue &Hi);
347 
348  void ExpandIntRes_ATOMIC_LOAD (SDNode *N, SDValue &Lo, SDValue &Hi);
349 
350  void ExpandShiftByConstant(SDNode *N, const APInt &Amt,
351  SDValue &Lo, SDValue &Hi);
352  bool ExpandShiftWithKnownAmountBit(SDNode *N, SDValue &Lo, SDValue &Hi);
353  bool ExpandShiftWithUnknownAmountBit(SDNode *N, SDValue &Lo, SDValue &Hi);
354 
355  // Integer Operand Expansion.
356  bool ExpandIntegerOperand(SDNode *N, unsigned OperandNo);
357  SDValue ExpandIntOp_BITCAST(SDNode *N);
358  SDValue ExpandIntOp_BR_CC(SDNode *N);
359  SDValue ExpandIntOp_BUILD_VECTOR(SDNode *N);
360  SDValue ExpandIntOp_EXTRACT_ELEMENT(SDNode *N);
361  SDValue ExpandIntOp_SELECT_CC(SDNode *N);
362  SDValue ExpandIntOp_SETCC(SDNode *N);
363  SDValue ExpandIntOp_Shift(SDNode *N);
364  SDValue ExpandIntOp_SINT_TO_FP(SDNode *N);
365  SDValue ExpandIntOp_STORE(StoreSDNode *N, unsigned OpNo);
366  SDValue ExpandIntOp_TRUNCATE(SDNode *N);
367  SDValue ExpandIntOp_UINT_TO_FP(SDNode *N);
368  SDValue ExpandIntOp_RETURNADDR(SDNode *N);
369  SDValue ExpandIntOp_ATOMIC_STORE(SDNode *N);
370 
371  void IntegerExpandSetCCOperands(SDValue &NewLHS, SDValue &NewRHS,
372  ISD::CondCode &CCCode, SDLoc dl);
373 
374  //===--------------------------------------------------------------------===//
375  // Float to Integer Conversion Support: LegalizeFloatTypes.cpp
376  //===--------------------------------------------------------------------===//
377 
378  /// GetSoftenedFloat - Given a processed operand Op which was converted to an
379  /// integer of the same size, this returns the integer. The integer contains
380  /// exactly the same bits as Op - only the type changed. For example, if Op
381  /// is an f32 which was softened to an i32, then this method returns an i32,
382  /// the bits of which coincide with those of Op.
383  SDValue GetSoftenedFloat(SDValue Op) {
384  SDValue &SoftenedOp = SoftenedFloats[Op];
385  RemapValue(SoftenedOp);
386  assert(SoftenedOp.getNode() && "Operand wasn't converted to integer?");
387  return SoftenedOp;
388  }
389  void SetSoftenedFloat(SDValue Op, SDValue Result);
390 
391  // Result Float to Integer Conversion.
392  void SoftenFloatResult(SDNode *N, unsigned OpNo);
393  SDValue SoftenFloatRes_MERGE_VALUES(SDNode *N, unsigned ResNo);
394  SDValue SoftenFloatRes_BITCAST(SDNode *N);
395  SDValue SoftenFloatRes_BUILD_PAIR(SDNode *N);
396  SDValue SoftenFloatRes_ConstantFP(ConstantFPSDNode *N);
397  SDValue SoftenFloatRes_EXTRACT_VECTOR_ELT(SDNode *N);
398  SDValue SoftenFloatRes_FABS(SDNode *N);
399  SDValue SoftenFloatRes_FMINNUM(SDNode *N);
400  SDValue SoftenFloatRes_FMAXNUM(SDNode *N);
401  SDValue SoftenFloatRes_FADD(SDNode *N);
402  SDValue SoftenFloatRes_FCEIL(SDNode *N);
403  SDValue SoftenFloatRes_FCOPYSIGN(SDNode *N);
404  SDValue SoftenFloatRes_FCOS(SDNode *N);
405  SDValue SoftenFloatRes_FDIV(SDNode *N);
406  SDValue SoftenFloatRes_FEXP(SDNode *N);
407  SDValue SoftenFloatRes_FEXP2(SDNode *N);
408  SDValue SoftenFloatRes_FFLOOR(SDNode *N);
409  SDValue SoftenFloatRes_FLOG(SDNode *N);
410  SDValue SoftenFloatRes_FLOG2(SDNode *N);
411  SDValue SoftenFloatRes_FLOG10(SDNode *N);
412  SDValue SoftenFloatRes_FMA(SDNode *N);
413  SDValue SoftenFloatRes_FMUL(SDNode *N);
414  SDValue SoftenFloatRes_FNEARBYINT(SDNode *N);
415  SDValue SoftenFloatRes_FNEG(SDNode *N);
416  SDValue SoftenFloatRes_FP_EXTEND(SDNode *N);
417  SDValue SoftenFloatRes_FP16_TO_FP(SDNode *N);
418  SDValue SoftenFloatRes_FP_ROUND(SDNode *N);
419  SDValue SoftenFloatRes_FPOW(SDNode *N);
420  SDValue SoftenFloatRes_FPOWI(SDNode *N);
421  SDValue SoftenFloatRes_FREM(SDNode *N);
422  SDValue SoftenFloatRes_FRINT(SDNode *N);
423  SDValue SoftenFloatRes_FROUND(SDNode *N);
424  SDValue SoftenFloatRes_FSIN(SDNode *N);
425  SDValue SoftenFloatRes_FSQRT(SDNode *N);
426  SDValue SoftenFloatRes_FSUB(SDNode *N);
427  SDValue SoftenFloatRes_FTRUNC(SDNode *N);
428  SDValue SoftenFloatRes_LOAD(SDNode *N);
429  SDValue SoftenFloatRes_SELECT(SDNode *N);
430  SDValue SoftenFloatRes_SELECT_CC(SDNode *N);
431  SDValue SoftenFloatRes_UNDEF(SDNode *N);
432  SDValue SoftenFloatRes_VAARG(SDNode *N);
433  SDValue SoftenFloatRes_XINT_TO_FP(SDNode *N);
434 
435  // Operand Float to Integer Conversion.
436  bool SoftenFloatOperand(SDNode *N, unsigned OpNo);
437  SDValue SoftenFloatOp_BITCAST(SDNode *N);
438  SDValue SoftenFloatOp_BR_CC(SDNode *N);
439  SDValue SoftenFloatOp_FP_EXTEND(SDNode *N);
440  SDValue SoftenFloatOp_FP_ROUND(SDNode *N);
441  SDValue SoftenFloatOp_FP_TO_SINT(SDNode *N);
442  SDValue SoftenFloatOp_FP_TO_UINT(SDNode *N);
443  SDValue SoftenFloatOp_SELECT_CC(SDNode *N);
444  SDValue SoftenFloatOp_SETCC(SDNode *N);
445  SDValue SoftenFloatOp_STORE(SDNode *N, unsigned OpNo);
446 
447  //===--------------------------------------------------------------------===//
448  // Float Expansion Support: LegalizeFloatTypes.cpp
449  //===--------------------------------------------------------------------===//
450 
451  /// GetExpandedFloat - Given a processed operand Op which was expanded into
452  /// two floating point values of half the size, this returns the two halves.
453  /// The low bits of Op are exactly equal to the bits of Lo; the high bits
454  /// exactly equal Hi. For example, if Op is a ppcf128 which was expanded
455  /// into two f64's, then this method returns the two f64's, with Lo being
456  /// equal to the lower 64 bits of Op, and Hi to the upper 64 bits.
457  void GetExpandedFloat(SDValue Op, SDValue &Lo, SDValue &Hi);
458  void SetExpandedFloat(SDValue Op, SDValue Lo, SDValue Hi);
459 
460  // Float Result Expansion.
461  void ExpandFloatResult(SDNode *N, unsigned ResNo);
462  void ExpandFloatRes_ConstantFP(SDNode *N, SDValue &Lo, SDValue &Hi);
463  void ExpandFloatRes_FABS (SDNode *N, SDValue &Lo, SDValue &Hi);
464  void ExpandFloatRes_FMINNUM (SDNode *N, SDValue &Lo, SDValue &Hi);
465  void ExpandFloatRes_FMAXNUM (SDNode *N, SDValue &Lo, SDValue &Hi);
466  void ExpandFloatRes_FADD (SDNode *N, SDValue &Lo, SDValue &Hi);
467  void ExpandFloatRes_FCEIL (SDNode *N, SDValue &Lo, SDValue &Hi);
468  void ExpandFloatRes_FCOPYSIGN (SDNode *N, SDValue &Lo, SDValue &Hi);
469  void ExpandFloatRes_FCOS (SDNode *N, SDValue &Lo, SDValue &Hi);
470  void ExpandFloatRes_FDIV (SDNode *N, SDValue &Lo, SDValue &Hi);
471  void ExpandFloatRes_FEXP (SDNode *N, SDValue &Lo, SDValue &Hi);
472  void ExpandFloatRes_FEXP2 (SDNode *N, SDValue &Lo, SDValue &Hi);
473  void ExpandFloatRes_FFLOOR (SDNode *N, SDValue &Lo, SDValue &Hi);
474  void ExpandFloatRes_FLOG (SDNode *N, SDValue &Lo, SDValue &Hi);
475  void ExpandFloatRes_FLOG2 (SDNode *N, SDValue &Lo, SDValue &Hi);
476  void ExpandFloatRes_FLOG10 (SDNode *N, SDValue &Lo, SDValue &Hi);
477  void ExpandFloatRes_FMA (SDNode *N, SDValue &Lo, SDValue &Hi);
478  void ExpandFloatRes_FMUL (SDNode *N, SDValue &Lo, SDValue &Hi);
479  void ExpandFloatRes_FNEARBYINT(SDNode *N, SDValue &Lo, SDValue &Hi);
480  void ExpandFloatRes_FNEG (SDNode *N, SDValue &Lo, SDValue &Hi);
481  void ExpandFloatRes_FP_EXTEND (SDNode *N, SDValue &Lo, SDValue &Hi);
482  void ExpandFloatRes_FPOW (SDNode *N, SDValue &Lo, SDValue &Hi);
483  void ExpandFloatRes_FPOWI (SDNode *N, SDValue &Lo, SDValue &Hi);
484  void ExpandFloatRes_FREM (SDNode *N, SDValue &Lo, SDValue &Hi);
485  void ExpandFloatRes_FRINT (SDNode *N, SDValue &Lo, SDValue &Hi);
486  void ExpandFloatRes_FROUND (SDNode *N, SDValue &Lo, SDValue &Hi);
487  void ExpandFloatRes_FSIN (SDNode *N, SDValue &Lo, SDValue &Hi);
488  void ExpandFloatRes_FSQRT (SDNode *N, SDValue &Lo, SDValue &Hi);
489  void ExpandFloatRes_FSUB (SDNode *N, SDValue &Lo, SDValue &Hi);
490  void ExpandFloatRes_FTRUNC (SDNode *N, SDValue &Lo, SDValue &Hi);
491  void ExpandFloatRes_LOAD (SDNode *N, SDValue &Lo, SDValue &Hi);
492  void ExpandFloatRes_XINT_TO_FP(SDNode *N, SDValue &Lo, SDValue &Hi);
493 
494  // Float Operand Expansion.
495  bool ExpandFloatOperand(SDNode *N, unsigned OperandNo);
496  SDValue ExpandFloatOp_BR_CC(SDNode *N);
497  SDValue ExpandFloatOp_FCOPYSIGN(SDNode *N);
498  SDValue ExpandFloatOp_FP_ROUND(SDNode *N);
499  SDValue ExpandFloatOp_FP_TO_SINT(SDNode *N);
500  SDValue ExpandFloatOp_FP_TO_UINT(SDNode *N);
501  SDValue ExpandFloatOp_SELECT_CC(SDNode *N);
502  SDValue ExpandFloatOp_SETCC(SDNode *N);
503  SDValue ExpandFloatOp_STORE(SDNode *N, unsigned OpNo);
504 
505  void FloatExpandSetCCOperands(SDValue &NewLHS, SDValue &NewRHS,
506  ISD::CondCode &CCCode, SDLoc dl);
507 
508 
509  //===--------------------------------------------------------------------===//
510  // Float promotion support: LegalizeFloatTypes.cpp
511  //===--------------------------------------------------------------------===//
512 
513  SDValue GetPromotedFloat(SDValue Op) {
514  SDValue &PromotedOp = PromotedFloats[Op];
515  RemapValue(PromotedOp);
516  assert(PromotedOp.getNode() && "Operand wasn't promoted?");
517  return PromotedOp;
518  }
519  void SetPromotedFloat(SDValue Op, SDValue Result);
520 
521  void PromoteFloatResult(SDNode *N, unsigned ResNo);
522  SDValue PromoteFloatRes_BITCAST(SDNode *N);
523  SDValue PromoteFloatRes_BinOp(SDNode *N);
524  SDValue PromoteFloatRes_ConstantFP(SDNode *N);
525  SDValue PromoteFloatRes_EXTRACT_VECTOR_ELT(SDNode *N);
526  SDValue PromoteFloatRes_FCOPYSIGN(SDNode *N);
527  SDValue PromoteFloatRes_FMAD(SDNode *N);
528  SDValue PromoteFloatRes_FPOWI(SDNode *N);
529  SDValue PromoteFloatRes_FP_ROUND(SDNode *N);
530  SDValue PromoteFloatRes_LOAD(SDNode *N);
531  SDValue PromoteFloatRes_SELECT(SDNode *N);
532  SDValue PromoteFloatRes_SELECT_CC(SDNode *N);
533  SDValue PromoteFloatRes_UnaryOp(SDNode *N);
534  SDValue PromoteFloatRes_UNDEF(SDNode *N);
535  SDValue PromoteFloatRes_XINT_TO_FP(SDNode *N);
536 
537  bool PromoteFloatOperand(SDNode *N, unsigned ResNo);
538  SDValue PromoteFloatOp_BITCAST(SDNode *N, unsigned OpNo);
539  SDValue PromoteFloatOp_FCOPYSIGN(SDNode *N, unsigned OpNo);
540  SDValue PromoteFloatOp_FP_EXTEND(SDNode *N, unsigned OpNo);
541  SDValue PromoteFloatOp_FP_TO_XINT(SDNode *N, unsigned OpNo);
542  SDValue PromoteFloatOp_STORE(SDNode *N, unsigned OpNo);
543  SDValue PromoteFloatOp_SELECT_CC(SDNode *N, unsigned OpNo);
544  SDValue PromoteFloatOp_SETCC(SDNode *N, unsigned OpNo);
545 
546  //===--------------------------------------------------------------------===//
547  // Scalarization Support: LegalizeVectorTypes.cpp
548  //===--------------------------------------------------------------------===//
549 
550  /// GetScalarizedVector - Given a processed one-element vector Op which was
551  /// scalarized to its element type, this returns the element. For example,
552  /// if Op is a v1i32, Op = < i32 val >, this method returns val, an i32.
553  SDValue GetScalarizedVector(SDValue Op) {
554  SDValue &ScalarizedOp = ScalarizedVectors[Op];
555  RemapValue(ScalarizedOp);
556  assert(ScalarizedOp.getNode() && "Operand wasn't scalarized?");
557  return ScalarizedOp;
558  }
559  void SetScalarizedVector(SDValue Op, SDValue Result);
560 
561  // Vector Result Scalarization: <1 x ty> -> ty.
562  void ScalarizeVectorResult(SDNode *N, unsigned OpNo);
563  SDValue ScalarizeVecRes_MERGE_VALUES(SDNode *N, unsigned ResNo);
564  SDValue ScalarizeVecRes_BinOp(SDNode *N);
565  SDValue ScalarizeVecRes_TernaryOp(SDNode *N);
566  SDValue ScalarizeVecRes_UnaryOp(SDNode *N);
567  SDValue ScalarizeVecRes_InregOp(SDNode *N);
568 
569  SDValue ScalarizeVecRes_BITCAST(SDNode *N);
570  SDValue ScalarizeVecRes_BUILD_VECTOR(SDNode *N);
571  SDValue ScalarizeVecRes_CONVERT_RNDSAT(SDNode *N);
572  SDValue ScalarizeVecRes_EXTRACT_SUBVECTOR(SDNode *N);
573  SDValue ScalarizeVecRes_FP_ROUND(SDNode *N);
574  SDValue ScalarizeVecRes_FPOWI(SDNode *N);
575  SDValue ScalarizeVecRes_INSERT_VECTOR_ELT(SDNode *N);
576  SDValue ScalarizeVecRes_LOAD(LoadSDNode *N);
577  SDValue ScalarizeVecRes_SCALAR_TO_VECTOR(SDNode *N);
578  SDValue ScalarizeVecRes_SIGN_EXTEND_INREG(SDNode *N);
579  SDValue ScalarizeVecRes_VSELECT(SDNode *N);
580  SDValue ScalarizeVecRes_SELECT(SDNode *N);
581  SDValue ScalarizeVecRes_SELECT_CC(SDNode *N);
582  SDValue ScalarizeVecRes_SETCC(SDNode *N);
583  SDValue ScalarizeVecRes_UNDEF(SDNode *N);
584  SDValue ScalarizeVecRes_VECTOR_SHUFFLE(SDNode *N);
585  SDValue ScalarizeVecRes_VSETCC(SDNode *N);
586 
587  // Vector Operand Scalarization: <1 x ty> -> ty.
588  bool ScalarizeVectorOperand(SDNode *N, unsigned OpNo);
589  SDValue ScalarizeVecOp_BITCAST(SDNode *N);
590  SDValue ScalarizeVecOp_UnaryOp(SDNode *N);
591  SDValue ScalarizeVecOp_CONCAT_VECTORS(SDNode *N);
592  SDValue ScalarizeVecOp_EXTRACT_VECTOR_ELT(SDNode *N);
593  SDValue ScalarizeVecOp_VSELECT(SDNode *N);
594  SDValue ScalarizeVecOp_STORE(StoreSDNode *N, unsigned OpNo);
595  SDValue ScalarizeVecOp_FP_ROUND(SDNode *N, unsigned OpNo);
596 
597  //===--------------------------------------------------------------------===//
598  // Vector Splitting Support: LegalizeVectorTypes.cpp
599  //===--------------------------------------------------------------------===//
600 
601  /// GetSplitVector - Given a processed vector Op which was split into vectors
602  /// of half the size, this method returns the halves. The first elements of
603  /// Op coincide with the elements of Lo; the remaining elements of Op coincide
604  /// with the elements of Hi: Op is what you would get by concatenating Lo and
605  /// Hi. For example, if Op is a v8i32 that was split into two v4i32's, then
606  /// this method returns the two v4i32's, with Lo corresponding to the first 4
607  /// elements of Op, and Hi to the last 4 elements.
608  void GetSplitVector(SDValue Op, SDValue &Lo, SDValue &Hi);
609  void SetSplitVector(SDValue Op, SDValue Lo, SDValue Hi);
610 
611  // Vector Result Splitting: <128 x ty> -> 2 x <64 x ty>.
612  void SplitVectorResult(SDNode *N, unsigned OpNo);
613  void SplitVecRes_BinOp(SDNode *N, SDValue &Lo, SDValue &Hi);
614  void SplitVecRes_TernaryOp(SDNode *N, SDValue &Lo, SDValue &Hi);
615  void SplitVecRes_UnaryOp(SDNode *N, SDValue &Lo, SDValue &Hi);
616  void SplitVecRes_ExtendOp(SDNode *N, SDValue &Lo, SDValue &Hi);
617  void SplitVecRes_InregOp(SDNode *N, SDValue &Lo, SDValue &Hi);
618 
619  void SplitVecRes_BITCAST(SDNode *N, SDValue &Lo, SDValue &Hi);
620  void SplitVecRes_BUILD_PAIR(SDNode *N, SDValue &Lo, SDValue &Hi);
621  void SplitVecRes_BUILD_VECTOR(SDNode *N, SDValue &Lo, SDValue &Hi);
622  void SplitVecRes_CONCAT_VECTORS(SDNode *N, SDValue &Lo, SDValue &Hi);
623  void SplitVecRes_EXTRACT_SUBVECTOR(SDNode *N, SDValue &Lo, SDValue &Hi);
624  void SplitVecRes_INSERT_SUBVECTOR(SDNode *N, SDValue &Lo, SDValue &Hi);
625  void SplitVecRes_FPOWI(SDNode *N, SDValue &Lo, SDValue &Hi);
626  void SplitVecRes_INSERT_VECTOR_ELT(SDNode *N, SDValue &Lo, SDValue &Hi);
627  void SplitVecRes_LOAD(LoadSDNode *N, SDValue &Lo, SDValue &Hi);
628  void SplitVecRes_MLOAD(MaskedLoadSDNode *N, SDValue &Lo, SDValue &Hi);
629  void SplitVecRes_MGATHER(MaskedGatherSDNode *N, SDValue &Lo, SDValue &Hi);
630  void SplitVecRes_SCALAR_TO_VECTOR(SDNode *N, SDValue &Lo, SDValue &Hi);
631  void SplitVecRes_SIGN_EXTEND_INREG(SDNode *N, SDValue &Lo, SDValue &Hi);
632  void SplitVecRes_SETCC(SDNode *N, SDValue &Lo, SDValue &Hi);
633  void SplitVecRes_UNDEF(SDNode *N, SDValue &Lo, SDValue &Hi);
634  void SplitVecRes_VECTOR_SHUFFLE(ShuffleVectorSDNode *N, SDValue &Lo,
635  SDValue &Hi);
636 
637  // Vector Operand Splitting: <128 x ty> -> 2 x <64 x ty>.
638  bool SplitVectorOperand(SDNode *N, unsigned OpNo);
639  SDValue SplitVecOp_VSELECT(SDNode *N, unsigned OpNo);
640  SDValue SplitVecOp_UnaryOp(SDNode *N);
641  SDValue SplitVecOp_TruncateHelper(SDNode *N);
642 
643  SDValue SplitVecOp_BITCAST(SDNode *N);
644  SDValue SplitVecOp_EXTRACT_SUBVECTOR(SDNode *N);
645  SDValue SplitVecOp_EXTRACT_VECTOR_ELT(SDNode *N);
646  SDValue SplitVecOp_STORE(StoreSDNode *N, unsigned OpNo);
647  SDValue SplitVecOp_MSTORE(MaskedStoreSDNode *N, unsigned OpNo);
648  SDValue SplitVecOp_MSCATTER(MaskedScatterSDNode *N, unsigned OpNo);
649  SDValue SplitVecOp_MGATHER(MaskedGatherSDNode *N, unsigned OpNo);
650  SDValue SplitVecOp_CONCAT_VECTORS(SDNode *N);
651  SDValue SplitVecOp_VSETCC(SDNode *N);
652  SDValue SplitVecOp_FP_ROUND(SDNode *N);
653 
654  //===--------------------------------------------------------------------===//
655  // Vector Widening Support: LegalizeVectorTypes.cpp
656  //===--------------------------------------------------------------------===//
657 
658  /// GetWidenedVector - Given a processed vector Op which was widened into a
659  /// larger vector, this method returns the larger vector. The elements of
660  /// the returned vector consist of the elements of Op followed by elements
661  /// containing rubbish. For example, if Op is a v2i32 that was widened to a
662  /// v4i32, then this method returns a v4i32 for which the first two elements
663  /// are the same as those of Op, while the last two elements contain rubbish.
664  SDValue GetWidenedVector(SDValue Op) {
665  SDValue &WidenedOp = WidenedVectors[Op];
666  RemapValue(WidenedOp);
667  assert(WidenedOp.getNode() && "Operand wasn't widened?");
668  return WidenedOp;
669  }
670  void SetWidenedVector(SDValue Op, SDValue Result);
671 
672  // Widen Vector Result Promotion.
673  void WidenVectorResult(SDNode *N, unsigned ResNo);
674  SDValue WidenVecRes_MERGE_VALUES(SDNode* N, unsigned ResNo);
675  SDValue WidenVecRes_BITCAST(SDNode* N);
676  SDValue WidenVecRes_BUILD_VECTOR(SDNode* N);
677  SDValue WidenVecRes_CONCAT_VECTORS(SDNode* N);
678  SDValue WidenVecRes_CONVERT_RNDSAT(SDNode* N);
679  SDValue WidenVecRes_EXTRACT_SUBVECTOR(SDNode* N);
680  SDValue WidenVecRes_INSERT_VECTOR_ELT(SDNode* N);
681  SDValue WidenVecRes_LOAD(SDNode* N);
682  SDValue WidenVecRes_MLOAD(MaskedLoadSDNode* N);
683  SDValue WidenVecRes_SCALAR_TO_VECTOR(SDNode* N);
684  SDValue WidenVecRes_SIGN_EXTEND_INREG(SDNode* N);
685  SDValue WidenVecRes_SELECT(SDNode* N);
686  SDValue WidenVecRes_SELECT_CC(SDNode* N);
687  SDValue WidenVecRes_SETCC(SDNode* N);
688  SDValue WidenVecRes_UNDEF(SDNode *N);
689  SDValue WidenVecRes_VECTOR_SHUFFLE(ShuffleVectorSDNode *N);
690  SDValue WidenVecRes_VSETCC(SDNode* N);
691 
692  SDValue WidenVecRes_Ternary(SDNode *N);
693  SDValue WidenVecRes_Binary(SDNode *N);
694  SDValue WidenVecRes_BinaryCanTrap(SDNode *N);
695  SDValue WidenVecRes_Convert(SDNode *N);
696  SDValue WidenVecRes_POWI(SDNode *N);
697  SDValue WidenVecRes_Shift(SDNode *N);
698  SDValue WidenVecRes_Unary(SDNode *N);
699  SDValue WidenVecRes_InregOp(SDNode *N);
700 
701  // Widen Vector Operand.
702  bool WidenVectorOperand(SDNode *N, unsigned OpNo);
703  SDValue WidenVecOp_BITCAST(SDNode *N);
704  SDValue WidenVecOp_CONCAT_VECTORS(SDNode *N);
705  SDValue WidenVecOp_EXTEND(SDNode *N);
706  SDValue WidenVecOp_EXTRACT_VECTOR_ELT(SDNode *N);
707  SDValue WidenVecOp_EXTRACT_SUBVECTOR(SDNode *N);
708  SDValue WidenVecOp_STORE(SDNode* N);
709  SDValue WidenVecOp_MSTORE(SDNode* N, unsigned OpNo);
710  SDValue WidenVecOp_SETCC(SDNode* N);
711 
712  SDValue WidenVecOp_Convert(SDNode *N);
713 
714  //===--------------------------------------------------------------------===//
715  // Vector Widening Utilities Support: LegalizeVectorTypes.cpp
716  //===--------------------------------------------------------------------===//
717 
718  /// Helper GenWidenVectorLoads - Helper function to generate a set of
719  /// loads to load a vector with a resulting wider type. It takes
720  /// LdChain: list of chains for the load to be generated.
721  /// Ld: load to widen
722  SDValue GenWidenVectorLoads(SmallVectorImpl<SDValue> &LdChain,
723  LoadSDNode *LD);
724 
725  /// GenWidenVectorExtLoads - Helper function to generate a set of extension
726  /// loads to load a ector with a resulting wider type. It takes
727  /// LdChain: list of chains for the load to be generated.
728  /// Ld: load to widen
729  /// ExtType: extension element type
730  SDValue GenWidenVectorExtLoads(SmallVectorImpl<SDValue> &LdChain,
731  LoadSDNode *LD, ISD::LoadExtType ExtType);
732 
733  /// Helper genWidenVectorStores - Helper function to generate a set of
734  /// stores to store a widen vector into non-widen memory
735  /// StChain: list of chains for the stores we have generated
736  /// ST: store of a widen value
737  void GenWidenVectorStores(SmallVectorImpl<SDValue> &StChain, StoreSDNode *ST);
738 
739  /// Helper genWidenVectorTruncStores - Helper function to generate a set of
740  /// stores to store a truncate widen vector into non-widen memory
741  /// StChain: list of chains for the stores we have generated
742  /// ST: store of a widen value
743  void GenWidenVectorTruncStores(SmallVectorImpl<SDValue> &StChain,
744  StoreSDNode *ST);
745 
746  /// Modifies a vector input (widen or narrows) to a vector of NVT. The
747  /// input vector must have the same element type as NVT.
748  SDValue ModifyToType(SDValue InOp, EVT WidenVT);
749 
750 
751  //===--------------------------------------------------------------------===//
752  // Generic Splitting: LegalizeTypesGeneric.cpp
753  //===--------------------------------------------------------------------===//
754 
755  // Legalization methods which only use that the illegal type is split into two
756  // not necessarily identical types. As such they can be used for splitting
757  // vectors and expanding integers and floats.
758 
759  void GetSplitOp(SDValue Op, SDValue &Lo, SDValue &Hi) {
760  if (Op.getValueType().isVector())
761  GetSplitVector(Op, Lo, Hi);
762  else if (Op.getValueType().isInteger())
763  GetExpandedInteger(Op, Lo, Hi);
764  else
765  GetExpandedFloat(Op, Lo, Hi);
766  }
767 
768  /// GetPairElements - Use ISD::EXTRACT_ELEMENT nodes to extract the low and
769  /// high parts of the given value.
770  void GetPairElements(SDValue Pair, SDValue &Lo, SDValue &Hi);
771 
772  // Generic Result Splitting.
773  void SplitRes_MERGE_VALUES(SDNode *N, unsigned ResNo,
774  SDValue &Lo, SDValue &Hi);
775  void SplitRes_SELECT (SDNode *N, SDValue &Lo, SDValue &Hi);
776  void SplitRes_SELECT_CC (SDNode *N, SDValue &Lo, SDValue &Hi);
777  void SplitRes_UNDEF (SDNode *N, SDValue &Lo, SDValue &Hi);
778 
779  //===--------------------------------------------------------------------===//
780  // Generic Expansion: LegalizeTypesGeneric.cpp
781  //===--------------------------------------------------------------------===//
782 
783  // Legalization methods which only use that the illegal type is split into two
784  // identical types of half the size, and that the Lo/Hi part is stored first
785  // in memory on little/big-endian machines, followed by the Hi/Lo part. As
786  // such they can be used for expanding integers and floats.
787 
788  void GetExpandedOp(SDValue Op, SDValue &Lo, SDValue &Hi) {
789  if (Op.getValueType().isInteger())
790  GetExpandedInteger(Op, Lo, Hi);
791  else
792  GetExpandedFloat(Op, Lo, Hi);
793  }
794 
795 
796  /// This function will split the integer \p Op into \p NumElements
797  /// operations of type \p EltVT and store them in \p Ops.
798  void IntegerToVector(SDValue Op, unsigned NumElements,
799  SmallVectorImpl<SDValue> &Ops, EVT EltVT);
800 
801  // Generic Result Expansion.
802  void ExpandRes_MERGE_VALUES (SDNode *N, unsigned ResNo,
803  SDValue &Lo, SDValue &Hi);
804  void ExpandRes_BITCAST (SDNode *N, SDValue &Lo, SDValue &Hi);
805  void ExpandRes_BUILD_PAIR (SDNode *N, SDValue &Lo, SDValue &Hi);
806  void ExpandRes_EXTRACT_ELEMENT (SDNode *N, SDValue &Lo, SDValue &Hi);
807  void ExpandRes_EXTRACT_VECTOR_ELT(SDNode *N, SDValue &Lo, SDValue &Hi);
808  void ExpandRes_NormalLoad (SDNode *N, SDValue &Lo, SDValue &Hi);
809  void ExpandRes_VAARG (SDNode *N, SDValue &Lo, SDValue &Hi);
810 
811  // Generic Operand Expansion.
812  SDValue ExpandOp_BITCAST (SDNode *N);
813  SDValue ExpandOp_BUILD_VECTOR (SDNode *N);
814  SDValue ExpandOp_EXTRACT_ELEMENT (SDNode *N);
815  SDValue ExpandOp_INSERT_VECTOR_ELT(SDNode *N);
816  SDValue ExpandOp_SCALAR_TO_VECTOR (SDNode *N);
817  SDValue ExpandOp_NormalStore (SDNode *N, unsigned OpNo);
818 };
819 
820 } // end namespace llvm.
821 
822 #endif
Libcall
RTLIB::Libcall enum - This enum defines all of the runtime library calls the backend can emit...
DAGTypeLegalizer - This takes an arbitrary SelectionDAG as input and hacks on it until only value typ...
Definition: LegalizeTypes.h:34
LegalizeTypeAction
This enum indicates whether a types are legal for a target, and if not, what action should be used to...
This class defines information used to lower LLVM code to legal SelectionDAG operators that the targe...
unsigned getNumValues() const
Return the number of values defined/returned by this operator.
CondCode
ISD::CondCode enum - These are ordered carefully to make the bitfields below work out...
Definition: ISDOpcodes.h:804
TargetConstant* - Like Constant*, but the DAG does not do any folding, simplification, or lowering of the constant.
Definition: ISDOpcodes.h:116
SDNode * getNode() const
get the SDNode which holds the desired result
LoadExtType
LoadExtType enum - This enum defines the three variants of LOADEXT (load with extension).
Definition: ISDOpcodes.h:780
#define LLVM_LIBRARY_VISIBILITY
LLVM_LIBRARY_VISIBILITY - If a class marked with this attribute is linked into a shared library...
Definition: Compiler.h:110
EVT - Extended Value Type.
Definition: ValueTypes.h:31
LegalizeTypeAction getTypeAction(MVT VT) const
SelectionDAG & getDAG() const
void NoteDeletion(SDNode *Old, SDNode *New)
This is used to represent a portion of an LLVM function in a low-level Data Dependence DAG representa...
Definition: SelectionDAG.h:179
Represents one node in the SelectionDAG.
SIGN_EXTEND_INREG - This operator atomically performs a SHL/SRA pair to sign extend a small value in ...
Definition: ISDOpcodes.h:401
#define N
Unlike LLVM values, Selection DAG nodes may return multiple values as the result of a computation...
This file describes how to lower LLVM code to machine code.
DAGTypeLegalizer(SelectionDAG &dag)