lib/CodeGen/SelectionDAG/LegalizeFloatTypes.cpp

   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 using namespace llvm;
  24
  25 /// GetFPLibCall - Return the right libcall for the given floating point type.
  26 static RTLIB::Libcall GetFPLibCall(MVT VT,
  27                                    RTLIB::Libcall Call_F32,
  28                                    RTLIB::Libcall Call_F64,
  29                                    RTLIB::Libcall Call_F80,
  30                                    RTLIB::Libcall Call_PPCF128) {
  31   return
  32     VT == MVT::f32 ? Call_F32 :
  33     VT == MVT::f64 ? Call_F64 :
  34     VT == MVT::f80 ? Call_F80 :
  35     VT == MVT::ppcf128 ? Call_PPCF128 :
  36     RTLIB::UNKNOWN_LIBCALL;
  37 }
  38
  39 //===----------------------------------------------------------------------===//
  40 //  Result Float to Integer Conversion.
  41 //===----------------------------------------------------------------------===//
  42
  43 void DAGTypeLegalizer::SoftenFloatResult(SDNode *N, unsigned ResNo) {
  44   DEBUG(cerr << "Soften float result " << ResNo << ": "; N->dump(&DAG);
  45         cerr << "\n");
  46   SDValue R = SDValue();
  47
  48   switch (N->getOpcode()) {
  49   default:
  50 #ifndef NDEBUG
  51     cerr << "SoftenFloatResult #" << ResNo << ": ";
  52     N->dump(&DAG); cerr << "\n";
  53 #endif
  54     assert(0 && "Do not know how to soften the result of this operator!");
  55     abort();
  56
  57     case ISD::BIT_CONVERT: R = SoftenFloatRes_BIT_CONVERT(N); break;
  58     case ISD::BUILD_PAIR:  R = SoftenFloatRes_BUILD_PAIR(N); break;
  59     case ISD::ConstantFP:
  60       R = SoftenFloatRes_ConstantFP(cast<ConstantFPSDNode>(N));
  61       break;
  62     case ISD::FABS:        R = SoftenFloatRes_FABS(N); break;
  63     case ISD::FADD:        R = SoftenFloatRes_FADD(N); break;
  64     case ISD::FCOPYSIGN:   R = SoftenFloatRes_FCOPYSIGN(N); break;
  65     case ISD::FDIV:        R = SoftenFloatRes_FDIV(N); break;
  66     case ISD::FMUL:        R = SoftenFloatRes_FMUL(N); break;
  67     case ISD::FP_EXTEND:   R = SoftenFloatRes_FP_EXTEND(N); break;
  68     case ISD::FP_ROUND:    R = SoftenFloatRes_FP_ROUND(N); break;
  69     case ISD::FPOW:        R = SoftenFloatRes_FPOW(N); break;
  70     case ISD::FPOWI:       R = SoftenFloatRes_FPOWI(N); break;
  71     case ISD::FSUB:        R = SoftenFloatRes_FSUB(N); break;
  72     case ISD::LOAD:        R = SoftenFloatRes_LOAD(N); break;
  73     case ISD::SELECT:      R = SoftenFloatRes_SELECT(N); break;
  74     case ISD::SELECT_CC:   R = SoftenFloatRes_SELECT_CC(N); break;
  75     case ISD::SINT_TO_FP:
  76     case ISD::UINT_TO_FP:  R = SoftenFloatRes_XINT_TO_FP(N); break;
  77   }
  78
  79   // If R is null, the sub-method took care of registering the result.
  80   if (R.getNode())
  81     SetSoftenedFloat(SDValue(N, ResNo), R);
  82 }
  83
  84 SDValue DAGTypeLegalizer::SoftenFloatRes_BIT_CONVERT(SDNode *N) {
  85   return BitConvertToInteger(N->getOperand(0));
  86 }
  87
  88 SDValue DAGTypeLegalizer::SoftenFloatRes_BUILD_PAIR(SDNode *N) {
  89   // Convert the inputs to integers, and build a new pair out of them.
  90   return DAG.getNode(ISD::BUILD_PAIR,
  91                      TLI.getTypeToTransformTo(N->getValueType(0)),
  92                      BitConvertToInteger(N->getOperand(0)),
  93                      BitConvertToInteger(N->getOperand(1)));
  94 }
  95
  96 SDValue DAGTypeLegalizer::SoftenFloatRes_ConstantFP(ConstantFPSDNode *N) {
  97   return DAG.getConstant(N->getValueAPF().bitcastToAPInt(),
  98                          TLI.getTypeToTransformTo(N->getValueType(0)));
  99 }
 100
 101 SDValue DAGTypeLegalizer::SoftenFloatRes_FABS(SDNode *N) {
 102   MVT NVT = TLI.getTypeToTransformTo(N->getValueType(0));
 103   unsigned Size = NVT.getSizeInBits();
 104
 105   // Mask = ~(1 << (Size-1))
 106   SDValue Mask = DAG.getConstant(APInt::getAllOnesValue(Size).clear(Size-1),
 107                                  NVT);
 108   SDValue Op = GetSoftenedFloat(N->getOperand(0));
 109   return DAG.getNode(ISD::AND, NVT, Op, Mask);
 110 }
 111
 112 SDValue DAGTypeLegalizer::SoftenFloatRes_FADD(SDNode *N) {
 113   MVT NVT = TLI.getTypeToTransformTo(N->getValueType(0));
 114   SDValue Ops[2] = { GetSoftenedFloat(N->getOperand(0)),
 115                      GetSoftenedFloat(N->getOperand(1)) };
 116   return MakeLibCall(GetFPLibCall(N->getValueType(0),
 117                                   RTLIB::ADD_F32,
 118                                   RTLIB::ADD_F64,
 119                                   RTLIB::ADD_F80,
 120                                   RTLIB::ADD_PPCF128),
 121                      NVT, Ops, 2, false);
 122 }
 123
 124 SDValue DAGTypeLegalizer::SoftenFloatRes_FCOPYSIGN(SDNode *N) {
 125   SDValue LHS = GetSoftenedFloat(N->getOperand(0));
 126   SDValue RHS = BitConvertToInteger(N->getOperand(1));
 127
 128   MVT LVT = LHS.getValueType();
 129   MVT RVT = RHS.getValueType();
 130
 131   unsigned LSize = LVT.getSizeInBits();
 132   unsigned RSize = RVT.getSizeInBits();
 133
 134   // First get the sign bit of second operand.
 135   SDValue SignBit = DAG.getNode(ISD::SHL, RVT, DAG.getConstant(1, RVT),
 136                                   DAG.getConstant(RSize - 1,
 137                                                   TLI.getShiftAmountTy()));
 138   SignBit = DAG.getNode(ISD::AND, RVT, RHS, SignBit);
 139
 140   // Shift right or sign-extend it if the two operands have different types.
 141   int SizeDiff = RVT.getSizeInBits() - LVT.getSizeInBits();
 142   if (SizeDiff > 0) {
 143     SignBit = DAG.getNode(ISD::SRL, RVT, SignBit,
 144                           DAG.getConstant(SizeDiff, TLI.getShiftAmountTy()));
 145     SignBit = DAG.getNode(ISD::TRUNCATE, LVT, SignBit);
 146   } else if (SizeDiff < 0) {
 147     SignBit = DAG.getNode(ISD::ANY_EXTEND, LVT, SignBit);
 148     SignBit = DAG.getNode(ISD::SHL, LVT, SignBit,
 149                           DAG.getConstant(-SizeDiff, TLI.getShiftAmountTy()));
 150   }
 151
 152   // Clear the sign bit of the first operand.
 153   SDValue Mask = DAG.getNode(ISD::SHL, LVT, DAG.getConstant(1, LVT),
 154                                DAG.getConstant(LSize - 1,
 155                                                TLI.getShiftAmountTy()));
 156   Mask = DAG.getNode(ISD::SUB, LVT, Mask, DAG.getConstant(1, LVT));
 157   LHS = DAG.getNode(ISD::AND, LVT, LHS, Mask);
 158
 159   // Or the value with the sign bit.
 160   return DAG.getNode(ISD::OR, LVT, LHS, SignBit);
 161 }
 162
 163 SDValue DAGTypeLegalizer::SoftenFloatRes_FDIV(SDNode *N) {
 164   MVT NVT = TLI.getTypeToTransformTo(N->getValueType(0));
 165   SDValue Ops[2] = { GetSoftenedFloat(N->getOperand(0)),
 166                      GetSoftenedFloat(N->getOperand(1)) };
 167   return MakeLibCall(GetFPLibCall(N->getValueType(0),
 168                                   RTLIB::DIV_F32,
 169                                   RTLIB::DIV_F64,
 170                                   RTLIB::DIV_F80,
 171                                   RTLIB::DIV_PPCF128),
 172                      NVT, Ops, 2, false);
 173 }
 174
 175 SDValue DAGTypeLegalizer::SoftenFloatRes_FMUL(SDNode *N) {
 176   MVT NVT = TLI.getTypeToTransformTo(N->getValueType(0));
 177   SDValue Ops[2] = { GetSoftenedFloat(N->getOperand(0)),
 178                      GetSoftenedFloat(N->getOperand(1)) };
 179   return MakeLibCall(GetFPLibCall(N->getValueType(0),
 180                                   RTLIB::MUL_F32,
 181                                   RTLIB::MUL_F64,
 182                                   RTLIB::MUL_F80,
 183                                   RTLIB::MUL_PPCF128),
 184                      NVT, Ops, 2, false);
 185 }
 186
 187 SDValue DAGTypeLegalizer::SoftenFloatRes_FP_EXTEND(SDNode *N) {
 188   MVT NVT = TLI.getTypeToTransformTo(N->getValueType(0));
 189   SDValue Op = N->getOperand(0);
 190   RTLIB::Libcall LC = RTLIB::getFPEXT(Op.getValueType(), N->getValueType(0));
 191   assert(LC != RTLIB::UNKNOWN_LIBCALL && "Unsupported FP_EXTEND!");
 192   return MakeLibCall(LC, NVT, &Op, 1, false);
 193 }
 194
 195 SDValue DAGTypeLegalizer::SoftenFloatRes_FP_ROUND(SDNode *N) {
 196   MVT NVT = TLI.getTypeToTransformTo(N->getValueType(0));
 197   SDValue Op = N->getOperand(0);
 198   RTLIB::Libcall LC = RTLIB::getFPROUND(Op.getValueType(), N->getValueType(0));
 199   assert(LC != RTLIB::UNKNOWN_LIBCALL && "Unsupported FP_ROUND!");
 200   return MakeLibCall(LC, NVT, &Op, 1, false);
 201 }
 202
 203 SDValue DAGTypeLegalizer::SoftenFloatRes_FPOW(SDNode *N) {
 204   MVT NVT = TLI.getTypeToTransformTo(N->getValueType(0));
 205   SDValue Ops[2] = { GetSoftenedFloat(N->getOperand(0)),
 206                      GetSoftenedFloat(N->getOperand(1)) };
 207   return MakeLibCall(GetFPLibCall(N->getValueType(0),
 208                                   RTLIB::POW_F32,
 209                                   RTLIB::POW_F64,
 210                                   RTLIB::POW_F80,
 211                                   RTLIB::POW_PPCF128),
 212                      NVT, Ops, 2, false);
 213 }
 214
 215 SDValue DAGTypeLegalizer::SoftenFloatRes_FPOWI(SDNode *N) {
 216   assert(N->getOperand(1).getValueType() == MVT::i32 &&
 217          "Unsupported power type!");
 218   MVT NVT = TLI.getTypeToTransformTo(N->getValueType(0));
 219   SDValue Ops[2] = { GetSoftenedFloat(N->getOperand(0)), N->getOperand(1) };
 220   return MakeLibCall(GetFPLibCall(N->getValueType(0),
 221                                   RTLIB::POWI_F32,
 222                                   RTLIB::POWI_F64,
 223                                   RTLIB::POWI_F80,
 224                                   RTLIB::POWI_PPCF128),
 225                      NVT, Ops, 2, false);
 226 }
 227
 228 SDValue DAGTypeLegalizer::SoftenFloatRes_FSUB(SDNode *N) {
 229   MVT NVT = TLI.getTypeToTransformTo(N->getValueType(0));
 230   SDValue Ops[2] = { GetSoftenedFloat(N->getOperand(0)),
 231                      GetSoftenedFloat(N->getOperand(1)) };
 232   return MakeLibCall(GetFPLibCall(N->getValueType(0),
 233                                   RTLIB::SUB_F32,
 234                                   RTLIB::SUB_F64,
 235                                   RTLIB::SUB_F80,
 236                                   RTLIB::SUB_PPCF128),
 237                      NVT, Ops, 2, false);
 238 }
 239
 240 SDValue DAGTypeLegalizer::SoftenFloatRes_LOAD(SDNode *N) {
 241   LoadSDNode *L = cast<LoadSDNode>(N);
 242   MVT VT = N->getValueType(0);
 243   MVT NVT = TLI.getTypeToTransformTo(VT);
 244
 245   SDValue NewL;
 246   if (L->getExtensionType() == ISD::NON_EXTLOAD) {
 247     NewL = DAG.getLoad(L->getAddressingMode(), L->getExtensionType(),
 248                        NVT, L->getChain(), L->getBasePtr(), L->getOffset(),
 249                        L->getSrcValue(), L->getSrcValueOffset(), NVT,
 250                        L->isVolatile(), L->getAlignment());
 251     // Legalized the chain result - switch anything that used the old chain to
 252     // use the new one.
 253     ReplaceValueWith(SDValue(N, 1), NewL.getValue(1));
 254     return NewL;
 255   }
 256
 257   // Do a non-extending load followed by FP_EXTEND.
 258   NewL = DAG.getLoad(L->getAddressingMode(), ISD::NON_EXTLOAD,
 259                      L->getMemoryVT(), L->getChain(),
 260                      L->getBasePtr(), L->getOffset(),
 261                      L->getSrcValue(), L->getSrcValueOffset(),
 262                      L->getMemoryVT(),
 263                      L->isVolatile(), L->getAlignment());
 264   // Legalized the chain result - switch anything that used the old chain to
 265   // use the new one.
 266   ReplaceValueWith(SDValue(N, 1), NewL.getValue(1));
 267   return BitConvertToInteger(DAG.getNode(ISD::FP_EXTEND, VT, NewL));
 268 }
 269
 270 SDValue DAGTypeLegalizer::SoftenFloatRes_SELECT(SDNode *N) {
 271   SDValue LHS = GetSoftenedFloat(N->getOperand(1));
 272   SDValue RHS = GetSoftenedFloat(N->getOperand(2));
 273   return DAG.getNode(ISD::SELECT, LHS.getValueType(), N->getOperand(0),LHS,RHS);
 274 }
 275
 276 SDValue DAGTypeLegalizer::SoftenFloatRes_SELECT_CC(SDNode *N) {
 277   SDValue LHS = GetSoftenedFloat(N->getOperand(2));
 278   SDValue RHS = GetSoftenedFloat(N->getOperand(3));
 279   return DAG.getNode(ISD::SELECT_CC, LHS.getValueType(), N->getOperand(0),
 280                      N->getOperand(1), LHS, RHS, N->getOperand(4));
 281 }
 282
 283 SDValue DAGTypeLegalizer::SoftenFloatRes_XINT_TO_FP(SDNode *N) {
 284   bool Signed = N->getOpcode() == ISD::SINT_TO_FP;
 285   MVT SVT = N->getOperand(0).getValueType();
 286   MVT RVT = N->getValueType(0);
 287   MVT NVT = MVT();
 288
 289   // If the input is not legal, eg: i1 -> fp, then it needs to be promoted to
 290   // a larger type, eg: i8 -> fp.  Even if it is legal, no libcall may exactly
 291   // match.  Look for an appropriate libcall.
 292   RTLIB::Libcall LC = RTLIB::UNKNOWN_LIBCALL;
 293   for (unsigned t = MVT::FIRST_INTEGER_VALUETYPE;
 294        t <= MVT::LAST_INTEGER_VALUETYPE && LC == RTLIB::UNKNOWN_LIBCALL; ++t) {
 295     NVT = (MVT::SimpleValueType)t;
 296     // The source needs to big enough to hold the operand.
 297     if (NVT.bitsGE(SVT))
 298       LC = Signed ? RTLIB::getSINTTOFP(NVT, RVT):RTLIB::getUINTTOFP (NVT, RVT);
 299   }
 300   assert(LC != RTLIB::UNKNOWN_LIBCALL && "Unsupported XINT_TO_FP!");
 301
 302   // Sign/zero extend the argument if the libcall takes a larger type.
 303   SDValue Op = DAG.getNode(Signed ? ISD::SIGN_EXTEND : ISD::ZERO_EXTEND,
 304                            NVT, N->getOperand(0));
 305   return MakeLibCall(LC, TLI.getTypeToTransformTo(RVT), &Op, 1, false);
 306 }
 307
 308
 309 //===----------------------------------------------------------------------===//
 310 //  Operand Float to Integer Conversion..
 311 //===----------------------------------------------------------------------===//
 312
 313 bool DAGTypeLegalizer::SoftenFloatOperand(SDNode *N, unsigned OpNo) {
 314   DEBUG(cerr << "Soften float operand " << OpNo << ": "; N->dump(&DAG);
 315         cerr << "\n");
 316   SDValue Res = SDValue();
 317
 318   switch (N->getOpcode()) {
 319   default:
 320 #ifndef NDEBUG
 321     cerr << "SoftenFloatOperand Op #" << OpNo << ": ";
 322     N->dump(&DAG); cerr << "\n";
 323 #endif
 324     assert(0 && "Do not know how to soften this operator's operand!");
 325     abort();
 326
 327   case ISD::BIT_CONVERT: Res = SoftenFloatOp_BIT_CONVERT(N); break;
 328   case ISD::BR_CC:       Res = SoftenFloatOp_BR_CC(N); break;
 329   case ISD::FP_ROUND:    Res = SoftenFloatOp_FP_ROUND(N); break;
 330   case ISD::FP_TO_SINT:  Res = SoftenFloatOp_FP_TO_SINT(N); break;
 331   case ISD::FP_TO_UINT:  Res = SoftenFloatOp_FP_TO_UINT(N); break;
 332   case ISD::SELECT_CC:   Res = SoftenFloatOp_SELECT_CC(N); break;
 333   case ISD::SETCC:       Res = SoftenFloatOp_SETCC(N); break;
 334   case ISD::STORE:       Res = SoftenFloatOp_STORE(N, OpNo); break;
 335   }
 336
 337   // If the result is null, the sub-method took care of registering results etc.
 338   if (!Res.getNode()) return false;
 339
 340   // If the result is N, the sub-method updated N in place.  Check to see if any
 341   // operands are new, and if so, mark them.
 342   if (Res.getNode() == N) {
 343     // Mark N as new and remark N and its operands.  This allows us to correctly
 344     // revisit N if it needs another step of promotion and allows us to visit
 345     // any new operands to N.
 346     ReanalyzeNode(N);
 347     return true;
 348   }
 349
 350   assert(Res.getValueType() == N->getValueType(0) && N->getNumValues() == 1 &&
 351          "Invalid operand expansion");
 352
 353   ReplaceValueWith(SDValue(N, 0), Res);
 354   return false;
 355 }
 356
 357 /// SoftenSetCCOperands - Soften the operands of a comparison.  This code is
 358 /// shared among BR_CC, SELECT_CC, and SETCC handlers.
 359 void DAGTypeLegalizer::SoftenSetCCOperands(SDValue &NewLHS, SDValue &NewRHS,
 360                                            ISD::CondCode &CCCode) {
 361   SDValue LHSInt = GetSoftenedFloat(NewLHS);
 362   SDValue RHSInt = GetSoftenedFloat(NewRHS);
 363   MVT VT = NewLHS.getValueType();
 364
 365   assert((VT == MVT::f32 || VT == MVT::f64) && "Unsupported setcc type!");
 366
 367   // Expand into one or more soft-fp libcall(s).
 368   RTLIB::Libcall LC1 = RTLIB::UNKNOWN_LIBCALL, LC2 = RTLIB::UNKNOWN_LIBCALL;
 369   switch (CCCode) {
 370   case ISD::SETEQ:
 371   case ISD::SETOEQ:
 372     LC1 = (VT == MVT::f32) ? RTLIB::OEQ_F32 : RTLIB::OEQ_F64;
 373     break;
 374   case ISD::SETNE:
 375   case ISD::SETUNE:
 376     LC1 = (VT == MVT::f32) ? RTLIB::UNE_F32 : RTLIB::UNE_F64;
 377     break;
 378   case ISD::SETGE:
 379   case ISD::SETOGE:
 380     LC1 = (VT == MVT::f32) ? RTLIB::OGE_F32 : RTLIB::OGE_F64;
 381     break;
 382   case ISD::SETLT:
 383   case ISD::SETOLT:
 384     LC1 = (VT == MVT::f32) ? RTLIB::OLT_F32 : RTLIB::OLT_F64;
 385     break;
 386   case ISD::SETLE:
 387   case ISD::SETOLE:
 388     LC1 = (VT == MVT::f32) ? RTLIB::OLE_F32 : RTLIB::OLE_F64;
 389     break;
 390   case ISD::SETGT:
 391   case ISD::SETOGT:
 392     LC1 = (VT == MVT::f32) ? RTLIB::OGT_F32 : RTLIB::OGT_F64;
 393     break;
 394   case ISD::SETUO:
 395     LC1 = (VT == MVT::f32) ? RTLIB::UO_F32 : RTLIB::UO_F64;
 396     break;
 397   case ISD::SETO:
 398     LC1 = (VT == MVT::f32) ? RTLIB::O_F32 : RTLIB::O_F64;
 399     break;
 400   default:
 401     LC1 = (VT == MVT::f32) ? RTLIB::UO_F32 : RTLIB::UO_F64;
 402     switch (CCCode) {
 403     case ISD::SETONE:
 404       // SETONE = SETOLT | SETOGT
 405       LC1 = (VT == MVT::f32) ? RTLIB::OLT_F32 : RTLIB::OLT_F64;
 406       // Fallthrough
 407     case ISD::SETUGT:
 408       LC2 = (VT == MVT::f32) ? RTLIB::OGT_F32 : RTLIB::OGT_F64;
 409       break;
 410     case ISD::SETUGE:
 411       LC2 = (VT == MVT::f32) ? RTLIB::OGE_F32 : RTLIB::OGE_F64;
 412       break;
 413     case ISD::SETULT:
 414       LC2 = (VT == MVT::f32) ? RTLIB::OLT_F32 : RTLIB::OLT_F64;
 415       break;
 416     case ISD::SETULE:
 417       LC2 = (VT == MVT::f32) ? RTLIB::OLE_F32 : RTLIB::OLE_F64;
 418       break;
 419     case ISD::SETUEQ:
 420       LC2 = (VT == MVT::f32) ? RTLIB::OEQ_F32 : RTLIB::OEQ_F64;
 421       break;
 422     default: assert(false && "Do not know how to soften this setcc!");
 423     }
 424   }
 425
 426   MVT RetVT = MVT::i32; // FIXME: is this the correct return type?
 427   SDValue Ops[2] = { LHSInt, RHSInt };
 428   NewLHS = MakeLibCall(LC1, RetVT, Ops, 2, false/*sign irrelevant*/);
 429   NewRHS = DAG.getConstant(0, RetVT);
 430   CCCode = TLI.getCmpLibcallCC(LC1);
 431   if (LC2 != RTLIB::UNKNOWN_LIBCALL) {
 432     SDValue Tmp = DAG.getNode(ISD::SETCC, TLI.getSetCCResultType(NewLHS),
 433                                 NewLHS, NewRHS, DAG.getCondCode(CCCode));
 434     NewLHS = MakeLibCall(LC2, RetVT, Ops, 2, false/*sign irrelevant*/);
 435     NewLHS = DAG.getNode(ISD::SETCC, TLI.getSetCCResultType(NewLHS), NewLHS,
 436                          NewRHS, DAG.getCondCode(TLI.getCmpLibcallCC(LC2)));
 437     NewLHS = DAG.getNode(ISD::OR, Tmp.getValueType(), Tmp, NewLHS);
 438     NewRHS = SDValue();
 439   }
 440 }
 441
 442 SDValue DAGTypeLegalizer::SoftenFloatOp_BIT_CONVERT(SDNode *N) {
 443   return DAG.getNode(ISD::BIT_CONVERT, N->getValueType(0),
 444                      GetSoftenedFloat(N->getOperand(0)));
 445 }
 446
 447 SDValue DAGTypeLegalizer::SoftenFloatOp_FP_ROUND(SDNode *N) {
 448   MVT SVT = N->getOperand(0).getValueType();
 449   MVT RVT = N->getValueType(0);
 450
 451   RTLIB::Libcall LC = RTLIB::getFPROUND(SVT, RVT);
 452   assert(LC != RTLIB::UNKNOWN_LIBCALL && "Unsupported FP_ROUND libcall");
 453
 454   SDValue Op = GetSoftenedFloat(N->getOperand(0));
 455   return MakeLibCall(LC, RVT, &Op, 1, false);
 456 }
 457
 458 SDValue DAGTypeLegalizer::SoftenFloatOp_BR_CC(SDNode *N) {
 459   SDValue NewLHS = N->getOperand(2), NewRHS = N->getOperand(3);
 460   ISD::CondCode CCCode = cast<CondCodeSDNode>(N->getOperand(1))->get();
 461   SoftenSetCCOperands(NewLHS, NewRHS, CCCode);
 462
 463   // If SoftenSetCCOperands returned a scalar, we need to compare the result
 464   // against zero to select between true and false values.
 465   if (NewRHS.getNode() == 0) {
 466     NewRHS = DAG.getConstant(0, NewLHS.getValueType());
 467     CCCode = ISD::SETNE;
 468   }
 469
 470   // Update N to have the operands specified.
 471   return DAG.UpdateNodeOperands(SDValue(N, 0), N->getOperand(0),
 472                                 DAG.getCondCode(CCCode), NewLHS, NewRHS,
 473                                 N->getOperand(4));
 474 }
 475
 476 SDValue DAGTypeLegalizer::SoftenFloatOp_FP_TO_SINT(SDNode *N) {
 477   MVT RVT = N->getValueType(0);
 478   RTLIB::Libcall LC = RTLIB::getFPTOSINT(N->getOperand(0).getValueType(), RVT);
 479   assert(LC != RTLIB::UNKNOWN_LIBCALL && "Unsupported FP_TO_SINT!");
 480   SDValue Op = GetSoftenedFloat(N->getOperand(0));
 481   return MakeLibCall(LC, RVT, &Op, 1, false);
 482 }
 483
 484 SDValue DAGTypeLegalizer::SoftenFloatOp_FP_TO_UINT(SDNode *N) {
 485   MVT RVT = N->getValueType(0);
 486   RTLIB::Libcall LC = RTLIB::getFPTOUINT(N->getOperand(0).getValueType(), RVT);
 487   assert(LC != RTLIB::UNKNOWN_LIBCALL && "Unsupported FP_TO_UINT!");
 488   SDValue Op = GetSoftenedFloat(N->getOperand(0));
 489   return MakeLibCall(LC, RVT, &Op, 1, false);
 490 }
 491
 492 SDValue DAGTypeLegalizer::SoftenFloatOp_SELECT_CC(SDNode *N) {
 493   SDValue NewLHS = N->getOperand(0), NewRHS = N->getOperand(1);
 494   ISD::CondCode CCCode = cast<CondCodeSDNode>(N->getOperand(4))->get();
 495   SoftenSetCCOperands(NewLHS, NewRHS, CCCode);
 496
 497   // If SoftenSetCCOperands returned a scalar, we need to compare the result
 498   // against zero to select between true and false values.
 499   if (NewRHS.getNode() == 0) {
 500     NewRHS = DAG.getConstant(0, NewLHS.getValueType());
 501     CCCode = ISD::SETNE;
 502   }
 503
 504   // Update N to have the operands specified.
 505   return DAG.UpdateNodeOperands(SDValue(N, 0), NewLHS, NewRHS,
 506                                 N->getOperand(2), N->getOperand(3),
 507                                 DAG.getCondCode(CCCode));
 508 }
 509
 510 SDValue DAGTypeLegalizer::SoftenFloatOp_SETCC(SDNode *N) {
 511   SDValue NewLHS = N->getOperand(0), NewRHS = N->getOperand(1);
 512   ISD::CondCode CCCode = cast<CondCodeSDNode>(N->getOperand(2))->get();
 513   SoftenSetCCOperands(NewLHS, NewRHS, CCCode);
 514
 515   // If SoftenSetCCOperands returned a scalar, use it.
 516   if (NewRHS.getNode() == 0) {
 517     assert(NewLHS.getValueType() == N->getValueType(0) &&
 518            "Unexpected setcc expansion!");
 519     return NewLHS;
 520   }
 521
 522   // Otherwise, update N to have the operands specified.
 523   return DAG.UpdateNodeOperands(SDValue(N, 0), NewLHS, NewRHS,
 524                                 DAG.getCondCode(CCCode));
 525 }
 526
 527 SDValue DAGTypeLegalizer::SoftenFloatOp_STORE(SDNode *N, unsigned OpNo) {
 528   assert(ISD::isUNINDEXEDStore(N) && "Indexed store during type legalization!");
 529   assert(OpNo == 1 && "Can only soften the stored value!");
 530   StoreSDNode *ST = cast<StoreSDNode>(N);
 531   SDValue Val = ST->getValue();
 532
 533   if (ST->isTruncatingStore())
 534     // Do an FP_ROUND followed by a non-truncating store.
 535     Val = BitConvertToInteger(DAG.getNode(ISD::FP_ROUND, ST->getMemoryVT(),
 536                                           Val, DAG.getIntPtrConstant(0)));
 537   else
 538     Val = GetSoftenedFloat(Val);
 539
 540   return DAG.getStore(ST->getChain(), Val, ST->getBasePtr(),
 541                       ST->getSrcValue(), ST->getSrcValueOffset(),
 542                       ST->isVolatile(), ST->getAlignment());
 543 }
 544
 545
 546 //===----------------------------------------------------------------------===//
 547 //  Float Result Expansion
 548 //===----------------------------------------------------------------------===//
 549
 550 /// ExpandFloatResult - This method is called when the specified result of the
 551 /// specified node is found to need expansion.  At this point, the node may also
 552 /// have invalid operands or may have other results that need promotion, we just
 553 /// know that (at least) one result needs expansion.
 554 void DAGTypeLegalizer::ExpandFloatResult(SDNode *N, unsigned ResNo) {
 555   DEBUG(cerr << "Expand float result: "; N->dump(&DAG); cerr << "\n");
 556   SDValue Lo, Hi;
 557   Lo = Hi = SDValue();
 558
 559   // See if the target wants to custom expand this node.
 560   if (TLI.getOperationAction(N->getOpcode(), N->getValueType(ResNo)) ==
 561       TargetLowering::Custom) {
 562     // If the target wants to, allow it to lower this itself.
 563     if (SDNode *P = TLI.ReplaceNodeResults(N, DAG)) {
 564       // Everything that once used N now uses P.  We are guaranteed that the
 565       // result value types of N and the result value types of P match.
 566       ReplaceNodeWith(N, P);
 567       return;
 568     }
 569   }
 570
 571   switch (N->getOpcode()) {
 572   default:
 573 #ifndef NDEBUG
 574     cerr << "ExpandFloatResult #" << ResNo << ": ";
 575     N->dump(&DAG); cerr << "\n";
 576 #endif
 577     assert(0 && "Do not know how to expand the result of this operator!");
 578     abort();
 579
 580   case ISD::MERGE_VALUES: SplitRes_MERGE_VALUES(N, Lo, Hi); break;
 581   case ISD::UNDEF:        SplitRes_UNDEF(N, Lo, Hi); break;
 582   case ISD::SELECT:       SplitRes_SELECT(N, Lo, Hi); break;
 583   case ISD::SELECT_CC:    SplitRes_SELECT_CC(N, Lo, Hi); break;
 584
 585   case ISD::BIT_CONVERT:        ExpandRes_BIT_CONVERT(N, Lo, Hi); break;
 586   case ISD::BUILD_PAIR:         ExpandRes_BUILD_PAIR(N, Lo, Hi); break;
 587   case ISD::EXTRACT_ELEMENT:    ExpandRes_EXTRACT_ELEMENT(N, Lo, Hi); break;
 588   case ISD::EXTRACT_VECTOR_ELT: ExpandRes_EXTRACT_VECTOR_ELT(N, Lo, Hi); break;
 589   case ISD::VAARG:              ExpandRes_VAARG(N, Lo, Hi); break;
 590
 591   case ISD::ConstantFP: ExpandFloatRes_ConstantFP(N, Lo, Hi); break;
 592   case ISD::FABS:       ExpandFloatRes_FABS(N, Lo, Hi); break;
 593   case ISD::FADD:       ExpandFloatRes_FADD(N, Lo, Hi); break;
 594   case ISD::FCEIL:      ExpandFloatRes_FCEIL(N, Lo, Hi); break;
 595   case ISD::FCOS:       ExpandFloatRes_FCOS(N, Lo, Hi); break;
 596   case ISD::FDIV:       ExpandFloatRes_FDIV(N, Lo, Hi); break;
 597   case ISD::FEXP:       ExpandFloatRes_FEXP(N, Lo, Hi); break;
 598   case ISD::FEXP2:      ExpandFloatRes_FEXP2(N, Lo, Hi); break;
 599   case ISD::FFLOOR:     ExpandFloatRes_FFLOOR(N, Lo, Hi); break;
 600   case ISD::FLOG:       ExpandFloatRes_FLOG(N, Lo, Hi); break;
 601   case ISD::FLOG2:      ExpandFloatRes_FLOG2(N, Lo, Hi); break;
 602   case ISD::FLOG10:     ExpandFloatRes_FLOG10(N, Lo, Hi); break;
 603   case ISD::FMUL:       ExpandFloatRes_FMUL(N, Lo, Hi); break;
 604   case ISD::FNEARBYINT: ExpandFloatRes_FNEARBYINT(N, Lo, Hi); break;
 605   case ISD::FNEG:       ExpandFloatRes_FNEG(N, Lo, Hi); break;
 606   case ISD::FP_EXTEND:  ExpandFloatRes_FP_EXTEND(N, Lo, Hi); break;
 607   case ISD::FPOW:       ExpandFloatRes_FPOW(N, Lo, Hi); break;
 608   case ISD::FPOWI:      ExpandFloatRes_FPOWI(N, Lo, Hi); break;
 609   case ISD::FRINT:      ExpandFloatRes_FRINT(N, Lo, Hi); break;
 610   case ISD::FSIN:       ExpandFloatRes_FABS(N, Lo, Hi); break;
 611   case ISD::FSQRT:      ExpandFloatRes_FSQRT(N, Lo, Hi); break;
 612   case ISD::FSUB:       ExpandFloatRes_FSUB(N, Lo, Hi); break;
 613   case ISD::FTRUNC:     ExpandFloatRes_FTRUNC(N, Lo, Hi); break;
 614   case ISD::LOAD:       ExpandFloatRes_LOAD(N, Lo, Hi); break;
 615   case ISD::SINT_TO_FP:
 616   case ISD::UINT_TO_FP: ExpandFloatRes_XINT_TO_FP(N, Lo, Hi); break;
 617   }
 618
 619   // If Lo/Hi is null, the sub-method took care of registering results etc.
 620   if (Lo.getNode())
 621     SetExpandedFloat(SDValue(N, ResNo), Lo, Hi);
 622 }
 623
 624 void DAGTypeLegalizer::ExpandFloatRes_ConstantFP(SDNode *N, SDValue &Lo,
 625                                                  SDValue &Hi) {
 626   MVT NVT = TLI.getTypeToTransformTo(N->getValueType(0));
 627   assert(NVT.getSizeInBits() == integerPartWidth &&
 628          "Do not know how to expand this float constant!");
 629   APInt C = cast<ConstantFPSDNode>(N)->getValueAPF().bitcastToAPInt();
 630   Lo = DAG.getConstantFP(APFloat(APInt(integerPartWidth, 1,
 631                                        &C.getRawData()[1])), NVT);
 632   Hi = DAG.getConstantFP(APFloat(APInt(integerPartWidth, 1,
 633                                        &C.getRawData()[0])), NVT);
 634 }
 635
 636 void DAGTypeLegalizer::ExpandFloatRes_FABS(SDNode *N, SDValue &Lo,
 637                                            SDValue &Hi) {
 638   assert(N->getValueType(0) == MVT::ppcf128 &&
 639          "Logic only correct for ppcf128!");
 640   SDValue Tmp;
 641   GetExpandedFloat(N->getOperand(0), Lo, Tmp);
 642   Hi = DAG.getNode(ISD::FABS, Tmp.getValueType(), Tmp);
 643   // Lo = Hi==fabs(Hi) ? Lo : -Lo;
 644   Lo = DAG.getNode(ISD::SELECT_CC, Lo.getValueType(), Tmp, Hi, Lo,
 645                    DAG.getNode(ISD::FNEG, Lo.getValueType(), Lo),
 646                    DAG.getCondCode(ISD::SETEQ));
 647 }
 648
 649 void DAGTypeLegalizer::ExpandFloatRes_FADD(SDNode *N, SDValue &Lo,
 650                                            SDValue &Hi) {
 651   SDValue Call = LibCallify(GetFPLibCall(N->getValueType(0),
 652                                          RTLIB::ADD_F32, RTLIB::ADD_F64,
 653                                          RTLIB::ADD_F80, RTLIB::ADD_PPCF128),
 654                             N, false);
 655   assert(Call.getNode()->getOpcode() == ISD::BUILD_PAIR &&
 656          "Call lowered wrongly!");
 657   Lo = Call.getOperand(0); Hi = Call.getOperand(1);
 658 }
 659
 660 void DAGTypeLegalizer::ExpandFloatRes_FCEIL(SDNode *N,
 661                                             SDValue &Lo, SDValue &Hi) {
 662   SDValue Call = LibCallify(GetFPLibCall(N->getValueType(0),
 663                                          RTLIB::CEIL_F32, RTLIB::CEIL_F64,
 664                                          RTLIB::CEIL_F80, RTLIB::CEIL_PPCF128),
 665                             N, false);
 666   assert(Call.getNode()->getOpcode() == ISD::BUILD_PAIR &&
 667          "Call lowered wrongly!");
 668   Lo = Call.getOperand(0); Hi = Call.getOperand(1);
 669 }
 670
 671 void DAGTypeLegalizer::ExpandFloatRes_FCOS(SDNode *N,
 672                                            SDValue &Lo, SDValue &Hi) {
 673   SDValue Call = LibCallify(GetFPLibCall(N->getValueType(0),
 674                                          RTLIB::COS_F32, RTLIB::COS_F64,
 675                                          RTLIB::COS_F80, RTLIB::COS_PPCF128),
 676                             N, false);
 677   assert(Call.getNode()->getOpcode() == ISD::BUILD_PAIR &&
 678          "Call lowered wrongly!");
 679   Lo = Call.getOperand(0); Hi = Call.getOperand(1);
 680 }
 681
 682 void DAGTypeLegalizer::ExpandFloatRes_FDIV(SDNode *N, SDValue &Lo,
 683                                            SDValue &Hi) {
 684   SDValue Ops[2] = { N->getOperand(0), N->getOperand(1) };
 685   SDValue Call = MakeLibCall(GetFPLibCall(N->getValueType(0),
 686                                           RTLIB::DIV_F32,
 687                                           RTLIB::DIV_F64,
 688                                           RTLIB::DIV_F80,
 689                                           RTLIB::DIV_PPCF128),
 690                              N->getValueType(0), Ops, 2, false);
 691   assert(Call.getNode()->getOpcode() == ISD::BUILD_PAIR &&
 692          "Call lowered wrongly!");
 693   Lo = Call.getOperand(0); Hi = Call.getOperand(1);
 694 }
 695
 696 void DAGTypeLegalizer::ExpandFloatRes_FEXP(SDNode *N,
 697                                            SDValue &Lo, SDValue &Hi) {
 698   SDValue Call = LibCallify(GetFPLibCall(N->getValueType(0),
 699                                          RTLIB::EXP_F32, RTLIB::EXP_F64,
 700                                          RTLIB::EXP_F80, RTLIB::EXP_PPCF128),
 701                             N, false);
 702   assert(Call.getNode()->getOpcode() == ISD::BUILD_PAIR &&
 703          "Call lowered wrongly!");
 704   Lo = Call.getOperand(0); Hi = Call.getOperand(1);
 705 }
 706
 707 void DAGTypeLegalizer::ExpandFloatRes_FEXP2(SDNode *N,
 708                                             SDValue &Lo, SDValue &Hi) {
 709   SDValue Call = LibCallify(GetFPLibCall(N->getValueType(0),
 710                                          RTLIB::EXP2_F32, RTLIB::EXP2_F64,
 711                                          RTLIB::EXP2_F80, RTLIB::EXP2_PPCF128),
 712                             N, false);
 713   assert(Call.getNode()->getOpcode() == ISD::BUILD_PAIR &&
 714          "Call lowered wrongly!");
 715   Lo = Call.getOperand(0); Hi = Call.getOperand(1);
 716 }
 717
 718 void DAGTypeLegalizer::ExpandFloatRes_FFLOOR(SDNode *N,
 719                                              SDValue &Lo, SDValue &Hi) {
 720   SDValue Call = LibCallify(GetFPLibCall(N->getValueType(0),
 721                                          RTLIB::FLOOR_F32,RTLIB::FLOOR_F64,
 722                                          RTLIB::FLOOR_F80,RTLIB::FLOOR_PPCF128),
 723                             N, false);
 724   assert(Call.getNode()->getOpcode() == ISD::BUILD_PAIR &&
 725          "Call lowered wrongly!");
 726   Lo = Call.getOperand(0); Hi = Call.getOperand(1);
 727 }
 728
 729 void DAGTypeLegalizer::ExpandFloatRes_FLOG(SDNode *N,
 730                                            SDValue &Lo, SDValue &Hi) {
 731   SDValue Call = LibCallify(GetFPLibCall(N->getValueType(0),
 732                                          RTLIB::LOG_F32, RTLIB::LOG_F64,
 733                                          RTLIB::LOG_F80, RTLIB::LOG_PPCF128),
 734                             N, false);
 735   assert(Call.getNode()->getOpcode() == ISD::BUILD_PAIR &&
 736          "Call lowered wrongly!");
 737   Lo = Call.getOperand(0); Hi = Call.getOperand(1);
 738 }
 739
 740 void DAGTypeLegalizer::ExpandFloatRes_FLOG2(SDNode *N,
 741                                             SDValue &Lo, SDValue &Hi) {
 742   SDValue Call = LibCallify(GetFPLibCall(N->getValueType(0),
 743                                          RTLIB::LOG2_F32, RTLIB::LOG2_F64,
 744                                          RTLIB::LOG2_F80, RTLIB::LOG2_PPCF128),
 745                             N, false);
 746   assert(Call.getNode()->getOpcode() == ISD::BUILD_PAIR &&
 747          "Call lowered wrongly!");
 748   Lo = Call.getOperand(0); Hi = Call.getOperand(1);
 749 }
 750
 751 void DAGTypeLegalizer::ExpandFloatRes_FLOG10(SDNode *N,
 752                                              SDValue &Lo, SDValue &Hi) {
 753   SDValue Call = LibCallify(GetFPLibCall(N->getValueType(0),
 754                                          RTLIB::LOG10_F32,RTLIB::LOG10_F64,
 755                                          RTLIB::LOG10_F80,RTLIB::LOG10_PPCF128),
 756                             N, false);
 757   assert(Call.getNode()->getOpcode() == ISD::BUILD_PAIR &&
 758          "Call lowered wrongly!");
 759   Lo = Call.getOperand(0); Hi = Call.getOperand(1);
 760 }
 761
 762 void DAGTypeLegalizer::ExpandFloatRes_FMUL(SDNode *N, SDValue &Lo,
 763                                            SDValue &Hi) {
 764   SDValue Ops[2] = { N->getOperand(0), N->getOperand(1) };
 765   SDValue Call = MakeLibCall(GetFPLibCall(N->getValueType(0),
 766                                           RTLIB::MUL_F32,
 767                                           RTLIB::MUL_F64,
 768                                           RTLIB::MUL_F80,
 769                                           RTLIB::MUL_PPCF128),
 770                              N->getValueType(0), Ops, 2, false);
 771   assert(Call.getNode()->getOpcode() == ISD::BUILD_PAIR &&
 772          "Call lowered wrongly!");
 773   Lo = Call.getOperand(0); Hi = Call.getOperand(1);
 774 }
 775
 776 void DAGTypeLegalizer::ExpandFloatRes_FNEARBYINT(SDNode *N,
 777                                                  SDValue &Lo, SDValue &Hi) {
 778   SDValue Call = LibCallify(GetFPLibCall(N->getValueType(0),
 779                                          RTLIB::NEARBYINT_F32,
 780                                          RTLIB::NEARBYINT_F64,
 781                                          RTLIB::NEARBYINT_F80,
 782                                          RTLIB::NEARBYINT_PPCF128),
 783                             N, false);
 784   assert(Call.getNode()->getOpcode() == ISD::BUILD_PAIR &&
 785          "Call lowered wrongly!");
 786   Lo = Call.getOperand(0); Hi = Call.getOperand(1);
 787 }
 788
 789 void DAGTypeLegalizer::ExpandFloatRes_FNEG(SDNode *N, SDValue &Lo,
 790                                            SDValue &Hi) {
 791   GetExpandedFloat(N->getOperand(0), Lo, Hi);
 792   Lo = DAG.getNode(ISD::FNEG, Lo.getValueType(), Lo);
 793   Hi = DAG.getNode(ISD::FNEG, Hi.getValueType(), Hi);
 794 }
 795
 796 void DAGTypeLegalizer::ExpandFloatRes_FP_EXTEND(SDNode *N, SDValue &Lo,
 797                                                 SDValue &Hi) {
 798   MVT NVT = TLI.getTypeToTransformTo(N->getValueType(0));
 799   Hi = DAG.getNode(ISD::FP_EXTEND, NVT, N->getOperand(0));
 800   Lo = DAG.getConstantFP(APFloat(APInt(NVT.getSizeInBits(), 0)), NVT);
 801 }
 802
 803 void DAGTypeLegalizer::ExpandFloatRes_FPOW(SDNode *N,
 804                                            SDValue &Lo, SDValue &Hi) {
 805   SDValue Call = LibCallify(GetFPLibCall(N->getValueType(0),
 806                                          RTLIB::POW_F32, RTLIB::POW_F64,
 807                                          RTLIB::POW_F80, RTLIB::POW_PPCF128),
 808                             N, false);
 809   assert(Call.getNode()->getOpcode() == ISD::BUILD_PAIR &&
 810          "Call lowered wrongly!");
 811   Lo = Call.getOperand(0); Hi = Call.getOperand(1);
 812 }
 813
 814 void DAGTypeLegalizer::ExpandFloatRes_FPOWI(SDNode *N,
 815                                             SDValue &Lo, SDValue &Hi) {
 816   SDValue Call = LibCallify(GetFPLibCall(N->getValueType(0),
 817                                          RTLIB::POWI_F32, RTLIB::POWI_F64,
 818                                          RTLIB::POWI_F80, RTLIB::POWI_PPCF128),
 819                             N, false);
 820   assert(Call.getNode()->getOpcode() == ISD::BUILD_PAIR &&
 821          "Call lowered wrongly!");
 822   Lo = Call.getOperand(0); Hi = Call.getOperand(1);
 823 }
 824
 825 void DAGTypeLegalizer::ExpandFloatRes_FRINT(SDNode *N,
 826                                             SDValue &Lo, SDValue &Hi) {
 827   SDValue Call = LibCallify(GetFPLibCall(N->getValueType(0),
 828                                          RTLIB::RINT_F32, RTLIB::RINT_F64,
 829                                          RTLIB::RINT_F80, RTLIB::RINT_PPCF128),
 830                             N, false);
 831   assert(Call.getNode()->getOpcode() == ISD::BUILD_PAIR &&
 832          "Call lowered wrongly!");
 833   Lo = Call.getOperand(0); Hi = Call.getOperand(1);
 834 }
 835
 836 void DAGTypeLegalizer::ExpandFloatRes_FSIN(SDNode *N,
 837                                            SDValue &Lo, SDValue &Hi) {
 838   SDValue Call = LibCallify(GetFPLibCall(N->getValueType(0),
 839                                          RTLIB::SIN_F32, RTLIB::SIN_F64,
 840                                          RTLIB::SIN_F80, RTLIB::SIN_PPCF128),
 841                             N, false);
 842   assert(Call.getNode()->getOpcode() == ISD::BUILD_PAIR &&
 843          "Call lowered wrongly!");
 844   Lo = Call.getOperand(0); Hi = Call.getOperand(1);
 845 }
 846
 847 void DAGTypeLegalizer::ExpandFloatRes_FSQRT(SDNode *N,
 848                                             SDValue &Lo, SDValue &Hi) {
 849   SDValue Call = LibCallify(GetFPLibCall(N->getValueType(0),
 850                                          RTLIB::SQRT_F32, RTLIB::SQRT_F64,
 851                                          RTLIB::SQRT_F80, RTLIB::SQRT_PPCF128),
 852                             N, false);
 853   assert(Call.getNode()->getOpcode() == ISD::BUILD_PAIR &&
 854          "Call lowered wrongly!");
 855   Lo = Call.getOperand(0); Hi = Call.getOperand(1);
 856 }
 857
 858 void DAGTypeLegalizer::ExpandFloatRes_FSUB(SDNode *N, SDValue &Lo,
 859                                            SDValue &Hi) {
 860   SDValue Ops[2] = { N->getOperand(0), N->getOperand(1) };
 861   SDValue Call = MakeLibCall(GetFPLibCall(N->getValueType(0),
 862                                           RTLIB::SUB_F32,
 863                                           RTLIB::SUB_F64,
 864                                           RTLIB::SUB_F80,
 865                                           RTLIB::SUB_PPCF128),
 866                              N->getValueType(0), Ops, 2, false);
 867   assert(Call.getNode()->getOpcode() == ISD::BUILD_PAIR &&
 868          "Call lowered wrongly!");
 869   Lo = Call.getOperand(0); Hi = Call.getOperand(1);
 870 }
 871
 872 void DAGTypeLegalizer::ExpandFloatRes_FTRUNC(SDNode *N,
 873                                              SDValue &Lo, SDValue &Hi) {
 874   SDValue Call = LibCallify(GetFPLibCall(N->getValueType(0),
 875                                          RTLIB::TRUNC_F32, RTLIB::TRUNC_F64,
 876                                          RTLIB::TRUNC_F80, RTLIB::TRUNC_PPCF128),
 877                             N, false);
 878   assert(Call.getNode()->getOpcode() == ISD::BUILD_PAIR &&
 879          "Call lowered wrongly!");
 880   Lo = Call.getOperand(0); Hi = Call.getOperand(1);
 881 }
 882
 883 void DAGTypeLegalizer::ExpandFloatRes_LOAD(SDNode *N, SDValue &Lo,
 884                                            SDValue &Hi) {
 885   if (ISD::isNormalLoad(N)) {
 886     ExpandRes_NormalLoad(N, Lo, Hi);
 887     return;
 888   }
 889
 890   assert(ISD::isUNINDEXEDLoad(N) && "Indexed load during type legalization!");
 891   LoadSDNode *LD = cast<LoadSDNode>(N);
 892   SDValue Chain = LD->getChain();
 893   SDValue Ptr = LD->getBasePtr();
 894
 895   MVT NVT = TLI.getTypeToTransformTo(LD->getValueType(0));
 896   assert(NVT.isByteSized() && "Expanded type not byte sized!");
 897   assert(LD->getMemoryVT().bitsLE(NVT) && "Float type not round?");
 898
 899   Hi = DAG.getExtLoad(LD->getExtensionType(), NVT, Chain, Ptr,
 900                       LD->getSrcValue(), LD->getSrcValueOffset(),
 901                       LD->getMemoryVT(),
 902                       LD->isVolatile(), LD->getAlignment());
 903
 904   // Remember the chain.
 905   Chain = Hi.getValue(1);
 906
 907   // The low part is zero.
 908   Lo = DAG.getConstantFP(APFloat(APInt(NVT.getSizeInBits(), 0)), NVT);
 909
 910   // Modified the chain - switch anything that used the old chain to use the
 911   // new one.
 912   ReplaceValueWith(SDValue(LD, 1), Chain);
 913 }
 914
 915 void DAGTypeLegalizer::ExpandFloatRes_XINT_TO_FP(SDNode *N, SDValue &Lo,
 916                                                  SDValue &Hi) {
 917   assert(N->getValueType(0) == MVT::ppcf128 && "Unsupported XINT_TO_FP!");
 918   MVT VT = N->getValueType(0);
 919   MVT NVT = TLI.getTypeToTransformTo(VT);
 920   SDValue Src = N->getOperand(0);
 921   MVT SrcVT = Src.getValueType();
 922   bool isSigned = N->getOpcode() == ISD::SINT_TO_FP;
 923
 924   // First do an SINT_TO_FP, whether the original was signed or unsigned.
 925   // When promoting partial word types to i32 we must honor the signedness,
 926   // though.
 927   if (SrcVT.bitsLE(MVT::i32)) {
 928     // The integer can be represented exactly in an f64.
 929     Src = DAG.getNode(isSigned ? ISD::SIGN_EXTEND : ISD::ZERO_EXTEND,
 930                       MVT::i32, Src);
 931     Lo = DAG.getConstantFP(APFloat(APInt(NVT.getSizeInBits(), 0)), NVT);
 932     Hi = DAG.getNode(ISD::SINT_TO_FP, NVT, Src);
 933   } else {
 934     RTLIB::Libcall LC = RTLIB::UNKNOWN_LIBCALL;
 935     if (SrcVT.bitsLE(MVT::i64)) {
 936       Src = DAG.getNode(isSigned ? ISD::SIGN_EXTEND : ISD::ZERO_EXTEND,
 937                         MVT::i64, Src);
 938       LC = RTLIB::SINTTOFP_I64_PPCF128;
 939     } else if (SrcVT.bitsLE(MVT::i128)) {
 940       Src = DAG.getNode(ISD::SIGN_EXTEND, MVT::i128, Src);
 941       LC = RTLIB::SINTTOFP_I128_PPCF128;
 942     }
 943     assert(LC != RTLIB::UNKNOWN_LIBCALL && "Unsupported XINT_TO_FP!");
 944
 945     Hi = MakeLibCall(LC, VT, &Src, 1, true);
 946     assert(Hi.getNode()->getOpcode() == ISD::BUILD_PAIR &&
 947            "Call lowered wrongly!");
 948     Lo = Hi.getOperand(0); Hi = Hi.getOperand(1);
 949   }
 950
 951   if (isSigned)
 952     return;
 953
 954   // Unsigned - fix up the SINT_TO_FP value just calculated.
 955   Hi = DAG.getNode(ISD::BUILD_PAIR, VT, Lo, Hi);
 956   SrcVT = Src.getValueType();
 957
 958   // x>=0 ? (ppcf128)(iN)x : (ppcf128)(iN)x + 2^N; N=32,64,128.
 959   static const uint64_t TwoE32[]  = { 0x41f0000000000000LL, 0 };
 960   static const uint64_t TwoE64[]  = { 0x43f0000000000000LL, 0 };
 961   static const uint64_t TwoE128[] = { 0x47f0000000000000LL, 0 };
 962   const uint64_t *Parts = 0;
 963
 964   switch (SrcVT.getSimpleVT()) {
 965   default:
 966     assert(false && "Unsupported UINT_TO_FP!");
 967   case MVT::i32:
 968     Parts = TwoE32;
 969     break;
 970   case MVT::i64:
 971     Parts = TwoE64;
 972     break;
 973   case MVT::i128:
 974     Parts = TwoE128;
 975     break;
 976   }
 977
 978   Lo = DAG.getNode(ISD::FADD, VT, Hi,
 979                    DAG.getConstantFP(APFloat(APInt(128, 2, Parts)),
 980                                      MVT::ppcf128));
 981   Lo = DAG.getNode(ISD::SELECT_CC, VT, Src, DAG.getConstant(0, SrcVT), Lo, Hi,
 982                    DAG.getCondCode(ISD::SETLT));
 983   Hi = DAG.getNode(ISD::EXTRACT_ELEMENT, NVT, Lo, DAG.getIntPtrConstant(1));
 984   Lo = DAG.getNode(ISD::EXTRACT_ELEMENT, NVT, Lo, DAG.getIntPtrConstant(0));
 985 }
 986
 987
 988 //===----------------------------------------------------------------------===//
 989 //  Float Operand Expansion
 990 //===----------------------------------------------------------------------===//
 991
 992 /// ExpandFloatOperand - This method is called when the specified operand of the
 993 /// specified node is found to need expansion.  At this point, all of the result
 994 /// types of the node are known to be legal, but other operands of the node may
 995 /// need promotion or expansion as well as the specified one.
 996 bool DAGTypeLegalizer::ExpandFloatOperand(SDNode *N, unsigned OpNo) {
 997   DEBUG(cerr << "Expand float operand: "; N->dump(&DAG); cerr << "\n");
 998   SDValue Res = SDValue();
 999
1000   if (TLI.getOperationAction(N->getOpcode(), N->getOperand(OpNo).getValueType())
1001       == TargetLowering::Custom)
1002     Res = TLI.LowerOperation(SDValue(N, 0), DAG);
1003
1004   if (Res.getNode() == 0) {
1005     switch (N->getOpcode()) {
1006     default:
1007   #ifndef NDEBUG
1008       cerr << "ExpandFloatOperand Op #" << OpNo << ": ";
1009       N->dump(&DAG); cerr << "\n";
1010   #endif
1011       assert(0 && "Do not know how to expand this operator's operand!");
1012       abort();
1013
1014     case ISD::BIT_CONVERT:     Res = ExpandOp_BIT_CONVERT(N); break;
1015     case ISD::BUILD_VECTOR:    Res = ExpandOp_BUILD_VECTOR(N); break;
1016     case ISD::EXTRACT_ELEMENT: Res = ExpandOp_EXTRACT_ELEMENT(N); break;
1017
1018     case ISD::BR_CC:      Res = ExpandFloatOp_BR_CC(N); break;
1019     case ISD::FP_ROUND:   Res = ExpandFloatOp_FP_ROUND(N); break;
1020     case ISD::FP_TO_SINT: Res = ExpandFloatOp_FP_TO_SINT(N); break;
1021     case ISD::FP_TO_UINT: Res = ExpandFloatOp_FP_TO_UINT(N); break;
1022     case ISD::SELECT_CC:  Res = ExpandFloatOp_SELECT_CC(N); break;
1023     case ISD::SETCC:      Res = ExpandFloatOp_SETCC(N); break;
1024     case ISD::STORE:      Res = ExpandFloatOp_STORE(cast<StoreSDNode>(N),
1025                                                     OpNo); break;
1026     }
1027   }
1028
1029   // If the result is null, the sub-method took care of registering results etc.
1030   if (!Res.getNode()) return false;
1031   // If the result is N, the sub-method updated N in place.  Check to see if any
1032   // operands are new, and if so, mark them.
1033   if (Res.getNode() == N) {
1034     // Mark N as new and remark N and its operands.  This allows us to correctly
1035     // revisit N if it needs another step of expansion and allows us to visit
1036     // any new operands to N.
1037     ReanalyzeNode(N);
1038     return true;
1039   }
1040
1041   assert(Res.getValueType() == N->getValueType(0) && N->getNumValues() == 1 &&
1042          "Invalid operand expansion");
1043
1044   ReplaceValueWith(SDValue(N, 0), Res);
1045   return false;
1046 }
1047
1048 /// FloatExpandSetCCOperands - Expand the operands of a comparison.  This code
1049 /// is shared among BR_CC, SELECT_CC, and SETCC handlers.
1050 void DAGTypeLegalizer::FloatExpandSetCCOperands(SDValue &NewLHS,
1051                                                 SDValue &NewRHS,
1052                                                 ISD::CondCode &CCCode) {
1053   SDValue LHSLo, LHSHi, RHSLo, RHSHi;
1054   GetExpandedFloat(NewLHS, LHSLo, LHSHi);
1055   GetExpandedFloat(NewRHS, RHSLo, RHSHi);
1056
1057   MVT VT = NewLHS.getValueType();
1058   assert(VT == MVT::ppcf128 && "Unsupported setcc type!");
1059
1060   // FIXME:  This generated code sucks.  We want to generate
1061   //         FCMPU crN, hi1, hi2
1062   //         BNE crN, L:
1063   //         FCMPU crN, lo1, lo2
1064   // The following can be improved, but not that much.
1065   SDValue Tmp1, Tmp2, Tmp3;
1066   Tmp1 = DAG.getSetCC(TLI.getSetCCResultType(LHSHi), LHSHi, RHSHi, ISD::SETOEQ);
1067   Tmp2 = DAG.getSetCC(TLI.getSetCCResultType(LHSLo), LHSLo, RHSLo, CCCode);
1068   Tmp3 = DAG.getNode(ISD::AND, Tmp1.getValueType(), Tmp1, Tmp2);
1069   Tmp1 = DAG.getSetCC(TLI.getSetCCResultType(LHSHi), LHSHi, RHSHi, ISD::SETUNE);
1070   Tmp2 = DAG.getSetCC(TLI.getSetCCResultType(LHSHi), LHSHi, RHSHi, CCCode);
1071   Tmp1 = DAG.getNode(ISD::AND, Tmp1.getValueType(), Tmp1, Tmp2);
1072   NewLHS = DAG.getNode(ISD::OR, Tmp1.getValueType(), Tmp1, Tmp3);
1073   NewRHS = SDValue();   // LHS is the result, not a compare.
1074 }
1075
1076 SDValue DAGTypeLegalizer::ExpandFloatOp_BR_CC(SDNode *N) {
1077   SDValue NewLHS = N->getOperand(2), NewRHS = N->getOperand(3);
1078   ISD::CondCode CCCode = cast<CondCodeSDNode>(N->getOperand(1))->get();
1079   FloatExpandSetCCOperands(NewLHS, NewRHS, CCCode);
1080
1081   // If ExpandSetCCOperands returned a scalar, we need to compare the result
1082   // against zero to select between true and false values.
1083   if (NewRHS.getNode() == 0) {
1084     NewRHS = DAG.getConstant(0, NewLHS.getValueType());
1085     CCCode = ISD::SETNE;
1086   }
1087
1088   // Update N to have the operands specified.
1089   return DAG.UpdateNodeOperands(SDValue(N, 0), N->getOperand(0),
1090                                 DAG.getCondCode(CCCode), NewLHS, NewRHS,
1091                                 N->getOperand(4));
1092 }
1093
1094 SDValue DAGTypeLegalizer::ExpandFloatOp_FP_ROUND(SDNode *N) {
1095   assert(N->getOperand(0).getValueType() == MVT::ppcf128 &&
1096          "Logic only correct for ppcf128!");
1097   SDValue Lo, Hi;
1098   GetExpandedFloat(N->getOperand(0), Lo, Hi);
1099   // Round it the rest of the way (e.g. to f32) if needed.
1100   return DAG.getNode(ISD::FP_ROUND, N->getValueType(0), Hi, N->getOperand(1));
1101 }
1102
1103 SDValue DAGTypeLegalizer::ExpandFloatOp_FP_TO_SINT(SDNode *N) {
1104   MVT RVT = N->getValueType(0);
1105
1106   // Expand ppcf128 to i32 by hand for the benefit of llvm-gcc bootstrap on
1107   // PPC (the libcall is not available).  FIXME: Do this in a less hacky way.
1108   if (RVT == MVT::i32) {
1109     assert(N->getOperand(0).getValueType() == MVT::ppcf128 &&
1110            "Logic only correct for ppcf128!");
1111     SDValue Res = DAG.getNode(ISD::FP_ROUND_INREG, MVT::ppcf128,
1112                               N->getOperand(0), DAG.getValueType(MVT::f64));
1113     Res = DAG.getNode(ISD::FP_ROUND, MVT::f64, Res, DAG.getIntPtrConstant(1));
1114     return DAG.getNode(ISD::FP_TO_SINT, MVT::i32, Res);
1115   }
1116
1117   RTLIB::Libcall LC = RTLIB::getFPTOSINT(N->getOperand(0).getValueType(), RVT);
1118   assert(LC != RTLIB::UNKNOWN_LIBCALL && "Unsupported FP_TO_SINT!");
1119   return MakeLibCall(LC, RVT, &N->getOperand(0), 1, false);
1120 }
1121
1122 SDValue DAGTypeLegalizer::ExpandFloatOp_FP_TO_UINT(SDNode *N) {
1123   MVT RVT = N->getValueType(0);
1124
1125   // Expand ppcf128 to i32 by hand for the benefit of llvm-gcc bootstrap on
1126   // PPC (the libcall is not available).  FIXME: Do this in a less hacky way.
1127   if (RVT == MVT::i32) {
1128     assert(N->getOperand(0).getValueType() == MVT::ppcf128 &&
1129            "Logic only correct for ppcf128!");
1130     const uint64_t TwoE31[] = {0x41e0000000000000LL, 0};
1131     APFloat APF = APFloat(APInt(128, 2, TwoE31));
1132     SDValue Tmp = DAG.getConstantFP(APF, MVT::ppcf128);
1133     //  X>=2^31 ? (int)(X-2^31)+0x80000000 : (int)X
1134     // FIXME: generated code sucks.
1135     return DAG.getNode(ISD::SELECT_CC, MVT::i32, N->getOperand(0), Tmp,
1136                        DAG.getNode(ISD::ADD, MVT::i32,
1137                                    DAG.getNode(ISD::FP_TO_SINT, MVT::i32,
1138                                                DAG.getNode(ISD::FSUB,
1139                                                            MVT::ppcf128,
1140                                                            N->getOperand(0),
1141                                                            Tmp)),
1142                                    DAG.getConstant(0x80000000, MVT::i32)),
1143                        DAG.getNode(ISD::FP_TO_SINT, MVT::i32, N->getOperand(0)),
1144                        DAG.getCondCode(ISD::SETGE));
1145   }
1146
1147   RTLIB::Libcall LC = RTLIB::getFPTOUINT(N->getOperand(0).getValueType(), RVT);
1148   assert(LC != RTLIB::UNKNOWN_LIBCALL && "Unsupported FP_TO_UINT!");
1149   return MakeLibCall(LC, N->getValueType(0), &N->getOperand(0), 1, false);
1150 }
1151
1152 SDValue DAGTypeLegalizer::ExpandFloatOp_SELECT_CC(SDNode *N) {
1153   SDValue NewLHS = N->getOperand(0), NewRHS = N->getOperand(1);
1154   ISD::CondCode CCCode = cast<CondCodeSDNode>(N->getOperand(4))->get();
1155   FloatExpandSetCCOperands(NewLHS, NewRHS, CCCode);
1156
1157   // If ExpandSetCCOperands returned a scalar, we need to compare the result
1158   // against zero to select between true and false values.
1159   if (NewRHS.getNode() == 0) {
1160     NewRHS = DAG.getConstant(0, NewLHS.getValueType());
1161     CCCode = ISD::SETNE;
1162   }
1163
1164   // Update N to have the operands specified.
1165   return DAG.UpdateNodeOperands(SDValue(N, 0), NewLHS, NewRHS,
1166                                 N->getOperand(2), N->getOperand(3),
1167                                 DAG.getCondCode(CCCode));
1168 }
1169
1170 SDValue DAGTypeLegalizer::ExpandFloatOp_SETCC(SDNode *N) {
1171   SDValue NewLHS = N->getOperand(0), NewRHS = N->getOperand(1);
1172   ISD::CondCode CCCode = cast<CondCodeSDNode>(N->getOperand(2))->get();
1173   FloatExpandSetCCOperands(NewLHS, NewRHS, CCCode);
1174
1175   // If ExpandSetCCOperands returned a scalar, use it.
1176   if (NewRHS.getNode() == 0) {
1177     assert(NewLHS.getValueType() == N->getValueType(0) &&
1178            "Unexpected setcc expansion!");
1179     return NewLHS;
1180   }
1181
1182   // Otherwise, update N to have the operands specified.
1183   return DAG.UpdateNodeOperands(SDValue(N, 0), NewLHS, NewRHS,
1184                                 DAG.getCondCode(CCCode));
1185 }
1186
1187 SDValue DAGTypeLegalizer::ExpandFloatOp_STORE(SDNode *N, unsigned OpNo) {
1188   if (ISD::isNormalStore(N))
1189     return ExpandOp_NormalStore(N, OpNo);
1190
1191   assert(ISD::isUNINDEXEDStore(N) && "Indexed store during type legalization!");
1192   assert(OpNo == 1 && "Can only expand the stored value so far");
1193   StoreSDNode *ST = cast<StoreSDNode>(N);
1194
1195   SDValue Chain = ST->getChain();
1196   SDValue Ptr = ST->getBasePtr();
1197
1198   MVT NVT = TLI.getTypeToTransformTo(ST->getValue().getValueType());
1199   assert(NVT.isByteSized() && "Expanded type not byte sized!");
1200   assert(ST->getMemoryVT().bitsLE(NVT) && "Float type not round?");
1201
1202   SDValue Lo, Hi;
1203   GetExpandedOp(ST->getValue(), Lo, Hi);
1204
1205   return DAG.getTruncStore(Chain, Hi, Ptr,
1206                            ST->getSrcValue(), ST->getSrcValueOffset(),
1207                            ST->getMemoryVT(),
1208                            ST->isVolatile(), ST->getAlignment());
1209 }