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