1 //===-------- LegalizeFloatTypes.cpp - Legalization of float types --------===//
3 // The LLVM Compiler Infrastructure
5 // This file is distributed under the University of Illinois Open Source
6 // License. See LICENSE.TXT for details.
8 //===----------------------------------------------------------------------===//
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.
20 //===----------------------------------------------------------------------===//
22 #include "LegalizeTypes.h"
23 #include "llvm/Support/ErrorHandling.h"
24 #include "llvm/Support/raw_ostream.h"
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_PPCF128) {
34 VT == MVT::f32 ? Call_F32 :
35 VT == MVT::f64 ? Call_F64 :
36 VT == MVT::f80 ? Call_F80 :
37 VT == MVT::ppcf128 ? Call_PPCF128 :
38 RTLIB::UNKNOWN_LIBCALL;
41 //===----------------------------------------------------------------------===//
42 // Result Float to Integer Conversion.
43 //===----------------------------------------------------------------------===//
45 void DAGTypeLegalizer::SoftenFloatResult(SDNode *N, unsigned ResNo) {
46 DEBUG(dbgs() << "Soften float result " << ResNo << ": "; N->dump(&DAG);
48 SDValue R = SDValue();
50 switch (N->getOpcode()) {
53 dbgs() << "SoftenFloatResult #" << ResNo << ": ";
54 N->dump(&DAG); dbgs() << "\n";
56 llvm_unreachable("Do not know how to soften the result of this operator!");
58 case ISD::MERGE_VALUES:R = SoftenFloatRes_MERGE_VALUES(N); break;
59 case ISD::BITCAST: R = SoftenFloatRes_BITCAST(N); break;
60 case ISD::BUILD_PAIR: R = SoftenFloatRes_BUILD_PAIR(N); break;
62 R = SoftenFloatRes_ConstantFP(cast<ConstantFPSDNode>(N));
64 case ISD::EXTRACT_VECTOR_ELT:
65 R = SoftenFloatRes_EXTRACT_VECTOR_ELT(N); break;
66 case ISD::FABS: R = SoftenFloatRes_FABS(N); break;
67 case ISD::FADD: R = SoftenFloatRes_FADD(N); break;
68 case ISD::FCEIL: R = SoftenFloatRes_FCEIL(N); break;
69 case ISD::FCOPYSIGN: R = SoftenFloatRes_FCOPYSIGN(N); break;
70 case ISD::FCOS: R = SoftenFloatRes_FCOS(N); break;
71 case ISD::FDIV: R = SoftenFloatRes_FDIV(N); break;
72 case ISD::FEXP: R = SoftenFloatRes_FEXP(N); break;
73 case ISD::FEXP2: R = SoftenFloatRes_FEXP2(N); break;
74 case ISD::FFLOOR: R = SoftenFloatRes_FFLOOR(N); break;
75 case ISD::FLOG: R = SoftenFloatRes_FLOG(N); break;
76 case ISD::FLOG2: R = SoftenFloatRes_FLOG2(N); break;
77 case ISD::FLOG10: R = SoftenFloatRes_FLOG10(N); break;
78 case ISD::FMA: R = SoftenFloatRes_FMA(N); break;
79 case ISD::FMUL: R = SoftenFloatRes_FMUL(N); break;
80 case ISD::FNEARBYINT: R = SoftenFloatRes_FNEARBYINT(N); break;
81 case ISD::FNEG: R = SoftenFloatRes_FNEG(N); break;
82 case ISD::FP_EXTEND: R = SoftenFloatRes_FP_EXTEND(N); break;
83 case ISD::FP_ROUND: R = SoftenFloatRes_FP_ROUND(N); break;
84 case ISD::FP16_TO_FP32:R = SoftenFloatRes_FP16_TO_FP32(N); break;
85 case ISD::FPOW: R = SoftenFloatRes_FPOW(N); break;
86 case ISD::FPOWI: R = SoftenFloatRes_FPOWI(N); break;
87 case ISD::FREM: R = SoftenFloatRes_FREM(N); break;
88 case ISD::FRINT: R = SoftenFloatRes_FRINT(N); break;
89 case ISD::FSIN: R = SoftenFloatRes_FSIN(N); break;
90 case ISD::FSQRT: R = SoftenFloatRes_FSQRT(N); break;
91 case ISD::FSUB: R = SoftenFloatRes_FSUB(N); break;
92 case ISD::FTRUNC: R = SoftenFloatRes_FTRUNC(N); break;
93 case ISD::LOAD: R = SoftenFloatRes_LOAD(N); break;
94 case ISD::SELECT: R = SoftenFloatRes_SELECT(N); break;
95 case ISD::SELECT_CC: R = SoftenFloatRes_SELECT_CC(N); break;
97 case ISD::UINT_TO_FP: R = SoftenFloatRes_XINT_TO_FP(N); break;
98 case ISD::UNDEF: R = SoftenFloatRes_UNDEF(N); break;
99 case ISD::VAARG: R = SoftenFloatRes_VAARG(N); break;
102 // If R is null, the sub-method took care of registering the result.
104 SetSoftenedFloat(SDValue(N, ResNo), R);
107 SDValue DAGTypeLegalizer::SoftenFloatRes_BITCAST(SDNode *N) {
108 return BitConvertToInteger(N->getOperand(0));
111 SDValue DAGTypeLegalizer::SoftenFloatRes_MERGE_VALUES(SDNode *N) {
112 SDValue Op = DecomposeMERGE_VALUES(N);
113 return BitConvertToInteger(Op);
116 SDValue DAGTypeLegalizer::SoftenFloatRes_BUILD_PAIR(SDNode *N) {
117 // Convert the inputs to integers, and build a new pair out of them.
118 return DAG.getNode(ISD::BUILD_PAIR, N->getDebugLoc(),
119 TLI.getTypeToTransformTo(*DAG.getContext(),
121 BitConvertToInteger(N->getOperand(0)),
122 BitConvertToInteger(N->getOperand(1)));
125 SDValue DAGTypeLegalizer::SoftenFloatRes_ConstantFP(ConstantFPSDNode *N) {
126 return DAG.getConstant(N->getValueAPF().bitcastToAPInt(),
127 TLI.getTypeToTransformTo(*DAG.getContext(),
128 N->getValueType(0)));
131 SDValue DAGTypeLegalizer::SoftenFloatRes_EXTRACT_VECTOR_ELT(SDNode *N) {
132 SDValue NewOp = BitConvertVectorToIntegerVector(N->getOperand(0));
133 return DAG.getNode(ISD::EXTRACT_VECTOR_ELT, N->getDebugLoc(),
134 NewOp.getValueType().getVectorElementType(),
135 NewOp, N->getOperand(1));
138 SDValue DAGTypeLegalizer::SoftenFloatRes_FABS(SDNode *N) {
139 EVT NVT = TLI.getTypeToTransformTo(*DAG.getContext(), N->getValueType(0));
140 unsigned Size = NVT.getSizeInBits();
142 // Mask = ~(1 << (Size-1))
143 APInt API = APInt::getAllOnesValue(Size);
144 API.clearBit(Size-1);
145 SDValue Mask = DAG.getConstant(API, NVT);
146 SDValue Op = GetSoftenedFloat(N->getOperand(0));
147 return DAG.getNode(ISD::AND, N->getDebugLoc(), NVT, Op, Mask);
150 SDValue DAGTypeLegalizer::SoftenFloatRes_FADD(SDNode *N) {
151 EVT NVT = TLI.getTypeToTransformTo(*DAG.getContext(), N->getValueType(0));
152 SDValue Ops[2] = { GetSoftenedFloat(N->getOperand(0)),
153 GetSoftenedFloat(N->getOperand(1)) };
154 return MakeLibCall(GetFPLibCall(N->getValueType(0),
159 NVT, Ops, 2, false, N->getDebugLoc());
162 SDValue DAGTypeLegalizer::SoftenFloatRes_FCEIL(SDNode *N) {
163 EVT NVT = TLI.getTypeToTransformTo(*DAG.getContext(), N->getValueType(0));
164 SDValue Op = GetSoftenedFloat(N->getOperand(0));
165 return MakeLibCall(GetFPLibCall(N->getValueType(0),
169 RTLIB::CEIL_PPCF128),
170 NVT, &Op, 1, false, N->getDebugLoc());
173 SDValue DAGTypeLegalizer::SoftenFloatRes_FCOPYSIGN(SDNode *N) {
174 SDValue LHS = GetSoftenedFloat(N->getOperand(0));
175 SDValue RHS = BitConvertToInteger(N->getOperand(1));
176 DebugLoc dl = N->getDebugLoc();
178 EVT LVT = LHS.getValueType();
179 EVT RVT = RHS.getValueType();
181 unsigned LSize = LVT.getSizeInBits();
182 unsigned RSize = RVT.getSizeInBits();
184 // First get the sign bit of second operand.
185 SDValue SignBit = DAG.getNode(ISD::SHL, dl, RVT, DAG.getConstant(1, RVT),
186 DAG.getConstant(RSize - 1,
187 TLI.getShiftAmountTy(RVT)));
188 SignBit = DAG.getNode(ISD::AND, dl, RVT, RHS, SignBit);
190 // Shift right or sign-extend it if the two operands have different types.
191 int SizeDiff = RVT.getSizeInBits() - LVT.getSizeInBits();
193 SignBit = DAG.getNode(ISD::SRL, dl, RVT, SignBit,
194 DAG.getConstant(SizeDiff,
195 TLI.getShiftAmountTy(SignBit.getValueType())));
196 SignBit = DAG.getNode(ISD::TRUNCATE, dl, LVT, SignBit);
197 } else if (SizeDiff < 0) {
198 SignBit = DAG.getNode(ISD::ANY_EXTEND, dl, LVT, SignBit);
199 SignBit = DAG.getNode(ISD::SHL, dl, LVT, SignBit,
200 DAG.getConstant(-SizeDiff,
201 TLI.getShiftAmountTy(SignBit.getValueType())));
204 // Clear the sign bit of the first operand.
205 SDValue Mask = DAG.getNode(ISD::SHL, dl, LVT, DAG.getConstant(1, LVT),
206 DAG.getConstant(LSize - 1,
207 TLI.getShiftAmountTy(LVT)));
208 Mask = DAG.getNode(ISD::SUB, dl, LVT, Mask, DAG.getConstant(1, LVT));
209 LHS = DAG.getNode(ISD::AND, dl, LVT, LHS, Mask);
211 // Or the value with the sign bit.
212 return DAG.getNode(ISD::OR, dl, LVT, LHS, SignBit);
215 SDValue DAGTypeLegalizer::SoftenFloatRes_FCOS(SDNode *N) {
216 EVT NVT = TLI.getTypeToTransformTo(*DAG.getContext(), N->getValueType(0));
217 SDValue Op = GetSoftenedFloat(N->getOperand(0));
218 return MakeLibCall(GetFPLibCall(N->getValueType(0),
223 NVT, &Op, 1, false, N->getDebugLoc());
226 SDValue DAGTypeLegalizer::SoftenFloatRes_FDIV(SDNode *N) {
227 EVT NVT = TLI.getTypeToTransformTo(*DAG.getContext(), N->getValueType(0));
228 SDValue Ops[2] = { GetSoftenedFloat(N->getOperand(0)),
229 GetSoftenedFloat(N->getOperand(1)) };
230 return MakeLibCall(GetFPLibCall(N->getValueType(0),
235 NVT, Ops, 2, false, N->getDebugLoc());
238 SDValue DAGTypeLegalizer::SoftenFloatRes_FEXP(SDNode *N) {
239 EVT NVT = TLI.getTypeToTransformTo(*DAG.getContext(), N->getValueType(0));
240 SDValue Op = GetSoftenedFloat(N->getOperand(0));
241 return MakeLibCall(GetFPLibCall(N->getValueType(0),
246 NVT, &Op, 1, false, N->getDebugLoc());
249 SDValue DAGTypeLegalizer::SoftenFloatRes_FEXP2(SDNode *N) {
250 EVT NVT = TLI.getTypeToTransformTo(*DAG.getContext(), N->getValueType(0));
251 SDValue Op = GetSoftenedFloat(N->getOperand(0));
252 return MakeLibCall(GetFPLibCall(N->getValueType(0),
256 RTLIB::EXP2_PPCF128),
257 NVT, &Op, 1, false, N->getDebugLoc());
260 SDValue DAGTypeLegalizer::SoftenFloatRes_FFLOOR(SDNode *N) {
261 EVT NVT = TLI.getTypeToTransformTo(*DAG.getContext(), N->getValueType(0));
262 SDValue Op = GetSoftenedFloat(N->getOperand(0));
263 return MakeLibCall(GetFPLibCall(N->getValueType(0),
267 RTLIB::FLOOR_PPCF128),
268 NVT, &Op, 1, false, N->getDebugLoc());
271 SDValue DAGTypeLegalizer::SoftenFloatRes_FLOG(SDNode *N) {
272 EVT NVT = TLI.getTypeToTransformTo(*DAG.getContext(), N->getValueType(0));
273 SDValue Op = GetSoftenedFloat(N->getOperand(0));
274 return MakeLibCall(GetFPLibCall(N->getValueType(0),
279 NVT, &Op, 1, false, N->getDebugLoc());
282 SDValue DAGTypeLegalizer::SoftenFloatRes_FLOG2(SDNode *N) {
283 EVT NVT = TLI.getTypeToTransformTo(*DAG.getContext(), N->getValueType(0));
284 SDValue Op = GetSoftenedFloat(N->getOperand(0));
285 return MakeLibCall(GetFPLibCall(N->getValueType(0),
289 RTLIB::LOG2_PPCF128),
290 NVT, &Op, 1, false, N->getDebugLoc());
293 SDValue DAGTypeLegalizer::SoftenFloatRes_FLOG10(SDNode *N) {
294 EVT NVT = TLI.getTypeToTransformTo(*DAG.getContext(), N->getValueType(0));
295 SDValue Op = GetSoftenedFloat(N->getOperand(0));
296 return MakeLibCall(GetFPLibCall(N->getValueType(0),
300 RTLIB::LOG10_PPCF128),
301 NVT, &Op, 1, false, N->getDebugLoc());
304 SDValue DAGTypeLegalizer::SoftenFloatRes_FMA(SDNode *N) {
305 EVT NVT = TLI.getTypeToTransformTo(*DAG.getContext(), N->getValueType(0));
306 SDValue Ops[3] = { GetSoftenedFloat(N->getOperand(0)),
307 GetSoftenedFloat(N->getOperand(1)),
308 GetSoftenedFloat(N->getOperand(2)) };
309 return MakeLibCall(GetFPLibCall(N->getValueType(0),
314 NVT, Ops, 3, false, N->getDebugLoc());
317 SDValue DAGTypeLegalizer::SoftenFloatRes_FMUL(SDNode *N) {
318 EVT NVT = TLI.getTypeToTransformTo(*DAG.getContext(), N->getValueType(0));
319 SDValue Ops[2] = { GetSoftenedFloat(N->getOperand(0)),
320 GetSoftenedFloat(N->getOperand(1)) };
321 return MakeLibCall(GetFPLibCall(N->getValueType(0),
326 NVT, Ops, 2, false, N->getDebugLoc());
329 SDValue DAGTypeLegalizer::SoftenFloatRes_FNEARBYINT(SDNode *N) {
330 EVT NVT = TLI.getTypeToTransformTo(*DAG.getContext(), N->getValueType(0));
331 SDValue Op = GetSoftenedFloat(N->getOperand(0));
332 return MakeLibCall(GetFPLibCall(N->getValueType(0),
333 RTLIB::NEARBYINT_F32,
334 RTLIB::NEARBYINT_F64,
335 RTLIB::NEARBYINT_F80,
336 RTLIB::NEARBYINT_PPCF128),
337 NVT, &Op, 1, false, N->getDebugLoc());
340 SDValue DAGTypeLegalizer::SoftenFloatRes_FNEG(SDNode *N) {
341 EVT NVT = TLI.getTypeToTransformTo(*DAG.getContext(), N->getValueType(0));
342 // Expand Y = FNEG(X) -> Y = SUB -0.0, X
343 SDValue Ops[2] = { DAG.getConstantFP(-0.0, N->getValueType(0)),
344 GetSoftenedFloat(N->getOperand(0)) };
345 return MakeLibCall(GetFPLibCall(N->getValueType(0),
350 NVT, Ops, 2, false, N->getDebugLoc());
353 SDValue DAGTypeLegalizer::SoftenFloatRes_FP_EXTEND(SDNode *N) {
354 EVT NVT = TLI.getTypeToTransformTo(*DAG.getContext(), N->getValueType(0));
355 SDValue Op = N->getOperand(0);
356 RTLIB::Libcall LC = RTLIB::getFPEXT(Op.getValueType(), N->getValueType(0));
357 assert(LC != RTLIB::UNKNOWN_LIBCALL && "Unsupported FP_EXTEND!");
358 return MakeLibCall(LC, NVT, &Op, 1, false, N->getDebugLoc());
361 // FIXME: Should we just use 'normal' FP_EXTEND / FP_TRUNC instead of special
363 SDValue DAGTypeLegalizer::SoftenFloatRes_FP16_TO_FP32(SDNode *N) {
364 EVT NVT = TLI.getTypeToTransformTo(*DAG.getContext(), N->getValueType(0));
365 SDValue Op = N->getOperand(0);
366 return MakeLibCall(RTLIB::FPEXT_F16_F32, NVT, &Op, 1, false,
370 SDValue DAGTypeLegalizer::SoftenFloatRes_FP_ROUND(SDNode *N) {
371 EVT NVT = TLI.getTypeToTransformTo(*DAG.getContext(), N->getValueType(0));
372 SDValue Op = N->getOperand(0);
373 RTLIB::Libcall LC = RTLIB::getFPROUND(Op.getValueType(), N->getValueType(0));
374 assert(LC != RTLIB::UNKNOWN_LIBCALL && "Unsupported FP_ROUND!");
375 return MakeLibCall(LC, NVT, &Op, 1, false, N->getDebugLoc());
378 SDValue DAGTypeLegalizer::SoftenFloatRes_FPOW(SDNode *N) {
379 EVT NVT = TLI.getTypeToTransformTo(*DAG.getContext(), N->getValueType(0));
380 SDValue Ops[2] = { GetSoftenedFloat(N->getOperand(0)),
381 GetSoftenedFloat(N->getOperand(1)) };
382 return MakeLibCall(GetFPLibCall(N->getValueType(0),
387 NVT, Ops, 2, false, N->getDebugLoc());
390 SDValue DAGTypeLegalizer::SoftenFloatRes_FPOWI(SDNode *N) {
391 assert(N->getOperand(1).getValueType() == MVT::i32 &&
392 "Unsupported power type!");
393 EVT NVT = TLI.getTypeToTransformTo(*DAG.getContext(), N->getValueType(0));
394 SDValue Ops[2] = { GetSoftenedFloat(N->getOperand(0)), N->getOperand(1) };
395 return MakeLibCall(GetFPLibCall(N->getValueType(0),
399 RTLIB::POWI_PPCF128),
400 NVT, Ops, 2, false, N->getDebugLoc());
403 SDValue DAGTypeLegalizer::SoftenFloatRes_FREM(SDNode *N) {
404 EVT NVT = TLI.getTypeToTransformTo(*DAG.getContext(), N->getValueType(0));
405 SDValue Ops[2] = { GetSoftenedFloat(N->getOperand(0)),
406 GetSoftenedFloat(N->getOperand(1)) };
407 return MakeLibCall(GetFPLibCall(N->getValueType(0),
412 NVT, Ops, 2, false, N->getDebugLoc());
415 SDValue DAGTypeLegalizer::SoftenFloatRes_FRINT(SDNode *N) {
416 EVT NVT = TLI.getTypeToTransformTo(*DAG.getContext(), N->getValueType(0));
417 SDValue Op = GetSoftenedFloat(N->getOperand(0));
418 return MakeLibCall(GetFPLibCall(N->getValueType(0),
422 RTLIB::RINT_PPCF128),
423 NVT, &Op, 1, false, N->getDebugLoc());
426 SDValue DAGTypeLegalizer::SoftenFloatRes_FSIN(SDNode *N) {
427 EVT NVT = TLI.getTypeToTransformTo(*DAG.getContext(), N->getValueType(0));
428 SDValue Op = GetSoftenedFloat(N->getOperand(0));
429 return MakeLibCall(GetFPLibCall(N->getValueType(0),
434 NVT, &Op, 1, false, N->getDebugLoc());
437 SDValue DAGTypeLegalizer::SoftenFloatRes_FSQRT(SDNode *N) {
438 EVT NVT = TLI.getTypeToTransformTo(*DAG.getContext(), N->getValueType(0));
439 SDValue Op = GetSoftenedFloat(N->getOperand(0));
440 return MakeLibCall(GetFPLibCall(N->getValueType(0),
444 RTLIB::SQRT_PPCF128),
445 NVT, &Op, 1, false, N->getDebugLoc());
448 SDValue DAGTypeLegalizer::SoftenFloatRes_FSUB(SDNode *N) {
449 EVT NVT = TLI.getTypeToTransformTo(*DAG.getContext(), N->getValueType(0));
450 SDValue Ops[2] = { GetSoftenedFloat(N->getOperand(0)),
451 GetSoftenedFloat(N->getOperand(1)) };
452 return MakeLibCall(GetFPLibCall(N->getValueType(0),
457 NVT, Ops, 2, false, N->getDebugLoc());
460 SDValue DAGTypeLegalizer::SoftenFloatRes_FTRUNC(SDNode *N) {
461 EVT NVT = TLI.getTypeToTransformTo(*DAG.getContext(), N->getValueType(0));
462 SDValue Op = GetSoftenedFloat(N->getOperand(0));
463 return MakeLibCall(GetFPLibCall(N->getValueType(0),
467 RTLIB::TRUNC_PPCF128),
468 NVT, &Op, 1, false, N->getDebugLoc());
471 SDValue DAGTypeLegalizer::SoftenFloatRes_LOAD(SDNode *N) {
472 LoadSDNode *L = cast<LoadSDNode>(N);
473 EVT VT = N->getValueType(0);
474 EVT NVT = TLI.getTypeToTransformTo(*DAG.getContext(), VT);
475 DebugLoc dl = N->getDebugLoc();
478 if (L->getExtensionType() == ISD::NON_EXTLOAD) {
479 NewL = DAG.getLoad(L->getAddressingMode(), L->getExtensionType(),
480 NVT, dl, L->getChain(), L->getBasePtr(), L->getOffset(),
481 L->getPointerInfo(), NVT,
482 L->isVolatile(), L->isNonTemporal(), L->getAlignment());
483 // Legalized the chain result - switch anything that used the old chain to
485 ReplaceValueWith(SDValue(N, 1), NewL.getValue(1));
489 // Do a non-extending load followed by FP_EXTEND.
490 NewL = DAG.getLoad(L->getAddressingMode(), ISD::NON_EXTLOAD,
491 L->getMemoryVT(), dl, L->getChain(),
492 L->getBasePtr(), L->getOffset(), L->getPointerInfo(),
493 L->getMemoryVT(), L->isVolatile(),
494 L->isNonTemporal(), L->getAlignment());
495 // Legalized the chain result - switch anything that used the old chain to
497 ReplaceValueWith(SDValue(N, 1), NewL.getValue(1));
498 return BitConvertToInteger(DAG.getNode(ISD::FP_EXTEND, dl, VT, NewL));
501 SDValue DAGTypeLegalizer::SoftenFloatRes_SELECT(SDNode *N) {
502 SDValue LHS = GetSoftenedFloat(N->getOperand(1));
503 SDValue RHS = GetSoftenedFloat(N->getOperand(2));
504 return DAG.getNode(ISD::SELECT, N->getDebugLoc(),
505 LHS.getValueType(), N->getOperand(0),LHS,RHS);
508 SDValue DAGTypeLegalizer::SoftenFloatRes_SELECT_CC(SDNode *N) {
509 SDValue LHS = GetSoftenedFloat(N->getOperand(2));
510 SDValue RHS = GetSoftenedFloat(N->getOperand(3));
511 return DAG.getNode(ISD::SELECT_CC, N->getDebugLoc(),
512 LHS.getValueType(), N->getOperand(0),
513 N->getOperand(1), LHS, RHS, N->getOperand(4));
516 SDValue DAGTypeLegalizer::SoftenFloatRes_UNDEF(SDNode *N) {
517 return DAG.getUNDEF(TLI.getTypeToTransformTo(*DAG.getContext(),
518 N->getValueType(0)));
521 SDValue DAGTypeLegalizer::SoftenFloatRes_VAARG(SDNode *N) {
522 SDValue Chain = N->getOperand(0); // Get the chain.
523 SDValue Ptr = N->getOperand(1); // Get the pointer.
524 EVT VT = N->getValueType(0);
525 EVT NVT = TLI.getTypeToTransformTo(*DAG.getContext(), VT);
526 DebugLoc dl = N->getDebugLoc();
529 NewVAARG = DAG.getVAArg(NVT, dl, Chain, Ptr, N->getOperand(2),
530 N->getConstantOperandVal(3));
532 // Legalized the chain result - switch anything that used the old chain to
534 ReplaceValueWith(SDValue(N, 1), NewVAARG.getValue(1));
538 SDValue DAGTypeLegalizer::SoftenFloatRes_XINT_TO_FP(SDNode *N) {
539 bool Signed = N->getOpcode() == ISD::SINT_TO_FP;
540 EVT SVT = N->getOperand(0).getValueType();
541 EVT RVT = N->getValueType(0);
543 DebugLoc dl = N->getDebugLoc();
545 // If the input is not legal, eg: i1 -> fp, then it needs to be promoted to
546 // a larger type, eg: i8 -> fp. Even if it is legal, no libcall may exactly
547 // match. Look for an appropriate libcall.
548 RTLIB::Libcall LC = RTLIB::UNKNOWN_LIBCALL;
549 for (unsigned t = MVT::FIRST_INTEGER_VALUETYPE;
550 t <= MVT::LAST_INTEGER_VALUETYPE && LC == RTLIB::UNKNOWN_LIBCALL; ++t) {
551 NVT = (MVT::SimpleValueType)t;
552 // The source needs to big enough to hold the operand.
554 LC = Signed ? RTLIB::getSINTTOFP(NVT, RVT):RTLIB::getUINTTOFP (NVT, RVT);
556 assert(LC != RTLIB::UNKNOWN_LIBCALL && "Unsupported XINT_TO_FP!");
558 // Sign/zero extend the argument if the libcall takes a larger type.
559 SDValue Op = DAG.getNode(Signed ? ISD::SIGN_EXTEND : ISD::ZERO_EXTEND, dl,
560 NVT, N->getOperand(0));
561 return MakeLibCall(LC, TLI.getTypeToTransformTo(*DAG.getContext(), RVT),
566 //===----------------------------------------------------------------------===//
567 // Operand Float to Integer Conversion..
568 //===----------------------------------------------------------------------===//
570 bool DAGTypeLegalizer::SoftenFloatOperand(SDNode *N, unsigned OpNo) {
571 DEBUG(dbgs() << "Soften float operand " << OpNo << ": "; N->dump(&DAG);
573 SDValue Res = SDValue();
575 switch (N->getOpcode()) {
578 dbgs() << "SoftenFloatOperand Op #" << OpNo << ": ";
579 N->dump(&DAG); dbgs() << "\n";
581 llvm_unreachable("Do not know how to soften this operator's operand!");
583 case ISD::BITCAST: Res = SoftenFloatOp_BITCAST(N); break;
584 case ISD::BR_CC: Res = SoftenFloatOp_BR_CC(N); break;
585 case ISD::FP_ROUND: Res = SoftenFloatOp_FP_ROUND(N); break;
586 case ISD::FP_TO_SINT: Res = SoftenFloatOp_FP_TO_SINT(N); break;
587 case ISD::FP_TO_UINT: Res = SoftenFloatOp_FP_TO_UINT(N); break;
588 case ISD::FP32_TO_FP16:Res = SoftenFloatOp_FP32_TO_FP16(N); break;
589 case ISD::SELECT_CC: Res = SoftenFloatOp_SELECT_CC(N); break;
590 case ISD::SETCC: Res = SoftenFloatOp_SETCC(N); break;
591 case ISD::STORE: Res = SoftenFloatOp_STORE(N, OpNo); break;
594 // If the result is null, the sub-method took care of registering results etc.
595 if (!Res.getNode()) return false;
597 // If the result is N, the sub-method updated N in place. Tell the legalizer
599 if (Res.getNode() == N)
602 assert(Res.getValueType() == N->getValueType(0) && N->getNumValues() == 1 &&
603 "Invalid operand expansion");
605 ReplaceValueWith(SDValue(N, 0), Res);
609 /// SoftenSetCCOperands - Soften the operands of a comparison. This code is
610 /// shared among BR_CC, SELECT_CC, and SETCC handlers.
611 void DAGTypeLegalizer::SoftenSetCCOperands(SDValue &NewLHS, SDValue &NewRHS,
612 ISD::CondCode &CCCode, DebugLoc dl) {
613 SDValue LHSInt = GetSoftenedFloat(NewLHS);
614 SDValue RHSInt = GetSoftenedFloat(NewRHS);
615 EVT VT = NewLHS.getValueType();
617 assert((VT == MVT::f32 || VT == MVT::f64) && "Unsupported setcc type!");
619 // Expand into one or more soft-fp libcall(s).
620 RTLIB::Libcall LC1 = RTLIB::UNKNOWN_LIBCALL, LC2 = RTLIB::UNKNOWN_LIBCALL;
624 LC1 = (VT == MVT::f32) ? RTLIB::OEQ_F32 : RTLIB::OEQ_F64;
628 LC1 = (VT == MVT::f32) ? RTLIB::UNE_F32 : RTLIB::UNE_F64;
632 LC1 = (VT == MVT::f32) ? RTLIB::OGE_F32 : RTLIB::OGE_F64;
636 LC1 = (VT == MVT::f32) ? RTLIB::OLT_F32 : RTLIB::OLT_F64;
640 LC1 = (VT == MVT::f32) ? RTLIB::OLE_F32 : RTLIB::OLE_F64;
644 LC1 = (VT == MVT::f32) ? RTLIB::OGT_F32 : RTLIB::OGT_F64;
647 LC1 = (VT == MVT::f32) ? RTLIB::UO_F32 : RTLIB::UO_F64;
650 LC1 = (VT == MVT::f32) ? RTLIB::O_F32 : RTLIB::O_F64;
653 LC1 = (VT == MVT::f32) ? RTLIB::UO_F32 : RTLIB::UO_F64;
656 // SETONE = SETOLT | SETOGT
657 LC1 = (VT == MVT::f32) ? RTLIB::OLT_F32 : RTLIB::OLT_F64;
660 LC2 = (VT == MVT::f32) ? RTLIB::OGT_F32 : RTLIB::OGT_F64;
663 LC2 = (VT == MVT::f32) ? RTLIB::OGE_F32 : RTLIB::OGE_F64;
666 LC2 = (VT == MVT::f32) ? RTLIB::OLT_F32 : RTLIB::OLT_F64;
669 LC2 = (VT == MVT::f32) ? RTLIB::OLE_F32 : RTLIB::OLE_F64;
672 LC2 = (VT == MVT::f32) ? RTLIB::OEQ_F32 : RTLIB::OEQ_F64;
674 default: assert(false && "Do not know how to soften this setcc!");
678 // Use the target specific return value for comparions lib calls.
679 EVT RetVT = TLI.getCmpLibcallReturnType();
680 SDValue Ops[2] = { LHSInt, RHSInt };
681 NewLHS = MakeLibCall(LC1, RetVT, Ops, 2, false/*sign irrelevant*/, dl);
682 NewRHS = DAG.getConstant(0, RetVT);
683 CCCode = TLI.getCmpLibcallCC(LC1);
684 if (LC2 != RTLIB::UNKNOWN_LIBCALL) {
685 SDValue Tmp = DAG.getNode(ISD::SETCC, dl, TLI.getSetCCResultType(RetVT),
686 NewLHS, NewRHS, DAG.getCondCode(CCCode));
687 NewLHS = MakeLibCall(LC2, RetVT, Ops, 2, false/*sign irrelevant*/, dl);
688 NewLHS = DAG.getNode(ISD::SETCC, dl, TLI.getSetCCResultType(RetVT), NewLHS,
689 NewRHS, DAG.getCondCode(TLI.getCmpLibcallCC(LC2)));
690 NewLHS = DAG.getNode(ISD::OR, dl, Tmp.getValueType(), Tmp, NewLHS);
695 SDValue DAGTypeLegalizer::SoftenFloatOp_BITCAST(SDNode *N) {
696 return DAG.getNode(ISD::BITCAST, N->getDebugLoc(), N->getValueType(0),
697 GetSoftenedFloat(N->getOperand(0)));
700 SDValue DAGTypeLegalizer::SoftenFloatOp_FP_ROUND(SDNode *N) {
701 EVT SVT = N->getOperand(0).getValueType();
702 EVT RVT = N->getValueType(0);
704 RTLIB::Libcall LC = RTLIB::getFPROUND(SVT, RVT);
705 assert(LC != RTLIB::UNKNOWN_LIBCALL && "Unsupported FP_ROUND libcall");
707 SDValue Op = GetSoftenedFloat(N->getOperand(0));
708 return MakeLibCall(LC, RVT, &Op, 1, false, N->getDebugLoc());
711 SDValue DAGTypeLegalizer::SoftenFloatOp_BR_CC(SDNode *N) {
712 SDValue NewLHS = N->getOperand(2), NewRHS = N->getOperand(3);
713 ISD::CondCode CCCode = cast<CondCodeSDNode>(N->getOperand(1))->get();
714 SoftenSetCCOperands(NewLHS, NewRHS, CCCode, N->getDebugLoc());
716 // If SoftenSetCCOperands returned a scalar, we need to compare the result
717 // against zero to select between true and false values.
718 if (NewRHS.getNode() == 0) {
719 NewRHS = DAG.getConstant(0, NewLHS.getValueType());
723 // Update N to have the operands specified.
724 return SDValue(DAG.UpdateNodeOperands(N, N->getOperand(0),
725 DAG.getCondCode(CCCode), NewLHS, NewRHS,
730 SDValue DAGTypeLegalizer::SoftenFloatOp_FP_TO_SINT(SDNode *N) {
731 EVT RVT = N->getValueType(0);
732 RTLIB::Libcall LC = RTLIB::getFPTOSINT(N->getOperand(0).getValueType(), RVT);
733 assert(LC != RTLIB::UNKNOWN_LIBCALL && "Unsupported FP_TO_SINT!");
734 SDValue Op = GetSoftenedFloat(N->getOperand(0));
735 return MakeLibCall(LC, RVT, &Op, 1, false, N->getDebugLoc());
738 SDValue DAGTypeLegalizer::SoftenFloatOp_FP_TO_UINT(SDNode *N) {
739 EVT RVT = N->getValueType(0);
740 RTLIB::Libcall LC = RTLIB::getFPTOUINT(N->getOperand(0).getValueType(), RVT);
741 assert(LC != RTLIB::UNKNOWN_LIBCALL && "Unsupported FP_TO_UINT!");
742 SDValue Op = GetSoftenedFloat(N->getOperand(0));
743 return MakeLibCall(LC, RVT, &Op, 1, false, N->getDebugLoc());
746 SDValue DAGTypeLegalizer::SoftenFloatOp_FP32_TO_FP16(SDNode *N) {
747 EVT RVT = N->getValueType(0);
748 RTLIB::Libcall LC = RTLIB::FPROUND_F32_F16;
749 SDValue Op = GetSoftenedFloat(N->getOperand(0));
750 return MakeLibCall(LC, RVT, &Op, 1, false, N->getDebugLoc());
753 SDValue DAGTypeLegalizer::SoftenFloatOp_SELECT_CC(SDNode *N) {
754 SDValue NewLHS = N->getOperand(0), NewRHS = N->getOperand(1);
755 ISD::CondCode CCCode = cast<CondCodeSDNode>(N->getOperand(4))->get();
756 SoftenSetCCOperands(NewLHS, NewRHS, CCCode, N->getDebugLoc());
758 // If SoftenSetCCOperands returned a scalar, we need to compare the result
759 // against zero to select between true and false values.
760 if (NewRHS.getNode() == 0) {
761 NewRHS = DAG.getConstant(0, NewLHS.getValueType());
765 // Update N to have the operands specified.
766 return SDValue(DAG.UpdateNodeOperands(N, NewLHS, NewRHS,
767 N->getOperand(2), N->getOperand(3),
768 DAG.getCondCode(CCCode)),
772 SDValue DAGTypeLegalizer::SoftenFloatOp_SETCC(SDNode *N) {
773 SDValue NewLHS = N->getOperand(0), NewRHS = N->getOperand(1);
774 ISD::CondCode CCCode = cast<CondCodeSDNode>(N->getOperand(2))->get();
775 SoftenSetCCOperands(NewLHS, NewRHS, CCCode, N->getDebugLoc());
777 // If SoftenSetCCOperands returned a scalar, use it.
778 if (NewRHS.getNode() == 0) {
779 assert(NewLHS.getValueType() == N->getValueType(0) &&
780 "Unexpected setcc expansion!");
784 // Otherwise, update N to have the operands specified.
785 return SDValue(DAG.UpdateNodeOperands(N, NewLHS, NewRHS,
786 DAG.getCondCode(CCCode)),
790 SDValue DAGTypeLegalizer::SoftenFloatOp_STORE(SDNode *N, unsigned OpNo) {
791 assert(ISD::isUNINDEXEDStore(N) && "Indexed store during type legalization!");
792 assert(OpNo == 1 && "Can only soften the stored value!");
793 StoreSDNode *ST = cast<StoreSDNode>(N);
794 SDValue Val = ST->getValue();
795 DebugLoc dl = N->getDebugLoc();
797 if (ST->isTruncatingStore())
798 // Do an FP_ROUND followed by a non-truncating store.
799 Val = BitConvertToInteger(DAG.getNode(ISD::FP_ROUND, dl, ST->getMemoryVT(),
800 Val, DAG.getIntPtrConstant(0)));
802 Val = GetSoftenedFloat(Val);
804 return DAG.getStore(ST->getChain(), dl, Val, ST->getBasePtr(),
805 ST->getPointerInfo(),
806 ST->isVolatile(), ST->isNonTemporal(),
811 //===----------------------------------------------------------------------===//
812 // Float Result Expansion
813 //===----------------------------------------------------------------------===//
815 /// ExpandFloatResult - This method is called when the specified result of the
816 /// specified node is found to need expansion. At this point, the node may also
817 /// have invalid operands or may have other results that need promotion, we just
818 /// know that (at least) one result needs expansion.
819 void DAGTypeLegalizer::ExpandFloatResult(SDNode *N, unsigned ResNo) {
820 DEBUG(dbgs() << "Expand float result: "; N->dump(&DAG); dbgs() << "\n");
824 // See if the target wants to custom expand this node.
825 if (CustomLowerNode(N, N->getValueType(ResNo), true))
828 switch (N->getOpcode()) {
831 dbgs() << "ExpandFloatResult #" << ResNo << ": ";
832 N->dump(&DAG); dbgs() << "\n";
834 llvm_unreachable("Do not know how to expand the result of this operator!");
836 case ISD::UNDEF: SplitRes_UNDEF(N, Lo, Hi); break;
837 case ISD::SELECT: SplitRes_SELECT(N, Lo, Hi); break;
838 case ISD::SELECT_CC: SplitRes_SELECT_CC(N, Lo, Hi); break;
840 case ISD::MERGE_VALUES: ExpandRes_MERGE_VALUES(N, Lo, Hi); break;
841 case ISD::BITCAST: ExpandRes_BITCAST(N, Lo, Hi); break;
842 case ISD::BUILD_PAIR: ExpandRes_BUILD_PAIR(N, Lo, Hi); break;
843 case ISD::EXTRACT_ELEMENT: ExpandRes_EXTRACT_ELEMENT(N, Lo, Hi); break;
844 case ISD::EXTRACT_VECTOR_ELT: ExpandRes_EXTRACT_VECTOR_ELT(N, Lo, Hi); break;
845 case ISD::VAARG: ExpandRes_VAARG(N, Lo, Hi); break;
847 case ISD::ConstantFP: ExpandFloatRes_ConstantFP(N, Lo, Hi); break;
848 case ISD::FABS: ExpandFloatRes_FABS(N, Lo, Hi); break;
849 case ISD::FADD: ExpandFloatRes_FADD(N, Lo, Hi); break;
850 case ISD::FCEIL: ExpandFloatRes_FCEIL(N, Lo, Hi); break;
851 case ISD::FCOPYSIGN: ExpandFloatRes_FCOPYSIGN(N, Lo, Hi); break;
852 case ISD::FCOS: ExpandFloatRes_FCOS(N, Lo, Hi); break;
853 case ISD::FDIV: ExpandFloatRes_FDIV(N, Lo, Hi); break;
854 case ISD::FEXP: ExpandFloatRes_FEXP(N, Lo, Hi); break;
855 case ISD::FEXP2: ExpandFloatRes_FEXP2(N, Lo, Hi); break;
856 case ISD::FFLOOR: ExpandFloatRes_FFLOOR(N, Lo, Hi); break;
857 case ISD::FLOG: ExpandFloatRes_FLOG(N, Lo, Hi); break;
858 case ISD::FLOG2: ExpandFloatRes_FLOG2(N, Lo, Hi); break;
859 case ISD::FLOG10: ExpandFloatRes_FLOG10(N, Lo, Hi); break;
860 case ISD::FMA: ExpandFloatRes_FMA(N, Lo, Hi); break;
861 case ISD::FMUL: ExpandFloatRes_FMUL(N, Lo, Hi); break;
862 case ISD::FNEARBYINT: ExpandFloatRes_FNEARBYINT(N, Lo, Hi); break;
863 case ISD::FNEG: ExpandFloatRes_FNEG(N, Lo, Hi); break;
864 case ISD::FP_EXTEND: ExpandFloatRes_FP_EXTEND(N, Lo, Hi); break;
865 case ISD::FPOW: ExpandFloatRes_FPOW(N, Lo, Hi); break;
866 case ISD::FPOWI: ExpandFloatRes_FPOWI(N, Lo, Hi); break;
867 case ISD::FRINT: ExpandFloatRes_FRINT(N, Lo, Hi); break;
868 case ISD::FSIN: ExpandFloatRes_FSIN(N, Lo, Hi); break;
869 case ISD::FSQRT: ExpandFloatRes_FSQRT(N, Lo, Hi); break;
870 case ISD::FSUB: ExpandFloatRes_FSUB(N, Lo, Hi); break;
871 case ISD::FTRUNC: ExpandFloatRes_FTRUNC(N, Lo, Hi); break;
872 case ISD::LOAD: ExpandFloatRes_LOAD(N, Lo, Hi); break;
873 case ISD::SINT_TO_FP:
874 case ISD::UINT_TO_FP: ExpandFloatRes_XINT_TO_FP(N, Lo, Hi); break;
877 // If Lo/Hi is null, the sub-method took care of registering results etc.
879 SetExpandedFloat(SDValue(N, ResNo), Lo, Hi);
882 void DAGTypeLegalizer::ExpandFloatRes_ConstantFP(SDNode *N, SDValue &Lo,
884 EVT NVT = TLI.getTypeToTransformTo(*DAG.getContext(), N->getValueType(0));
885 assert(NVT.getSizeInBits() == integerPartWidth &&
886 "Do not know how to expand this float constant!");
887 APInt C = cast<ConstantFPSDNode>(N)->getValueAPF().bitcastToAPInt();
888 Lo = DAG.getConstantFP(APFloat(APInt(integerPartWidth, C.getRawData()[1])),
890 Hi = DAG.getConstantFP(APFloat(APInt(integerPartWidth, C.getRawData()[0])),
894 void DAGTypeLegalizer::ExpandFloatRes_FABS(SDNode *N, SDValue &Lo,
896 assert(N->getValueType(0) == MVT::ppcf128 &&
897 "Logic only correct for ppcf128!");
898 DebugLoc dl = N->getDebugLoc();
900 GetExpandedFloat(N->getOperand(0), Lo, Tmp);
901 Hi = DAG.getNode(ISD::FABS, dl, Tmp.getValueType(), Tmp);
902 // Lo = Hi==fabs(Hi) ? Lo : -Lo;
903 Lo = DAG.getNode(ISD::SELECT_CC, dl, Lo.getValueType(), Tmp, Hi, Lo,
904 DAG.getNode(ISD::FNEG, dl, Lo.getValueType(), Lo),
905 DAG.getCondCode(ISD::SETEQ));
908 void DAGTypeLegalizer::ExpandFloatRes_FADD(SDNode *N, SDValue &Lo,
910 SDValue Call = LibCallify(GetFPLibCall(N->getValueType(0),
911 RTLIB::ADD_F32, RTLIB::ADD_F64,
912 RTLIB::ADD_F80, RTLIB::ADD_PPCF128),
914 GetPairElements(Call, Lo, Hi);
917 void DAGTypeLegalizer::ExpandFloatRes_FCEIL(SDNode *N,
918 SDValue &Lo, SDValue &Hi) {
919 SDValue Call = LibCallify(GetFPLibCall(N->getValueType(0),
920 RTLIB::CEIL_F32, RTLIB::CEIL_F64,
921 RTLIB::CEIL_F80, RTLIB::CEIL_PPCF128),
923 GetPairElements(Call, Lo, Hi);
926 void DAGTypeLegalizer::ExpandFloatRes_FCOPYSIGN(SDNode *N,
927 SDValue &Lo, SDValue &Hi) {
928 SDValue Call = LibCallify(GetFPLibCall(N->getValueType(0),
932 RTLIB::COPYSIGN_PPCF128),
934 GetPairElements(Call, Lo, Hi);
937 void DAGTypeLegalizer::ExpandFloatRes_FCOS(SDNode *N,
938 SDValue &Lo, SDValue &Hi) {
939 SDValue Call = LibCallify(GetFPLibCall(N->getValueType(0),
940 RTLIB::COS_F32, RTLIB::COS_F64,
941 RTLIB::COS_F80, RTLIB::COS_PPCF128),
943 GetPairElements(Call, Lo, Hi);
946 void DAGTypeLegalizer::ExpandFloatRes_FDIV(SDNode *N, SDValue &Lo,
948 SDValue Ops[2] = { N->getOperand(0), N->getOperand(1) };
949 SDValue Call = MakeLibCall(GetFPLibCall(N->getValueType(0),
954 N->getValueType(0), Ops, 2, false,
956 GetPairElements(Call, Lo, Hi);
959 void DAGTypeLegalizer::ExpandFloatRes_FEXP(SDNode *N,
960 SDValue &Lo, SDValue &Hi) {
961 SDValue Call = LibCallify(GetFPLibCall(N->getValueType(0),
962 RTLIB::EXP_F32, RTLIB::EXP_F64,
963 RTLIB::EXP_F80, RTLIB::EXP_PPCF128),
965 GetPairElements(Call, Lo, Hi);
968 void DAGTypeLegalizer::ExpandFloatRes_FEXP2(SDNode *N,
969 SDValue &Lo, SDValue &Hi) {
970 SDValue Call = LibCallify(GetFPLibCall(N->getValueType(0),
971 RTLIB::EXP2_F32, RTLIB::EXP2_F64,
972 RTLIB::EXP2_F80, RTLIB::EXP2_PPCF128),
974 GetPairElements(Call, Lo, Hi);
977 void DAGTypeLegalizer::ExpandFloatRes_FFLOOR(SDNode *N,
978 SDValue &Lo, SDValue &Hi) {
979 SDValue Call = LibCallify(GetFPLibCall(N->getValueType(0),
980 RTLIB::FLOOR_F32,RTLIB::FLOOR_F64,
981 RTLIB::FLOOR_F80,RTLIB::FLOOR_PPCF128),
983 GetPairElements(Call, Lo, Hi);
986 void DAGTypeLegalizer::ExpandFloatRes_FLOG(SDNode *N,
987 SDValue &Lo, SDValue &Hi) {
988 SDValue Call = LibCallify(GetFPLibCall(N->getValueType(0),
989 RTLIB::LOG_F32, RTLIB::LOG_F64,
990 RTLIB::LOG_F80, RTLIB::LOG_PPCF128),
992 GetPairElements(Call, Lo, Hi);
995 void DAGTypeLegalizer::ExpandFloatRes_FLOG2(SDNode *N,
996 SDValue &Lo, SDValue &Hi) {
997 SDValue Call = LibCallify(GetFPLibCall(N->getValueType(0),
998 RTLIB::LOG2_F32, RTLIB::LOG2_F64,
999 RTLIB::LOG2_F80, RTLIB::LOG2_PPCF128),
1001 GetPairElements(Call, Lo, Hi);
1004 void DAGTypeLegalizer::ExpandFloatRes_FLOG10(SDNode *N,
1005 SDValue &Lo, SDValue &Hi) {
1006 SDValue Call = LibCallify(GetFPLibCall(N->getValueType(0),
1007 RTLIB::LOG10_F32,RTLIB::LOG10_F64,
1008 RTLIB::LOG10_F80,RTLIB::LOG10_PPCF128),
1010 GetPairElements(Call, Lo, Hi);
1013 void DAGTypeLegalizer::ExpandFloatRes_FMA(SDNode *N, SDValue &Lo,
1015 SDValue Ops[3] = { N->getOperand(0), N->getOperand(1), N->getOperand(2) };
1016 SDValue Call = MakeLibCall(GetFPLibCall(N->getValueType(0),
1020 RTLIB::FMA_PPCF128),
1021 N->getValueType(0), Ops, 3, false,
1023 GetPairElements(Call, Lo, Hi);
1026 void DAGTypeLegalizer::ExpandFloatRes_FMUL(SDNode *N, SDValue &Lo,
1028 SDValue Ops[2] = { N->getOperand(0), N->getOperand(1) };
1029 SDValue Call = MakeLibCall(GetFPLibCall(N->getValueType(0),
1033 RTLIB::MUL_PPCF128),
1034 N->getValueType(0), Ops, 2, false,
1036 GetPairElements(Call, Lo, Hi);
1039 void DAGTypeLegalizer::ExpandFloatRes_FNEARBYINT(SDNode *N,
1040 SDValue &Lo, SDValue &Hi) {
1041 SDValue Call = LibCallify(GetFPLibCall(N->getValueType(0),
1042 RTLIB::NEARBYINT_F32,
1043 RTLIB::NEARBYINT_F64,
1044 RTLIB::NEARBYINT_F80,
1045 RTLIB::NEARBYINT_PPCF128),
1047 GetPairElements(Call, Lo, Hi);
1050 void DAGTypeLegalizer::ExpandFloatRes_FNEG(SDNode *N, SDValue &Lo,
1052 DebugLoc dl = N->getDebugLoc();
1053 GetExpandedFloat(N->getOperand(0), Lo, Hi);
1054 Lo = DAG.getNode(ISD::FNEG, dl, Lo.getValueType(), Lo);
1055 Hi = DAG.getNode(ISD::FNEG, dl, Hi.getValueType(), Hi);
1058 void DAGTypeLegalizer::ExpandFloatRes_FP_EXTEND(SDNode *N, SDValue &Lo,
1060 EVT NVT = TLI.getTypeToTransformTo(*DAG.getContext(), N->getValueType(0));
1061 Hi = DAG.getNode(ISD::FP_EXTEND, N->getDebugLoc(), NVT, N->getOperand(0));
1062 Lo = DAG.getConstantFP(APFloat(APInt(NVT.getSizeInBits(), 0)), NVT);
1065 void DAGTypeLegalizer::ExpandFloatRes_FPOW(SDNode *N,
1066 SDValue &Lo, SDValue &Hi) {
1067 SDValue Call = LibCallify(GetFPLibCall(N->getValueType(0),
1068 RTLIB::POW_F32, RTLIB::POW_F64,
1069 RTLIB::POW_F80, RTLIB::POW_PPCF128),
1071 GetPairElements(Call, Lo, Hi);
1074 void DAGTypeLegalizer::ExpandFloatRes_FPOWI(SDNode *N,
1075 SDValue &Lo, SDValue &Hi) {
1076 SDValue Call = LibCallify(GetFPLibCall(N->getValueType(0),
1077 RTLIB::POWI_F32, RTLIB::POWI_F64,
1078 RTLIB::POWI_F80, RTLIB::POWI_PPCF128),
1080 GetPairElements(Call, Lo, Hi);
1083 void DAGTypeLegalizer::ExpandFloatRes_FRINT(SDNode *N,
1084 SDValue &Lo, SDValue &Hi) {
1085 SDValue Call = LibCallify(GetFPLibCall(N->getValueType(0),
1086 RTLIB::RINT_F32, RTLIB::RINT_F64,
1087 RTLIB::RINT_F80, RTLIB::RINT_PPCF128),
1089 GetPairElements(Call, Lo, Hi);
1092 void DAGTypeLegalizer::ExpandFloatRes_FSIN(SDNode *N,
1093 SDValue &Lo, SDValue &Hi) {
1094 SDValue Call = LibCallify(GetFPLibCall(N->getValueType(0),
1095 RTLIB::SIN_F32, RTLIB::SIN_F64,
1096 RTLIB::SIN_F80, RTLIB::SIN_PPCF128),
1098 GetPairElements(Call, Lo, Hi);
1101 void DAGTypeLegalizer::ExpandFloatRes_FSQRT(SDNode *N,
1102 SDValue &Lo, SDValue &Hi) {
1103 SDValue Call = LibCallify(GetFPLibCall(N->getValueType(0),
1104 RTLIB::SQRT_F32, RTLIB::SQRT_F64,
1105 RTLIB::SQRT_F80, RTLIB::SQRT_PPCF128),
1107 GetPairElements(Call, Lo, Hi);
1110 void DAGTypeLegalizer::ExpandFloatRes_FSUB(SDNode *N, SDValue &Lo,
1112 SDValue Ops[2] = { N->getOperand(0), N->getOperand(1) };
1113 SDValue Call = MakeLibCall(GetFPLibCall(N->getValueType(0),
1117 RTLIB::SUB_PPCF128),
1118 N->getValueType(0), Ops, 2, false,
1120 GetPairElements(Call, Lo, Hi);
1123 void DAGTypeLegalizer::ExpandFloatRes_FTRUNC(SDNode *N,
1124 SDValue &Lo, SDValue &Hi) {
1125 SDValue Call = LibCallify(GetFPLibCall(N->getValueType(0),
1126 RTLIB::TRUNC_F32, RTLIB::TRUNC_F64,
1127 RTLIB::TRUNC_F80, RTLIB::TRUNC_PPCF128),
1129 GetPairElements(Call, Lo, Hi);
1132 void DAGTypeLegalizer::ExpandFloatRes_LOAD(SDNode *N, SDValue &Lo,
1134 if (ISD::isNormalLoad(N)) {
1135 ExpandRes_NormalLoad(N, Lo, Hi);
1139 assert(ISD::isUNINDEXEDLoad(N) && "Indexed load during type legalization!");
1140 LoadSDNode *LD = cast<LoadSDNode>(N);
1141 SDValue Chain = LD->getChain();
1142 SDValue Ptr = LD->getBasePtr();
1143 DebugLoc dl = N->getDebugLoc();
1145 EVT NVT = TLI.getTypeToTransformTo(*DAG.getContext(), LD->getValueType(0));
1146 assert(NVT.isByteSized() && "Expanded type not byte sized!");
1147 assert(LD->getMemoryVT().bitsLE(NVT) && "Float type not round?");
1149 Hi = DAG.getExtLoad(LD->getExtensionType(), dl, NVT, Chain, Ptr,
1150 LD->getPointerInfo(), LD->getMemoryVT(), LD->isVolatile(),
1151 LD->isNonTemporal(), LD->getAlignment());
1153 // Remember the chain.
1154 Chain = Hi.getValue(1);
1156 // The low part is zero.
1157 Lo = DAG.getConstantFP(APFloat(APInt(NVT.getSizeInBits(), 0)), NVT);
1159 // Modified the chain - switch anything that used the old chain to use the
1161 ReplaceValueWith(SDValue(LD, 1), Chain);
1164 void DAGTypeLegalizer::ExpandFloatRes_XINT_TO_FP(SDNode *N, SDValue &Lo,
1166 assert(N->getValueType(0) == MVT::ppcf128 && "Unsupported XINT_TO_FP!");
1167 EVT VT = N->getValueType(0);
1168 EVT NVT = TLI.getTypeToTransformTo(*DAG.getContext(), VT);
1169 SDValue Src = N->getOperand(0);
1170 EVT SrcVT = Src.getValueType();
1171 bool isSigned = N->getOpcode() == ISD::SINT_TO_FP;
1172 DebugLoc dl = N->getDebugLoc();
1174 // First do an SINT_TO_FP, whether the original was signed or unsigned.
1175 // When promoting partial word types to i32 we must honor the signedness,
1177 if (SrcVT.bitsLE(MVT::i32)) {
1178 // The integer can be represented exactly in an f64.
1179 Src = DAG.getNode(isSigned ? ISD::SIGN_EXTEND : ISD::ZERO_EXTEND, dl,
1181 Lo = DAG.getConstantFP(APFloat(APInt(NVT.getSizeInBits(), 0)), NVT);
1182 Hi = DAG.getNode(ISD::SINT_TO_FP, dl, NVT, Src);
1184 RTLIB::Libcall LC = RTLIB::UNKNOWN_LIBCALL;
1185 if (SrcVT.bitsLE(MVT::i64)) {
1186 Src = DAG.getNode(isSigned ? ISD::SIGN_EXTEND : ISD::ZERO_EXTEND, dl,
1188 LC = RTLIB::SINTTOFP_I64_PPCF128;
1189 } else if (SrcVT.bitsLE(MVT::i128)) {
1190 Src = DAG.getNode(ISD::SIGN_EXTEND, dl, MVT::i128, Src);
1191 LC = RTLIB::SINTTOFP_I128_PPCF128;
1193 assert(LC != RTLIB::UNKNOWN_LIBCALL && "Unsupported XINT_TO_FP!");
1195 Hi = MakeLibCall(LC, VT, &Src, 1, true, dl);
1196 GetPairElements(Hi, Lo, Hi);
1202 // Unsigned - fix up the SINT_TO_FP value just calculated.
1203 Hi = DAG.getNode(ISD::BUILD_PAIR, dl, VT, Lo, Hi);
1204 SrcVT = Src.getValueType();
1206 // x>=0 ? (ppcf128)(iN)x : (ppcf128)(iN)x + 2^N; N=32,64,128.
1207 static const uint64_t TwoE32[] = { 0x41f0000000000000LL, 0 };
1208 static const uint64_t TwoE64[] = { 0x43f0000000000000LL, 0 };
1209 static const uint64_t TwoE128[] = { 0x47f0000000000000LL, 0 };
1210 ArrayRef<uint64_t> Parts;
1212 switch (SrcVT.getSimpleVT().SimpleTy) {
1214 assert(false && "Unsupported UINT_TO_FP!");
1226 Lo = DAG.getNode(ISD::FADD, dl, VT, Hi,
1227 DAG.getConstantFP(APFloat(APInt(128, Parts)),
1229 Lo = DAG.getNode(ISD::SELECT_CC, dl, VT, Src, DAG.getConstant(0, SrcVT),
1230 Lo, Hi, DAG.getCondCode(ISD::SETLT));
1231 GetPairElements(Lo, Lo, Hi);
1235 //===----------------------------------------------------------------------===//
1236 // Float Operand Expansion
1237 //===----------------------------------------------------------------------===//
1239 /// ExpandFloatOperand - This method is called when the specified operand of the
1240 /// specified node is found to need expansion. At this point, all of the result
1241 /// types of the node are known to be legal, but other operands of the node may
1242 /// need promotion or expansion as well as the specified one.
1243 bool DAGTypeLegalizer::ExpandFloatOperand(SDNode *N, unsigned OpNo) {
1244 DEBUG(dbgs() << "Expand float operand: "; N->dump(&DAG); dbgs() << "\n");
1245 SDValue Res = SDValue();
1247 if (TLI.getOperationAction(N->getOpcode(), N->getOperand(OpNo).getValueType())
1248 == TargetLowering::Custom)
1249 Res = TLI.LowerOperation(SDValue(N, 0), DAG);
1251 if (Res.getNode() == 0) {
1252 switch (N->getOpcode()) {
1255 dbgs() << "ExpandFloatOperand Op #" << OpNo << ": ";
1256 N->dump(&DAG); dbgs() << "\n";
1258 llvm_unreachable("Do not know how to expand this operator's operand!");
1260 case ISD::BITCAST: Res = ExpandOp_BITCAST(N); break;
1261 case ISD::BUILD_VECTOR: Res = ExpandOp_BUILD_VECTOR(N); break;
1262 case ISD::EXTRACT_ELEMENT: Res = ExpandOp_EXTRACT_ELEMENT(N); break;
1264 case ISD::BR_CC: Res = ExpandFloatOp_BR_CC(N); break;
1265 case ISD::FP_ROUND: Res = ExpandFloatOp_FP_ROUND(N); break;
1266 case ISD::FP_TO_SINT: Res = ExpandFloatOp_FP_TO_SINT(N); break;
1267 case ISD::FP_TO_UINT: Res = ExpandFloatOp_FP_TO_UINT(N); break;
1268 case ISD::SELECT_CC: Res = ExpandFloatOp_SELECT_CC(N); break;
1269 case ISD::SETCC: Res = ExpandFloatOp_SETCC(N); break;
1270 case ISD::STORE: Res = ExpandFloatOp_STORE(cast<StoreSDNode>(N),
1275 // If the result is null, the sub-method took care of registering results etc.
1276 if (!Res.getNode()) return false;
1278 // If the result is N, the sub-method updated N in place. Tell the legalizer
1280 if (Res.getNode() == N)
1283 assert(Res.getValueType() == N->getValueType(0) && N->getNumValues() == 1 &&
1284 "Invalid operand expansion");
1286 ReplaceValueWith(SDValue(N, 0), Res);
1290 /// FloatExpandSetCCOperands - Expand the operands of a comparison. This code
1291 /// is shared among BR_CC, SELECT_CC, and SETCC handlers.
1292 void DAGTypeLegalizer::FloatExpandSetCCOperands(SDValue &NewLHS,
1294 ISD::CondCode &CCCode,
1296 SDValue LHSLo, LHSHi, RHSLo, RHSHi;
1297 GetExpandedFloat(NewLHS, LHSLo, LHSHi);
1298 GetExpandedFloat(NewRHS, RHSLo, RHSHi);
1300 assert(NewLHS.getValueType() == MVT::ppcf128 && "Unsupported setcc type!");
1302 // FIXME: This generated code sucks. We want to generate
1303 // FCMPU crN, hi1, hi2
1305 // FCMPU crN, lo1, lo2
1306 // The following can be improved, but not that much.
1307 SDValue Tmp1, Tmp2, Tmp3;
1308 Tmp1 = DAG.getSetCC(dl, TLI.getSetCCResultType(LHSHi.getValueType()),
1309 LHSHi, RHSHi, ISD::SETOEQ);
1310 Tmp2 = DAG.getSetCC(dl, TLI.getSetCCResultType(LHSLo.getValueType()),
1311 LHSLo, RHSLo, CCCode);
1312 Tmp3 = DAG.getNode(ISD::AND, dl, Tmp1.getValueType(), Tmp1, Tmp2);
1313 Tmp1 = DAG.getSetCC(dl, TLI.getSetCCResultType(LHSHi.getValueType()),
1314 LHSHi, RHSHi, ISD::SETUNE);
1315 Tmp2 = DAG.getSetCC(dl, TLI.getSetCCResultType(LHSHi.getValueType()),
1316 LHSHi, RHSHi, CCCode);
1317 Tmp1 = DAG.getNode(ISD::AND, dl, Tmp1.getValueType(), Tmp1, Tmp2);
1318 NewLHS = DAG.getNode(ISD::OR, dl, Tmp1.getValueType(), Tmp1, Tmp3);
1319 NewRHS = SDValue(); // LHS is the result, not a compare.
1322 SDValue DAGTypeLegalizer::ExpandFloatOp_BR_CC(SDNode *N) {
1323 SDValue NewLHS = N->getOperand(2), NewRHS = N->getOperand(3);
1324 ISD::CondCode CCCode = cast<CondCodeSDNode>(N->getOperand(1))->get();
1325 FloatExpandSetCCOperands(NewLHS, NewRHS, CCCode, N->getDebugLoc());
1327 // If ExpandSetCCOperands returned a scalar, we need to compare the result
1328 // against zero to select between true and false values.
1329 if (NewRHS.getNode() == 0) {
1330 NewRHS = DAG.getConstant(0, NewLHS.getValueType());
1331 CCCode = ISD::SETNE;
1334 // Update N to have the operands specified.
1335 return SDValue(DAG.UpdateNodeOperands(N, N->getOperand(0),
1336 DAG.getCondCode(CCCode), NewLHS, NewRHS,
1337 N->getOperand(4)), 0);
1340 SDValue DAGTypeLegalizer::ExpandFloatOp_FP_ROUND(SDNode *N) {
1341 assert(N->getOperand(0).getValueType() == MVT::ppcf128 &&
1342 "Logic only correct for ppcf128!");
1344 GetExpandedFloat(N->getOperand(0), Lo, Hi);
1345 // Round it the rest of the way (e.g. to f32) if needed.
1346 return DAG.getNode(ISD::FP_ROUND, N->getDebugLoc(),
1347 N->getValueType(0), Hi, N->getOperand(1));
1350 SDValue DAGTypeLegalizer::ExpandFloatOp_FP_TO_SINT(SDNode *N) {
1351 EVT RVT = N->getValueType(0);
1352 DebugLoc dl = N->getDebugLoc();
1354 // Expand ppcf128 to i32 by hand for the benefit of llvm-gcc bootstrap on
1355 // PPC (the libcall is not available). FIXME: Do this in a less hacky way.
1356 if (RVT == MVT::i32) {
1357 assert(N->getOperand(0).getValueType() == MVT::ppcf128 &&
1358 "Logic only correct for ppcf128!");
1359 SDValue Res = DAG.getNode(ISD::FP_ROUND_INREG, dl, MVT::ppcf128,
1360 N->getOperand(0), DAG.getValueType(MVT::f64));
1361 Res = DAG.getNode(ISD::FP_ROUND, dl, MVT::f64, Res,
1362 DAG.getIntPtrConstant(1));
1363 return DAG.getNode(ISD::FP_TO_SINT, dl, MVT::i32, Res);
1366 RTLIB::Libcall LC = RTLIB::getFPTOSINT(N->getOperand(0).getValueType(), RVT);
1367 assert(LC != RTLIB::UNKNOWN_LIBCALL && "Unsupported FP_TO_SINT!");
1368 return MakeLibCall(LC, RVT, &N->getOperand(0), 1, false, dl);
1371 SDValue DAGTypeLegalizer::ExpandFloatOp_FP_TO_UINT(SDNode *N) {
1372 EVT RVT = N->getValueType(0);
1373 DebugLoc dl = N->getDebugLoc();
1375 // Expand ppcf128 to i32 by hand for the benefit of llvm-gcc bootstrap on
1376 // PPC (the libcall is not available). FIXME: Do this in a less hacky way.
1377 if (RVT == MVT::i32) {
1378 assert(N->getOperand(0).getValueType() == MVT::ppcf128 &&
1379 "Logic only correct for ppcf128!");
1380 const uint64_t TwoE31[] = {0x41e0000000000000LL, 0};
1381 APFloat APF = APFloat(APInt(128, TwoE31));
1382 SDValue Tmp = DAG.getConstantFP(APF, MVT::ppcf128);
1383 // X>=2^31 ? (int)(X-2^31)+0x80000000 : (int)X
1384 // FIXME: generated code sucks.
1385 return DAG.getNode(ISD::SELECT_CC, dl, MVT::i32, N->getOperand(0), Tmp,
1386 DAG.getNode(ISD::ADD, dl, MVT::i32,
1387 DAG.getNode(ISD::FP_TO_SINT, dl, MVT::i32,
1388 DAG.getNode(ISD::FSUB, dl,
1392 DAG.getConstant(0x80000000, MVT::i32)),
1393 DAG.getNode(ISD::FP_TO_SINT, dl,
1394 MVT::i32, N->getOperand(0)),
1395 DAG.getCondCode(ISD::SETGE));
1398 RTLIB::Libcall LC = RTLIB::getFPTOUINT(N->getOperand(0).getValueType(), RVT);
1399 assert(LC != RTLIB::UNKNOWN_LIBCALL && "Unsupported FP_TO_UINT!");
1400 return MakeLibCall(LC, N->getValueType(0), &N->getOperand(0), 1, false, dl);
1403 SDValue DAGTypeLegalizer::ExpandFloatOp_SELECT_CC(SDNode *N) {
1404 SDValue NewLHS = N->getOperand(0), NewRHS = N->getOperand(1);
1405 ISD::CondCode CCCode = cast<CondCodeSDNode>(N->getOperand(4))->get();
1406 FloatExpandSetCCOperands(NewLHS, NewRHS, CCCode, N->getDebugLoc());
1408 // If ExpandSetCCOperands returned a scalar, we need to compare the result
1409 // against zero to select between true and false values.
1410 if (NewRHS.getNode() == 0) {
1411 NewRHS = DAG.getConstant(0, NewLHS.getValueType());
1412 CCCode = ISD::SETNE;
1415 // Update N to have the operands specified.
1416 return SDValue(DAG.UpdateNodeOperands(N, NewLHS, NewRHS,
1417 N->getOperand(2), N->getOperand(3),
1418 DAG.getCondCode(CCCode)), 0);
1421 SDValue DAGTypeLegalizer::ExpandFloatOp_SETCC(SDNode *N) {
1422 SDValue NewLHS = N->getOperand(0), NewRHS = N->getOperand(1);
1423 ISD::CondCode CCCode = cast<CondCodeSDNode>(N->getOperand(2))->get();
1424 FloatExpandSetCCOperands(NewLHS, NewRHS, CCCode, N->getDebugLoc());
1426 // If ExpandSetCCOperands returned a scalar, use it.
1427 if (NewRHS.getNode() == 0) {
1428 assert(NewLHS.getValueType() == N->getValueType(0) &&
1429 "Unexpected setcc expansion!");
1433 // Otherwise, update N to have the operands specified.
1434 return SDValue(DAG.UpdateNodeOperands(N, NewLHS, NewRHS,
1435 DAG.getCondCode(CCCode)), 0);
1438 SDValue DAGTypeLegalizer::ExpandFloatOp_STORE(SDNode *N, unsigned OpNo) {
1439 if (ISD::isNormalStore(N))
1440 return ExpandOp_NormalStore(N, OpNo);
1442 assert(ISD::isUNINDEXEDStore(N) && "Indexed store during type legalization!");
1443 assert(OpNo == 1 && "Can only expand the stored value so far");
1444 StoreSDNode *ST = cast<StoreSDNode>(N);
1446 SDValue Chain = ST->getChain();
1447 SDValue Ptr = ST->getBasePtr();
1449 EVT NVT = TLI.getTypeToTransformTo(*DAG.getContext(),
1450 ST->getValue().getValueType());
1451 assert(NVT.isByteSized() && "Expanded type not byte sized!");
1452 assert(ST->getMemoryVT().bitsLE(NVT) && "Float type not round?");
1456 GetExpandedOp(ST->getValue(), Lo, Hi);
1458 return DAG.getTruncStore(Chain, N->getDebugLoc(), Hi, Ptr,
1459 ST->getPointerInfo(),
1460 ST->getMemoryVT(), ST->isVolatile(),
1461 ST->isNonTemporal(), ST->getAlignment());