← Back to branch summary

~pali/+junk/llvm-toolchain-3.7

« back to all changes in this revision

Viewing changes to lib/CodeGen/SelectionDAG/LegalizeTypes.h

  • Committer: Package Import Robot
  • Author(s): Sylvestre Ledru
  • Date: 2015-07-15 17:51:08 UTC
  • Revision ID: package-import@ubuntu.com-20150715175108-l8mynwovkx4zx697
Tags: upstream-3.7~+rc2
Import upstream version 3.7~+rc2

Show diffs side-by-side

added added

removed removed

Lines of Context:
lib/CodeGen/SelectionDAG/LegalizeTypes.h
 
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"
 
21
#include "llvm/CodeGen/SelectionDAG.h"
 
22
#include "llvm/Support/Compiler.h"
 
23
#include "llvm/Support/Debug.h"
 
24
#include "llvm/Target/TargetLowering.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
///
 
34
class LLVM_LIBRARY_VISIBILITY DAGTypeLegalizer {
 
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:
 
127
  explicit DAGTypeLegalizer(SelectionDAG &dag)
 
128
    : TLI(dag.getTargetLoweringInfo()), DAG(dag),
 
129
    ValueTypeActions(TLI.getValueTypeActions()) {
 
130
    static_assert(MVT::LAST_VALUETYPE <= MVT::MAX_ALLOWED_VALUETYPE,
 
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