lib/Target/PowerPC/PPCISelLowering.cpp

   1 //===-- PPCISelLowering.cpp - PPC DAG Lowering Implementation -------------===//
   2 //
   3 //                     The LLVM Compiler Infrastructure
   4 //
   5 // This file was developed by Chris Lattner and is distributed under
   6 // the University of Illinois Open Source License. See LICENSE.TXT for details.
   7 //
   8 //===----------------------------------------------------------------------===//
   9 //
  10 // This file implements the PPCISelLowering class.
  11 //
  12 //===----------------------------------------------------------------------===//
  13
  14 #include "PPCISelLowering.h"
  15 #include "PPCTargetMachine.h"
  16 #include "llvm/CodeGen/MachineFrameInfo.h"
  17 #include "llvm/CodeGen/MachineFunction.h"
  18 #include "llvm/CodeGen/MachineInstrBuilder.h"
  19 #include "llvm/CodeGen/SelectionDAG.h"
  20 #include "llvm/CodeGen/SSARegMap.h"
  21 #include "llvm/Constants.h"
  22 #include "llvm/Function.h"
  23 using namespace llvm;
  24
  25 PPCTargetLowering::PPCTargetLowering(TargetMachine &TM)
  26   : TargetLowering(TM) {
  27
  28   // Fold away setcc operations if possible.
  29   setSetCCIsExpensive();
  30   setPow2DivIsCheap();
  31
  32   // Use _setjmp/_longjmp instead of setjmp/longjmp.
  33   setUseUnderscoreSetJmpLongJmp(true);
  34
  35   // Set up the register classes.
  36   addRegisterClass(MVT::i32, PPC::GPRCRegisterClass);
  37   addRegisterClass(MVT::f32, PPC::F4RCRegisterClass);
  38   addRegisterClass(MVT::f64, PPC::F8RCRegisterClass);
  39
  40   setOperationAction(ISD::ConstantFP, MVT::f64, Expand);
  41   setOperationAction(ISD::ConstantFP, MVT::f32, Expand);
  42
  43   // PowerPC has no intrinsics for these particular operations
  44   setOperationAction(ISD::MEMMOVE, MVT::Other, Expand);
  45   setOperationAction(ISD::MEMSET, MVT::Other, Expand);
  46   setOperationAction(ISD::MEMCPY, MVT::Other, Expand);
  47
  48   // PowerPC has an i16 but no i8 (or i1) SEXTLOAD
  49   setOperationAction(ISD::SEXTLOAD, MVT::i1, Expand);
  50   setOperationAction(ISD::SEXTLOAD, MVT::i8, Expand);
  51
  52   // PowerPC has no SREM/UREM instructions
  53   setOperationAction(ISD::SREM, MVT::i32, Expand);
  54   setOperationAction(ISD::UREM, MVT::i32, Expand);
  55
  56   // We don't support sin/cos/sqrt/fmod
  57   setOperationAction(ISD::FSIN , MVT::f64, Expand);
  58   setOperationAction(ISD::FCOS , MVT::f64, Expand);
  59   setOperationAction(ISD::FREM , MVT::f64, Expand);
  60   setOperationAction(ISD::FSIN , MVT::f32, Expand);
  61   setOperationAction(ISD::FCOS , MVT::f32, Expand);
  62   setOperationAction(ISD::FREM , MVT::f32, Expand);
  63
  64   // If we're enabling GP optimizations, use hardware square root
  65   if (!TM.getSubtarget<PPCSubtarget>().hasFSQRT()) {
  66     setOperationAction(ISD::FSQRT, MVT::f64, Expand);
  67     setOperationAction(ISD::FSQRT, MVT::f32, Expand);
  68   }
  69
  70   // PowerPC does not have BSWAP, CTPOP or CTTZ
  71   setOperationAction(ISD::BSWAP, MVT::i32  , Expand);
  72   setOperationAction(ISD::CTPOP, MVT::i32  , Expand);
  73   setOperationAction(ISD::CTTZ , MVT::i32  , Expand);
  74
  75   // PowerPC does not have ROTR
  76   setOperationAction(ISD::ROTR, MVT::i32   , Expand);
  77
  78   // PowerPC does not have Select
  79   setOperationAction(ISD::SELECT, MVT::i32, Expand);
  80   setOperationAction(ISD::SELECT, MVT::f32, Expand);
  81   setOperationAction(ISD::SELECT, MVT::f64, Expand);
  82
  83   // PowerPC wants to turn select_cc of FP into fsel when possible.
  84   setOperationAction(ISD::SELECT_CC, MVT::f32, Custom);
  85   setOperationAction(ISD::SELECT_CC, MVT::f64, Custom);
  86
  87   // PowerPC wants to optimize setcc i32, imm a bit.
  88   setOperationAction(ISD::SETCC, MVT::i32, Custom);
  89
  90   // PowerPC does not have BRCOND* which requires SetCC
  91   setOperationAction(ISD::BRCOND,       MVT::Other, Expand);
  92   setOperationAction(ISD::BRCONDTWOWAY, MVT::Other, Expand);
  93
  94   // PowerPC turns FP_TO_SINT into FCTIWZ and some load/stores.
  95   setOperationAction(ISD::FP_TO_SINT, MVT::i32, Custom);
  96
  97   // PowerPC does not have [U|S]INT_TO_FP
  98   setOperationAction(ISD::SINT_TO_FP, MVT::i32, Expand);
  99   setOperationAction(ISD::UINT_TO_FP, MVT::i32, Expand);
 100
 101   setOperationAction(ISD::BIT_CONVERT, MVT::f32, Expand);
 102   setOperationAction(ISD::BIT_CONVERT, MVT::i32, Expand);
 103
 104   // PowerPC does not have truncstore for i1.
 105   setOperationAction(ISD::TRUNCSTORE, MVT::i1, Promote);
 106
 107   // Support label based line numbers.
 108   setOperationAction(ISD::LOCATION, MVT::Other, Expand);
 109   setOperationAction(ISD::DEBUG_LOC, MVT::Other, Expand);
 110   // FIXME - use subtarget debug flags
 111   if (!TM.getSubtarget<PPCSubtarget>().isDarwin())
 112     setOperationAction(ISD::DEBUG_LABEL, MVT::Other, Expand);
 113
 114   // We want to legalize GlobalAddress and ConstantPool nodes into the
 115   // appropriate instructions to materialize the address.
 116   setOperationAction(ISD::GlobalAddress, MVT::i32, Custom);
 117   setOperationAction(ISD::ConstantPool,  MVT::i32, Custom);
 118
 119   // RET must be custom lowered, to meet ABI requirements
 120   setOperationAction(ISD::RET               , MVT::Other, Custom);
 121
 122   // VASTART needs to be custom lowered to use the VarArgsFrameIndex
 123   setOperationAction(ISD::VASTART           , MVT::Other, Custom);
 124
 125   // Use the default implementation.
 126   setOperationAction(ISD::VAARG             , MVT::Other, Expand);
 127   setOperationAction(ISD::VACOPY            , MVT::Other, Expand);
 128   setOperationAction(ISD::VAEND             , MVT::Other, Expand);
 129   setOperationAction(ISD::STACKSAVE         , MVT::Other, Expand);
 130   setOperationAction(ISD::STACKRESTORE      , MVT::Other, Expand);
 131   setOperationAction(ISD::DYNAMIC_STACKALLOC, MVT::i32  , Expand);
 132
 133   if (TM.getSubtarget<PPCSubtarget>().is64Bit()) {
 134     // They also have instructions for converting between i64 and fp.
 135     setOperationAction(ISD::FP_TO_SINT, MVT::i64, Custom);
 136     setOperationAction(ISD::SINT_TO_FP, MVT::i64, Custom);
 137     // To take advantage of the above i64 FP_TO_SINT, promote i32 FP_TO_UINT
 138     setOperationAction(ISD::FP_TO_UINT, MVT::i32, Promote);
 139   } else {
 140     // PowerPC does not have FP_TO_UINT on 32-bit implementations.
 141     setOperationAction(ISD::FP_TO_UINT, MVT::i32, Expand);
 142   }
 143
 144   if (TM.getSubtarget<PPCSubtarget>().has64BitRegs()) {
 145     // 64 bit PowerPC implementations can support i64 types directly
 146     addRegisterClass(MVT::i64, PPC::G8RCRegisterClass);
 147     // BUILD_PAIR can't be handled natively, and should be expanded to shl/or
 148     setOperationAction(ISD::BUILD_PAIR, MVT::i64, Expand);
 149   } else {
 150     // 32 bit PowerPC wants to expand i64 shifts itself.
 151     setOperationAction(ISD::SHL, MVT::i64, Custom);
 152     setOperationAction(ISD::SRL, MVT::i64, Custom);
 153     setOperationAction(ISD::SRA, MVT::i64, Custom);
 154   }
 155
 156   if (TM.getSubtarget<PPCSubtarget>().hasAltivec()) {
 157     addRegisterClass(MVT::v4f32, PPC::VRRCRegisterClass);
 158     addRegisterClass(MVT::v4i32, PPC::VRRCRegisterClass);
 159
 160     // FIXME: We don't support any ConstantVec's yet.  We should custom expand
 161     // the ones we do!
 162     setOperationAction(ISD::ConstantVec, MVT::v4f32, Expand);
 163     setOperationAction(ISD::ConstantVec, MVT::v4i32, Expand);
 164   }
 165
 166   setSetCCResultContents(ZeroOrOneSetCCResult);
 167   setStackPointerRegisterToSaveRestore(PPC::R1);
 168
 169   computeRegisterProperties();
 170 }
 171
 172 const char *PPCTargetLowering::getTargetNodeName(unsigned Opcode) const {
 173   switch (Opcode) {
 174   default: return 0;
 175   case PPCISD::FSEL:          return "PPCISD::FSEL";
 176   case PPCISD::FCFID:         return "PPCISD::FCFID";
 177   case PPCISD::FCTIDZ:        return "PPCISD::FCTIDZ";
 178   case PPCISD::FCTIWZ:        return "PPCISD::FCTIWZ";
 179   case PPCISD::VMADDFP:       return "PPCISD::VMADDFP";
 180   case PPCISD::VNMSUBFP:      return "PPCISD::VNMSUBFP";
 181   case PPCISD::Hi:            return "PPCISD::Hi";
 182   case PPCISD::Lo:            return "PPCISD::Lo";
 183   case PPCISD::GlobalBaseReg: return "PPCISD::GlobalBaseReg";
 184   case PPCISD::SRL:           return "PPCISD::SRL";
 185   case PPCISD::SRA:           return "PPCISD::SRA";
 186   case PPCISD::SHL:           return "PPCISD::SHL";
 187   case PPCISD::CALL:          return "PPCISD::CALL";
 188   case PPCISD::RET_FLAG:      return "PPCISD::RET_FLAG";
 189   }
 190 }
 191
 192 /// isFloatingPointZero - Return true if this is 0.0 or -0.0.
 193 static bool isFloatingPointZero(SDOperand Op) {
 194   if (ConstantFPSDNode *CFP = dyn_cast<ConstantFPSDNode>(Op))
 195     return CFP->isExactlyValue(-0.0) || CFP->isExactlyValue(0.0);
 196   else if (Op.getOpcode() == ISD::EXTLOAD || Op.getOpcode() == ISD::LOAD) {
 197     // Maybe this has already been legalized into the constant pool?
 198     if (ConstantPoolSDNode *CP = dyn_cast<ConstantPoolSDNode>(Op.getOperand(1)))
 199       if (ConstantFP *CFP = dyn_cast<ConstantFP>(CP->get()))
 200         return CFP->isExactlyValue(-0.0) || CFP->isExactlyValue(0.0);
 201   }
 202   return false;
 203 }
 204
 205 /// LowerOperation - Provide custom lowering hooks for some operations.
 206 ///
 207 SDOperand PPCTargetLowering::LowerOperation(SDOperand Op, SelectionDAG &DAG) {
 208   switch (Op.getOpcode()) {
 209   default: assert(0 && "Wasn't expecting to be able to lower this!");
 210   case ISD::FP_TO_SINT: {
 211     assert(MVT::isFloatingPoint(Op.getOperand(0).getValueType()));
 212     SDOperand Src = Op.getOperand(0);
 213     if (Src.getValueType() == MVT::f32)
 214       Src = DAG.getNode(ISD::FP_EXTEND, MVT::f64, Src);
 215
 216     SDOperand Tmp;
 217     switch (Op.getValueType()) {
 218     default: assert(0 && "Unhandled FP_TO_SINT type in custom expander!");
 219     case MVT::i32:
 220       Tmp = DAG.getNode(PPCISD::FCTIWZ, MVT::f64, Src);
 221       break;
 222     case MVT::i64:
 223       Tmp = DAG.getNode(PPCISD::FCTIDZ, MVT::f64, Src);
 224       break;
 225     }
 226
 227     // Convert the FP value to an int value through memory.
 228     SDOperand Bits = DAG.getNode(ISD::BIT_CONVERT, MVT::i64, Tmp);
 229     if (Op.getValueType() == MVT::i32)
 230       Bits = DAG.getNode(ISD::TRUNCATE, MVT::i32, Bits);
 231     return Bits;
 232   }
 233   case ISD::SINT_TO_FP: {
 234     assert(MVT::i64 == Op.getOperand(0).getValueType() &&
 235            "Unhandled SINT_TO_FP type in custom expander!");
 236     SDOperand Bits = DAG.getNode(ISD::BIT_CONVERT, MVT::f64, Op.getOperand(0));
 237     SDOperand FP = DAG.getNode(PPCISD::FCFID, MVT::f64, Bits);
 238     if (MVT::f32 == Op.getValueType())
 239       FP = DAG.getNode(ISD::FP_ROUND, MVT::f32, FP);
 240     return FP;
 241   }
 242   case ISD::SELECT_CC: {
 243     // Turn FP only select_cc's into fsel instructions.
 244     if (!MVT::isFloatingPoint(Op.getOperand(0).getValueType()) ||
 245         !MVT::isFloatingPoint(Op.getOperand(2).getValueType()))
 246       break;
 247
 248     ISD::CondCode CC = cast<CondCodeSDNode>(Op.getOperand(4))->get();
 249
 250     // Cannot handle SETEQ/SETNE.
 251     if (CC == ISD::SETEQ || CC == ISD::SETNE) break;
 252
 253     MVT::ValueType ResVT = Op.getValueType();
 254     MVT::ValueType CmpVT = Op.getOperand(0).getValueType();
 255     SDOperand LHS = Op.getOperand(0), RHS = Op.getOperand(1);
 256     SDOperand TV  = Op.getOperand(2), FV  = Op.getOperand(3);
 257
 258     // If the RHS of the comparison is a 0.0, we don't need to do the
 259     // subtraction at all.
 260     if (isFloatingPointZero(RHS))
 261       switch (CC) {
 262       default: break;       // SETUO etc aren't handled by fsel.
 263       case ISD::SETULT:
 264       case ISD::SETLT:
 265         std::swap(TV, FV);  // fsel is natively setge, swap operands for setlt
 266       case ISD::SETUGE:
 267       case ISD::SETGE:
 268         if (LHS.getValueType() == MVT::f32)   // Comparison is always 64-bits
 269           LHS = DAG.getNode(ISD::FP_EXTEND, MVT::f64, LHS);
 270         return DAG.getNode(PPCISD::FSEL, ResVT, LHS, TV, FV);
 271       case ISD::SETUGT:
 272       case ISD::SETGT:
 273         std::swap(TV, FV);  // fsel is natively setge, swap operands for setlt
 274       case ISD::SETULE:
 275       case ISD::SETLE:
 276         if (LHS.getValueType() == MVT::f32)   // Comparison is always 64-bits
 277           LHS = DAG.getNode(ISD::FP_EXTEND, MVT::f64, LHS);
 278         return DAG.getNode(PPCISD::FSEL, ResVT,
 279                            DAG.getNode(ISD::FNEG, MVT::f64, LHS), TV, FV);
 280       }
 281
 282     SDOperand Cmp;
 283     switch (CC) {
 284     default: break;       // SETUO etc aren't handled by fsel.
 285     case ISD::SETULT:
 286     case ISD::SETLT:
 287       Cmp = DAG.getNode(ISD::FSUB, CmpVT, LHS, RHS);
 288       if (Cmp.getValueType() == MVT::f32)   // Comparison is always 64-bits
 289         Cmp = DAG.getNode(ISD::FP_EXTEND, MVT::f64, Cmp);
 290       return DAG.getNode(PPCISD::FSEL, ResVT, Cmp, FV, TV);
 291     case ISD::SETUGE:
 292     case ISD::SETGE:
 293       Cmp = DAG.getNode(ISD::FSUB, CmpVT, LHS, RHS);
 294       if (Cmp.getValueType() == MVT::f32)   // Comparison is always 64-bits
 295         Cmp = DAG.getNode(ISD::FP_EXTEND, MVT::f64, Cmp);
 296       return DAG.getNode(PPCISD::FSEL, ResVT, Cmp, TV, FV);
 297     case ISD::SETUGT:
 298     case ISD::SETGT:
 299       Cmp = DAG.getNode(ISD::FSUB, CmpVT, RHS, LHS);
 300       if (Cmp.getValueType() == MVT::f32)   // Comparison is always 64-bits
 301         Cmp = DAG.getNode(ISD::FP_EXTEND, MVT::f64, Cmp);
 302       return DAG.getNode(PPCISD::FSEL, ResVT, Cmp, FV, TV);
 303     case ISD::SETULE:
 304     case ISD::SETLE:
 305       Cmp = DAG.getNode(ISD::FSUB, CmpVT, RHS, LHS);
 306       if (Cmp.getValueType() == MVT::f32)   // Comparison is always 64-bits
 307         Cmp = DAG.getNode(ISD::FP_EXTEND, MVT::f64, Cmp);
 308       return DAG.getNode(PPCISD::FSEL, ResVT, Cmp, TV, FV);
 309     }
 310     break;
 311   }
 312   case ISD::SHL: {
 313     assert(Op.getValueType() == MVT::i64 &&
 314            Op.getOperand(1).getValueType() == MVT::i32 && "Unexpected SHL!");
 315     // The generic code does a fine job expanding shift by a constant.
 316     if (isa<ConstantSDNode>(Op.getOperand(1))) break;
 317
 318     // Otherwise, expand into a bunch of logical ops.  Note that these ops
 319     // depend on the PPC behavior for oversized shift amounts.
 320     SDOperand Lo = DAG.getNode(ISD::EXTRACT_ELEMENT, MVT::i32, Op.getOperand(0),
 321                                DAG.getConstant(0, MVT::i32));
 322     SDOperand Hi = DAG.getNode(ISD::EXTRACT_ELEMENT, MVT::i32, Op.getOperand(0),
 323                                DAG.getConstant(1, MVT::i32));
 324     SDOperand Amt = Op.getOperand(1);
 325
 326     SDOperand Tmp1 = DAG.getNode(ISD::SUB, MVT::i32,
 327                                  DAG.getConstant(32, MVT::i32), Amt);
 328     SDOperand Tmp2 = DAG.getNode(PPCISD::SHL, MVT::i32, Hi, Amt);
 329     SDOperand Tmp3 = DAG.getNode(PPCISD::SRL, MVT::i32, Lo, Tmp1);
 330     SDOperand Tmp4 = DAG.getNode(ISD::OR , MVT::i32, Tmp2, Tmp3);
 331     SDOperand Tmp5 = DAG.getNode(ISD::ADD, MVT::i32, Amt,
 332                                  DAG.getConstant(-32U, MVT::i32));
 333     SDOperand Tmp6 = DAG.getNode(PPCISD::SHL, MVT::i32, Lo, Tmp5);
 334     SDOperand OutHi = DAG.getNode(ISD::OR, MVT::i32, Tmp4, Tmp6);
 335     SDOperand OutLo = DAG.getNode(PPCISD::SHL, MVT::i32, Lo, Amt);
 336     return DAG.getNode(ISD::BUILD_PAIR, MVT::i64, OutLo, OutHi);
 337   }
 338   case ISD::SRL: {
 339     assert(Op.getValueType() == MVT::i64 &&
 340            Op.getOperand(1).getValueType() == MVT::i32 && "Unexpected SHL!");
 341     // The generic code does a fine job expanding shift by a constant.
 342     if (isa<ConstantSDNode>(Op.getOperand(1))) break;
 343
 344     // Otherwise, expand into a bunch of logical ops.  Note that these ops
 345     // depend on the PPC behavior for oversized shift amounts.
 346     SDOperand Lo = DAG.getNode(ISD::EXTRACT_ELEMENT, MVT::i32, Op.getOperand(0),
 347                                DAG.getConstant(0, MVT::i32));
 348     SDOperand Hi = DAG.getNode(ISD::EXTRACT_ELEMENT, MVT::i32, Op.getOperand(0),
 349                                DAG.getConstant(1, MVT::i32));
 350     SDOperand Amt = Op.getOperand(1);
 351
 352     SDOperand Tmp1 = DAG.getNode(ISD::SUB, MVT::i32,
 353                                  DAG.getConstant(32, MVT::i32), Amt);
 354     SDOperand Tmp2 = DAG.getNode(PPCISD::SRL, MVT::i32, Lo, Amt);
 355     SDOperand Tmp3 = DAG.getNode(PPCISD::SHL, MVT::i32, Hi, Tmp1);
 356     SDOperand Tmp4 = DAG.getNode(ISD::OR , MVT::i32, Tmp2, Tmp3);
 357     SDOperand Tmp5 = DAG.getNode(ISD::ADD, MVT::i32, Amt,
 358                                  DAG.getConstant(-32U, MVT::i32));
 359     SDOperand Tmp6 = DAG.getNode(PPCISD::SRL, MVT::i32, Hi, Tmp5);
 360     SDOperand OutLo = DAG.getNode(ISD::OR, MVT::i32, Tmp4, Tmp6);
 361     SDOperand OutHi = DAG.getNode(PPCISD::SRL, MVT::i32, Hi, Amt);
 362     return DAG.getNode(ISD::BUILD_PAIR, MVT::i64, OutLo, OutHi);
 363   }
 364   case ISD::SRA: {
 365     assert(Op.getValueType() == MVT::i64 &&
 366            Op.getOperand(1).getValueType() == MVT::i32 && "Unexpected SRA!");
 367     // The generic code does a fine job expanding shift by a constant.
 368     if (isa<ConstantSDNode>(Op.getOperand(1))) break;
 369
 370     // Otherwise, expand into a bunch of logical ops, followed by a select_cc.
 371     SDOperand Lo = DAG.getNode(ISD::EXTRACT_ELEMENT, MVT::i32, Op.getOperand(0),
 372                                DAG.getConstant(0, MVT::i32));
 373     SDOperand Hi = DAG.getNode(ISD::EXTRACT_ELEMENT, MVT::i32, Op.getOperand(0),
 374                                DAG.getConstant(1, MVT::i32));
 375     SDOperand Amt = Op.getOperand(1);
 376
 377     SDOperand Tmp1 = DAG.getNode(ISD::SUB, MVT::i32,
 378                                  DAG.getConstant(32, MVT::i32), Amt);
 379     SDOperand Tmp2 = DAG.getNode(PPCISD::SRL, MVT::i32, Lo, Amt);
 380     SDOperand Tmp3 = DAG.getNode(PPCISD::SHL, MVT::i32, Hi, Tmp1);
 381     SDOperand Tmp4 = DAG.getNode(ISD::OR , MVT::i32, Tmp2, Tmp3);
 382     SDOperand Tmp5 = DAG.getNode(ISD::ADD, MVT::i32, Amt,
 383                                  DAG.getConstant(-32U, MVT::i32));
 384     SDOperand Tmp6 = DAG.getNode(PPCISD::SRA, MVT::i32, Hi, Tmp5);
 385     SDOperand OutHi = DAG.getNode(PPCISD::SRA, MVT::i32, Hi, Amt);
 386     SDOperand OutLo = DAG.getSelectCC(Tmp5, DAG.getConstant(0, MVT::i32),
 387                                       Tmp4, Tmp6, ISD::SETLE);
 388     return DAG.getNode(ISD::BUILD_PAIR, MVT::i64, OutLo, OutHi);
 389   }
 390   case ISD::ConstantPool: {
 391     Constant *C = cast<ConstantPoolSDNode>(Op)->get();
 392     SDOperand CPI = DAG.getTargetConstantPool(C, MVT::i32);
 393     SDOperand Zero = DAG.getConstant(0, MVT::i32);
 394
 395     if (PPCGenerateStaticCode) {
 396       // Generate non-pic code that has direct accesses to the constant pool.
 397       // The address of the global is just (hi(&g)+lo(&g)).
 398       SDOperand Hi = DAG.getNode(PPCISD::Hi, MVT::i32, CPI, Zero);
 399       SDOperand Lo = DAG.getNode(PPCISD::Lo, MVT::i32, CPI, Zero);
 400       return DAG.getNode(ISD::ADD, MVT::i32, Hi, Lo);
 401     }
 402
 403     // Only lower ConstantPool on Darwin.
 404     if (!getTargetMachine().getSubtarget<PPCSubtarget>().isDarwin()) break;
 405     SDOperand Hi = DAG.getNode(PPCISD::Hi, MVT::i32, CPI, Zero);
 406     if (PICEnabled) {
 407       // With PIC, the first instruction is actually "GR+hi(&G)".
 408       Hi = DAG.getNode(ISD::ADD, MVT::i32,
 409                        DAG.getNode(PPCISD::GlobalBaseReg, MVT::i32), Hi);
 410     }
 411
 412     SDOperand Lo = DAG.getNode(PPCISD::Lo, MVT::i32, CPI, Zero);
 413     Lo = DAG.getNode(ISD::ADD, MVT::i32, Hi, Lo);
 414     return Lo;
 415   }
 416   case ISD::GlobalAddress: {
 417     GlobalAddressSDNode *GSDN = cast<GlobalAddressSDNode>(Op);
 418     GlobalValue *GV = GSDN->getGlobal();
 419     SDOperand GA = DAG.getTargetGlobalAddress(GV, MVT::i32, GSDN->getOffset());
 420     SDOperand Zero = DAG.getConstant(0, MVT::i32);
 421
 422     if (PPCGenerateStaticCode) {
 423       // Generate non-pic code that has direct accesses to globals.
 424       // The address of the global is just (hi(&g)+lo(&g)).
 425       SDOperand Hi = DAG.getNode(PPCISD::Hi, MVT::i32, GA, Zero);
 426       SDOperand Lo = DAG.getNode(PPCISD::Lo, MVT::i32, GA, Zero);
 427       return DAG.getNode(ISD::ADD, MVT::i32, Hi, Lo);
 428     }
 429
 430     // Only lower GlobalAddress on Darwin.
 431     if (!getTargetMachine().getSubtarget<PPCSubtarget>().isDarwin()) break;
 432
 433     SDOperand Hi = DAG.getNode(PPCISD::Hi, MVT::i32, GA, Zero);
 434     if (PICEnabled) {
 435       // With PIC, the first instruction is actually "GR+hi(&G)".
 436       Hi = DAG.getNode(ISD::ADD, MVT::i32,
 437                        DAG.getNode(PPCISD::GlobalBaseReg, MVT::i32), Hi);
 438     }
 439
 440     SDOperand Lo = DAG.getNode(PPCISD::Lo, MVT::i32, GA, Zero);
 441     Lo = DAG.getNode(ISD::ADD, MVT::i32, Hi, Lo);
 442
 443     if (!GV->hasWeakLinkage() && !GV->hasLinkOnceLinkage() &&
 444         (!GV->isExternal() || GV->hasNotBeenReadFromBytecode()))
 445       return Lo;
 446
 447     // If the global is weak or external, we have to go through the lazy
 448     // resolution stub.
 449     return DAG.getLoad(MVT::i32, DAG.getEntryNode(), Lo, DAG.getSrcValue(0));
 450   }
 451   case ISD::SETCC: {
 452     ISD::CondCode CC = cast<CondCodeSDNode>(Op.getOperand(2))->get();
 453     if (ConstantSDNode *C = dyn_cast<ConstantSDNode>(Op.getOperand(1)))
 454       if (C->getValue() && !C->isAllOnesValue())
 455         if (CC == ISD::SETEQ || CC == ISD::SETNE ||
 456             CC == ISD::SETLT || CC == ISD::SETGT) {
 457           MVT::ValueType VT = Op.getValueType();
 458           SDOperand SUB = DAG.getNode(ISD::SUB, Op.getOperand(0).getValueType(),
 459                                       Op.getOperand(0), Op.getOperand(1));
 460           return DAG.getSetCC(VT, SUB, DAG.getConstant(0, VT), CC);
 461         }
 462     break;
 463   }
 464   case ISD::VASTART: {
 465     // vastart just stores the address of the VarArgsFrameIndex slot into the
 466     // memory location argument.
 467     // FIXME: Replace MVT::i32 with PointerTy
 468     SDOperand FR = DAG.getFrameIndex(VarArgsFrameIndex, MVT::i32);
 469     return DAG.getNode(ISD::STORE, MVT::Other, Op.getOperand(0), FR,
 470                        Op.getOperand(1), Op.getOperand(2));
 471   }
 472   case ISD::RET: {
 473     SDOperand Copy;
 474
 475     switch(Op.getNumOperands()) {
 476     default:
 477       assert(0 && "Do not know how to return this many arguments!");
 478       abort();
 479     case 1:
 480       return SDOperand(); // ret void is legal
 481     case 2: {
 482       MVT::ValueType ArgVT = Op.getOperand(1).getValueType();
 483       unsigned ArgReg = MVT::isInteger(ArgVT) ? PPC::R3 : PPC::F1;
 484       Copy = DAG.getCopyToReg(Op.getOperand(0), ArgReg, Op.getOperand(1),
 485                               SDOperand());
 486       break;
 487     }
 488     case 3:
 489       Copy = DAG.getCopyToReg(Op.getOperand(0), PPC::R3, Op.getOperand(2),
 490                               SDOperand());
 491       Copy = DAG.getCopyToReg(Copy, PPC::R4, Op.getOperand(1),Copy.getValue(1));
 492       break;
 493     }
 494     return DAG.getNode(PPCISD::RET_FLAG, MVT::Other, Copy, Copy.getValue(1));
 495   }
 496   }
 497   return SDOperand();
 498 }
 499
 500 std::vector<SDOperand>
 501 PPCTargetLowering::LowerArguments(Function &F, SelectionDAG &DAG) {
 502   //
 503   // add beautiful description of PPC stack frame format, or at least some docs
 504   //
 505   MachineFunction &MF = DAG.getMachineFunction();
 506   MachineFrameInfo *MFI = MF.getFrameInfo();
 507   MachineBasicBlock& BB = MF.front();
 508   SSARegMap *RegMap = MF.getSSARegMap();
 509   std::vector<SDOperand> ArgValues;
 510
 511   unsigned ArgOffset = 24;
 512   unsigned GPR_remaining = 8;
 513   unsigned FPR_remaining = 13;
 514   unsigned GPR_idx = 0, FPR_idx = 0;
 515   static const unsigned GPR[] = {
 516     PPC::R3, PPC::R4, PPC::R5, PPC::R6,
 517     PPC::R7, PPC::R8, PPC::R9, PPC::R10,
 518   };
 519   static const unsigned FPR[] = {
 520     PPC::F1, PPC::F2, PPC::F3, PPC::F4, PPC::F5, PPC::F6, PPC::F7,
 521     PPC::F8, PPC::F9, PPC::F10, PPC::F11, PPC::F12, PPC::F13
 522   };
 523
 524   // Add DAG nodes to load the arguments...  On entry to a function on PPC,
 525   // the arguments start at offset 24, although they are likely to be passed
 526   // in registers.
 527   for (Function::arg_iterator I = F.arg_begin(), E = F.arg_end(); I != E; ++I) {
 528     SDOperand newroot, argt;
 529     unsigned ObjSize;
 530     bool needsLoad = false;
 531     bool ArgLive = !I->use_empty();
 532     MVT::ValueType ObjectVT = getValueType(I->getType());
 533
 534     switch (ObjectVT) {
 535     default: assert(0 && "Unhandled argument type!");
 536     case MVT::i1:
 537     case MVT::i8:
 538     case MVT::i16:
 539     case MVT::i32:
 540       ObjSize = 4;
 541       if (!ArgLive) break;
 542       if (GPR_remaining > 0) {
 543         unsigned VReg = RegMap->createVirtualRegister(&PPC::GPRCRegClass);
 544         MF.addLiveIn(GPR[GPR_idx], VReg);
 545         argt = newroot = DAG.getCopyFromReg(DAG.getRoot(), VReg, MVT::i32);
 546         if (ObjectVT != MVT::i32) {
 547           unsigned AssertOp = I->getType()->isSigned() ? ISD::AssertSext
 548                                                        : ISD::AssertZext;
 549           argt = DAG.getNode(AssertOp, MVT::i32, argt,
 550                              DAG.getValueType(ObjectVT));
 551           argt = DAG.getNode(ISD::TRUNCATE, ObjectVT, argt);
 552         }
 553       } else {
 554         needsLoad = true;
 555       }
 556       break;
 557     case MVT::i64:
 558       ObjSize = 8;
 559       if (!ArgLive) break;
 560       if (GPR_remaining > 0) {
 561         SDOperand argHi, argLo;
 562         unsigned VReg = RegMap->createVirtualRegister(&PPC::GPRCRegClass);
 563         MF.addLiveIn(GPR[GPR_idx], VReg);
 564         argHi = DAG.getCopyFromReg(DAG.getRoot(), VReg, MVT::i32);
 565         // If we have two or more remaining argument registers, then both halves
 566         // of the i64 can be sourced from there.  Otherwise, the lower half will
 567         // have to come off the stack.  This can happen when an i64 is preceded
 568         // by 28 bytes of arguments.
 569         if (GPR_remaining > 1) {
 570           unsigned VReg = RegMap->createVirtualRegister(&PPC::GPRCRegClass);
 571           MF.addLiveIn(GPR[GPR_idx+1], VReg);
 572           argLo = DAG.getCopyFromReg(argHi, VReg, MVT::i32);
 573         } else {
 574           int FI = MFI->CreateFixedObject(4, ArgOffset+4);
 575           SDOperand FIN = DAG.getFrameIndex(FI, MVT::i32);
 576           argLo = DAG.getLoad(MVT::i32, DAG.getEntryNode(), FIN,
 577                               DAG.getSrcValue(NULL));
 578         }
 579         // Build the outgoing arg thingy
 580         argt = DAG.getNode(ISD::BUILD_PAIR, MVT::i64, argLo, argHi);
 581         newroot = argLo;
 582       } else {
 583         needsLoad = true;
 584       }
 585       break;
 586     case MVT::f32:
 587     case MVT::f64:
 588       ObjSize = (ObjectVT == MVT::f64) ? 8 : 4;
 589       if (!ArgLive) {
 590         if (FPR_remaining > 0) {
 591           --FPR_remaining;
 592           ++FPR_idx;
 593         }
 594         break;
 595       }
 596       if (FPR_remaining > 0) {
 597         unsigned VReg;
 598         if (ObjectVT == MVT::f32)
 599           VReg = RegMap->createVirtualRegister(&PPC::F4RCRegClass);
 600         else
 601           VReg = RegMap->createVirtualRegister(&PPC::F8RCRegClass);
 602         MF.addLiveIn(FPR[FPR_idx], VReg);
 603         argt = newroot = DAG.getCopyFromReg(DAG.getRoot(), VReg, ObjectVT);
 604         --FPR_remaining;
 605         ++FPR_idx;
 606       } else {
 607         needsLoad = true;
 608       }
 609       break;
 610     }
 611
 612     // We need to load the argument to a virtual register if we determined above
 613     // that we ran out of physical registers of the appropriate type
 614     if (needsLoad) {
 615       unsigned SubregOffset = 0;
 616       if (ObjectVT == MVT::i8 || ObjectVT == MVT::i1) SubregOffset = 3;
 617       if (ObjectVT == MVT::i16) SubregOffset = 2;
 618       int FI = MFI->CreateFixedObject(ObjSize, ArgOffset);
 619       SDOperand FIN = DAG.getFrameIndex(FI, MVT::i32);
 620       FIN = DAG.getNode(ISD::ADD, MVT::i32, FIN,
 621                         DAG.getConstant(SubregOffset, MVT::i32));
 622       argt = newroot = DAG.getLoad(ObjectVT, DAG.getEntryNode(), FIN,
 623                                    DAG.getSrcValue(NULL));
 624     }
 625
 626     // Every 4 bytes of argument space consumes one of the GPRs available for
 627     // argument passing.
 628     if (GPR_remaining > 0) {
 629       unsigned delta = (GPR_remaining > 1 && ObjSize == 8) ? 2 : 1;
 630       GPR_remaining -= delta;
 631       GPR_idx += delta;
 632     }
 633     ArgOffset += ObjSize;
 634     if (newroot.Val)
 635       DAG.setRoot(newroot.getValue(1));
 636
 637     ArgValues.push_back(argt);
 638   }
 639
 640   // If the function takes variable number of arguments, make a frame index for
 641   // the start of the first vararg value... for expansion of llvm.va_start.
 642   if (F.isVarArg()) {
 643     VarArgsFrameIndex = MFI->CreateFixedObject(4, ArgOffset);
 644     SDOperand FIN = DAG.getFrameIndex(VarArgsFrameIndex, MVT::i32);
 645     // If this function is vararg, store any remaining integer argument regs
 646     // to their spots on the stack so that they may be loaded by deferencing the
 647     // result of va_next.
 648     std::vector<SDOperand> MemOps;
 649     for (; GPR_remaining > 0; --GPR_remaining, ++GPR_idx) {
 650       unsigned VReg = RegMap->createVirtualRegister(&PPC::GPRCRegClass);
 651       MF.addLiveIn(GPR[GPR_idx], VReg);
 652       SDOperand Val = DAG.getCopyFromReg(DAG.getRoot(), VReg, MVT::i32);
 653       SDOperand Store = DAG.getNode(ISD::STORE, MVT::Other, Val.getValue(1),
 654                                     Val, FIN, DAG.getSrcValue(NULL));
 655       MemOps.push_back(Store);
 656       // Increment the address by four for the next argument to store
 657       SDOperand PtrOff = DAG.getConstant(4, getPointerTy());
 658       FIN = DAG.getNode(ISD::ADD, MVT::i32, FIN, PtrOff);
 659     }
 660     if (!MemOps.empty()) {
 661       MemOps.push_back(DAG.getRoot());
 662       DAG.setRoot(DAG.getNode(ISD::TokenFactor, MVT::Other, MemOps));
 663     }
 664   }
 665
 666   // Finally, inform the code generator which regs we return values in.
 667   switch (getValueType(F.getReturnType())) {
 668     default: assert(0 && "Unknown type!");
 669     case MVT::isVoid: break;
 670     case MVT::i1:
 671     case MVT::i8:
 672     case MVT::i16:
 673     case MVT::i32:
 674       MF.addLiveOut(PPC::R3);
 675       break;
 676     case MVT::i64:
 677       MF.addLiveOut(PPC::R3);
 678       MF.addLiveOut(PPC::R4);
 679       break;
 680     case MVT::f32:
 681     case MVT::f64:
 682       MF.addLiveOut(PPC::F1);
 683       break;
 684   }
 685
 686   return ArgValues;
 687 }
 688
 689 std::pair<SDOperand, SDOperand>
 690 PPCTargetLowering::LowerCallTo(SDOperand Chain,
 691                                const Type *RetTy, bool isVarArg,
 692                                unsigned CallingConv, bool isTailCall,
 693                                SDOperand Callee, ArgListTy &Args,
 694                                SelectionDAG &DAG) {
 695   // args_to_use will accumulate outgoing args for the PPCISD::CALL case in
 696   // SelectExpr to use to put the arguments in the appropriate registers.
 697   std::vector<SDOperand> args_to_use;
 698
 699   // Count how many bytes are to be pushed on the stack, including the linkage
 700   // area, and parameter passing area.
 701   unsigned NumBytes = 24;
 702
 703   if (Args.empty()) {
 704     Chain = DAG.getNode(ISD::CALLSEQ_START, MVT::Other, Chain,
 705                         DAG.getConstant(NumBytes, getPointerTy()));
 706   } else {
 707     for (unsigned i = 0, e = Args.size(); i != e; ++i) {
 708       switch (getValueType(Args[i].second)) {
 709       default: assert(0 && "Unknown value type!");
 710       case MVT::i1:
 711       case MVT::i8:
 712       case MVT::i16:
 713       case MVT::i32:
 714       case MVT::f32:
 715         NumBytes += 4;
 716         break;
 717       case MVT::i64:
 718       case MVT::f64:
 719         NumBytes += 8;
 720         break;
 721       }
 722     }
 723
 724     // Just to be safe, we'll always reserve the full 24 bytes of linkage area
 725     // plus 32 bytes of argument space in case any called code gets funky on us.
 726     // (Required by ABI to support var arg)
 727     if (NumBytes < 56) NumBytes = 56;
 728
 729     // Adjust the stack pointer for the new arguments...
 730     // These operations are automatically eliminated by the prolog/epilog pass
 731     Chain = DAG.getNode(ISD::CALLSEQ_START, MVT::Other, Chain,
 732                         DAG.getConstant(NumBytes, getPointerTy()));
 733
 734     // Set up a copy of the stack pointer for use loading and storing any
 735     // arguments that may not fit in the registers available for argument
 736     // passing.
 737     SDOperand StackPtr = DAG.getRegister(PPC::R1, MVT::i32);
 738
 739     // Figure out which arguments are going to go in registers, and which in
 740     // memory.  Also, if this is a vararg function, floating point operations
 741     // must be stored to our stack, and loaded into integer regs as well, if
 742     // any integer regs are available for argument passing.
 743     unsigned ArgOffset = 24;
 744     unsigned GPR_remaining = 8;
 745     unsigned FPR_remaining = 13;
 746
 747     std::vector<SDOperand> MemOps;
 748     for (unsigned i = 0, e = Args.size(); i != e; ++i) {
 749       // PtrOff will be used to store the current argument to the stack if a
 750       // register cannot be found for it.
 751       SDOperand PtrOff = DAG.getConstant(ArgOffset, getPointerTy());
 752       PtrOff = DAG.getNode(ISD::ADD, MVT::i32, StackPtr, PtrOff);
 753       MVT::ValueType ArgVT = getValueType(Args[i].second);
 754
 755       switch (ArgVT) {
 756       default: assert(0 && "Unexpected ValueType for argument!");
 757       case MVT::i1:
 758       case MVT::i8:
 759       case MVT::i16:
 760         // Promote the integer to 32 bits.  If the input type is signed use a
 761         // sign extend, otherwise use a zero extend.
 762         if (Args[i].second->isSigned())
 763           Args[i].first =DAG.getNode(ISD::SIGN_EXTEND, MVT::i32, Args[i].first);
 764         else
 765           Args[i].first =DAG.getNode(ISD::ZERO_EXTEND, MVT::i32, Args[i].first);
 766         // FALL THROUGH
 767       case MVT::i32:
 768         if (GPR_remaining > 0) {
 769           args_to_use.push_back(Args[i].first);
 770           --GPR_remaining;
 771         } else {
 772           MemOps.push_back(DAG.getNode(ISD::STORE, MVT::Other, Chain,
 773                                        Args[i].first, PtrOff,
 774                                        DAG.getSrcValue(NULL)));
 775         }
 776         ArgOffset += 4;
 777         break;
 778       case MVT::i64:
 779         // If we have one free GPR left, we can place the upper half of the i64
 780         // in it, and store the other half to the stack.  If we have two or more
 781         // free GPRs, then we can pass both halves of the i64 in registers.
 782         if (GPR_remaining > 0) {
 783           SDOperand Hi = DAG.getNode(ISD::EXTRACT_ELEMENT, MVT::i32,
 784                                      Args[i].first, DAG.getConstant(1, MVT::i32));
 785           SDOperand Lo = DAG.getNode(ISD::EXTRACT_ELEMENT, MVT::i32,
 786                                      Args[i].first, DAG.getConstant(0, MVT::i32));
 787           args_to_use.push_back(Hi);
 788           --GPR_remaining;
 789           if (GPR_remaining > 0) {
 790             args_to_use.push_back(Lo);
 791             --GPR_remaining;
 792           } else {
 793             SDOperand ConstFour = DAG.getConstant(4, getPointerTy());
 794             PtrOff = DAG.getNode(ISD::ADD, MVT::i32, PtrOff, ConstFour);
 795             MemOps.push_back(DAG.getNode(ISD::STORE, MVT::Other, Chain,
 796                                          Lo, PtrOff, DAG.getSrcValue(NULL)));
 797           }
 798         } else {
 799           MemOps.push_back(DAG.getNode(ISD::STORE, MVT::Other, Chain,
 800                                        Args[i].first, PtrOff,
 801                                        DAG.getSrcValue(NULL)));
 802         }
 803         ArgOffset += 8;
 804         break;
 805       case MVT::f32:
 806       case MVT::f64:
 807         if (FPR_remaining > 0) {
 808           args_to_use.push_back(Args[i].first);
 809           --FPR_remaining;
 810           if (isVarArg) {
 811             SDOperand Store = DAG.getNode(ISD::STORE, MVT::Other, Chain,
 812                                           Args[i].first, PtrOff,
 813                                           DAG.getSrcValue(NULL));
 814             MemOps.push_back(Store);
 815             // Float varargs are always shadowed in available integer registers
 816             if (GPR_remaining > 0) {
 817               SDOperand Load = DAG.getLoad(MVT::i32, Store, PtrOff,
 818                                            DAG.getSrcValue(NULL));
 819               MemOps.push_back(Load.getValue(1));
 820               args_to_use.push_back(Load);
 821               --GPR_remaining;
 822             }
 823             if (GPR_remaining > 0 && MVT::f64 == ArgVT) {
 824               SDOperand ConstFour = DAG.getConstant(4, getPointerTy());
 825               PtrOff = DAG.getNode(ISD::ADD, MVT::i32, PtrOff, ConstFour);
 826               SDOperand Load = DAG.getLoad(MVT::i32, Store, PtrOff,
 827                                            DAG.getSrcValue(NULL));
 828               MemOps.push_back(Load.getValue(1));
 829               args_to_use.push_back(Load);
 830               --GPR_remaining;
 831             }
 832           } else {
 833             // If we have any FPRs remaining, we may also have GPRs remaining.
 834             // Args passed in FPRs consume either 1 (f32) or 2 (f64) available
 835             // GPRs.
 836             if (GPR_remaining > 0) {
 837               args_to_use.push_back(DAG.getNode(ISD::UNDEF, MVT::i32));
 838               --GPR_remaining;
 839             }
 840             if (GPR_remaining > 0 && MVT::f64 == ArgVT) {
 841               args_to_use.push_back(DAG.getNode(ISD::UNDEF, MVT::i32));
 842               --GPR_remaining;
 843             }
 844           }
 845         } else {
 846           MemOps.push_back(DAG.getNode(ISD::STORE, MVT::Other, Chain,
 847                                        Args[i].first, PtrOff,
 848                                        DAG.getSrcValue(NULL)));
 849         }
 850         ArgOffset += (ArgVT == MVT::f32) ? 4 : 8;
 851         break;
 852       }
 853     }
 854     if (!MemOps.empty())
 855       Chain = DAG.getNode(ISD::TokenFactor, MVT::Other, MemOps);
 856   }
 857
 858   std::vector<MVT::ValueType> RetVals;
 859   MVT::ValueType RetTyVT = getValueType(RetTy);
 860   MVT::ValueType ActualRetTyVT = RetTyVT;
 861   if (RetTyVT >= MVT::i1 && RetTyVT <= MVT::i16)
 862     ActualRetTyVT = MVT::i32;   // Promote result to i32.
 863
 864   if (RetTyVT == MVT::i64) {
 865     RetVals.push_back(MVT::i32);
 866     RetVals.push_back(MVT::i32);
 867   } else if (RetTyVT != MVT::isVoid) {
 868     RetVals.push_back(ActualRetTyVT);
 869   }
 870   RetVals.push_back(MVT::Other);
 871
 872   // If the callee is a GlobalAddress node (quite common, every direct call is)
 873   // turn it into a TargetGlobalAddress node so that legalize doesn't hack it.
 874   if (GlobalAddressSDNode *G = dyn_cast<GlobalAddressSDNode>(Callee))
 875     Callee = DAG.getTargetGlobalAddress(G->getGlobal(), MVT::i32);
 876
 877   std::vector<SDOperand> Ops;
 878   Ops.push_back(Chain);
 879   Ops.push_back(Callee);
 880   Ops.insert(Ops.end(), args_to_use.begin(), args_to_use.end());
 881   SDOperand TheCall = DAG.getNode(PPCISD::CALL, RetVals, Ops);
 882   Chain = TheCall.getValue(TheCall.Val->getNumValues()-1);
 883   Chain = DAG.getNode(ISD::CALLSEQ_END, MVT::Other, Chain,
 884                       DAG.getConstant(NumBytes, getPointerTy()));
 885   SDOperand RetVal = TheCall;
 886
 887   // If the result is a small value, add a note so that we keep track of the
 888   // information about whether it is sign or zero extended.
 889   if (RetTyVT != ActualRetTyVT) {
 890     RetVal = DAG.getNode(RetTy->isSigned() ? ISD::AssertSext : ISD::AssertZext,
 891                          MVT::i32, RetVal, DAG.getValueType(RetTyVT));
 892     RetVal = DAG.getNode(ISD::TRUNCATE, RetTyVT, RetVal);
 893   } else if (RetTyVT == MVT::i64) {
 894     RetVal = DAG.getNode(ISD::BUILD_PAIR, MVT::i64, RetVal, RetVal.getValue(1));
 895   }
 896
 897   return std::make_pair(RetVal, Chain);
 898 }
 899
 900 MachineBasicBlock *
 901 PPCTargetLowering::InsertAtEndOfBasicBlock(MachineInstr *MI,
 902                                            MachineBasicBlock *BB) {
 903   assert((MI->getOpcode() == PPC::SELECT_CC_Int ||
 904           MI->getOpcode() == PPC::SELECT_CC_F4 ||
 905           MI->getOpcode() == PPC::SELECT_CC_F8) &&
 906          "Unexpected instr type to insert");
 907
 908   // To "insert" a SELECT_CC instruction, we actually have to insert the diamond
 909   // control-flow pattern.  The incoming instruction knows the destination vreg
 910   // to set, the condition code register to branch on, the true/false values to
 911   // select between, and a branch opcode to use.
 912   const BasicBlock *LLVM_BB = BB->getBasicBlock();
 913   ilist<MachineBasicBlock>::iterator It = BB;
 914   ++It;
 915
 916   //  thisMBB:
 917   //  ...
 918   //   TrueVal = ...
 919   //   cmpTY ccX, r1, r2
 920   //   bCC copy1MBB
 921   //   fallthrough --> copy0MBB
 922   MachineBasicBlock *thisMBB = BB;
 923   MachineBasicBlock *copy0MBB = new MachineBasicBlock(LLVM_BB);
 924   MachineBasicBlock *sinkMBB = new MachineBasicBlock(LLVM_BB);
 925   BuildMI(BB, MI->getOperand(4).getImmedValue(), 2)
 926     .addReg(MI->getOperand(1).getReg()).addMBB(sinkMBB);
 927   MachineFunction *F = BB->getParent();
 928   F->getBasicBlockList().insert(It, copy0MBB);
 929   F->getBasicBlockList().insert(It, sinkMBB);
 930   // Update machine-CFG edges
 931   BB->addSuccessor(copy0MBB);
 932   BB->addSuccessor(sinkMBB);
 933
 934   //  copy0MBB:
 935   //   %FalseValue = ...
 936   //   # fallthrough to sinkMBB
 937   BB = copy0MBB;
 938
 939   // Update machine-CFG edges
 940   BB->addSuccessor(sinkMBB);
 941
 942   //  sinkMBB:
 943   //   %Result = phi [ %FalseValue, copy0MBB ], [ %TrueValue, thisMBB ]
 944   //  ...
 945   BB = sinkMBB;
 946   BuildMI(BB, PPC::PHI, 4, MI->getOperand(0).getReg())
 947     .addReg(MI->getOperand(3).getReg()).addMBB(copy0MBB)
 948     .addReg(MI->getOperand(2).getReg()).addMBB(thisMBB);
 949
 950   delete MI;   // The pseudo instruction is gone now.
 951   return BB;
 952 }
 953