LLVM API Documentation

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

Generated on Tue Mar 18 2014 10:35:42 for LLVM by Doxygen1.8.6
Copyright © 2003-2013 University of Illinois at Urbana-Champaign. All Rights Reserved.