LLVM API Documentation

 All Classes Namespaces Files Functions Variables Typedefs Enumerations Enumerator Friends Macros Groups Pages
LegalizeFloatTypes.cpp
Go to the documentation of this file.
1 //===-------- LegalizeFloatTypes.cpp - Legalization of float types --------===//
2 //
3 // The LLVM Compiler Infrastructure
4 //
5 // This file is distributed under the University of Illinois Open Source
6 // License. See LICENSE.TXT for details.
7 //
8 //===----------------------------------------------------------------------===//
9 //
10 // This file implements float type expansion and softening for LegalizeTypes.
11 // Softening is the act of turning a computation in an illegal floating point
12 // type into a computation in an integer type of the same size; also known as
13 // "soft float". For example, turning f32 arithmetic into operations using i32.
14 // The resulting integer value is the same as what you would get by performing
15 // the floating point operation and bitcasting the result to the integer type.
16 // Expansion is the act of changing a computation in an illegal type to be a
17 // computation in two identical registers of a smaller type. For example,
18 // implementing ppcf128 arithmetic in two f64 registers.
19 //
20 //===----------------------------------------------------------------------===//
21 
22 #include "LegalizeTypes.h"
23 #include "llvm/Support/ErrorHandling.h"
24 #include "llvm/Support/raw_ostream.h"
25 using namespace llvm;
26 
27 /// GetFPLibCall - Return the right libcall for the given floating point type.
28 static RTLIB::Libcall GetFPLibCall(EVT VT,
29  RTLIB::Libcall Call_F32,
30  RTLIB::Libcall Call_F64,
31  RTLIB::Libcall Call_F80,
32  RTLIB::Libcall Call_F128,
33  RTLIB::Libcall Call_PPCF128) {
34  return
35  VT == MVT::f32 ? Call_F32 :
36  VT == MVT::f64 ? Call_F64 :
37  VT == MVT::f80 ? Call_F80 :
38  VT == MVT::f128 ? Call_F128 :
39  VT == MVT::ppcf128 ? Call_PPCF128 :
40  RTLIB::UNKNOWN_LIBCALL;
41 }
42 
43 //===----------------------------------------------------------------------===//
44 // Result Float to Integer Conversion.
45 //===----------------------------------------------------------------------===//
46 
47 void DAGTypeLegalizer::SoftenFloatResult(SDNode *N, unsigned ResNo) {
48  DEBUG(dbgs() << "Soften float result " << ResNo << ": "; N->dump(&DAG);
49  dbgs() << "\n");
50  SDValue R = SDValue();
51 
52  switch (N->getOpcode()) {
53  default:
54 #ifndef NDEBUG
55  dbgs() << "SoftenFloatResult #" << ResNo << ": ";
56  N->dump(&DAG); dbgs() << "\n";
57 #endif
58  llvm_unreachable("Do not know how to soften the result of this operator!");
59 
60  case ISD::MERGE_VALUES:R = SoftenFloatRes_MERGE_VALUES(N, ResNo); break;
61  case ISD::BITCAST: R = SoftenFloatRes_BITCAST(N); break;
62  case ISD::BUILD_PAIR: R = SoftenFloatRes_BUILD_PAIR(N); break;
63  case ISD::ConstantFP:
64  R = SoftenFloatRes_ConstantFP(cast<ConstantFPSDNode>(N));
65  break;
66  case ISD::EXTRACT_VECTOR_ELT:
67  R = SoftenFloatRes_EXTRACT_VECTOR_ELT(N); break;
68  case ISD::FABS: R = SoftenFloatRes_FABS(N); break;
69  case ISD::FADD: R = SoftenFloatRes_FADD(N); break;
70  case ISD::FCEIL: R = SoftenFloatRes_FCEIL(N); break;
71  case ISD::FCOPYSIGN: R = SoftenFloatRes_FCOPYSIGN(N); break;
72  case ISD::FCOS: R = SoftenFloatRes_FCOS(N); break;
73  case ISD::FDIV: R = SoftenFloatRes_FDIV(N); break;
74  case ISD::FEXP: R = SoftenFloatRes_FEXP(N); break;
75  case ISD::FEXP2: R = SoftenFloatRes_FEXP2(N); break;
76  case ISD::FFLOOR: R = SoftenFloatRes_FFLOOR(N); break;
77  case ISD::FLOG: R = SoftenFloatRes_FLOG(N); break;
78  case ISD::FLOG2: R = SoftenFloatRes_FLOG2(N); break;
79  case ISD::FLOG10: R = SoftenFloatRes_FLOG10(N); break;
80  case ISD::FMA: R = SoftenFloatRes_FMA(N); break;
81  case ISD::FMUL: R = SoftenFloatRes_FMUL(N); break;
82  case ISD::FNEARBYINT: R = SoftenFloatRes_FNEARBYINT(N); break;
83  case ISD::FNEG: R = SoftenFloatRes_FNEG(N); break;
84  case ISD::FP_EXTEND: R = SoftenFloatRes_FP_EXTEND(N); break;
85  case ISD::FP_ROUND: R = SoftenFloatRes_FP_ROUND(N); break;
86  case ISD::FP16_TO_FP32:R = SoftenFloatRes_FP16_TO_FP32(N); break;
87  case ISD::FPOW: R = SoftenFloatRes_FPOW(N); break;
88  case ISD::FPOWI: R = SoftenFloatRes_FPOWI(N); break;
89  case ISD::FREM: R = SoftenFloatRes_FREM(N); break;
90  case ISD::FRINT: R = SoftenFloatRes_FRINT(N); break;
91  case ISD::FROUND: R = SoftenFloatRes_FROUND(N); break;
92  case ISD::FSIN: R = SoftenFloatRes_FSIN(N); break;
93  case ISD::FSQRT: R = SoftenFloatRes_FSQRT(N); break;
94  case ISD::FSUB: R = SoftenFloatRes_FSUB(N); break;
95  case ISD::FTRUNC: R = SoftenFloatRes_FTRUNC(N); break;
96  case ISD::LOAD: R = SoftenFloatRes_LOAD(N); break;
97  case ISD::SELECT: R = SoftenFloatRes_SELECT(N); break;
98  case ISD::SELECT_CC: R = SoftenFloatRes_SELECT_CC(N); break;
99  case ISD::SINT_TO_FP:
100  case ISD::UINT_TO_FP: R = SoftenFloatRes_XINT_TO_FP(N); break;
101  case ISD::UNDEF: R = SoftenFloatRes_UNDEF(N); break;
102  case ISD::VAARG: R = SoftenFloatRes_VAARG(N); break;
103  }
104 
105  // If R is null, the sub-method took care of registering the result.
106  if (R.getNode())
107  SetSoftenedFloat(SDValue(N, ResNo), R);
108 }
109 
110 SDValue DAGTypeLegalizer::SoftenFloatRes_BITCAST(SDNode *N) {
111  return BitConvertToInteger(N->getOperand(0));
112 }
113 
114 SDValue DAGTypeLegalizer::SoftenFloatRes_MERGE_VALUES(SDNode *N,
115  unsigned ResNo) {
116  SDValue Op = DisintegrateMERGE_VALUES(N, ResNo);
117  return BitConvertToInteger(Op);
118 }
119 
120 SDValue DAGTypeLegalizer::SoftenFloatRes_BUILD_PAIR(SDNode *N) {
121  // Convert the inputs to integers, and build a new pair out of them.
122  return DAG.getNode(ISD::BUILD_PAIR, SDLoc(N),
123  TLI.getTypeToTransformTo(*DAG.getContext(),
124  N->getValueType(0)),
125  BitConvertToInteger(N->getOperand(0)),
126  BitConvertToInteger(N->getOperand(1)));
127 }
128 
129 SDValue DAGTypeLegalizer::SoftenFloatRes_ConstantFP(ConstantFPSDNode *N) {
130  return DAG.getConstant(N->getValueAPF().bitcastToAPInt(),
131  TLI.getTypeToTransformTo(*DAG.getContext(),
132  N->getValueType(0)));
133 }
134 
135 SDValue DAGTypeLegalizer::SoftenFloatRes_EXTRACT_VECTOR_ELT(SDNode *N) {
136  SDValue NewOp = BitConvertVectorToIntegerVector(N->getOperand(0));
137  return DAG.getNode(ISD::EXTRACT_VECTOR_ELT, SDLoc(N),
138  NewOp.getValueType().getVectorElementType(),
139  NewOp, N->getOperand(1));
140 }
141 
142 SDValue DAGTypeLegalizer::SoftenFloatRes_FABS(SDNode *N) {
143  EVT NVT = TLI.getTypeToTransformTo(*DAG.getContext(), N->getValueType(0));
144  unsigned Size = NVT.getSizeInBits();
145 
146  // Mask = ~(1 << (Size-1))
147  APInt API = APInt::getAllOnesValue(Size);
148  API.clearBit(Size-1);
149  SDValue Mask = DAG.getConstant(API, NVT);
150  SDValue Op = GetSoftenedFloat(N->getOperand(0));
151  return DAG.getNode(ISD::AND, SDLoc(N), NVT, Op, Mask);
152 }
153 
154 SDValue DAGTypeLegalizer::SoftenFloatRes_FADD(SDNode *N) {
155  EVT NVT = TLI.getTypeToTransformTo(*DAG.getContext(), N->getValueType(0));
156  SDValue Ops[2] = { GetSoftenedFloat(N->getOperand(0)),
157  GetSoftenedFloat(N->getOperand(1)) };
158  return TLI.makeLibCall(DAG, GetFPLibCall(N->getValueType(0),
159  RTLIB::ADD_F32,
160  RTLIB::ADD_F64,
161  RTLIB::ADD_F80,
162  RTLIB::ADD_F128,
163  RTLIB::ADD_PPCF128),
164  NVT, Ops, 2, false, SDLoc(N)).first;
165 }
166 
167 SDValue DAGTypeLegalizer::SoftenFloatRes_FCEIL(SDNode *N) {
168  EVT NVT = TLI.getTypeToTransformTo(*DAG.getContext(), N->getValueType(0));
169  SDValue Op = GetSoftenedFloat(N->getOperand(0));
170  return TLI.makeLibCall(DAG, GetFPLibCall(N->getValueType(0),
171  RTLIB::CEIL_F32,
172  RTLIB::CEIL_F64,
173  RTLIB::CEIL_F80,
174  RTLIB::CEIL_F128,
175  RTLIB::CEIL_PPCF128),
176  NVT, &Op, 1, false, SDLoc(N)).first;
177 }
178 
179 SDValue DAGTypeLegalizer::SoftenFloatRes_FCOPYSIGN(SDNode *N) {
180  SDValue LHS = GetSoftenedFloat(N->getOperand(0));
181  SDValue RHS = BitConvertToInteger(N->getOperand(1));
182  SDLoc dl(N);
183 
184  EVT LVT = LHS.getValueType();
185  EVT RVT = RHS.getValueType();
186 
187  unsigned LSize = LVT.getSizeInBits();
188  unsigned RSize = RVT.getSizeInBits();
189 
190  // First get the sign bit of second operand.
191  SDValue SignBit = DAG.getNode(ISD::SHL, dl, RVT, DAG.getConstant(1, RVT),
192  DAG.getConstant(RSize - 1,
193  TLI.getShiftAmountTy(RVT)));
194  SignBit = DAG.getNode(ISD::AND, dl, RVT, RHS, SignBit);
195 
196  // Shift right or sign-extend it if the two operands have different types.
197  int SizeDiff = RVT.getSizeInBits() - LVT.getSizeInBits();
198  if (SizeDiff > 0) {
199  SignBit = DAG.getNode(ISD::SRL, dl, RVT, SignBit,
200  DAG.getConstant(SizeDiff,
201  TLI.getShiftAmountTy(SignBit.getValueType())));
202  SignBit = DAG.getNode(ISD::TRUNCATE, dl, LVT, SignBit);
203  } else if (SizeDiff < 0) {
204  SignBit = DAG.getNode(ISD::ANY_EXTEND, dl, LVT, SignBit);
205  SignBit = DAG.getNode(ISD::SHL, dl, LVT, SignBit,
206  DAG.getConstant(-SizeDiff,
207  TLI.getShiftAmountTy(SignBit.getValueType())));
208  }
209 
210  // Clear the sign bit of the first operand.
211  SDValue Mask = DAG.getNode(ISD::SHL, dl, LVT, DAG.getConstant(1, LVT),
212  DAG.getConstant(LSize - 1,
213  TLI.getShiftAmountTy(LVT)));
214  Mask = DAG.getNode(ISD::SUB, dl, LVT, Mask, DAG.getConstant(1, LVT));
215  LHS = DAG.getNode(ISD::AND, dl, LVT, LHS, Mask);
216 
217  // Or the value with the sign bit.
218  return DAG.getNode(ISD::OR, dl, LVT, LHS, SignBit);
219 }
220 
221 SDValue DAGTypeLegalizer::SoftenFloatRes_FCOS(SDNode *N) {
222  EVT NVT = TLI.getTypeToTransformTo(*DAG.getContext(), N->getValueType(0));
223  SDValue Op = GetSoftenedFloat(N->getOperand(0));
224  return TLI.makeLibCall(DAG, GetFPLibCall(N->getValueType(0),
225  RTLIB::COS_F32,
226  RTLIB::COS_F64,
227  RTLIB::COS_F80,
228  RTLIB::COS_F128,
229  RTLIB::COS_PPCF128),
230  NVT, &Op, 1, false, SDLoc(N)).first;
231 }
232 
233 SDValue DAGTypeLegalizer::SoftenFloatRes_FDIV(SDNode *N) {
234  EVT NVT = TLI.getTypeToTransformTo(*DAG.getContext(), N->getValueType(0));
235  SDValue Ops[2] = { GetSoftenedFloat(N->getOperand(0)),
236  GetSoftenedFloat(N->getOperand(1)) };
237  return TLI.makeLibCall(DAG, GetFPLibCall(N->getValueType(0),
238  RTLIB::DIV_F32,
239  RTLIB::DIV_F64,
240  RTLIB::DIV_F80,
241  RTLIB::DIV_F128,
242  RTLIB::DIV_PPCF128),
243  NVT, Ops, 2, false, SDLoc(N)).first;
244 }
245 
246 SDValue DAGTypeLegalizer::SoftenFloatRes_FEXP(SDNode *N) {
247  EVT NVT = TLI.getTypeToTransformTo(*DAG.getContext(), N->getValueType(0));
248  SDValue Op = GetSoftenedFloat(N->getOperand(0));
249  return TLI.makeLibCall(DAG, GetFPLibCall(N->getValueType(0),
250  RTLIB::EXP_F32,
251  RTLIB::EXP_F64,
252  RTLIB::EXP_F80,
253  RTLIB::EXP_F128,
254  RTLIB::EXP_PPCF128),
255  NVT, &Op, 1, false, SDLoc(N)).first;
256 }
257 
258 SDValue DAGTypeLegalizer::SoftenFloatRes_FEXP2(SDNode *N) {
259  EVT NVT = TLI.getTypeToTransformTo(*DAG.getContext(), N->getValueType(0));
260  SDValue Op = GetSoftenedFloat(N->getOperand(0));
261  return TLI.makeLibCall(DAG, GetFPLibCall(N->getValueType(0),
262  RTLIB::EXP2_F32,
263  RTLIB::EXP2_F64,
264  RTLIB::EXP2_F80,
265  RTLIB::EXP2_F128,
266  RTLIB::EXP2_PPCF128),
267  NVT, &Op, 1, false, SDLoc(N)).first;
268 }
269 
270 SDValue DAGTypeLegalizer::SoftenFloatRes_FFLOOR(SDNode *N) {
271  EVT NVT = TLI.getTypeToTransformTo(*DAG.getContext(), N->getValueType(0));
272  SDValue Op = GetSoftenedFloat(N->getOperand(0));
273  return TLI.makeLibCall(DAG, GetFPLibCall(N->getValueType(0),
274  RTLIB::FLOOR_F32,
275  RTLIB::FLOOR_F64,
276  RTLIB::FLOOR_F80,
277  RTLIB::FLOOR_F128,
278  RTLIB::FLOOR_PPCF128),
279  NVT, &Op, 1, false, SDLoc(N)).first;
280 }
281 
282 SDValue DAGTypeLegalizer::SoftenFloatRes_FLOG(SDNode *N) {
283  EVT NVT = TLI.getTypeToTransformTo(*DAG.getContext(), N->getValueType(0));
284  SDValue Op = GetSoftenedFloat(N->getOperand(0));
285  return TLI.makeLibCall(DAG, GetFPLibCall(N->getValueType(0),
286  RTLIB::LOG_F32,
287  RTLIB::LOG_F64,
288  RTLIB::LOG_F80,
289  RTLIB::LOG_F128,
290  RTLIB::LOG_PPCF128),
291  NVT, &Op, 1, false, SDLoc(N)).first;
292 }
293 
294 SDValue DAGTypeLegalizer::SoftenFloatRes_FLOG2(SDNode *N) {
295  EVT NVT = TLI.getTypeToTransformTo(*DAG.getContext(), N->getValueType(0));
296  SDValue Op = GetSoftenedFloat(N->getOperand(0));
297  return TLI.makeLibCall(DAG, GetFPLibCall(N->getValueType(0),
298  RTLIB::LOG2_F32,
299  RTLIB::LOG2_F64,
300  RTLIB::LOG2_F80,
301  RTLIB::LOG2_F128,
302  RTLIB::LOG2_PPCF128),
303  NVT, &Op, 1, false, SDLoc(N)).first;
304 }
305 
306 SDValue DAGTypeLegalizer::SoftenFloatRes_FLOG10(SDNode *N) {
307  EVT NVT = TLI.getTypeToTransformTo(*DAG.getContext(), N->getValueType(0));
308  SDValue Op = GetSoftenedFloat(N->getOperand(0));
309  return TLI.makeLibCall(DAG, GetFPLibCall(N->getValueType(0),
310  RTLIB::LOG10_F32,
311  RTLIB::LOG10_F64,
312  RTLIB::LOG10_F80,
313  RTLIB::LOG10_F128,
314  RTLIB::LOG10_PPCF128),
315  NVT, &Op, 1, false, SDLoc(N)).first;
316 }
317 
318 SDValue DAGTypeLegalizer::SoftenFloatRes_FMA(SDNode *N) {
319  EVT NVT = TLI.getTypeToTransformTo(*DAG.getContext(), N->getValueType(0));
320  SDValue Ops[3] = { GetSoftenedFloat(N->getOperand(0)),
321  GetSoftenedFloat(N->getOperand(1)),
322  GetSoftenedFloat(N->getOperand(2)) };
323  return TLI.makeLibCall(DAG, GetFPLibCall(N->getValueType(0),
324  RTLIB::FMA_F32,
325  RTLIB::FMA_F64,
326  RTLIB::FMA_F80,
327  RTLIB::FMA_F128,
328  RTLIB::FMA_PPCF128),
329  NVT, Ops, 3, false, SDLoc(N)).first;
330 }
331 
332 SDValue DAGTypeLegalizer::SoftenFloatRes_FMUL(SDNode *N) {
333  EVT NVT = TLI.getTypeToTransformTo(*DAG.getContext(), N->getValueType(0));
334  SDValue Ops[2] = { GetSoftenedFloat(N->getOperand(0)),
335  GetSoftenedFloat(N->getOperand(1)) };
336  return TLI.makeLibCall(DAG, GetFPLibCall(N->getValueType(0),
337  RTLIB::MUL_F32,
338  RTLIB::MUL_F64,
339  RTLIB::MUL_F80,
340  RTLIB::MUL_F128,
341  RTLIB::MUL_PPCF128),
342  NVT, Ops, 2, false, SDLoc(N)).first;
343 }
344 
345 SDValue DAGTypeLegalizer::SoftenFloatRes_FNEARBYINT(SDNode *N) {
346  EVT NVT = TLI.getTypeToTransformTo(*DAG.getContext(), N->getValueType(0));
347  SDValue Op = GetSoftenedFloat(N->getOperand(0));
348  return TLI.makeLibCall(DAG, GetFPLibCall(N->getValueType(0),
349  RTLIB::NEARBYINT_F32,
350  RTLIB::NEARBYINT_F64,
351  RTLIB::NEARBYINT_F80,
352  RTLIB::NEARBYINT_F128,
353  RTLIB::NEARBYINT_PPCF128),
354  NVT, &Op, 1, false, SDLoc(N)).first;
355 }
356 
357 SDValue DAGTypeLegalizer::SoftenFloatRes_FNEG(SDNode *N) {
358  EVT NVT = TLI.getTypeToTransformTo(*DAG.getContext(), N->getValueType(0));
359  // Expand Y = FNEG(X) -> Y = SUB -0.0, X
360  SDValue Ops[2] = { DAG.getConstantFP(-0.0, N->getValueType(0)),
361  GetSoftenedFloat(N->getOperand(0)) };
362  return TLI.makeLibCall(DAG, GetFPLibCall(N->getValueType(0),
363  RTLIB::SUB_F32,
364  RTLIB::SUB_F64,
365  RTLIB::SUB_F80,
366  RTLIB::SUB_F128,
367  RTLIB::SUB_PPCF128),
368  NVT, Ops, 2, false, SDLoc(N)).first;
369 }
370 
371 SDValue DAGTypeLegalizer::SoftenFloatRes_FP_EXTEND(SDNode *N) {
372  EVT NVT = TLI.getTypeToTransformTo(*DAG.getContext(), N->getValueType(0));
373  SDValue Op = N->getOperand(0);
374  RTLIB::Libcall LC = RTLIB::getFPEXT(Op.getValueType(), N->getValueType(0));
375  assert(LC != RTLIB::UNKNOWN_LIBCALL && "Unsupported FP_EXTEND!");
376  return TLI.makeLibCall(DAG, LC, NVT, &Op, 1, false, SDLoc(N)).first;
377 }
378 
379 // FIXME: Should we just use 'normal' FP_EXTEND / FP_TRUNC instead of special
380 // nodes?
381 SDValue DAGTypeLegalizer::SoftenFloatRes_FP16_TO_FP32(SDNode *N) {
382  EVT NVT = TLI.getTypeToTransformTo(*DAG.getContext(), N->getValueType(0));
383  SDValue Op = N->getOperand(0);
384  return TLI.makeLibCall(DAG, RTLIB::FPEXT_F16_F32, NVT, &Op, 1, false,
385  SDLoc(N)).first;
386 }
387 
388 SDValue DAGTypeLegalizer::SoftenFloatRes_FP_ROUND(SDNode *N) {
389  EVT NVT = TLI.getTypeToTransformTo(*DAG.getContext(), N->getValueType(0));
390  SDValue Op = N->getOperand(0);
391  RTLIB::Libcall LC = RTLIB::getFPROUND(Op.getValueType(), N->getValueType(0));
392  assert(LC != RTLIB::UNKNOWN_LIBCALL && "Unsupported FP_ROUND!");
393  return TLI.makeLibCall(DAG, LC, NVT, &Op, 1, false, SDLoc(N)).first;
394 }
395 
396 SDValue DAGTypeLegalizer::SoftenFloatRes_FPOW(SDNode *N) {
397  EVT NVT = TLI.getTypeToTransformTo(*DAG.getContext(), N->getValueType(0));
398  SDValue Ops[2] = { GetSoftenedFloat(N->getOperand(0)),
399  GetSoftenedFloat(N->getOperand(1)) };
400  return TLI.makeLibCall(DAG, GetFPLibCall(N->getValueType(0),
401  RTLIB::POW_F32,
402  RTLIB::POW_F64,
403  RTLIB::POW_F80,
404  RTLIB::POW_F128,
405  RTLIB::POW_PPCF128),
406  NVT, Ops, 2, false, SDLoc(N)).first;
407 }
408 
409 SDValue DAGTypeLegalizer::SoftenFloatRes_FPOWI(SDNode *N) {
410  assert(N->getOperand(1).getValueType() == MVT::i32 &&
411  "Unsupported power type!");
412  EVT NVT = TLI.getTypeToTransformTo(*DAG.getContext(), N->getValueType(0));
413  SDValue Ops[2] = { GetSoftenedFloat(N->getOperand(0)), N->getOperand(1) };
414  return TLI.makeLibCall(DAG, GetFPLibCall(N->getValueType(0),
415  RTLIB::POWI_F32,
416  RTLIB::POWI_F64,
417  RTLIB::POWI_F80,
418  RTLIB::POWI_F128,
419  RTLIB::POWI_PPCF128),
420  NVT, Ops, 2, false, SDLoc(N)).first;
421 }
422 
423 SDValue DAGTypeLegalizer::SoftenFloatRes_FREM(SDNode *N) {
424  EVT NVT = TLI.getTypeToTransformTo(*DAG.getContext(), N->getValueType(0));
425  SDValue Ops[2] = { GetSoftenedFloat(N->getOperand(0)),
426  GetSoftenedFloat(N->getOperand(1)) };
427  return TLI.makeLibCall(DAG, GetFPLibCall(N->getValueType(0),
428  RTLIB::REM_F32,
429  RTLIB::REM_F64,
430  RTLIB::REM_F80,
431  RTLIB::REM_F128,
432  RTLIB::REM_PPCF128),
433  NVT, Ops, 2, false, SDLoc(N)).first;
434 }
435 
436 SDValue DAGTypeLegalizer::SoftenFloatRes_FRINT(SDNode *N) {
437  EVT NVT = TLI.getTypeToTransformTo(*DAG.getContext(), N->getValueType(0));
438  SDValue Op = GetSoftenedFloat(N->getOperand(0));
439  return TLI.makeLibCall(DAG, GetFPLibCall(N->getValueType(0),
440  RTLIB::RINT_F32,
441  RTLIB::RINT_F64,
442  RTLIB::RINT_F80,
443  RTLIB::RINT_F128,
444  RTLIB::RINT_PPCF128),
445  NVT, &Op, 1, false, SDLoc(N)).first;
446 }
447 
448 SDValue DAGTypeLegalizer::SoftenFloatRes_FROUND(SDNode *N) {
449  EVT NVT = TLI.getTypeToTransformTo(*DAG.getContext(), N->getValueType(0));
450  SDValue Op = GetSoftenedFloat(N->getOperand(0));
451  return TLI.makeLibCall(DAG, GetFPLibCall(N->getValueType(0),
452  RTLIB::ROUND_F32,
453  RTLIB::ROUND_F64,
454  RTLIB::ROUND_F80,
455  RTLIB::ROUND_F128,
456  RTLIB::ROUND_PPCF128),
457  NVT, &Op, 1, false, SDLoc(N)).first;
458 }
459 
460 SDValue DAGTypeLegalizer::SoftenFloatRes_FSIN(SDNode *N) {
461  EVT NVT = TLI.getTypeToTransformTo(*DAG.getContext(), N->getValueType(0));
462  SDValue Op = GetSoftenedFloat(N->getOperand(0));
463  return TLI.makeLibCall(DAG, GetFPLibCall(N->getValueType(0),
464  RTLIB::SIN_F32,
465  RTLIB::SIN_F64,
466  RTLIB::SIN_F80,
467  RTLIB::SIN_F128,
468  RTLIB::SIN_PPCF128),
469  NVT, &Op, 1, false, SDLoc(N)).first;
470 }
471 
472 SDValue DAGTypeLegalizer::SoftenFloatRes_FSQRT(SDNode *N) {
473  EVT NVT = TLI.getTypeToTransformTo(*DAG.getContext(), N->getValueType(0));
474  SDValue Op = GetSoftenedFloat(N->getOperand(0));
475  return TLI.makeLibCall(DAG, GetFPLibCall(N->getValueType(0),
476  RTLIB::SQRT_F32,
477  RTLIB::SQRT_F64,
478  RTLIB::SQRT_F80,
479  RTLIB::SQRT_F128,
480  RTLIB::SQRT_PPCF128),
481  NVT, &Op, 1, false, SDLoc(N)).first;
482 }
483 
484 SDValue DAGTypeLegalizer::SoftenFloatRes_FSUB(SDNode *N) {
485  EVT NVT = TLI.getTypeToTransformTo(*DAG.getContext(), N->getValueType(0));
486  SDValue Ops[2] = { GetSoftenedFloat(N->getOperand(0)),
487  GetSoftenedFloat(N->getOperand(1)) };
488  return TLI.makeLibCall(DAG, GetFPLibCall(N->getValueType(0),
489  RTLIB::SUB_F32,
490  RTLIB::SUB_F64,
491  RTLIB::SUB_F80,
492  RTLIB::SUB_F128,
493  RTLIB::SUB_PPCF128),
494  NVT, Ops, 2, false, SDLoc(N)).first;
495 }
496 
497 SDValue DAGTypeLegalizer::SoftenFloatRes_FTRUNC(SDNode *N) {
498  EVT NVT = TLI.getTypeToTransformTo(*DAG.getContext(), N->getValueType(0));
499  SDValue Op = GetSoftenedFloat(N->getOperand(0));
500  return TLI.makeLibCall(DAG, GetFPLibCall(N->getValueType(0),
501  RTLIB::TRUNC_F32,
502  RTLIB::TRUNC_F64,
503  RTLIB::TRUNC_F80,
504  RTLIB::TRUNC_F128,
505  RTLIB::TRUNC_PPCF128),
506  NVT, &Op, 1, false, SDLoc(N)).first;
507 }
508 
509 SDValue DAGTypeLegalizer::SoftenFloatRes_LOAD(SDNode *N) {
510  LoadSDNode *L = cast<LoadSDNode>(N);
511  EVT VT = N->getValueType(0);
512  EVT NVT = TLI.getTypeToTransformTo(*DAG.getContext(), VT);
513  SDLoc dl(N);
514 
515  SDValue NewL;
516  if (L->getExtensionType() == ISD::NON_EXTLOAD) {
517  NewL = DAG.getLoad(L->getAddressingMode(), L->getExtensionType(),
518  NVT, dl, L->getChain(), L->getBasePtr(), L->getOffset(),
519  L->getPointerInfo(), NVT, L->isVolatile(),
520  L->isNonTemporal(), false, L->getAlignment(),
521  L->getTBAAInfo());
522  // Legalized the chain result - switch anything that used the old chain to
523  // use the new one.
524  ReplaceValueWith(SDValue(N, 1), NewL.getValue(1));
525  return NewL;
526  }
527 
528  // Do a non-extending load followed by FP_EXTEND.
529  NewL = DAG.getLoad(L->getAddressingMode(), ISD::NON_EXTLOAD,
530  L->getMemoryVT(), dl, L->getChain(),
531  L->getBasePtr(), L->getOffset(), L->getPointerInfo(),
532  L->getMemoryVT(), L->isVolatile(),
533  L->isNonTemporal(), false, L->getAlignment(),
534  L->getTBAAInfo());
535  // Legalized the chain result - switch anything that used the old chain to
536  // use the new one.
537  ReplaceValueWith(SDValue(N, 1), NewL.getValue(1));
538  return BitConvertToInteger(DAG.getNode(ISD::FP_EXTEND, dl, VT, NewL));
539 }
540 
541 SDValue DAGTypeLegalizer::SoftenFloatRes_SELECT(SDNode *N) {
542  SDValue LHS = GetSoftenedFloat(N->getOperand(1));
543  SDValue RHS = GetSoftenedFloat(N->getOperand(2));
544  return DAG.getSelect(SDLoc(N),
545  LHS.getValueType(), N->getOperand(0), LHS, RHS);
546 }
547 
548 SDValue DAGTypeLegalizer::SoftenFloatRes_SELECT_CC(SDNode *N) {
549  SDValue LHS = GetSoftenedFloat(N->getOperand(2));
550  SDValue RHS = GetSoftenedFloat(N->getOperand(3));
551  return DAG.getNode(ISD::SELECT_CC, SDLoc(N),
552  LHS.getValueType(), N->getOperand(0),
553  N->getOperand(1), LHS, RHS, N->getOperand(4));
554 }
555 
556 SDValue DAGTypeLegalizer::SoftenFloatRes_UNDEF(SDNode *N) {
557  return DAG.getUNDEF(TLI.getTypeToTransformTo(*DAG.getContext(),
558  N->getValueType(0)));
559 }
560 
561 SDValue DAGTypeLegalizer::SoftenFloatRes_VAARG(SDNode *N) {
562  SDValue Chain = N->getOperand(0); // Get the chain.
563  SDValue Ptr = N->getOperand(1); // Get the pointer.
564  EVT VT = N->getValueType(0);
565  EVT NVT = TLI.getTypeToTransformTo(*DAG.getContext(), VT);
566  SDLoc dl(N);
567 
568  SDValue NewVAARG;
569  NewVAARG = DAG.getVAArg(NVT, dl, Chain, Ptr, N->getOperand(2),
570  N->getConstantOperandVal(3));
571 
572  // Legalized the chain result - switch anything that used the old chain to
573  // use the new one.
574  ReplaceValueWith(SDValue(N, 1), NewVAARG.getValue(1));
575  return NewVAARG;
576 }
577 
578 SDValue DAGTypeLegalizer::SoftenFloatRes_XINT_TO_FP(SDNode *N) {
579  bool Signed = N->getOpcode() == ISD::SINT_TO_FP;
580  EVT SVT = N->getOperand(0).getValueType();
581  EVT RVT = N->getValueType(0);
582  EVT NVT = EVT();
583  SDLoc dl(N);
584 
585  // If the input is not legal, eg: i1 -> fp, then it needs to be promoted to
586  // a larger type, eg: i8 -> fp. Even if it is legal, no libcall may exactly
587  // match. Look for an appropriate libcall.
588  RTLIB::Libcall LC = RTLIB::UNKNOWN_LIBCALL;
589  for (unsigned t = MVT::FIRST_INTEGER_VALUETYPE;
590  t <= MVT::LAST_INTEGER_VALUETYPE && LC == RTLIB::UNKNOWN_LIBCALL; ++t) {
591  NVT = (MVT::SimpleValueType)t;
592  // The source needs to big enough to hold the operand.
593  if (NVT.bitsGE(SVT))
594  LC = Signed ? RTLIB::getSINTTOFP(NVT, RVT):RTLIB::getUINTTOFP (NVT, RVT);
595  }
596  assert(LC != RTLIB::UNKNOWN_LIBCALL && "Unsupported XINT_TO_FP!");
597 
598  // Sign/zero extend the argument if the libcall takes a larger type.
599  SDValue Op = DAG.getNode(Signed ? ISD::SIGN_EXTEND : ISD::ZERO_EXTEND, dl,
600  NVT, N->getOperand(0));
601  return TLI.makeLibCall(DAG, LC,
602  TLI.getTypeToTransformTo(*DAG.getContext(), RVT),
603  &Op, 1, false, dl).first;
604 }
605 
606 
607 //===----------------------------------------------------------------------===//
608 // Operand Float to Integer Conversion..
609 //===----------------------------------------------------------------------===//
610 
611 bool DAGTypeLegalizer::SoftenFloatOperand(SDNode *N, unsigned OpNo) {
612  DEBUG(dbgs() << "Soften float operand " << OpNo << ": "; N->dump(&DAG);
613  dbgs() << "\n");
614  SDValue Res = SDValue();
615 
616  switch (N->getOpcode()) {
617  default:
618 #ifndef NDEBUG
619  dbgs() << "SoftenFloatOperand Op #" << OpNo << ": ";
620  N->dump(&DAG); dbgs() << "\n";
621 #endif
622  llvm_unreachable("Do not know how to soften this operator's operand!");
623 
624  case ISD::BITCAST: Res = SoftenFloatOp_BITCAST(N); break;
625  case ISD::BR_CC: Res = SoftenFloatOp_BR_CC(N); break;
626  case ISD::FP_ROUND: Res = SoftenFloatOp_FP_ROUND(N); break;
627  case ISD::FP_TO_SINT: Res = SoftenFloatOp_FP_TO_SINT(N); break;
628  case ISD::FP_TO_UINT: Res = SoftenFloatOp_FP_TO_UINT(N); break;
629  case ISD::FP32_TO_FP16:Res = SoftenFloatOp_FP32_TO_FP16(N); break;
630  case ISD::SELECT_CC: Res = SoftenFloatOp_SELECT_CC(N); break;
631  case ISD::SETCC: Res = SoftenFloatOp_SETCC(N); break;
632  case ISD::STORE: Res = SoftenFloatOp_STORE(N, OpNo); break;
633  }
634 
635  // If the result is null, the sub-method took care of registering results etc.
636  if (!Res.getNode()) return false;
637 
638  // If the result is N, the sub-method updated N in place. Tell the legalizer
639  // core about this.
640  if (Res.getNode() == N)
641  return true;
642 
643  assert(Res.getValueType() == N->getValueType(0) && N->getNumValues() == 1 &&
644  "Invalid operand expansion");
645 
646  ReplaceValueWith(SDValue(N, 0), Res);
647  return false;
648 }
649 
650 SDValue DAGTypeLegalizer::SoftenFloatOp_BITCAST(SDNode *N) {
651  return DAG.getNode(ISD::BITCAST, SDLoc(N), N->getValueType(0),
652  GetSoftenedFloat(N->getOperand(0)));
653 }
654 
655 SDValue DAGTypeLegalizer::SoftenFloatOp_FP_ROUND(SDNode *N) {
656  EVT SVT = N->getOperand(0).getValueType();
657  EVT RVT = N->getValueType(0);
658 
659  RTLIB::Libcall LC = RTLIB::getFPROUND(SVT, RVT);
660  assert(LC != RTLIB::UNKNOWN_LIBCALL && "Unsupported FP_ROUND libcall");
661 
662  SDValue Op = GetSoftenedFloat(N->getOperand(0));
663  return TLI.makeLibCall(DAG, LC, RVT, &Op, 1, false, SDLoc(N)).first;
664 }
665 
666 SDValue DAGTypeLegalizer::SoftenFloatOp_BR_CC(SDNode *N) {
667  SDValue NewLHS = N->getOperand(2), NewRHS = N->getOperand(3);
668  ISD::CondCode CCCode = cast<CondCodeSDNode>(N->getOperand(1))->get();
669 
670  EVT VT = NewLHS.getValueType();
671  NewLHS = GetSoftenedFloat(NewLHS);
672  NewRHS = GetSoftenedFloat(NewRHS);
673  TLI.softenSetCCOperands(DAG, VT, NewLHS, NewRHS, CCCode, SDLoc(N));
674 
675  // If softenSetCCOperands returned a scalar, we need to compare the result
676  // against zero to select between true and false values.
677  if (NewRHS.getNode() == 0) {
678  NewRHS = DAG.getConstant(0, NewLHS.getValueType());
679  CCCode = ISD::SETNE;
680  }
681 
682  // Update N to have the operands specified.
683  return SDValue(DAG.UpdateNodeOperands(N, N->getOperand(0),
684  DAG.getCondCode(CCCode), NewLHS, NewRHS,
685  N->getOperand(4)),
686  0);
687 }
688 
689 SDValue DAGTypeLegalizer::SoftenFloatOp_FP_TO_SINT(SDNode *N) {
690  EVT RVT = N->getValueType(0);
691  RTLIB::Libcall LC = RTLIB::getFPTOSINT(N->getOperand(0).getValueType(), RVT);
692  assert(LC != RTLIB::UNKNOWN_LIBCALL && "Unsupported FP_TO_SINT!");
693  SDValue Op = GetSoftenedFloat(N->getOperand(0));
694  return TLI.makeLibCall(DAG, LC, RVT, &Op, 1, false, SDLoc(N)).first;
695 }
696 
697 SDValue DAGTypeLegalizer::SoftenFloatOp_FP_TO_UINT(SDNode *N) {
698  EVT RVT = N->getValueType(0);
699  RTLIB::Libcall LC = RTLIB::getFPTOUINT(N->getOperand(0).getValueType(), RVT);
700  assert(LC != RTLIB::UNKNOWN_LIBCALL && "Unsupported FP_TO_UINT!");
701  SDValue Op = GetSoftenedFloat(N->getOperand(0));
702  return TLI.makeLibCall(DAG, LC, RVT, &Op, 1, false, SDLoc(N)).first;
703 }
704 
705 SDValue DAGTypeLegalizer::SoftenFloatOp_FP32_TO_FP16(SDNode *N) {
706  EVT RVT = N->getValueType(0);
707  RTLIB::Libcall LC = RTLIB::FPROUND_F32_F16;
708  SDValue Op = GetSoftenedFloat(N->getOperand(0));
709  return TLI.makeLibCall(DAG, LC, RVT, &Op, 1, false, SDLoc(N)).first;
710 }
711 
712 SDValue DAGTypeLegalizer::SoftenFloatOp_SELECT_CC(SDNode *N) {
713  SDValue NewLHS = N->getOperand(0), NewRHS = N->getOperand(1);
714  ISD::CondCode CCCode = cast<CondCodeSDNode>(N->getOperand(4))->get();
715 
716  EVT VT = NewLHS.getValueType();
717  NewLHS = GetSoftenedFloat(NewLHS);
718  NewRHS = GetSoftenedFloat(NewRHS);
719  TLI.softenSetCCOperands(DAG, VT, NewLHS, NewRHS, CCCode, SDLoc(N));
720 
721  // If softenSetCCOperands returned a scalar, we need to compare the result
722  // against zero to select between true and false values.
723  if (NewRHS.getNode() == 0) {
724  NewRHS = DAG.getConstant(0, NewLHS.getValueType());
725  CCCode = ISD::SETNE;
726  }
727 
728  // Update N to have the operands specified.
729  return SDValue(DAG.UpdateNodeOperands(N, NewLHS, NewRHS,
730  N->getOperand(2), N->getOperand(3),
731  DAG.getCondCode(CCCode)),
732  0);
733 }
734 
735 SDValue DAGTypeLegalizer::SoftenFloatOp_SETCC(SDNode *N) {
736  SDValue NewLHS = N->getOperand(0), NewRHS = N->getOperand(1);
737  ISD::CondCode CCCode = cast<CondCodeSDNode>(N->getOperand(2))->get();
738 
739  EVT VT = NewLHS.getValueType();
740  NewLHS = GetSoftenedFloat(NewLHS);
741  NewRHS = GetSoftenedFloat(NewRHS);
742  TLI.softenSetCCOperands(DAG, VT, NewLHS, NewRHS, CCCode, SDLoc(N));
743 
744  // If softenSetCCOperands returned a scalar, use it.
745  if (NewRHS.getNode() == 0) {
746  assert(NewLHS.getValueType() == N->getValueType(0) &&
747  "Unexpected setcc expansion!");
748  return NewLHS;
749  }
750 
751  // Otherwise, update N to have the operands specified.
752  return SDValue(DAG.UpdateNodeOperands(N, NewLHS, NewRHS,
753  DAG.getCondCode(CCCode)),
754  0);
755 }
756 
757 SDValue DAGTypeLegalizer::SoftenFloatOp_STORE(SDNode *N, unsigned OpNo) {
758  assert(ISD::isUNINDEXEDStore(N) && "Indexed store during type legalization!");
759  assert(OpNo == 1 && "Can only soften the stored value!");
760  StoreSDNode *ST = cast<StoreSDNode>(N);
761  SDValue Val = ST->getValue();
762  SDLoc dl(N);
763 
764  if (ST->isTruncatingStore())
765  // Do an FP_ROUND followed by a non-truncating store.
766  Val = BitConvertToInteger(DAG.getNode(ISD::FP_ROUND, dl, ST->getMemoryVT(),
767  Val, DAG.getIntPtrConstant(0)));
768  else
769  Val = GetSoftenedFloat(Val);
770 
771  return DAG.getStore(ST->getChain(), dl, Val, ST->getBasePtr(),
772  ST->getMemOperand());
773 }
774 
775 
776 //===----------------------------------------------------------------------===//
777 // Float Result Expansion
778 //===----------------------------------------------------------------------===//
779 
780 /// ExpandFloatResult - This method is called when the specified result of the
781 /// specified node is found to need expansion. At this point, the node may also
782 /// have invalid operands or may have other results that need promotion, we just
783 /// know that (at least) one result needs expansion.
784 void DAGTypeLegalizer::ExpandFloatResult(SDNode *N, unsigned ResNo) {
785  DEBUG(dbgs() << "Expand float result: "; N->dump(&DAG); dbgs() << "\n");
786  SDValue Lo, Hi;
787  Lo = Hi = SDValue();
788 
789  // See if the target wants to custom expand this node.
790  if (CustomLowerNode(N, N->getValueType(ResNo), true))
791  return;
792 
793  switch (N->getOpcode()) {
794  default:
795 #ifndef NDEBUG
796  dbgs() << "ExpandFloatResult #" << ResNo << ": ";
797  N->dump(&DAG); dbgs() << "\n";
798 #endif
799  llvm_unreachable("Do not know how to expand the result of this operator!");
800 
801  case ISD::UNDEF: SplitRes_UNDEF(N, Lo, Hi); break;
802  case ISD::SELECT: SplitRes_SELECT(N, Lo, Hi); break;
803  case ISD::SELECT_CC: SplitRes_SELECT_CC(N, Lo, Hi); break;
804 
805  case ISD::MERGE_VALUES: ExpandRes_MERGE_VALUES(N, ResNo, Lo, Hi); break;
806  case ISD::BITCAST: ExpandRes_BITCAST(N, Lo, Hi); break;
807  case ISD::BUILD_PAIR: ExpandRes_BUILD_PAIR(N, Lo, Hi); break;
808  case ISD::EXTRACT_ELEMENT: ExpandRes_EXTRACT_ELEMENT(N, Lo, Hi); break;
809  case ISD::EXTRACT_VECTOR_ELT: ExpandRes_EXTRACT_VECTOR_ELT(N, Lo, Hi); break;
810  case ISD::VAARG: ExpandRes_VAARG(N, Lo, Hi); break;
811 
812  case ISD::ConstantFP: ExpandFloatRes_ConstantFP(N, Lo, Hi); break;
813  case ISD::FABS: ExpandFloatRes_FABS(N, Lo, Hi); break;
814  case ISD::FADD: ExpandFloatRes_FADD(N, Lo, Hi); break;
815  case ISD::FCEIL: ExpandFloatRes_FCEIL(N, Lo, Hi); break;
816  case ISD::FCOPYSIGN: ExpandFloatRes_FCOPYSIGN(N, Lo, Hi); break;
817  case ISD::FCOS: ExpandFloatRes_FCOS(N, Lo, Hi); break;
818  case ISD::FDIV: ExpandFloatRes_FDIV(N, Lo, Hi); break;
819  case ISD::FEXP: ExpandFloatRes_FEXP(N, Lo, Hi); break;
820  case ISD::FEXP2: ExpandFloatRes_FEXP2(N, Lo, Hi); break;
821  case ISD::FFLOOR: ExpandFloatRes_FFLOOR(N, Lo, Hi); break;
822  case ISD::FLOG: ExpandFloatRes_FLOG(N, Lo, Hi); break;
823  case ISD::FLOG2: ExpandFloatRes_FLOG2(N, Lo, Hi); break;
824  case ISD::FLOG10: ExpandFloatRes_FLOG10(N, Lo, Hi); break;
825  case ISD::FMA: ExpandFloatRes_FMA(N, Lo, Hi); break;
826  case ISD::FMUL: ExpandFloatRes_FMUL(N, Lo, Hi); break;
827  case ISD::FNEARBYINT: ExpandFloatRes_FNEARBYINT(N, Lo, Hi); break;
828  case ISD::FNEG: ExpandFloatRes_FNEG(N, Lo, Hi); break;
829  case ISD::FP_EXTEND: ExpandFloatRes_FP_EXTEND(N, Lo, Hi); break;
830  case ISD::FPOW: ExpandFloatRes_FPOW(N, Lo, Hi); break;
831  case ISD::FPOWI: ExpandFloatRes_FPOWI(N, Lo, Hi); break;
832  case ISD::FRINT: ExpandFloatRes_FRINT(N, Lo, Hi); break;
833  case ISD::FROUND: ExpandFloatRes_FROUND(N, Lo, Hi); break;
834  case ISD::FSIN: ExpandFloatRes_FSIN(N, Lo, Hi); break;
835  case ISD::FSQRT: ExpandFloatRes_FSQRT(N, Lo, Hi); break;
836  case ISD::FSUB: ExpandFloatRes_FSUB(N, Lo, Hi); break;
837  case ISD::FTRUNC: ExpandFloatRes_FTRUNC(N, Lo, Hi); break;
838  case ISD::LOAD: ExpandFloatRes_LOAD(N, Lo, Hi); break;
839  case ISD::SINT_TO_FP:
840  case ISD::UINT_TO_FP: ExpandFloatRes_XINT_TO_FP(N, Lo, Hi); break;
841  case ISD::FREM: ExpandFloatRes_FREM(N, Lo, Hi); break;
842  }
843 
844  // If Lo/Hi is null, the sub-method took care of registering results etc.
845  if (Lo.getNode())
846  SetExpandedFloat(SDValue(N, ResNo), Lo, Hi);
847 }
848 
849 void DAGTypeLegalizer::ExpandFloatRes_ConstantFP(SDNode *N, SDValue &Lo,
850  SDValue &Hi) {
851  EVT NVT = TLI.getTypeToTransformTo(*DAG.getContext(), N->getValueType(0));
852  assert(NVT.getSizeInBits() == integerPartWidth &&
853  "Do not know how to expand this float constant!");
854  APInt C = cast<ConstantFPSDNode>(N)->getValueAPF().bitcastToAPInt();
855  Lo = DAG.getConstantFP(APFloat(DAG.EVTToAPFloatSemantics(NVT),
856  APInt(integerPartWidth, C.getRawData()[1])),
857  NVT);
858  Hi = DAG.getConstantFP(APFloat(DAG.EVTToAPFloatSemantics(NVT),
859  APInt(integerPartWidth, C.getRawData()[0])),
860  NVT);
861 }
862 
863 void DAGTypeLegalizer::ExpandFloatRes_FABS(SDNode *N, SDValue &Lo,
864  SDValue &Hi) {
865  assert(N->getValueType(0) == MVT::ppcf128 &&
866  "Logic only correct for ppcf128!");
867  SDLoc dl(N);
868  SDValue Tmp;
869  GetExpandedFloat(N->getOperand(0), Lo, Tmp);
870  Hi = DAG.getNode(ISD::FABS, dl, Tmp.getValueType(), Tmp);
871  // Lo = Hi==fabs(Hi) ? Lo : -Lo;
872  Lo = DAG.getSelectCC(dl, Tmp, Hi, Lo,
873  DAG.getNode(ISD::FNEG, dl, Lo.getValueType(), Lo),
874  ISD::SETEQ);
875 }
876 
877 void DAGTypeLegalizer::ExpandFloatRes_FADD(SDNode *N, SDValue &Lo,
878  SDValue &Hi) {
879  SDValue Call = LibCallify(GetFPLibCall(N->getValueType(0),
880  RTLIB::ADD_F32, RTLIB::ADD_F64,
881  RTLIB::ADD_F80, RTLIB::ADD_F128,
882  RTLIB::ADD_PPCF128),
883  N, false);
884  GetPairElements(Call, Lo, Hi);
885 }
886 
887 void DAGTypeLegalizer::ExpandFloatRes_FCEIL(SDNode *N,
888  SDValue &Lo, SDValue &Hi) {
889  SDValue Call = LibCallify(GetFPLibCall(N->getValueType(0),
890  RTLIB::CEIL_F32, RTLIB::CEIL_F64,
891  RTLIB::CEIL_F80, RTLIB::CEIL_F128,
892  RTLIB::CEIL_PPCF128),
893  N, false);
894  GetPairElements(Call, Lo, Hi);
895 }
896 
897 void DAGTypeLegalizer::ExpandFloatRes_FCOPYSIGN(SDNode *N,
898  SDValue &Lo, SDValue &Hi) {
899  SDValue Call = LibCallify(GetFPLibCall(N->getValueType(0),
900  RTLIB::COPYSIGN_F32,
901  RTLIB::COPYSIGN_F64,
902  RTLIB::COPYSIGN_F80,
903  RTLIB::COPYSIGN_F128,
904  RTLIB::COPYSIGN_PPCF128),
905  N, false);
906  GetPairElements(Call, Lo, Hi);
907 }
908 
909 void DAGTypeLegalizer::ExpandFloatRes_FCOS(SDNode *N,
910  SDValue &Lo, SDValue &Hi) {
911  SDValue Call = LibCallify(GetFPLibCall(N->getValueType(0),
912  RTLIB::COS_F32, RTLIB::COS_F64,
913  RTLIB::COS_F80, RTLIB::COS_F128,
914  RTLIB::COS_PPCF128),
915  N, false);
916  GetPairElements(Call, Lo, Hi);
917 }
918 
919 void DAGTypeLegalizer::ExpandFloatRes_FDIV(SDNode *N, SDValue &Lo,
920  SDValue &Hi) {
921  SDValue Ops[2] = { N->getOperand(0), N->getOperand(1) };
922  SDValue Call = TLI.makeLibCall(DAG, GetFPLibCall(N->getValueType(0),
923  RTLIB::DIV_F32,
924  RTLIB::DIV_F64,
925  RTLIB::DIV_F80,
926  RTLIB::DIV_F128,
927  RTLIB::DIV_PPCF128),
928  N->getValueType(0), Ops, 2, false,
929  SDLoc(N)).first;
930  GetPairElements(Call, Lo, Hi);
931 }
932 
933 void DAGTypeLegalizer::ExpandFloatRes_FEXP(SDNode *N,
934  SDValue &Lo, SDValue &Hi) {
935  SDValue Call = LibCallify(GetFPLibCall(N->getValueType(0),
936  RTLIB::EXP_F32, RTLIB::EXP_F64,
937  RTLIB::EXP_F80, RTLIB::EXP_F128,
938  RTLIB::EXP_PPCF128),
939  N, false);
940  GetPairElements(Call, Lo, Hi);
941 }
942 
943 void DAGTypeLegalizer::ExpandFloatRes_FEXP2(SDNode *N,
944  SDValue &Lo, SDValue &Hi) {
945  SDValue Call = LibCallify(GetFPLibCall(N->getValueType(0),
946  RTLIB::EXP2_F32, RTLIB::EXP2_F64,
947  RTLIB::EXP2_F80, RTLIB::EXP2_F128,
948  RTLIB::EXP2_PPCF128),
949  N, false);
950  GetPairElements(Call, Lo, Hi);
951 }
952 
953 void DAGTypeLegalizer::ExpandFloatRes_FFLOOR(SDNode *N,
954  SDValue &Lo, SDValue &Hi) {
955  SDValue Call = LibCallify(GetFPLibCall(N->getValueType(0),
956  RTLIB::FLOOR_F32, RTLIB::FLOOR_F64,
957  RTLIB::FLOOR_F80, RTLIB::FLOOR_F128,
958  RTLIB::FLOOR_PPCF128),
959  N, false);
960  GetPairElements(Call, Lo, Hi);
961 }
962 
963 void DAGTypeLegalizer::ExpandFloatRes_FLOG(SDNode *N,
964  SDValue &Lo, SDValue &Hi) {
965  SDValue Call = LibCallify(GetFPLibCall(N->getValueType(0),
966  RTLIB::LOG_F32, RTLIB::LOG_F64,
967  RTLIB::LOG_F80, RTLIB::LOG_F128,
968  RTLIB::LOG_PPCF128),
969  N, false);
970  GetPairElements(Call, Lo, Hi);
971 }
972 
973 void DAGTypeLegalizer::ExpandFloatRes_FLOG2(SDNode *N,
974  SDValue &Lo, SDValue &Hi) {
975  SDValue Call = LibCallify(GetFPLibCall(N->getValueType(0),
976  RTLIB::LOG2_F32, RTLIB::LOG2_F64,
977  RTLIB::LOG2_F80, RTLIB::LOG2_F128,
978  RTLIB::LOG2_PPCF128),
979  N, false);
980  GetPairElements(Call, Lo, Hi);
981 }
982 
983 void DAGTypeLegalizer::ExpandFloatRes_FLOG10(SDNode *N,
984  SDValue &Lo, SDValue &Hi) {
985  SDValue Call = LibCallify(GetFPLibCall(N->getValueType(0),
986  RTLIB::LOG10_F32, RTLIB::LOG10_F64,
987  RTLIB::LOG10_F80, RTLIB::LOG10_F128,
988  RTLIB::LOG10_PPCF128),
989  N, false);
990  GetPairElements(Call, Lo, Hi);
991 }
992 
993 void DAGTypeLegalizer::ExpandFloatRes_FMA(SDNode *N, SDValue &Lo,
994  SDValue &Hi) {
995  SDValue Ops[3] = { N->getOperand(0), N->getOperand(1), N->getOperand(2) };
996  SDValue Call = TLI.makeLibCall(DAG, GetFPLibCall(N->getValueType(0),
997  RTLIB::FMA_F32,
998  RTLIB::FMA_F64,
999  RTLIB::FMA_F80,
1000  RTLIB::FMA_F128,
1001  RTLIB::FMA_PPCF128),
1002  N->getValueType(0), Ops, 3, false,
1003  SDLoc(N)).first;
1004  GetPairElements(Call, Lo, Hi);
1005 }
1006 
1007 void DAGTypeLegalizer::ExpandFloatRes_FMUL(SDNode *N, SDValue &Lo,
1008  SDValue &Hi) {
1009  SDValue Ops[2] = { N->getOperand(0), N->getOperand(1) };
1010  SDValue Call = TLI.makeLibCall(DAG, GetFPLibCall(N->getValueType(0),
1011  RTLIB::MUL_F32,
1012  RTLIB::MUL_F64,
1013  RTLIB::MUL_F80,
1014  RTLIB::MUL_F128,
1015  RTLIB::MUL_PPCF128),
1016  N->getValueType(0), Ops, 2, false,
1017  SDLoc(N)).first;
1018  GetPairElements(Call, Lo, Hi);
1019 }
1020 
1021 void DAGTypeLegalizer::ExpandFloatRes_FNEARBYINT(SDNode *N,
1022  SDValue &Lo, SDValue &Hi) {
1023  SDValue Call = LibCallify(GetFPLibCall(N->getValueType(0),
1024  RTLIB::NEARBYINT_F32,
1025  RTLIB::NEARBYINT_F64,
1026  RTLIB::NEARBYINT_F80,
1027  RTLIB::NEARBYINT_F128,
1028  RTLIB::NEARBYINT_PPCF128),
1029  N, false);
1030  GetPairElements(Call, Lo, Hi);
1031 }
1032 
1033 void DAGTypeLegalizer::ExpandFloatRes_FNEG(SDNode *N, SDValue &Lo,
1034  SDValue &Hi) {
1035  SDLoc dl(N);
1036  GetExpandedFloat(N->getOperand(0), Lo, Hi);
1037  Lo = DAG.getNode(ISD::FNEG, dl, Lo.getValueType(), Lo);
1038  Hi = DAG.getNode(ISD::FNEG, dl, Hi.getValueType(), Hi);
1039 }
1040 
1041 void DAGTypeLegalizer::ExpandFloatRes_FP_EXTEND(SDNode *N, SDValue &Lo,
1042  SDValue &Hi) {
1043  EVT NVT = TLI.getTypeToTransformTo(*DAG.getContext(), N->getValueType(0));
1044  Hi = DAG.getNode(ISD::FP_EXTEND, SDLoc(N), NVT, N->getOperand(0));
1045  Lo = DAG.getConstantFP(APFloat(DAG.EVTToAPFloatSemantics(NVT),
1046  APInt(NVT.getSizeInBits(), 0)), NVT);
1047 }
1048 
1049 void DAGTypeLegalizer::ExpandFloatRes_FPOW(SDNode *N,
1050  SDValue &Lo, SDValue &Hi) {
1051  SDValue Call = LibCallify(GetFPLibCall(N->getValueType(0),
1052  RTLIB::POW_F32, RTLIB::POW_F64,
1053  RTLIB::POW_F80, RTLIB::POW_F128,
1054  RTLIB::POW_PPCF128),
1055  N, false);
1056  GetPairElements(Call, Lo, Hi);
1057 }
1058 
1059 void DAGTypeLegalizer::ExpandFloatRes_FPOWI(SDNode *N,
1060  SDValue &Lo, SDValue &Hi) {
1061  SDValue Call = LibCallify(GetFPLibCall(N->getValueType(0),
1062  RTLIB::POWI_F32, RTLIB::POWI_F64,
1063  RTLIB::POWI_F80, RTLIB::POWI_F128,
1064  RTLIB::POWI_PPCF128),
1065  N, false);
1066  GetPairElements(Call, Lo, Hi);
1067 }
1068 
1069 void DAGTypeLegalizer::ExpandFloatRes_FREM(SDNode *N,
1070  SDValue &Lo, SDValue &Hi) {
1071  SDValue Call = LibCallify(GetFPLibCall(N->getValueType(0),
1072  RTLIB::REM_F32, RTLIB::REM_F64,
1073  RTLIB::REM_F80, RTLIB::REM_F128,
1074  RTLIB::REM_PPCF128),
1075  N, false);
1076  GetPairElements(Call, Lo, Hi);
1077 }
1078 
1079 void DAGTypeLegalizer::ExpandFloatRes_FRINT(SDNode *N,
1080  SDValue &Lo, SDValue &Hi) {
1081  SDValue Call = LibCallify(GetFPLibCall(N->getValueType(0),
1082  RTLIB::RINT_F32, RTLIB::RINT_F64,
1083  RTLIB::RINT_F80, RTLIB::RINT_F128,
1084  RTLIB::RINT_PPCF128),
1085  N, false);
1086  GetPairElements(Call, Lo, Hi);
1087 }
1088 
1089 void DAGTypeLegalizer::ExpandFloatRes_FROUND(SDNode *N,
1090  SDValue &Lo, SDValue &Hi) {
1091  SDValue Call = LibCallify(GetFPLibCall(N->getValueType(0),
1092  RTLIB::ROUND_F32,
1093  RTLIB::ROUND_F64,
1094  RTLIB::ROUND_F80,
1095  RTLIB::ROUND_F128,
1096  RTLIB::ROUND_PPCF128),
1097  N, false);
1098  GetPairElements(Call, Lo, Hi);
1099 }
1100 
1101 void DAGTypeLegalizer::ExpandFloatRes_FSIN(SDNode *N,
1102  SDValue &Lo, SDValue &Hi) {
1103  SDValue Call = LibCallify(GetFPLibCall(N->getValueType(0),
1104  RTLIB::SIN_F32, RTLIB::SIN_F64,
1105  RTLIB::SIN_F80, RTLIB::SIN_F128,
1106  RTLIB::SIN_PPCF128),
1107  N, false);
1108  GetPairElements(Call, Lo, Hi);
1109 }
1110 
1111 void DAGTypeLegalizer::ExpandFloatRes_FSQRT(SDNode *N,
1112  SDValue &Lo, SDValue &Hi) {
1113  SDValue Call = LibCallify(GetFPLibCall(N->getValueType(0),
1114  RTLIB::SQRT_F32, RTLIB::SQRT_F64,
1115  RTLIB::SQRT_F80, RTLIB::SQRT_F128,
1116  RTLIB::SQRT_PPCF128),
1117  N, false);
1118  GetPairElements(Call, Lo, Hi);
1119 }
1120 
1121 void DAGTypeLegalizer::ExpandFloatRes_FSUB(SDNode *N, SDValue &Lo,
1122  SDValue &Hi) {
1123  SDValue Ops[2] = { N->getOperand(0), N->getOperand(1) };
1124  SDValue Call = TLI.makeLibCall(DAG, GetFPLibCall(N->getValueType(0),
1125  RTLIB::SUB_F32,
1126  RTLIB::SUB_F64,
1127  RTLIB::SUB_F80,
1128  RTLIB::SUB_F128,
1129  RTLIB::SUB_PPCF128),
1130  N->getValueType(0), Ops, 2, false,
1131  SDLoc(N)).first;
1132  GetPairElements(Call, Lo, Hi);
1133 }
1134 
1135 void DAGTypeLegalizer::ExpandFloatRes_FTRUNC(SDNode *N,
1136  SDValue &Lo, SDValue &Hi) {
1137  SDValue Call = LibCallify(GetFPLibCall(N->getValueType(0),
1138  RTLIB::TRUNC_F32, RTLIB::TRUNC_F64,
1139  RTLIB::TRUNC_F80, RTLIB::TRUNC_F128,
1140  RTLIB::TRUNC_PPCF128),
1141  N, false);
1142  GetPairElements(Call, Lo, Hi);
1143 }
1144 
1145 void DAGTypeLegalizer::ExpandFloatRes_LOAD(SDNode *N, SDValue &Lo,
1146  SDValue &Hi) {
1147  if (ISD::isNormalLoad(N)) {
1148  ExpandRes_NormalLoad(N, Lo, Hi);
1149  return;
1150  }
1151 
1152  assert(ISD::isUNINDEXEDLoad(N) && "Indexed load during type legalization!");
1153  LoadSDNode *LD = cast<LoadSDNode>(N);
1154  SDValue Chain = LD->getChain();
1155  SDValue Ptr = LD->getBasePtr();
1156  SDLoc dl(N);
1157 
1158  EVT NVT = TLI.getTypeToTransformTo(*DAG.getContext(), LD->getValueType(0));
1159  assert(NVT.isByteSized() && "Expanded type not byte sized!");
1160  assert(LD->getMemoryVT().bitsLE(NVT) && "Float type not round?");
1161 
1162  Hi = DAG.getExtLoad(LD->getExtensionType(), dl, NVT, Chain, Ptr,
1163  LD->getMemoryVT(), LD->getMemOperand());
1164 
1165  // Remember the chain.
1166  Chain = Hi.getValue(1);
1167 
1168  // The low part is zero.
1169  Lo = DAG.getConstantFP(APFloat(DAG.EVTToAPFloatSemantics(NVT),
1170  APInt(NVT.getSizeInBits(), 0)), NVT);
1171 
1172  // Modified the chain - switch anything that used the old chain to use the
1173  // new one.
1174  ReplaceValueWith(SDValue(LD, 1), Chain);
1175 }
1176 
1177 void DAGTypeLegalizer::ExpandFloatRes_XINT_TO_FP(SDNode *N, SDValue &Lo,
1178  SDValue &Hi) {
1179  assert(N->getValueType(0) == MVT::ppcf128 && "Unsupported XINT_TO_FP!");
1180  EVT VT = N->getValueType(0);
1181  EVT NVT = TLI.getTypeToTransformTo(*DAG.getContext(), VT);
1182  SDValue Src = N->getOperand(0);
1183  EVT SrcVT = Src.getValueType();
1184  bool isSigned = N->getOpcode() == ISD::SINT_TO_FP;
1185  SDLoc dl(N);
1186 
1187  // First do an SINT_TO_FP, whether the original was signed or unsigned.
1188  // When promoting partial word types to i32 we must honor the signedness,
1189  // though.
1190  if (SrcVT.bitsLE(MVT::i32)) {
1191  // The integer can be represented exactly in an f64.
1192  Src = DAG.getNode(isSigned ? ISD::SIGN_EXTEND : ISD::ZERO_EXTEND, dl,
1193  MVT::i32, Src);
1194  Lo = DAG.getConstantFP(APFloat(DAG.EVTToAPFloatSemantics(NVT),
1195  APInt(NVT.getSizeInBits(), 0)), NVT);
1196  Hi = DAG.getNode(ISD::SINT_TO_FP, dl, NVT, Src);
1197  } else {
1198  RTLIB::Libcall LC = RTLIB::UNKNOWN_LIBCALL;
1199  if (SrcVT.bitsLE(MVT::i64)) {
1200  Src = DAG.getNode(isSigned ? ISD::SIGN_EXTEND : ISD::ZERO_EXTEND, dl,
1201  MVT::i64, Src);
1202  LC = RTLIB::SINTTOFP_I64_PPCF128;
1203  } else if (SrcVT.bitsLE(MVT::i128)) {
1204  Src = DAG.getNode(ISD::SIGN_EXTEND, dl, MVT::i128, Src);
1205  LC = RTLIB::SINTTOFP_I128_PPCF128;
1206  }
1207  assert(LC != RTLIB::UNKNOWN_LIBCALL && "Unsupported XINT_TO_FP!");
1208 
1209  Hi = TLI.makeLibCall(DAG, LC, VT, &Src, 1, true, dl).first;
1210  GetPairElements(Hi, Lo, Hi);
1211  }
1212 
1213  if (isSigned)
1214  return;
1215 
1216  // Unsigned - fix up the SINT_TO_FP value just calculated.
1217  Hi = DAG.getNode(ISD::BUILD_PAIR, dl, VT, Lo, Hi);
1218  SrcVT = Src.getValueType();
1219 
1220  // x>=0 ? (ppcf128)(iN)x : (ppcf128)(iN)x + 2^N; N=32,64,128.
1221  static const uint64_t TwoE32[] = { 0x41f0000000000000LL, 0 };
1222  static const uint64_t TwoE64[] = { 0x43f0000000000000LL, 0 };
1223  static const uint64_t TwoE128[] = { 0x47f0000000000000LL, 0 };
1224  ArrayRef<uint64_t> Parts;
1225 
1226  switch (SrcVT.getSimpleVT().SimpleTy) {
1227  default:
1228  llvm_unreachable("Unsupported UINT_TO_FP!");
1229  case MVT::i32:
1230  Parts = TwoE32;
1231  break;
1232  case MVT::i64:
1233  Parts = TwoE64;
1234  break;
1235  case MVT::i128:
1236  Parts = TwoE128;
1237  break;
1238  }
1239 
1240  Lo = DAG.getNode(ISD::FADD, dl, VT, Hi,
1241  DAG.getConstantFP(APFloat(APFloat::PPCDoubleDouble,
1242  APInt(128, Parts)),
1243  MVT::ppcf128));
1244  Lo = DAG.getSelectCC(dl, Src, DAG.getConstant(0, SrcVT),
1245  Lo, Hi, ISD::SETLT);
1246  GetPairElements(Lo, Lo, Hi);
1247 }
1248 
1249 
1250 //===----------------------------------------------------------------------===//
1251 // Float Operand Expansion
1252 //===----------------------------------------------------------------------===//
1253 
1254 /// ExpandFloatOperand - This method is called when the specified operand of the
1255 /// specified node is found to need expansion. At this point, all of the result
1256 /// types of the node are known to be legal, but other operands of the node may
1257 /// need promotion or expansion as well as the specified one.
1258 bool DAGTypeLegalizer::ExpandFloatOperand(SDNode *N, unsigned OpNo) {
1259  DEBUG(dbgs() << "Expand float operand: "; N->dump(&DAG); dbgs() << "\n");
1260  SDValue Res = SDValue();
1261 
1262  // See if the target wants to custom expand this node.
1263  if (CustomLowerNode(N, N->getOperand(OpNo).getValueType(), false))
1264  return false;
1265 
1266  switch (N->getOpcode()) {
1267  default:
1268 #ifndef NDEBUG
1269  dbgs() << "ExpandFloatOperand Op #" << OpNo << ": ";
1270  N->dump(&DAG); dbgs() << "\n";
1271 #endif
1272  llvm_unreachable("Do not know how to expand this operator's operand!");
1273 
1274  case ISD::BITCAST: Res = ExpandOp_BITCAST(N); break;
1275  case ISD::BUILD_VECTOR: Res = ExpandOp_BUILD_VECTOR(N); break;
1276  case ISD::EXTRACT_ELEMENT: Res = ExpandOp_EXTRACT_ELEMENT(N); break;
1277 
1278  case ISD::BR_CC: Res = ExpandFloatOp_BR_CC(N); break;
1279  case ISD::FCOPYSIGN: Res = ExpandFloatOp_FCOPYSIGN(N); break;
1280  case ISD::FP_ROUND: Res = ExpandFloatOp_FP_ROUND(N); break;
1281  case ISD::FP_TO_SINT: Res = ExpandFloatOp_FP_TO_SINT(N); break;
1282  case ISD::FP_TO_UINT: Res = ExpandFloatOp_FP_TO_UINT(N); break;
1283  case ISD::SELECT_CC: Res = ExpandFloatOp_SELECT_CC(N); break;
1284  case ISD::SETCC: Res = ExpandFloatOp_SETCC(N); break;
1285  case ISD::STORE: Res = ExpandFloatOp_STORE(cast<StoreSDNode>(N),
1286  OpNo); break;
1287  }
1288 
1289  // If the result is null, the sub-method took care of registering results etc.
1290  if (!Res.getNode()) return false;
1291 
1292  // If the result is N, the sub-method updated N in place. Tell the legalizer
1293  // core about this.
1294  if (Res.getNode() == N)
1295  return true;
1296 
1297  assert(Res.getValueType() == N->getValueType(0) && N->getNumValues() == 1 &&
1298  "Invalid operand expansion");
1299 
1300  ReplaceValueWith(SDValue(N, 0), Res);
1301  return false;
1302 }
1303 
1304 /// FloatExpandSetCCOperands - Expand the operands of a comparison. This code
1305 /// is shared among BR_CC, SELECT_CC, and SETCC handlers.
1306 void DAGTypeLegalizer::FloatExpandSetCCOperands(SDValue &NewLHS,
1307  SDValue &NewRHS,
1308  ISD::CondCode &CCCode,
1309  SDLoc dl) {
1310  SDValue LHSLo, LHSHi, RHSLo, RHSHi;
1311  GetExpandedFloat(NewLHS, LHSLo, LHSHi);
1312  GetExpandedFloat(NewRHS, RHSLo, RHSHi);
1313 
1314  assert(NewLHS.getValueType() == MVT::ppcf128 && "Unsupported setcc type!");
1315 
1316  // FIXME: This generated code sucks. We want to generate
1317  // FCMPU crN, hi1, hi2
1318  // BNE crN, L:
1319  // FCMPU crN, lo1, lo2
1320  // The following can be improved, but not that much.
1321  SDValue Tmp1, Tmp2, Tmp3;
1322  Tmp1 = DAG.getSetCC(dl, getSetCCResultType(LHSHi.getValueType()),
1323  LHSHi, RHSHi, ISD::SETOEQ);
1324  Tmp2 = DAG.getSetCC(dl, getSetCCResultType(LHSLo.getValueType()),
1325  LHSLo, RHSLo, CCCode);
1326  Tmp3 = DAG.getNode(ISD::AND, dl, Tmp1.getValueType(), Tmp1, Tmp2);
1327  Tmp1 = DAG.getSetCC(dl, getSetCCResultType(LHSHi.getValueType()),
1328  LHSHi, RHSHi, ISD::SETUNE);
1329  Tmp2 = DAG.getSetCC(dl, getSetCCResultType(LHSHi.getValueType()),
1330  LHSHi, RHSHi, CCCode);
1331  Tmp1 = DAG.getNode(ISD::AND, dl, Tmp1.getValueType(), Tmp1, Tmp2);
1332  NewLHS = DAG.getNode(ISD::OR, dl, Tmp1.getValueType(), Tmp1, Tmp3);
1333  NewRHS = SDValue(); // LHS is the result, not a compare.
1334 }
1335 
1336 SDValue DAGTypeLegalizer::ExpandFloatOp_BR_CC(SDNode *N) {
1337  SDValue NewLHS = N->getOperand(2), NewRHS = N->getOperand(3);
1338  ISD::CondCode CCCode = cast<CondCodeSDNode>(N->getOperand(1))->get();
1339  FloatExpandSetCCOperands(NewLHS, NewRHS, CCCode, SDLoc(N));
1340 
1341  // If ExpandSetCCOperands returned a scalar, we need to compare the result
1342  // against zero to select between true and false values.
1343  if (NewRHS.getNode() == 0) {
1344  NewRHS = DAG.getConstant(0, NewLHS.getValueType());
1345  CCCode = ISD::SETNE;
1346  }
1347 
1348  // Update N to have the operands specified.
1349  return SDValue(DAG.UpdateNodeOperands(N, N->getOperand(0),
1350  DAG.getCondCode(CCCode), NewLHS, NewRHS,
1351  N->getOperand(4)), 0);
1352 }
1353 
1354 SDValue DAGTypeLegalizer::ExpandFloatOp_FCOPYSIGN(SDNode *N) {
1355  assert(N->getOperand(1).getValueType() == MVT::ppcf128 &&
1356  "Logic only correct for ppcf128!");
1357  SDValue Lo, Hi;
1358  GetExpandedFloat(N->getOperand(1), Lo, Hi);
1359  // The ppcf128 value is providing only the sign; take it from the
1360  // higher-order double (which must have the larger magnitude).
1361  return DAG.getNode(ISD::FCOPYSIGN, SDLoc(N),
1362  N->getValueType(0), N->getOperand(0), Hi);
1363 }
1364 
1365 SDValue DAGTypeLegalizer::ExpandFloatOp_FP_ROUND(SDNode *N) {
1366  assert(N->getOperand(0).getValueType() == MVT::ppcf128 &&
1367  "Logic only correct for ppcf128!");
1368  SDValue Lo, Hi;
1369  GetExpandedFloat(N->getOperand(0), Lo, Hi);
1370  // Round it the rest of the way (e.g. to f32) if needed.
1371  return DAG.getNode(ISD::FP_ROUND, SDLoc(N),
1372  N->getValueType(0), Hi, N->getOperand(1));
1373 }
1374 
1375 SDValue DAGTypeLegalizer::ExpandFloatOp_FP_TO_SINT(SDNode *N) {
1376  EVT RVT = N->getValueType(0);
1377  SDLoc dl(N);
1378 
1379  // Expand ppcf128 to i32 by hand for the benefit of llvm-gcc bootstrap on
1380  // PPC (the libcall is not available). FIXME: Do this in a less hacky way.
1381  if (RVT == MVT::i32) {
1382  assert(N->getOperand(0).getValueType() == MVT::ppcf128 &&
1383  "Logic only correct for ppcf128!");
1384  SDValue Res = DAG.getNode(ISD::FP_ROUND_INREG, dl, MVT::ppcf128,
1385  N->getOperand(0), DAG.getValueType(MVT::f64));
1386  Res = DAG.getNode(ISD::FP_ROUND, dl, MVT::f64, Res,
1387  DAG.getIntPtrConstant(1));
1388  return DAG.getNode(ISD::FP_TO_SINT, dl, MVT::i32, Res);
1389  }
1390 
1391  RTLIB::Libcall LC = RTLIB::getFPTOSINT(N->getOperand(0).getValueType(), RVT);
1392  assert(LC != RTLIB::UNKNOWN_LIBCALL && "Unsupported FP_TO_SINT!");
1393  return TLI.makeLibCall(DAG, LC, RVT, &N->getOperand(0), 1, false, dl).first;
1394 }
1395 
1396 SDValue DAGTypeLegalizer::ExpandFloatOp_FP_TO_UINT(SDNode *N) {
1397  EVT RVT = N->getValueType(0);
1398  SDLoc dl(N);
1399 
1400  // Expand ppcf128 to i32 by hand for the benefit of llvm-gcc bootstrap on
1401  // PPC (the libcall is not available). FIXME: Do this in a less hacky way.
1402  if (RVT == MVT::i32) {
1403  assert(N->getOperand(0).getValueType() == MVT::ppcf128 &&
1404  "Logic only correct for ppcf128!");
1405  const uint64_t TwoE31[] = {0x41e0000000000000LL, 0};
1406  APFloat APF = APFloat(APFloat::PPCDoubleDouble, APInt(128, TwoE31));
1407  SDValue Tmp = DAG.getConstantFP(APF, MVT::ppcf128);
1408  // X>=2^31 ? (int)(X-2^31)+0x80000000 : (int)X
1409  // FIXME: generated code sucks.
1410  return DAG.getSelectCC(dl, N->getOperand(0), Tmp,
1411  DAG.getNode(ISD::ADD, dl, MVT::i32,
1412  DAG.getNode(ISD::FP_TO_SINT, dl, MVT::i32,
1413  DAG.getNode(ISD::FSUB, dl,
1414  MVT::ppcf128,
1415  N->getOperand(0),
1416  Tmp)),
1417  DAG.getConstant(0x80000000, MVT::i32)),
1418  DAG.getNode(ISD::FP_TO_SINT, dl,
1419  MVT::i32, N->getOperand(0)),
1420  ISD::SETGE);
1421  }
1422 
1423  RTLIB::Libcall LC = RTLIB::getFPTOUINT(N->getOperand(0).getValueType(), RVT);
1424  assert(LC != RTLIB::UNKNOWN_LIBCALL && "Unsupported FP_TO_UINT!");
1425  return TLI.makeLibCall(DAG, LC, N->getValueType(0), &N->getOperand(0), 1,
1426  false, dl).first;
1427 }
1428 
1429 SDValue DAGTypeLegalizer::ExpandFloatOp_SELECT_CC(SDNode *N) {
1430  SDValue NewLHS = N->getOperand(0), NewRHS = N->getOperand(1);
1431  ISD::CondCode CCCode = cast<CondCodeSDNode>(N->getOperand(4))->get();
1432  FloatExpandSetCCOperands(NewLHS, NewRHS, CCCode, SDLoc(N));
1433 
1434  // If ExpandSetCCOperands returned a scalar, we need to compare the result
1435  // against zero to select between true and false values.
1436  if (NewRHS.getNode() == 0) {
1437  NewRHS = DAG.getConstant(0, NewLHS.getValueType());
1438  CCCode = ISD::SETNE;
1439  }
1440 
1441  // Update N to have the operands specified.
1442  return SDValue(DAG.UpdateNodeOperands(N, NewLHS, NewRHS,
1443  N->getOperand(2), N->getOperand(3),
1444  DAG.getCondCode(CCCode)), 0);
1445 }
1446 
1447 SDValue DAGTypeLegalizer::ExpandFloatOp_SETCC(SDNode *N) {
1448  SDValue NewLHS = N->getOperand(0), NewRHS = N->getOperand(1);
1449  ISD::CondCode CCCode = cast<CondCodeSDNode>(N->getOperand(2))->get();
1450  FloatExpandSetCCOperands(NewLHS, NewRHS, CCCode, SDLoc(N));
1451 
1452  // If ExpandSetCCOperands returned a scalar, use it.
1453  if (NewRHS.getNode() == 0) {
1454  assert(NewLHS.getValueType() == N->getValueType(0) &&
1455  "Unexpected setcc expansion!");
1456  return NewLHS;
1457  }
1458 
1459  // Otherwise, update N to have the operands specified.
1460  return SDValue(DAG.UpdateNodeOperands(N, NewLHS, NewRHS,
1461  DAG.getCondCode(CCCode)), 0);
1462 }
1463 
1464 SDValue DAGTypeLegalizer::ExpandFloatOp_STORE(SDNode *N, unsigned OpNo) {
1465  if (ISD::isNormalStore(N))
1466  return ExpandOp_NormalStore(N, OpNo);
1467 
1468  assert(ISD::isUNINDEXEDStore(N) && "Indexed store during type legalization!");
1469  assert(OpNo == 1 && "Can only expand the stored value so far");
1470  StoreSDNode *ST = cast<StoreSDNode>(N);
1471 
1472  SDValue Chain = ST->getChain();
1473  SDValue Ptr = ST->getBasePtr();
1474 
1475  EVT NVT = TLI.getTypeToTransformTo(*DAG.getContext(),
1476  ST->getValue().getValueType());
1477  assert(NVT.isByteSized() && "Expanded type not byte sized!");
1478  assert(ST->getMemoryVT().bitsLE(NVT) && "Float type not round?");
1479  (void)NVT;
1480 
1481  SDValue Lo, Hi;
1482  GetExpandedOp(ST->getValue(), Lo, Hi);
1483 
1484  return DAG.getTruncStore(Chain, SDLoc(N), Hi, Ptr,
1485  ST->getMemoryVT(), ST->getMemOperand());
1486 }
llvm::SelectionDAG::getConstant
SDValue getConstant(uint64_t Val, EVT VT, bool isTarget=false)
Definition: SelectionDAG.cpp:959
llvm::SDValue::getValue
SDValue getValue(unsigned R) const
Definition: SelectionDAGNodes.h:122
llvm::APInt::getAllOnesValue
static APInt getAllOnesValue(unsigned numBits)
Get the all-ones value.
Definition: APInt.h:450
llvm::SelectionDAG::getContext
LLVMContext * getContext() const
Definition: SelectionDAG.h:285
llvm::SDNode::dump
void dump() const
dump - Dump this node, for debugging.
Definition: SelectionDAGDumper.cpp:328
llvm::SelectionDAG::getVAArg
SDValue getVAArg(EVT VT, SDLoc dl, SDValue Chain, SDValue Ptr, SDValue SV, unsigned Align)
Definition: SelectionDAG.cpp:4768
llvm::SDNode::getOpcode
unsigned getOpcode() const
Definition: SelectionDAGNodes.h:369
llvm::SelectionDAG::getSelectCC
SDValue getSelectCC(SDLoc DL, SDValue LHS, SDValue RHS, SDValue True, SDValue False, ISD::CondCode Cond)
Definition: SelectionDAG.h:679
llvm::SelectionDAG::EVTToAPFloatSemantics
static const fltSemantics & EVTToAPFloatSemantics(EVT VT)
Definition: SelectionDAG.h:1013
llvm::SDNode::getOperand
const SDValue & getOperand(unsigned Num) const
Definition: SelectionDAGNodes.h:554
llvm::LoadSDNode::getBasePtr
const SDValue & getBasePtr() const
Definition: SelectionDAGNodes.h:1739
llvm::RTLIB::getFPROUND
Libcall getFPROUND(EVT OpVT, EVT RetVT)
Definition: TargetLoweringBase.cpp:427
llvm::RTLIB::getUINTTOFP
Libcall getUINTTOFP(EVT OpVT, EVT RetVT)
Definition: TargetLoweringBase.cpp:591
llvm::SelectionDAG::getLoad
SDValue getLoad(EVT VT, SDLoc dl, SDValue Chain, SDValue Ptr, MachinePointerInfo PtrInfo, bool isVolatile, bool isNonTemporal, bool isInvariant, unsigned Alignment, const MDNode *TBAAInfo=0, const MDNode *Ranges=0)
Definition: SelectionDAG.cpp:4565
llvm::TargetLoweringBase::getShiftAmountTy
EVT getShiftAmountTy(EVT LHSTy) const
Definition: TargetLoweringBase.cpp:814
llvm::SelectionDAG::getStore
SDValue getStore(SDValue Chain, SDLoc dl, SDValue Val, SDValue Ptr, MachinePointerInfo PtrInfo, bool isVolatile, bool isNonTemporal, unsigned Alignment, const MDNode *TBAAInfo=0)
Definition: SelectionDAG.cpp:4618
llvm::ISD::isNormalStore
bool isNormalStore(const SDNode *N)
Definition: SelectionDAGNodes.h:1929
llvm_unreachable
#define llvm_unreachable(msg)
Definition: ErrorHandling.h:103
llvm::SDNode::getValueType
EVT getValueType(unsigned ResNo) const
Definition: SelectionDAGNodes.h:609
llvm::TargetLowering::makeLibCall
std::pair< SDValue, SDValue > makeLibCall(SelectionDAG &DAG, RTLIB::Libcall LC, EVT RetVT, const SDValue *Ops, unsigned NumOps, bool isSigned, SDLoc dl, bool doesNotReturn=false, bool isReturnValueUsed=true) const
Returns a pair of (return value, chain).
Definition: TargetLowering.cpp:84
llvm::MVT::SimpleTy
SimpleValueType SimpleTy
Definition: ValueTypes.h:161
llvm::EVT::bitsGE
bool bitsGE(EVT VT) const
bitsGE - Return true if this has no less bits than VT.
Definition: ValueTypes.h:729
llvm::SelectionDAG::getConstantFP
SDValue getConstantFP(double Val, EVT VT, bool isTarget=false)
Definition: SelectionDAG.cpp:1108
llvm::EVT::getVectorElementType
EVT getVectorElementType() const
Definition: ValueTypes.h:762
llvm::ISD::isUNINDEXEDStore
bool isUNINDEXEDStore(const SDNode *N)
Definition: SelectionDAGNodes.h:1949
llvm::SDNode::getNumValues
unsigned getNumValues() const
Definition: SelectionDAGNodes.h:605
llvm::ISD::ADD
Simple integer binary arithmetic operators.
Definition: ISDOpcodes.h:176
llvm::StoreSDNode::getBasePtr
const SDValue & getBasePtr() const
Definition: SelectionDAGNodes.h:1769
llvm::SelectionDAG::getUNDEF
SDValue getUNDEF(EVT VT)
getUNDEF - Return an UNDEF node. UNDEF does not have a useful SDLoc.
Definition: SelectionDAG.h:585
llvm::MemSDNode::getMemoryVT
EVT getMemoryVT() const
getMemoryVT - Return the type of the in-memory value.
Definition: SelectionDAGNodes.h:1030
GetFPLibCall
static RTLIB::Libcall GetFPLibCall(EVT VT, RTLIB::Libcall Call_F32, RTLIB::Libcall Call_F64, RTLIB::Libcall Call_F80, RTLIB::Libcall Call_F128, RTLIB::Libcall Call_PPCF128)
GetFPLibCall - Return the right libcall for the given floating point type.
Definition: LegalizeFloatTypes.cpp:28
llvm::EVT::bitsLE
bool bitsLE(EVT VT) const
bitsLE - Return true if this has no more bits than VT.
Definition: ValueTypes.h:741
llvm::ISD::UNDEF
UNDEF - An undefined node.
Definition: ISDOpcodes.h:154
llvm::SDValue::getNode
SDNode * getNode() const
get the SDNode which holds the desired result
Definition: SelectionDAGNodes.h:105
llvm::APFloat
A self-contained host- and target-independent arbitrary-precision floating-point software implementat...
Definition: APFloat.h:122
llvm::ISD::isNormalLoad
bool isNormalLoad(const SDNode *N)
Definition: SelectionDAGNodes.h:1886
llvm::ISD::FADD
Simple binary floating point operators.
Definition: ISDOpcodes.h:222
llvm::MemSDNode::isNonTemporal
bool isNonTemporal() const
Definition: SelectionDAGNodes.h:1009
llvm::integerPartWidth
const unsigned int integerPartWidth
Definition: APInt.h:42
llvm::RTLIB::getFPTOSINT
Libcall getFPTOSINT(EVT OpVT, EVT RetVT)
Definition: TargetLoweringBase.cpp:451
llvm::MemSDNode::isVolatile
bool isVolatile() const
Definition: SelectionDAGNodes.h:1008
llvm::StoreSDNode::getValue
const SDValue & getValue() const
Definition: SelectionDAGNodes.h:1768
llvm::ISD::FP_EXTEND
X = FP_EXTEND(Y) - Extend a smaller FP type into a larger FP type.
Definition: ISDOpcodes.h:411
llvm::ConstantFPSDNode::getValueAPF
const APFloat & getValueAPF() const
Definition: SelectionDAGNodes.h:1279
llvm::LSBaseSDNode::getAddressingMode
ISD::MemIndexedMode getAddressingMode() const
Definition: SelectionDAGNodes.h:1702
llvm::SDNode::getConstantOperandVal
uint64_t getConstantOperandVal(unsigned Num) const
Definition: SelectionDAG.cpp:6248
llvm::MemSDNode::getPointerInfo
const MachinePointerInfo & getPointerInfo() const
Definition: SelectionDAGNodes.h:1036
llvm::ISD::isUNINDEXEDLoad
bool isUNINDEXEDLoad(const SDNode *N)
Definition: SelectionDAGNodes.h:1922
llvm::LoadSDNode::getOffset
const SDValue & getOffset() const
Definition: SelectionDAGNodes.h:1740
llvm::RTLIB::getFPEXT
Libcall getFPEXT(EVT OpVT, EVT RetVT)
Definition: TargetLoweringBase.cpp:411
llvm::APFloat::PPCDoubleDouble
static const fltSemantics PPCDoubleDouble
Definition: APFloat.h:135
llvm::SelectionDAG::UpdateNodeOperands
SDNode * UpdateNodeOperands(SDNode *N, SDValue Op)
Definition: SelectionDAG.cpp:5066
llvm::SelectionDAG::getExtLoad
SDValue getExtLoad(ISD::LoadExtType ExtType, SDLoc dl, EVT VT, SDValue Chain, SDValue Ptr, MachinePointerInfo PtrInfo, EVT MemVT, bool isVolatile, bool isNonTemporal, unsigned Alignment, const MDNode *TBAAInfo=0)
Definition: SelectionDAG.cpp:4586
llvm::SelectionDAG::getIntPtrConstant
SDValue getIntPtrConstant(uint64_t Val, bool isTarget=false)
Definition: SelectionDAG.cpp:1065
llvm::MemSDNode::getChain
const SDValue & getChain() const
Definition: SelectionDAGNodes.h:1053
llvm::MemSDNode::getMemOperand
MachineMemOperand * getMemOperand() const
Definition: SelectionDAGNodes.h:1034
llvm::dbgs
raw_ostream & dbgs()
dbgs - Return a circular-buffered debug stream.
Definition: Debug.cpp:101
llvm::MemSDNode::getTBAAInfo
const MDNode * getTBAAInfo() const
Returns the TBAAInfo that describes the dereference.
Definition: SelectionDAGNodes.h:1024
llvm::LoadSDNode::getExtensionType
ISD::LoadExtType getExtensionType() const
Definition: SelectionDAGNodes.h:1735
llvm::APInt
Class for arbitrary precision integers.
Definition: APInt.h:75
llvm::ISD::ZERO_EXTEND
ZERO_EXTEND - Used for integer types, zeroing the new bits.
Definition: ISDOpcodes.h:357
llvm::APFloat::bitcastToAPInt
APInt bitcastToAPInt() const
Definition: APFloat.cpp:3050
llvm::SelectionDAG::getNode
SDValue getNode(unsigned Opcode, SDLoc DL, EVT VT)
Definition: SelectionDAG.cpp:2485
llvm::ISD::ANY_EXTEND
ANY_EXTEND - Used for integer types. The high bits are undefined.
Definition: ISDOpcodes.h:360
llvm::RTLIB::getFPTOUINT
Libcall getFPTOUINT(EVT OpVT, EVT RetVT)
Definition: TargetLoweringBase.cpp:501
llvm::ISD::AND
Bitwise operators - logical and, logical or, logical xor.
Definition: ISDOpcodes.h:295
llvm::EVT::getSizeInBits
unsigned getSizeInBits() const
getSizeInBits - Return the size of the specified value type in bits.
Definition: ValueTypes.h:779
llvm::APInt::clearBit
void clearBit(unsigned bitPosition)
Set a given bit to 0.
Definition: APInt.cpp:592
N
#define N
llvm::SelectionDAG::getTruncStore
SDValue getTruncStore(SDValue Chain, SDLoc dl, SDValue Val, SDValue Ptr, MachinePointerInfo PtrInfo, EVT TVT, bool isNonTemporal, bool isVolatile, unsigned Alignment, const MDNode *TBAAInfo=0)
Definition: SelectionDAG.cpp:4672
llvm::SDValue::getValueType
EVT getValueType() const
Definition: SelectionDAGNodes.h:843
llvm::SelectionDAG::getCondCode
SDValue getCondCode(ISD::CondCode Cond)
Definition: SelectionDAG.cpp:1324
llvm::RTLIB::getSINTTOFP
Libcall getSINTTOFP(EVT OpVT, EVT RetVT)
Definition: TargetLoweringBase.cpp:551
llvm::EVT::isByteSized
bool isByteSized() const
isByteSized - Return true if the bit size is a multiple of 8.
Definition: ValueTypes.h:706
llvm::SelectionDAG::getSelect
SDValue getSelect(SDLoc DL, EVT VT, SDValue Cond, SDValue LHS, SDValue RHS)
Definition: SelectionDAG.h:666
llvm::TargetLoweringBase::getTypeToTransformTo
EVT getTypeToTransformTo(LLVMContext &Context, EVT VT) const
Definition: TargetLowering.h:332
llvm::StoreSDNode::isTruncatingStore
bool isTruncatingStore() const
Definition: SelectionDAGNodes.h:1766
llvm::SelectionDAG::getValueType
SDValue getValueType(EVT)
Definition: SelectionDAG.cpp:1291
DEBUG
#define DEBUG(X)
Definition: Debug.h:97
raw_ostream.h
llvm::SelectionDAG::getSetCC
SDValue getSetCC(SDLoc DL, EVT VT, SDValue LHS, SDValue RHS, ISD::CondCode Cond)
Definition: SelectionDAG.h:653
llvm::ISD::TRUNCATE
TRUNCATE - Completely drop the high bits.
Definition: ISDOpcodes.h:363
llvm::MemSDNode::getAlignment
unsigned getAlignment() const
Definition: SelectionDAGNodes.h:995
llvm::EVT::getSimpleVT
MVT getSimpleVT() const
Definition: ValueTypes.h:749
llvm::TargetLowering::softenSetCCOperands
void softenSetCCOperands(SelectionDAG &DAG, EVT VT, SDValue &NewLHS, SDValue &NewRHS, ISD::CondCode &CCCode, SDLoc DL) const
Definition: TargetLowering.cpp:116

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