lib/Target/R600/R600ISelLowering.cpp

   1 //===-- R600ISelLowering.cpp - R600 DAG Lowering Implementation -----------===//
   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 /// \file
  11 /// \brief Custom DAG lowering for R600
  12 //
  13 //===----------------------------------------------------------------------===//
  14
  15 #include "R600ISelLowering.h"
  16 #include "R600Defines.h"
  17 #include "R600InstrInfo.h"
  18 #include "R600MachineFunctionInfo.h"
  19 #include "llvm/CodeGen/MachineFrameInfo.h"
  20 #include "llvm/CodeGen/MachineInstrBuilder.h"
  21 #include "llvm/CodeGen/MachineRegisterInfo.h"
  22 #include "llvm/CodeGen/SelectionDAG.h"
  23 #include "llvm/IR/Argument.h"
  24 #include "llvm/IR/Function.h"
  25
  26 using namespace llvm;
  27
  28 R600TargetLowering::R600TargetLowering(TargetMachine &TM) :
  29     AMDGPUTargetLowering(TM),
  30     Gen(TM.getSubtarget<AMDGPUSubtarget>().getGeneration()) {
  31   addRegisterClass(MVT::v4f32, &AMDGPU::R600_Reg128RegClass);
  32   addRegisterClass(MVT::f32, &AMDGPU::R600_Reg32RegClass);
  33   addRegisterClass(MVT::v4i32, &AMDGPU::R600_Reg128RegClass);
  34   addRegisterClass(MVT::i32, &AMDGPU::R600_Reg32RegClass);
  35   computeRegisterProperties();
  36
  37   setOperationAction(ISD::FADD, MVT::v4f32, Expand);
  38   setOperationAction(ISD::FMUL, MVT::v4f32, Expand);
  39   setOperationAction(ISD::FDIV, MVT::v4f32, Expand);
  40   setOperationAction(ISD::FSUB, MVT::v4f32, Expand);
  41
  42   setOperationAction(ISD::FCOS, MVT::f32, Custom);
  43   setOperationAction(ISD::FSIN, MVT::f32, Custom);
  44
  45   setOperationAction(ISD::FP_TO_SINT, MVT::v4i32, Expand);
  46   setOperationAction(ISD::FP_TO_UINT, MVT::v4i32, Expand);
  47   setOperationAction(ISD::SINT_TO_FP, MVT::v4i32, Expand);
  48   setOperationAction(ISD::UINT_TO_FP, MVT::v4i32, Expand);
  49   setOperationAction(ISD::SETCC, MVT::v4i32, Expand);
  50
  51   setOperationAction(ISD::BR_CC, MVT::i32, Expand);
  52   setOperationAction(ISD::BR_CC, MVT::f32, Expand);
  53
  54   setOperationAction(ISD::FSUB, MVT::f32, Expand);
  55
  56   setOperationAction(ISD::INTRINSIC_VOID, MVT::Other, Custom);
  57   setOperationAction(ISD::INTRINSIC_WO_CHAIN, MVT::Other, Custom);
  58   setOperationAction(ISD::INTRINSIC_WO_CHAIN, MVT::i1, Custom);
  59
  60   setOperationAction(ISD::SELECT_CC, MVT::f32, Custom);
  61   setOperationAction(ISD::SELECT_CC, MVT::i32, Custom);
  62
  63   setOperationAction(ISD::SETCC, MVT::i32, Expand);
  64   setOperationAction(ISD::SETCC, MVT::f32, Expand);
  65   setOperationAction(ISD::FP_TO_UINT, MVT::i1, Custom);
  66
  67   setOperationAction(ISD::SELECT, MVT::i32, Custom);
  68   setOperationAction(ISD::SELECT, MVT::f32, Custom);
  69
  70   setOperationAction(ISD::VSELECT, MVT::v4i32, Expand);
  71   setOperationAction(ISD::VSELECT, MVT::v2i32, Expand);
  72
  73   // Legalize loads and stores to the private address space.
  74   setOperationAction(ISD::LOAD, MVT::i32, Custom);
  75   setOperationAction(ISD::LOAD, MVT::v2i32, Expand);
  76   setOperationAction(ISD::LOAD, MVT::v4i32, Custom);
  77   setLoadExtAction(ISD::EXTLOAD, MVT::v4i8, Custom);
  78   setLoadExtAction(ISD::EXTLOAD, MVT::i8, Custom);
  79   setLoadExtAction(ISD::ZEXTLOAD, MVT::i8, Custom);
  80   setLoadExtAction(ISD::ZEXTLOAD, MVT::v4i8, Custom);
  81   setOperationAction(ISD::STORE, MVT::i8, Custom);
  82   setOperationAction(ISD::STORE, MVT::i32, Custom);
  83   setOperationAction(ISD::STORE, MVT::v2i32, Expand);
  84   setOperationAction(ISD::STORE, MVT::v4i32, Custom);
  85
  86   setOperationAction(ISD::LOAD, MVT::i32, Custom);
  87   setOperationAction(ISD::LOAD, MVT::v4i32, Custom);
  88   setOperationAction(ISD::FrameIndex, MVT::i32, Custom);
  89
  90   setTargetDAGCombine(ISD::FP_ROUND);
  91   setTargetDAGCombine(ISD::FP_TO_SINT);
  92   setTargetDAGCombine(ISD::EXTRACT_VECTOR_ELT);
  93   setTargetDAGCombine(ISD::SELECT_CC);
  94
  95   setBooleanContents(ZeroOrNegativeOneBooleanContent);
  96   setBooleanVectorContents(ZeroOrNegativeOneBooleanContent);
  97   setSchedulingPreference(Sched::VLIW);
  98 }
  99
 100 MachineBasicBlock * R600TargetLowering::EmitInstrWithCustomInserter(
 101     MachineInstr * MI, MachineBasicBlock * BB) const {
 102   MachineFunction * MF = BB->getParent();
 103   MachineRegisterInfo &MRI = MF->getRegInfo();
 104   MachineBasicBlock::iterator I = *MI;
 105   const R600InstrInfo *TII =
 106     static_cast<const R600InstrInfo*>(MF->getTarget().getInstrInfo());
 107
 108   switch (MI->getOpcode()) {
 109   default: return AMDGPUTargetLowering::EmitInstrWithCustomInserter(MI, BB);
 110   case AMDGPU::CLAMP_R600: {
 111     MachineInstr *NewMI = TII->buildDefaultInstruction(*BB, I,
 112                                                    AMDGPU::MOV,
 113                                                    MI->getOperand(0).getReg(),
 114                                                    MI->getOperand(1).getReg());
 115     TII->addFlag(NewMI, 0, MO_FLAG_CLAMP);
 116     break;
 117   }
 118
 119   case AMDGPU::FABS_R600: {
 120     MachineInstr *NewMI = TII->buildDefaultInstruction(*BB, I,
 121                                                     AMDGPU::MOV,
 122                                                     MI->getOperand(0).getReg(),
 123                                                     MI->getOperand(1).getReg());
 124     TII->addFlag(NewMI, 0, MO_FLAG_ABS);
 125     break;
 126   }
 127
 128   case AMDGPU::FNEG_R600: {
 129     MachineInstr *NewMI = TII->buildDefaultInstruction(*BB, I,
 130                                                     AMDGPU::MOV,
 131                                                     MI->getOperand(0).getReg(),
 132                                                     MI->getOperand(1).getReg());
 133     TII->addFlag(NewMI, 0, MO_FLAG_NEG);
 134     break;
 135   }
 136
 137   case AMDGPU::MASK_WRITE: {
 138     unsigned maskedRegister = MI->getOperand(0).getReg();
 139     assert(TargetRegisterInfo::isVirtualRegister(maskedRegister));
 140     MachineInstr * defInstr = MRI.getVRegDef(maskedRegister);
 141     TII->addFlag(defInstr, 0, MO_FLAG_MASK);
 142     break;
 143   }
 144
 145   case AMDGPU::LDS_READ_RET: {
 146     MachineInstrBuilder NewMI = BuildMI(*BB, I, BB->findDebugLoc(I),
 147                                         TII->get(MI->getOpcode()),
 148                                         AMDGPU::OQAP);
 149     for (unsigned i = 1, e = MI->getNumOperands(); i < e; ++i) {
 150       NewMI.addOperand(MI->getOperand(i));
 151     }
 152     TII->buildDefaultInstruction(*BB, I, AMDGPU::MOV,
 153                                  MI->getOperand(0).getReg(),
 154                                  AMDGPU::OQAP);
 155     break;
 156   }
 157
 158   case AMDGPU::MOV_IMM_F32:
 159     TII->buildMovImm(*BB, I, MI->getOperand(0).getReg(),
 160                      MI->getOperand(1).getFPImm()->getValueAPF()
 161                          .bitcastToAPInt().getZExtValue());
 162     break;
 163   case AMDGPU::MOV_IMM_I32:
 164     TII->buildMovImm(*BB, I, MI->getOperand(0).getReg(),
 165                      MI->getOperand(1).getImm());
 166     break;
 167   case AMDGPU::CONST_COPY: {
 168     MachineInstr *NewMI = TII->buildDefaultInstruction(*BB, MI, AMDGPU::MOV,
 169         MI->getOperand(0).getReg(), AMDGPU::ALU_CONST);
 170     TII->setImmOperand(NewMI, AMDGPU::OpName::src0_sel,
 171         MI->getOperand(1).getImm());
 172     break;
 173   }
 174
 175   case AMDGPU::RAT_WRITE_CACHELESS_32_eg:
 176   case AMDGPU::RAT_WRITE_CACHELESS_128_eg: {
 177     unsigned EOP = (llvm::next(I)->getOpcode() == AMDGPU::RETURN) ? 1 : 0;
 178
 179     BuildMI(*BB, I, BB->findDebugLoc(I), TII->get(MI->getOpcode()))
 180             .addOperand(MI->getOperand(0))
 181             .addOperand(MI->getOperand(1))
 182             .addImm(EOP); // Set End of program bit
 183     break;
 184   }
 185
 186   case AMDGPU::TXD: {
 187     unsigned T0 = MRI.createVirtualRegister(&AMDGPU::R600_Reg128RegClass);
 188     unsigned T1 = MRI.createVirtualRegister(&AMDGPU::R600_Reg128RegClass);
 189     MachineOperand &RID = MI->getOperand(4);
 190     MachineOperand &SID = MI->getOperand(5);
 191     unsigned TextureId = MI->getOperand(6).getImm();
 192     unsigned SrcX = 0, SrcY = 1, SrcZ = 2, SrcW = 3;
 193     unsigned CTX = 1, CTY = 1, CTZ = 1, CTW = 1;
 194
 195     switch (TextureId) {
 196     case 5: // Rect
 197       CTX = CTY = 0;
 198       break;
 199     case 6: // Shadow1D
 200       SrcW = SrcZ;
 201       break;
 202     case 7: // Shadow2D
 203       SrcW = SrcZ;
 204       break;
 205     case 8: // ShadowRect
 206       CTX = CTY = 0;
 207       SrcW = SrcZ;
 208       break;
 209     case 9: // 1DArray
 210       SrcZ = SrcY;
 211       CTZ = 0;
 212       break;
 213     case 10: // 2DArray
 214       CTZ = 0;
 215       break;
 216     case 11: // Shadow1DArray
 217       SrcZ = SrcY;
 218       CTZ = 0;
 219       break;
 220     case 12: // Shadow2DArray
 221       CTZ = 0;
 222       break;
 223     }
 224     BuildMI(*BB, I, BB->findDebugLoc(I), TII->get(AMDGPU::TEX_SET_GRADIENTS_H), T0)
 225             .addOperand(MI->getOperand(3))
 226             .addImm(SrcX)
 227             .addImm(SrcY)
 228             .addImm(SrcZ)
 229             .addImm(SrcW)
 230             .addImm(0)
 231             .addImm(0)
 232             .addImm(0)
 233             .addImm(0)
 234             .addImm(1)
 235             .addImm(2)
 236             .addImm(3)
 237             .addOperand(RID)
 238             .addOperand(SID)
 239             .addImm(CTX)
 240             .addImm(CTY)
 241             .addImm(CTZ)
 242             .addImm(CTW);
 243     BuildMI(*BB, I, BB->findDebugLoc(I), TII->get(AMDGPU::TEX_SET_GRADIENTS_V), T1)
 244             .addOperand(MI->getOperand(2))
 245             .addImm(SrcX)
 246             .addImm(SrcY)
 247             .addImm(SrcZ)
 248             .addImm(SrcW)
 249             .addImm(0)
 250             .addImm(0)
 251             .addImm(0)
 252             .addImm(0)
 253             .addImm(1)
 254             .addImm(2)
 255             .addImm(3)
 256             .addOperand(RID)
 257             .addOperand(SID)
 258             .addImm(CTX)
 259             .addImm(CTY)
 260             .addImm(CTZ)
 261             .addImm(CTW);
 262     BuildMI(*BB, I, BB->findDebugLoc(I), TII->get(AMDGPU::TEX_SAMPLE_G))
 263             .addOperand(MI->getOperand(0))
 264             .addOperand(MI->getOperand(1))
 265             .addImm(SrcX)
 266             .addImm(SrcY)
 267             .addImm(SrcZ)
 268             .addImm(SrcW)
 269             .addImm(0)
 270             .addImm(0)
 271             .addImm(0)
 272             .addImm(0)
 273             .addImm(1)
 274             .addImm(2)
 275             .addImm(3)
 276             .addOperand(RID)
 277             .addOperand(SID)
 278             .addImm(CTX)
 279             .addImm(CTY)
 280             .addImm(CTZ)
 281             .addImm(CTW)
 282             .addReg(T0, RegState::Implicit)
 283             .addReg(T1, RegState::Implicit);
 284     break;
 285   }
 286
 287   case AMDGPU::TXD_SHADOW: {
 288     unsigned T0 = MRI.createVirtualRegister(&AMDGPU::R600_Reg128RegClass);
 289     unsigned T1 = MRI.createVirtualRegister(&AMDGPU::R600_Reg128RegClass);
 290     MachineOperand &RID = MI->getOperand(4);
 291     MachineOperand &SID = MI->getOperand(5);
 292     unsigned TextureId = MI->getOperand(6).getImm();
 293     unsigned SrcX = 0, SrcY = 1, SrcZ = 2, SrcW = 3;
 294     unsigned CTX = 1, CTY = 1, CTZ = 1, CTW = 1;
 295
 296     switch (TextureId) {
 297     case 5: // Rect
 298       CTX = CTY = 0;
 299       break;
 300     case 6: // Shadow1D
 301       SrcW = SrcZ;
 302       break;
 303     case 7: // Shadow2D
 304       SrcW = SrcZ;
 305       break;
 306     case 8: // ShadowRect
 307       CTX = CTY = 0;
 308       SrcW = SrcZ;
 309       break;
 310     case 9: // 1DArray
 311       SrcZ = SrcY;
 312       CTZ = 0;
 313       break;
 314     case 10: // 2DArray
 315       CTZ = 0;
 316       break;
 317     case 11: // Shadow1DArray
 318       SrcZ = SrcY;
 319       CTZ = 0;
 320       break;
 321     case 12: // Shadow2DArray
 322       CTZ = 0;
 323       break;
 324     }
 325
 326     BuildMI(*BB, I, BB->findDebugLoc(I), TII->get(AMDGPU::TEX_SET_GRADIENTS_H), T0)
 327             .addOperand(MI->getOperand(3))
 328             .addImm(SrcX)
 329             .addImm(SrcY)
 330             .addImm(SrcZ)
 331             .addImm(SrcW)
 332             .addImm(0)
 333             .addImm(0)
 334             .addImm(0)
 335             .addImm(0)
 336             .addImm(1)
 337             .addImm(2)
 338             .addImm(3)
 339             .addOperand(RID)
 340             .addOperand(SID)
 341             .addImm(CTX)
 342             .addImm(CTY)
 343             .addImm(CTZ)
 344             .addImm(CTW);
 345     BuildMI(*BB, I, BB->findDebugLoc(I), TII->get(AMDGPU::TEX_SET_GRADIENTS_V), T1)
 346             .addOperand(MI->getOperand(2))
 347             .addImm(SrcX)
 348             .addImm(SrcY)
 349             .addImm(SrcZ)
 350             .addImm(SrcW)
 351             .addImm(0)
 352             .addImm(0)
 353             .addImm(0)
 354             .addImm(0)
 355             .addImm(1)
 356             .addImm(2)
 357             .addImm(3)
 358             .addOperand(RID)
 359             .addOperand(SID)
 360             .addImm(CTX)
 361             .addImm(CTY)
 362             .addImm(CTZ)
 363             .addImm(CTW);
 364     BuildMI(*BB, I, BB->findDebugLoc(I), TII->get(AMDGPU::TEX_SAMPLE_C_G))
 365             .addOperand(MI->getOperand(0))
 366             .addOperand(MI->getOperand(1))
 367             .addImm(SrcX)
 368             .addImm(SrcY)
 369             .addImm(SrcZ)
 370             .addImm(SrcW)
 371             .addImm(0)
 372             .addImm(0)
 373             .addImm(0)
 374             .addImm(0)
 375             .addImm(1)
 376             .addImm(2)
 377             .addImm(3)
 378             .addOperand(RID)
 379             .addOperand(SID)
 380             .addImm(CTX)
 381             .addImm(CTY)
 382             .addImm(CTZ)
 383             .addImm(CTW)
 384             .addReg(T0, RegState::Implicit)
 385             .addReg(T1, RegState::Implicit);
 386     break;
 387   }
 388
 389   case AMDGPU::BRANCH:
 390       BuildMI(*BB, I, BB->findDebugLoc(I), TII->get(AMDGPU::JUMP))
 391               .addOperand(MI->getOperand(0));
 392       break;
 393
 394   case AMDGPU::BRANCH_COND_f32: {
 395     MachineInstr *NewMI =
 396       BuildMI(*BB, I, BB->findDebugLoc(I), TII->get(AMDGPU::PRED_X),
 397               AMDGPU::PREDICATE_BIT)
 398               .addOperand(MI->getOperand(1))
 399               .addImm(OPCODE_IS_NOT_ZERO)
 400               .addImm(0); // Flags
 401     TII->addFlag(NewMI, 0, MO_FLAG_PUSH);
 402     BuildMI(*BB, I, BB->findDebugLoc(I), TII->get(AMDGPU::JUMP_COND))
 403             .addOperand(MI->getOperand(0))
 404             .addReg(AMDGPU::PREDICATE_BIT, RegState::Kill);
 405     break;
 406   }
 407
 408   case AMDGPU::BRANCH_COND_i32: {
 409     MachineInstr *NewMI =
 410       BuildMI(*BB, I, BB->findDebugLoc(I), TII->get(AMDGPU::PRED_X),
 411             AMDGPU::PREDICATE_BIT)
 412             .addOperand(MI->getOperand(1))
 413             .addImm(OPCODE_IS_NOT_ZERO_INT)
 414             .addImm(0); // Flags
 415     TII->addFlag(NewMI, 0, MO_FLAG_PUSH);
 416     BuildMI(*BB, I, BB->findDebugLoc(I), TII->get(AMDGPU::JUMP_COND))
 417            .addOperand(MI->getOperand(0))
 418             .addReg(AMDGPU::PREDICATE_BIT, RegState::Kill);
 419     break;
 420   }
 421
 422   case AMDGPU::EG_ExportSwz:
 423   case AMDGPU::R600_ExportSwz: {
 424     // Instruction is left unmodified if its not the last one of its type
 425     bool isLastInstructionOfItsType = true;
 426     unsigned InstExportType = MI->getOperand(1).getImm();
 427     for (MachineBasicBlock::iterator NextExportInst = llvm::next(I),
 428          EndBlock = BB->end(); NextExportInst != EndBlock;
 429          NextExportInst = llvm::next(NextExportInst)) {
 430       if (NextExportInst->getOpcode() == AMDGPU::EG_ExportSwz ||
 431           NextExportInst->getOpcode() == AMDGPU::R600_ExportSwz) {
 432         unsigned CurrentInstExportType = NextExportInst->getOperand(1)
 433             .getImm();
 434         if (CurrentInstExportType == InstExportType) {
 435           isLastInstructionOfItsType = false;
 436           break;
 437         }
 438       }
 439     }
 440     bool EOP = (llvm::next(I)->getOpcode() == AMDGPU::RETURN)? 1 : 0;
 441     if (!EOP && !isLastInstructionOfItsType)
 442       return BB;
 443     unsigned CfInst = (MI->getOpcode() == AMDGPU::EG_ExportSwz)? 84 : 40;
 444     BuildMI(*BB, I, BB->findDebugLoc(I), TII->get(MI->getOpcode()))
 445             .addOperand(MI->getOperand(0))
 446             .addOperand(MI->getOperand(1))
 447             .addOperand(MI->getOperand(2))
 448             .addOperand(MI->getOperand(3))
 449             .addOperand(MI->getOperand(4))
 450             .addOperand(MI->getOperand(5))
 451             .addOperand(MI->getOperand(6))
 452             .addImm(CfInst)
 453             .addImm(EOP);
 454     break;
 455   }
 456   case AMDGPU::RETURN: {
 457     // RETURN instructions must have the live-out registers as implicit uses,
 458     // otherwise they appear dead.
 459     R600MachineFunctionInfo *MFI = MF->getInfo<R600MachineFunctionInfo>();
 460     MachineInstrBuilder MIB(*MF, MI);
 461     for (unsigned i = 0, e = MFI->LiveOuts.size(); i != e; ++i)
 462       MIB.addReg(MFI->LiveOuts[i], RegState::Implicit);
 463     return BB;
 464   }
 465   }
 466
 467   MI->eraseFromParent();
 468   return BB;
 469 }
 470
 471 //===----------------------------------------------------------------------===//
 472 // Custom DAG Lowering Operations
 473 //===----------------------------------------------------------------------===//
 474
 475 SDValue R600TargetLowering::LowerOperation(SDValue Op, SelectionDAG &DAG) const {
 476   MachineFunction &MF = DAG.getMachineFunction();
 477   R600MachineFunctionInfo *MFI = MF.getInfo<R600MachineFunctionInfo>();
 478   switch (Op.getOpcode()) {
 479   default: return AMDGPUTargetLowering::LowerOperation(Op, DAG);
 480   case ISD::FCOS:
 481   case ISD::FSIN: return LowerTrig(Op, DAG);
 482   case ISD::SELECT_CC: return LowerSELECT_CC(Op, DAG);
 483   case ISD::SELECT: return LowerSELECT(Op, DAG);
 484   case ISD::STORE: return LowerSTORE(Op, DAG);
 485   case ISD::LOAD: return LowerLOAD(Op, DAG);
 486   case ISD::FrameIndex: return LowerFrameIndex(Op, DAG);
 487   case ISD::GlobalAddress: return LowerGlobalAddress(MFI, Op, DAG);
 488   case ISD::INTRINSIC_VOID: {
 489     SDValue Chain = Op.getOperand(0);
 490     unsigned IntrinsicID =
 491                          cast<ConstantSDNode>(Op.getOperand(1))->getZExtValue();
 492     switch (IntrinsicID) {
 493     case AMDGPUIntrinsic::AMDGPU_store_output: {
 494       int64_t RegIndex = cast<ConstantSDNode>(Op.getOperand(3))->getZExtValue();
 495       unsigned Reg = AMDGPU::R600_TReg32RegClass.getRegister(RegIndex);
 496       MFI->LiveOuts.push_back(Reg);
 497       return DAG.getCopyToReg(Chain, SDLoc(Op), Reg, Op.getOperand(2));
 498     }
 499     case AMDGPUIntrinsic::R600_store_swizzle: {
 500       const SDValue Args[8] = {
 501         Chain,
 502         Op.getOperand(2), // Export Value
 503         Op.getOperand(3), // ArrayBase
 504         Op.getOperand(4), // Type
 505         DAG.getConstant(0, MVT::i32), // SWZ_X
 506         DAG.getConstant(1, MVT::i32), // SWZ_Y
 507         DAG.getConstant(2, MVT::i32), // SWZ_Z
 508         DAG.getConstant(3, MVT::i32) // SWZ_W
 509       };
 510       return DAG.getNode(AMDGPUISD::EXPORT, SDLoc(Op), Op.getValueType(),
 511           Args, 8);
 512     }
 513
 514     // default for switch(IntrinsicID)
 515     default: break;
 516     }
 517     // break out of case ISD::INTRINSIC_VOID in switch(Op.getOpcode())
 518     break;
 519   }
 520   case ISD::INTRINSIC_WO_CHAIN: {
 521     unsigned IntrinsicID =
 522                          cast<ConstantSDNode>(Op.getOperand(0))->getZExtValue();
 523     EVT VT = Op.getValueType();
 524     SDLoc DL(Op);
 525     switch(IntrinsicID) {
 526     default: return AMDGPUTargetLowering::LowerOperation(Op, DAG);
 527     case AMDGPUIntrinsic::R600_load_input: {
 528       int64_t RegIndex = cast<ConstantSDNode>(Op.getOperand(1))->getZExtValue();
 529       unsigned Reg = AMDGPU::R600_TReg32RegClass.getRegister(RegIndex);
 530       MachineFunction &MF = DAG.getMachineFunction();
 531       MachineRegisterInfo &MRI = MF.getRegInfo();
 532       MRI.addLiveIn(Reg);
 533       return DAG.getCopyFromReg(DAG.getEntryNode(),
 534           SDLoc(DAG.getEntryNode()), Reg, VT);
 535     }
 536
 537     case AMDGPUIntrinsic::R600_interp_input: {
 538       int slot = cast<ConstantSDNode>(Op.getOperand(1))->getZExtValue();
 539       int ijb = cast<ConstantSDNode>(Op.getOperand(2))->getSExtValue();
 540       MachineSDNode *interp;
 541       if (ijb < 0) {
 542         const MachineFunction &MF = DAG.getMachineFunction();
 543         const R600InstrInfo *TII =
 544           static_cast<const R600InstrInfo*>(MF.getTarget().getInstrInfo());
 545         interp = DAG.getMachineNode(AMDGPU::INTERP_VEC_LOAD, DL,
 546             MVT::v4f32, DAG.getTargetConstant(slot / 4 , MVT::i32));
 547         return DAG.getTargetExtractSubreg(
 548             TII->getRegisterInfo().getSubRegFromChannel(slot % 4),
 549             DL, MVT::f32, SDValue(interp, 0));
 550       }
 551
 552       MachineFunction &MF = DAG.getMachineFunction();
 553       MachineRegisterInfo &MRI = MF.getRegInfo();
 554       unsigned RegisterI = AMDGPU::R600_TReg32RegClass.getRegister(2 * ijb);
 555       unsigned RegisterJ = AMDGPU::R600_TReg32RegClass.getRegister(2 * ijb + 1);
 556       MRI.addLiveIn(RegisterI);
 557       MRI.addLiveIn(RegisterJ);
 558       SDValue RegisterINode = DAG.getCopyFromReg(DAG.getEntryNode(),
 559           SDLoc(DAG.getEntryNode()), RegisterI, MVT::f32);
 560       SDValue RegisterJNode = DAG.getCopyFromReg(DAG.getEntryNode(),
 561           SDLoc(DAG.getEntryNode()), RegisterJ, MVT::f32);
 562
 563       if (slot % 4 < 2)
 564         interp = DAG.getMachineNode(AMDGPU::INTERP_PAIR_XY, DL,
 565             MVT::f32, MVT::f32, DAG.getTargetConstant(slot / 4 , MVT::i32),
 566             RegisterJNode, RegisterINode);
 567       else
 568         interp = DAG.getMachineNode(AMDGPU::INTERP_PAIR_ZW, DL,
 569             MVT::f32, MVT::f32, DAG.getTargetConstant(slot / 4 , MVT::i32),
 570             RegisterJNode, RegisterINode);
 571       return SDValue(interp, slot % 2);
 572     }
 573     case AMDGPUIntrinsic::R600_tex:
 574     case AMDGPUIntrinsic::R600_texc:
 575     case AMDGPUIntrinsic::R600_txl:
 576     case AMDGPUIntrinsic::R600_txlc:
 577     case AMDGPUIntrinsic::R600_txb:
 578     case AMDGPUIntrinsic::R600_txbc:
 579     case AMDGPUIntrinsic::R600_txf:
 580     case AMDGPUIntrinsic::R600_txq:
 581     case AMDGPUIntrinsic::R600_ddx:
 582     case AMDGPUIntrinsic::R600_ddy: {
 583       unsigned TextureOp;
 584       switch (IntrinsicID) {
 585       case AMDGPUIntrinsic::R600_tex:
 586         TextureOp = 0;
 587         break;
 588       case AMDGPUIntrinsic::R600_texc:
 589         TextureOp = 1;
 590         break;
 591       case AMDGPUIntrinsic::R600_txl:
 592         TextureOp = 2;
 593         break;
 594       case AMDGPUIntrinsic::R600_txlc:
 595         TextureOp = 3;
 596         break;
 597       case AMDGPUIntrinsic::R600_txb:
 598         TextureOp = 4;
 599         break;
 600       case AMDGPUIntrinsic::R600_txbc:
 601         TextureOp = 5;
 602         break;
 603       case AMDGPUIntrinsic::R600_txf:
 604         TextureOp = 6;
 605         break;
 606       case AMDGPUIntrinsic::R600_txq:
 607         TextureOp = 7;
 608         break;
 609       case AMDGPUIntrinsic::R600_ddx:
 610         TextureOp = 8;
 611         break;
 612       case AMDGPUIntrinsic::R600_ddy:
 613         TextureOp = 9;
 614         break;
 615       default:
 616         llvm_unreachable("Unknow Texture Operation");
 617       }
 618
 619       SDValue TexArgs[19] = {
 620         DAG.getConstant(TextureOp, MVT::i32),
 621         Op.getOperand(1),
 622         DAG.getConstant(0, MVT::i32),
 623         DAG.getConstant(1, MVT::i32),
 624         DAG.getConstant(2, MVT::i32),
 625         DAG.getConstant(3, MVT::i32),
 626         Op.getOperand(2),
 627         Op.getOperand(3),
 628         Op.getOperand(4),
 629         DAG.getConstant(0, MVT::i32),
 630         DAG.getConstant(1, MVT::i32),
 631         DAG.getConstant(2, MVT::i32),
 632         DAG.getConstant(3, MVT::i32),
 633         Op.getOperand(5),
 634         Op.getOperand(6),
 635         Op.getOperand(7),
 636         Op.getOperand(8),
 637         Op.getOperand(9),
 638         Op.getOperand(10)
 639       };
 640       return DAG.getNode(AMDGPUISD::TEXTURE_FETCH, DL, MVT::v4f32, TexArgs, 19);
 641     }
 642     case AMDGPUIntrinsic::AMDGPU_dp4: {
 643       SDValue Args[8] = {
 644       DAG.getNode(ISD::EXTRACT_VECTOR_ELT, DL, MVT::f32, Op.getOperand(1),
 645           DAG.getConstant(0, MVT::i32)),
 646       DAG.getNode(ISD::EXTRACT_VECTOR_ELT, DL, MVT::f32, Op.getOperand(2),
 647           DAG.getConstant(0, MVT::i32)),
 648       DAG.getNode(ISD::EXTRACT_VECTOR_ELT, DL, MVT::f32, Op.getOperand(1),
 649           DAG.getConstant(1, MVT::i32)),
 650       DAG.getNode(ISD::EXTRACT_VECTOR_ELT, DL, MVT::f32, Op.getOperand(2),
 651           DAG.getConstant(1, MVT::i32)),
 652       DAG.getNode(ISD::EXTRACT_VECTOR_ELT, DL, MVT::f32, Op.getOperand(1),
 653           DAG.getConstant(2, MVT::i32)),
 654       DAG.getNode(ISD::EXTRACT_VECTOR_ELT, DL, MVT::f32, Op.getOperand(2),
 655           DAG.getConstant(2, MVT::i32)),
 656       DAG.getNode(ISD::EXTRACT_VECTOR_ELT, DL, MVT::f32, Op.getOperand(1),
 657           DAG.getConstant(3, MVT::i32)),
 658       DAG.getNode(ISD::EXTRACT_VECTOR_ELT, DL, MVT::f32, Op.getOperand(2),
 659           DAG.getConstant(3, MVT::i32))
 660       };
 661       return DAG.getNode(AMDGPUISD::DOT4, DL, MVT::f32, Args, 8);
 662     }
 663
 664     case Intrinsic::r600_read_ngroups_x:
 665       return LowerImplicitParameter(DAG, VT, DL, 0);
 666     case Intrinsic::r600_read_ngroups_y:
 667       return LowerImplicitParameter(DAG, VT, DL, 1);
 668     case Intrinsic::r600_read_ngroups_z:
 669       return LowerImplicitParameter(DAG, VT, DL, 2);
 670     case Intrinsic::r600_read_global_size_x:
 671       return LowerImplicitParameter(DAG, VT, DL, 3);
 672     case Intrinsic::r600_read_global_size_y:
 673       return LowerImplicitParameter(DAG, VT, DL, 4);
 674     case Intrinsic::r600_read_global_size_z:
 675       return LowerImplicitParameter(DAG, VT, DL, 5);
 676     case Intrinsic::r600_read_local_size_x:
 677       return LowerImplicitParameter(DAG, VT, DL, 6);
 678     case Intrinsic::r600_read_local_size_y:
 679       return LowerImplicitParameter(DAG, VT, DL, 7);
 680     case Intrinsic::r600_read_local_size_z:
 681       return LowerImplicitParameter(DAG, VT, DL, 8);
 682
 683     case Intrinsic::r600_read_tgid_x:
 684       return CreateLiveInRegister(DAG, &AMDGPU::R600_TReg32RegClass,
 685                                   AMDGPU::T1_X, VT);
 686     case Intrinsic::r600_read_tgid_y:
 687       return CreateLiveInRegister(DAG, &AMDGPU::R600_TReg32RegClass,
 688                                   AMDGPU::T1_Y, VT);
 689     case Intrinsic::r600_read_tgid_z:
 690       return CreateLiveInRegister(DAG, &AMDGPU::R600_TReg32RegClass,
 691                                   AMDGPU::T1_Z, VT);
 692     case Intrinsic::r600_read_tidig_x:
 693       return CreateLiveInRegister(DAG, &AMDGPU::R600_TReg32RegClass,
 694                                   AMDGPU::T0_X, VT);
 695     case Intrinsic::r600_read_tidig_y:
 696       return CreateLiveInRegister(DAG, &AMDGPU::R600_TReg32RegClass,
 697                                   AMDGPU::T0_Y, VT);
 698     case Intrinsic::r600_read_tidig_z:
 699       return CreateLiveInRegister(DAG, &AMDGPU::R600_TReg32RegClass,
 700                                   AMDGPU::T0_Z, VT);
 701     }
 702     // break out of case ISD::INTRINSIC_WO_CHAIN in switch(Op.getOpcode())
 703     break;
 704   }
 705   } // end switch(Op.getOpcode())
 706   return SDValue();
 707 }
 708
 709 void R600TargetLowering::ReplaceNodeResults(SDNode *N,
 710                                             SmallVectorImpl<SDValue> &Results,
 711                                             SelectionDAG &DAG) const {
 712   switch (N->getOpcode()) {
 713   default: return;
 714   case ISD::FP_TO_UINT: Results.push_back(LowerFPTOUINT(N->getOperand(0), DAG));
 715     return;
 716   case ISD::LOAD: {
 717     SDNode *Node = LowerLOAD(SDValue(N, 0), DAG).getNode();
 718     Results.push_back(SDValue(Node, 0));
 719     Results.push_back(SDValue(Node, 1));
 720     // XXX: LLVM seems not to replace Chain Value inside CustomWidenLowerNode
 721     // function
 722     DAG.ReplaceAllUsesOfValueWith(SDValue(N,1), SDValue(Node, 1));
 723     return;
 724   }
 725   case ISD::STORE:
 726     SDNode *Node = LowerSTORE(SDValue(N, 0), DAG).getNode();
 727     Results.push_back(SDValue(Node, 0));
 728     return;
 729   }
 730 }
 731
 732 SDValue R600TargetLowering::LowerTrig(SDValue Op, SelectionDAG &DAG) const {
 733   // On hw >= R700, COS/SIN input must be between -1. and 1.
 734   // Thus we lower them to TRIG ( FRACT ( x / 2Pi + 0.5) - 0.5)
 735   EVT VT = Op.getValueType();
 736   SDValue Arg = Op.getOperand(0);
 737   SDValue FractPart = DAG.getNode(AMDGPUISD::FRACT, SDLoc(Op), VT,
 738       DAG.getNode(ISD::FADD, SDLoc(Op), VT,
 739         DAG.getNode(ISD::FMUL, SDLoc(Op), VT, Arg,
 740           DAG.getConstantFP(0.15915494309, MVT::f32)),
 741         DAG.getConstantFP(0.5, MVT::f32)));
 742   unsigned TrigNode;
 743   switch (Op.getOpcode()) {
 744   case ISD::FCOS:
 745     TrigNode = AMDGPUISD::COS_HW;
 746     break;
 747   case ISD::FSIN:
 748     TrigNode = AMDGPUISD::SIN_HW;
 749     break;
 750   default:
 751     llvm_unreachable("Wrong trig opcode");
 752   }
 753   SDValue TrigVal = DAG.getNode(TrigNode, SDLoc(Op), VT,
 754       DAG.getNode(ISD::FADD, SDLoc(Op), VT, FractPart,
 755         DAG.getConstantFP(-0.5, MVT::f32)));
 756   if (Gen >= AMDGPUSubtarget::R700)
 757     return TrigVal;
 758   // On R600 hw, COS/SIN input must be between -Pi and Pi.
 759   return DAG.getNode(ISD::FMUL, SDLoc(Op), VT, TrigVal,
 760       DAG.getConstantFP(3.14159265359, MVT::f32));
 761 }
 762
 763 SDValue R600TargetLowering::LowerFPTOUINT(SDValue Op, SelectionDAG &DAG) const {
 764   return DAG.getNode(
 765       ISD::SETCC,
 766       SDLoc(Op),
 767       MVT::i1,
 768       Op, DAG.getConstantFP(0.0f, MVT::f32),
 769       DAG.getCondCode(ISD::SETNE)
 770       );
 771 }
 772
 773 SDValue R600TargetLowering::LowerImplicitParameter(SelectionDAG &DAG, EVT VT,
 774                                                    SDLoc DL,
 775                                                    unsigned DwordOffset) const {
 776   unsigned ByteOffset = DwordOffset * 4;
 777   PointerType * PtrType = PointerType::get(VT.getTypeForEVT(*DAG.getContext()),
 778                                       AMDGPUAS::PARAM_I_ADDRESS);
 779
 780   // We shouldn't be using an offset wider than 16-bits for implicit parameters.
 781   assert(isInt<16>(ByteOffset));
 782
 783   return DAG.getLoad(VT, DL, DAG.getEntryNode(),
 784                      DAG.getConstant(ByteOffset, MVT::i32), // PTR
 785                      MachinePointerInfo(ConstantPointerNull::get(PtrType)),
 786                      false, false, false, 0);
 787 }
 788
 789 SDValue R600TargetLowering::LowerFrameIndex(SDValue Op, SelectionDAG &DAG) const {
 790
 791   MachineFunction &MF = DAG.getMachineFunction();
 792   const AMDGPUFrameLowering *TFL =
 793    static_cast<const AMDGPUFrameLowering*>(getTargetMachine().getFrameLowering());
 794
 795   FrameIndexSDNode *FIN = dyn_cast<FrameIndexSDNode>(Op);
 796   assert(FIN);
 797
 798   unsigned FrameIndex = FIN->getIndex();
 799   unsigned Offset = TFL->getFrameIndexOffset(MF, FrameIndex);
 800   return DAG.getConstant(Offset * 4 * TFL->getStackWidth(MF), MVT::i32);
 801 }
 802
 803 bool R600TargetLowering::isZero(SDValue Op) const {
 804   if(ConstantSDNode *Cst = dyn_cast<ConstantSDNode>(Op)) {
 805     return Cst->isNullValue();
 806   } else if(ConstantFPSDNode *CstFP = dyn_cast<ConstantFPSDNode>(Op)){
 807     return CstFP->isZero();
 808   } else {
 809     return false;
 810   }
 811 }
 812
 813 SDValue R600TargetLowering::LowerSELECT_CC(SDValue Op, SelectionDAG &DAG) const {
 814   SDLoc DL(Op);
 815   EVT VT = Op.getValueType();
 816
 817   SDValue LHS = Op.getOperand(0);
 818   SDValue RHS = Op.getOperand(1);
 819   SDValue True = Op.getOperand(2);
 820   SDValue False = Op.getOperand(3);
 821   SDValue CC = Op.getOperand(4);
 822   SDValue Temp;
 823
 824   // LHS and RHS are guaranteed to be the same value type
 825   EVT CompareVT = LHS.getValueType();
 826
 827   // Check if we can lower this to a native operation.
 828
 829   // Try to lower to a SET* instruction:
 830   //
 831   // SET* can match the following patterns:
 832   //
 833   // select_cc f32, f32, -1,  0, cc_any
 834   // select_cc f32, f32, 1.0f, 0.0f, cc_any
 835   // select_cc i32, i32, -1,  0, cc_any
 836   //
 837
 838   // Move hardware True/False values to the correct operand.
 839   if (isHWTrueValue(False) && isHWFalseValue(True)) {
 840     ISD::CondCode CCOpcode = cast<CondCodeSDNode>(CC)->get();
 841     std::swap(False, True);
 842     CC = DAG.getCondCode(ISD::getSetCCInverse(CCOpcode, CompareVT == MVT::i32));
 843   }
 844
 845   if (isHWTrueValue(True) && isHWFalseValue(False) &&
 846       (CompareVT == VT || VT == MVT::i32)) {
 847     // This can be matched by a SET* instruction.
 848     return DAG.getNode(ISD::SELECT_CC, DL, VT, LHS, RHS, True, False, CC);
 849   }
 850
 851   // Try to lower to a CND* instruction:
 852   //
 853   // CND* can match the following patterns:
 854   //
 855   // select_cc f32, 0.0, f32, f32, cc_any
 856   // select_cc f32, 0.0, i32, i32, cc_any
 857   // select_cc i32, 0,   f32, f32, cc_any
 858   // select_cc i32, 0,   i32, i32, cc_any
 859   //
 860   if (isZero(LHS) || isZero(RHS)) {
 861     SDValue Cond = (isZero(LHS) ? RHS : LHS);
 862     SDValue Zero = (isZero(LHS) ? LHS : RHS);
 863     ISD::CondCode CCOpcode = cast<CondCodeSDNode>(CC)->get();
 864     if (CompareVT != VT) {
 865       // Bitcast True / False to the correct types.  This will end up being
 866       // a nop, but it allows us to define only a single pattern in the
 867       // .TD files for each CND* instruction rather than having to have
 868       // one pattern for integer True/False and one for fp True/False
 869       True = DAG.getNode(ISD::BITCAST, DL, CompareVT, True);
 870       False = DAG.getNode(ISD::BITCAST, DL, CompareVT, False);
 871     }
 872     if (isZero(LHS)) {
 873       CCOpcode = ISD::getSetCCSwappedOperands(CCOpcode);
 874     }
 875
 876     switch (CCOpcode) {
 877     case ISD::SETONE:
 878     case ISD::SETUNE:
 879     case ISD::SETNE:
 880     case ISD::SETULE:
 881     case ISD::SETULT:
 882     case ISD::SETOLE:
 883     case ISD::SETOLT:
 884     case ISD::SETLE:
 885     case ISD::SETLT:
 886       CCOpcode = ISD::getSetCCInverse(CCOpcode, CompareVT == MVT::i32);
 887       Temp = True;
 888       True = False;
 889       False = Temp;
 890       break;
 891     default:
 892       break;
 893     }
 894     SDValue SelectNode = DAG.getNode(ISD::SELECT_CC, DL, CompareVT,
 895         Cond, Zero,
 896         True, False,
 897         DAG.getCondCode(CCOpcode));
 898     return DAG.getNode(ISD::BITCAST, DL, VT, SelectNode);
 899   }
 900
 901
 902   // Possible Min/Max pattern
 903   SDValue MinMax = LowerMinMax(Op, DAG);
 904   if (MinMax.getNode()) {
 905     return MinMax;
 906   }
 907
 908   // If we make it this for it means we have no native instructions to handle
 909   // this SELECT_CC, so we must lower it.
 910   SDValue HWTrue, HWFalse;
 911
 912   if (CompareVT == MVT::f32) {
 913     HWTrue = DAG.getConstantFP(1.0f, CompareVT);
 914     HWFalse = DAG.getConstantFP(0.0f, CompareVT);
 915   } else if (CompareVT == MVT::i32) {
 916     HWTrue = DAG.getConstant(-1, CompareVT);
 917     HWFalse = DAG.getConstant(0, CompareVT);
 918   }
 919   else {
 920     assert(!"Unhandled value type in LowerSELECT_CC");
 921   }
 922
 923   // Lower this unsupported SELECT_CC into a combination of two supported
 924   // SELECT_CC operations.
 925   SDValue Cond = DAG.getNode(ISD::SELECT_CC, DL, CompareVT, LHS, RHS, HWTrue, HWFalse, CC);
 926
 927   return DAG.getNode(ISD::SELECT_CC, DL, VT,
 928       Cond, HWFalse,
 929       True, False,
 930       DAG.getCondCode(ISD::SETNE));
 931 }
 932
 933 SDValue R600TargetLowering::LowerSELECT(SDValue Op, SelectionDAG &DAG) const {
 934   return DAG.getNode(ISD::SELECT_CC,
 935       SDLoc(Op),
 936       Op.getValueType(),
 937       Op.getOperand(0),
 938       DAG.getConstant(0, MVT::i32),
 939       Op.getOperand(1),
 940       Op.getOperand(2),
 941       DAG.getCondCode(ISD::SETNE));
 942 }
 943
 944 /// LLVM generates byte-addresed pointers.  For indirect addressing, we need to
 945 /// convert these pointers to a register index.  Each register holds
 946 /// 16 bytes, (4 x 32bit sub-register), but we need to take into account the
 947 /// \p StackWidth, which tells us how many of the 4 sub-registrers will be used
 948 /// for indirect addressing.
 949 SDValue R600TargetLowering::stackPtrToRegIndex(SDValue Ptr,
 950                                                unsigned StackWidth,
 951                                                SelectionDAG &DAG) const {
 952   unsigned SRLPad;
 953   switch(StackWidth) {
 954   case 1:
 955     SRLPad = 2;
 956     break;
 957   case 2:
 958     SRLPad = 3;
 959     break;
 960   case 4:
 961     SRLPad = 4;
 962     break;
 963   default: llvm_unreachable("Invalid stack width");
 964   }
 965
 966   return DAG.getNode(ISD::SRL, SDLoc(Ptr), Ptr.getValueType(), Ptr,
 967                      DAG.getConstant(SRLPad, MVT::i32));
 968 }
 969
 970 void R600TargetLowering::getStackAddress(unsigned StackWidth,
 971                                          unsigned ElemIdx,
 972                                          unsigned &Channel,
 973                                          unsigned &PtrIncr) const {
 974   switch (StackWidth) {
 975   default:
 976   case 1:
 977     Channel = 0;
 978     if (ElemIdx > 0) {
 979       PtrIncr = 1;
 980     } else {
 981       PtrIncr = 0;
 982     }
 983     break;
 984   case 2:
 985     Channel = ElemIdx % 2;
 986     if (ElemIdx == 2) {
 987       PtrIncr = 1;
 988     } else {
 989       PtrIncr = 0;
 990     }
 991     break;
 992   case 4:
 993     Channel = ElemIdx;
 994     PtrIncr = 0;
 995     break;
 996   }
 997 }
 998
 999 SDValue R600TargetLowering::LowerSTORE(SDValue Op, SelectionDAG &DAG) const {
1000   SDLoc DL(Op);
1001   StoreSDNode *StoreNode = cast<StoreSDNode>(Op);
1002   SDValue Chain = Op.getOperand(0);
1003   SDValue Value = Op.getOperand(1);
1004   SDValue Ptr = Op.getOperand(2);
1005
1006   if (StoreNode->getAddressSpace() == AMDGPUAS::GLOBAL_ADDRESS &&
1007       Ptr->getOpcode() != AMDGPUISD::DWORDADDR) {
1008     // Convert pointer from byte address to dword address.
1009     Ptr = DAG.getNode(AMDGPUISD::DWORDADDR, DL, Ptr.getValueType(),
1010                       DAG.getNode(ISD::SRL, DL, Ptr.getValueType(),
1011                                   Ptr, DAG.getConstant(2, MVT::i32)));
1012
1013     if (StoreNode->isTruncatingStore() || StoreNode->isIndexed()) {
1014       assert(!"Truncated and indexed stores not supported yet");
1015     } else {
1016       Chain = DAG.getStore(Chain, DL, Value, Ptr, StoreNode->getMemOperand());
1017     }
1018     return Chain;
1019   }
1020
1021   EVT ValueVT = Value.getValueType();
1022
1023   if (StoreNode->getAddressSpace() != AMDGPUAS::PRIVATE_ADDRESS) {
1024     return SDValue();
1025   }
1026
1027   // Lowering for indirect addressing
1028
1029   const MachineFunction &MF = DAG.getMachineFunction();
1030   const AMDGPUFrameLowering *TFL = static_cast<const AMDGPUFrameLowering*>(
1031                                          getTargetMachine().getFrameLowering());
1032   unsigned StackWidth = TFL->getStackWidth(MF);
1033
1034   Ptr = stackPtrToRegIndex(Ptr, StackWidth, DAG);
1035
1036   if (ValueVT.isVector()) {
1037     unsigned NumElemVT = ValueVT.getVectorNumElements();
1038     EVT ElemVT = ValueVT.getVectorElementType();
1039     SDValue Stores[4];
1040
1041     assert(NumElemVT >= StackWidth && "Stack width cannot be greater than "
1042                                       "vector width in load");
1043
1044     for (unsigned i = 0; i < NumElemVT; ++i) {
1045       unsigned Channel, PtrIncr;
1046       getStackAddress(StackWidth, i, Channel, PtrIncr);
1047       Ptr = DAG.getNode(ISD::ADD, DL, MVT::i32, Ptr,
1048                         DAG.getConstant(PtrIncr, MVT::i32));
1049       SDValue Elem = DAG.getNode(ISD::EXTRACT_VECTOR_ELT, DL, ElemVT,
1050                                  Value, DAG.getConstant(i, MVT::i32));
1051
1052       Stores[i] = DAG.getNode(AMDGPUISD::REGISTER_STORE, DL, MVT::Other,
1053                               Chain, Elem, Ptr,
1054                               DAG.getTargetConstant(Channel, MVT::i32));
1055     }
1056      Chain =  DAG.getNode(ISD::TokenFactor, DL, MVT::Other, Stores, NumElemVT);
1057    } else {
1058     if (ValueVT == MVT::i8) {
1059       Value = DAG.getNode(ISD::ZERO_EXTEND, DL, MVT::i32, Value);
1060     }
1061     Chain = DAG.getNode(AMDGPUISD::REGISTER_STORE, DL, MVT::Other, Chain, Value, Ptr,
1062     DAG.getTargetConstant(0, MVT::i32)); // Channel
1063   }
1064
1065   return Chain;
1066 }
1067
1068 // return (512 + (kc_bank << 12)
1069 static int
1070 ConstantAddressBlock(unsigned AddressSpace) {
1071   switch (AddressSpace) {
1072   case AMDGPUAS::CONSTANT_BUFFER_0:
1073     return 512;
1074   case AMDGPUAS::CONSTANT_BUFFER_1:
1075     return 512 + 4096;
1076   case AMDGPUAS::CONSTANT_BUFFER_2:
1077     return 512 + 4096 * 2;
1078   case AMDGPUAS::CONSTANT_BUFFER_3:
1079     return 512 + 4096 * 3;
1080   case AMDGPUAS::CONSTANT_BUFFER_4:
1081     return 512 + 4096 * 4;
1082   case AMDGPUAS::CONSTANT_BUFFER_5:
1083     return 512 + 4096 * 5;
1084   case AMDGPUAS::CONSTANT_BUFFER_6:
1085     return 512 + 4096 * 6;
1086   case AMDGPUAS::CONSTANT_BUFFER_7:
1087     return 512 + 4096 * 7;
1088   case AMDGPUAS::CONSTANT_BUFFER_8:
1089     return 512 + 4096 * 8;
1090   case AMDGPUAS::CONSTANT_BUFFER_9:
1091     return 512 + 4096 * 9;
1092   case AMDGPUAS::CONSTANT_BUFFER_10:
1093     return 512 + 4096 * 10;
1094   case AMDGPUAS::CONSTANT_BUFFER_11:
1095     return 512 + 4096 * 11;
1096   case AMDGPUAS::CONSTANT_BUFFER_12:
1097     return 512 + 4096 * 12;
1098   case AMDGPUAS::CONSTANT_BUFFER_13:
1099     return 512 + 4096 * 13;
1100   case AMDGPUAS::CONSTANT_BUFFER_14:
1101     return 512 + 4096 * 14;
1102   case AMDGPUAS::CONSTANT_BUFFER_15:
1103     return 512 + 4096 * 15;
1104   default:
1105     return -1;
1106   }
1107 }
1108
1109 SDValue R600TargetLowering::LowerLOAD(SDValue Op, SelectionDAG &DAG) const
1110 {
1111   EVT VT = Op.getValueType();
1112   SDLoc DL(Op);
1113   LoadSDNode *LoadNode = cast<LoadSDNode>(Op);
1114   SDValue Chain = Op.getOperand(0);
1115   SDValue Ptr = Op.getOperand(1);
1116   SDValue LoweredLoad;
1117
1118   int ConstantBlock = ConstantAddressBlock(LoadNode->getAddressSpace());
1119   if (ConstantBlock > -1) {
1120     SDValue Result;
1121     if (dyn_cast<ConstantExpr>(LoadNode->getSrcValue()) ||
1122         dyn_cast<Constant>(LoadNode->getSrcValue()) ||
1123         dyn_cast<ConstantSDNode>(Ptr)) {
1124       SDValue Slots[4];
1125       for (unsigned i = 0; i < 4; i++) {
1126         // We want Const position encoded with the following formula :
1127         // (((512 + (kc_bank << 12) + const_index) << 2) + chan)
1128         // const_index is Ptr computed by llvm using an alignment of 16.
1129         // Thus we add (((512 + (kc_bank << 12)) + chan ) * 4 here and
1130         // then div by 4 at the ISel step
1131         SDValue NewPtr = DAG.getNode(ISD::ADD, DL, Ptr.getValueType(), Ptr,
1132             DAG.getConstant(4 * i + ConstantBlock * 16, MVT::i32));
1133         Slots[i] = DAG.getNode(AMDGPUISD::CONST_ADDRESS, DL, MVT::i32, NewPtr);
1134       }
1135       Result = DAG.getNode(ISD::BUILD_VECTOR, DL, MVT::v4i32, Slots, 4);
1136     } else {
1137       // non constant ptr cant be folded, keeps it as a v4f32 load
1138       Result = DAG.getNode(AMDGPUISD::CONST_ADDRESS, DL, MVT::v4i32,
1139           DAG.getNode(ISD::SRL, DL, MVT::i32, Ptr, DAG.getConstant(4, MVT::i32)),
1140           DAG.getConstant(LoadNode->getAddressSpace() -
1141                           AMDGPUAS::CONSTANT_BUFFER_0, MVT::i32)
1142           );
1143     }
1144
1145     if (!VT.isVector()) {
1146       Result = DAG.getNode(ISD::EXTRACT_VECTOR_ELT, DL, MVT::i32, Result,
1147           DAG.getConstant(0, MVT::i32));
1148     }
1149
1150     SDValue MergedValues[2] = {
1151         Result,
1152         Chain
1153     };
1154     return DAG.getMergeValues(MergedValues, 2, DL);
1155   }
1156
1157   if (LoadNode->getAddressSpace() != AMDGPUAS::PRIVATE_ADDRESS) {
1158     return SDValue();
1159   }
1160
1161   // Lowering for indirect addressing
1162   const MachineFunction &MF = DAG.getMachineFunction();
1163   const AMDGPUFrameLowering *TFL = static_cast<const AMDGPUFrameLowering*>(
1164                                          getTargetMachine().getFrameLowering());
1165   unsigned StackWidth = TFL->getStackWidth(MF);
1166
1167   Ptr = stackPtrToRegIndex(Ptr, StackWidth, DAG);
1168
1169   if (VT.isVector()) {
1170     unsigned NumElemVT = VT.getVectorNumElements();
1171     EVT ElemVT = VT.getVectorElementType();
1172     SDValue Loads[4];
1173
1174     assert(NumElemVT >= StackWidth && "Stack width cannot be greater than "
1175                                       "vector width in load");
1176
1177     for (unsigned i = 0; i < NumElemVT; ++i) {
1178       unsigned Channel, PtrIncr;
1179       getStackAddress(StackWidth, i, Channel, PtrIncr);
1180       Ptr = DAG.getNode(ISD::ADD, DL, MVT::i32, Ptr,
1181                         DAG.getConstant(PtrIncr, MVT::i32));
1182       Loads[i] = DAG.getNode(AMDGPUISD::REGISTER_LOAD, DL, ElemVT,
1183                              Chain, Ptr,
1184                              DAG.getTargetConstant(Channel, MVT::i32),
1185                              Op.getOperand(2));
1186     }
1187     for (unsigned i = NumElemVT; i < 4; ++i) {
1188       Loads[i] = DAG.getUNDEF(ElemVT);
1189     }
1190     EVT TargetVT = EVT::getVectorVT(*DAG.getContext(), ElemVT, 4);
1191     LoweredLoad = DAG.getNode(ISD::BUILD_VECTOR, DL, TargetVT, Loads, 4);
1192   } else {
1193     LoweredLoad = DAG.getNode(AMDGPUISD::REGISTER_LOAD, DL, VT,
1194                               Chain, Ptr,
1195                               DAG.getTargetConstant(0, MVT::i32), // Channel
1196                               Op.getOperand(2));
1197   }
1198
1199   SDValue Ops[2];
1200   Ops[0] = LoweredLoad;
1201   Ops[1] = Chain;
1202
1203   return DAG.getMergeValues(Ops, 2, DL);
1204 }
1205
1206 /// XXX Only kernel functions are supported, so we can assume for now that
1207 /// every function is a kernel function, but in the future we should use
1208 /// separate calling conventions for kernel and non-kernel functions.
1209 SDValue R600TargetLowering::LowerFormalArguments(
1210                                       SDValue Chain,
1211                                       CallingConv::ID CallConv,
1212                                       bool isVarArg,
1213                                       const SmallVectorImpl<ISD::InputArg> &Ins,
1214                                       SDLoc DL, SelectionDAG &DAG,
1215                                       SmallVectorImpl<SDValue> &InVals) const {
1216   unsigned ParamOffsetBytes = 36;
1217   Function::const_arg_iterator FuncArg =
1218                             DAG.getMachineFunction().getFunction()->arg_begin();
1219   for (unsigned i = 0, e = Ins.size(); i < e; ++i, ++FuncArg) {
1220     EVT VT = Ins[i].VT;
1221     Type *ArgType = FuncArg->getType();
1222     unsigned ArgSizeInBits = ArgType->isPointerTy() ?
1223                              32 : ArgType->getPrimitiveSizeInBits();
1224     unsigned ArgBytes = ArgSizeInBits >> 3;
1225     EVT ArgVT;
1226     if (ArgSizeInBits < VT.getSizeInBits()) {
1227       assert(!ArgType->isFloatTy() &&
1228              "Extending floating point arguments not supported yet");
1229       ArgVT = MVT::getIntegerVT(ArgSizeInBits);
1230     } else {
1231       ArgVT = VT;
1232     }
1233     PointerType *PtrTy = PointerType::get(VT.getTypeForEVT(*DAG.getContext()),
1234                                                     AMDGPUAS::PARAM_I_ADDRESS);
1235     SDValue Arg = DAG.getExtLoad(ISD::ZEXTLOAD, DL, VT, DAG.getRoot(),
1236                                 DAG.getConstant(ParamOffsetBytes, MVT::i32),
1237                                        MachinePointerInfo(UndefValue::get(PtrTy)),
1238                                        ArgVT, false, false, ArgBytes);
1239     InVals.push_back(Arg);
1240     ParamOffsetBytes += ArgBytes;
1241   }
1242   return Chain;
1243 }
1244
1245 EVT R600TargetLowering::getSetCCResultType(LLVMContext &, EVT VT) const {
1246    if (!VT.isVector()) return MVT::i32;
1247    return VT.changeVectorElementTypeToInteger();
1248 }
1249
1250 static SDValue
1251 CompactSwizzlableVector(SelectionDAG &DAG, SDValue VectorEntry,
1252                         DenseMap<unsigned, unsigned> &RemapSwizzle) {
1253   assert(VectorEntry.getOpcode() == ISD::BUILD_VECTOR);
1254   assert(RemapSwizzle.empty());
1255   SDValue NewBldVec[4] = {
1256       VectorEntry.getOperand(0),
1257       VectorEntry.getOperand(1),
1258       VectorEntry.getOperand(2),
1259       VectorEntry.getOperand(3)
1260   };
1261
1262   for (unsigned i = 0; i < 4; i++) {
1263     if (ConstantFPSDNode *C = dyn_cast<ConstantFPSDNode>(NewBldVec[i])) {
1264       if (C->isZero()) {
1265         RemapSwizzle[i] = 4; // SEL_0
1266         NewBldVec[i] = DAG.getUNDEF(MVT::f32);
1267       } else if (C->isExactlyValue(1.0)) {
1268         RemapSwizzle[i] = 5; // SEL_1
1269         NewBldVec[i] = DAG.getUNDEF(MVT::f32);
1270       }
1271     }
1272
1273     if (NewBldVec[i].getOpcode() == ISD::UNDEF)
1274       continue;
1275     for (unsigned j = 0; j < i; j++) {
1276       if (NewBldVec[i] == NewBldVec[j]) {
1277         NewBldVec[i] = DAG.getUNDEF(NewBldVec[i].getValueType());
1278         RemapSwizzle[i] = j;
1279         break;
1280       }
1281     }
1282   }
1283
1284   return DAG.getNode(ISD::BUILD_VECTOR, SDLoc(VectorEntry),
1285       VectorEntry.getValueType(), NewBldVec, 4);
1286 }
1287
1288 static SDValue ReorganizeVector(SelectionDAG &DAG, SDValue VectorEntry,
1289                                 DenseMap<unsigned, unsigned> &RemapSwizzle) {
1290   assert(VectorEntry.getOpcode() == ISD::BUILD_VECTOR);
1291   assert(RemapSwizzle.empty());
1292   SDValue NewBldVec[4] = {
1293       VectorEntry.getOperand(0),
1294       VectorEntry.getOperand(1),
1295       VectorEntry.getOperand(2),
1296       VectorEntry.getOperand(3)
1297   };
1298   bool isUnmovable[4] = { false, false, false, false };
1299
1300   for (unsigned i = 0; i < 4; i++) {
1301     if (NewBldVec[i].getOpcode() == ISD::EXTRACT_VECTOR_ELT) {
1302       unsigned Idx = dyn_cast<ConstantSDNode>(NewBldVec[i].getOperand(1))
1303           ->getZExtValue();
1304       if (!isUnmovable[Idx]) {
1305         // Swap i and Idx
1306         std::swap(NewBldVec[Idx], NewBldVec[i]);
1307         RemapSwizzle[Idx] = i;
1308         RemapSwizzle[i] = Idx;
1309       }
1310       isUnmovable[Idx] = true;
1311     }
1312   }
1313
1314   return DAG.getNode(ISD::BUILD_VECTOR, SDLoc(VectorEntry),
1315       VectorEntry.getValueType(), NewBldVec, 4);
1316 }
1317
1318
1319 SDValue R600TargetLowering::OptimizeSwizzle(SDValue BuildVector,
1320 SDValue Swz[4], SelectionDAG &DAG) const {
1321   assert(BuildVector.getOpcode() == ISD::BUILD_VECTOR);
1322   // Old -> New swizzle values
1323   DenseMap<unsigned, unsigned> SwizzleRemap;
1324
1325   BuildVector = CompactSwizzlableVector(DAG, BuildVector, SwizzleRemap);
1326   for (unsigned i = 0; i < 4; i++) {
1327     unsigned Idx = dyn_cast<ConstantSDNode>(Swz[i])->getZExtValue();
1328     if (SwizzleRemap.find(Idx) != SwizzleRemap.end())
1329       Swz[i] = DAG.getConstant(SwizzleRemap[Idx], MVT::i32);
1330   }
1331
1332   SwizzleRemap.clear();
1333   BuildVector = ReorganizeVector(DAG, BuildVector, SwizzleRemap);
1334   for (unsigned i = 0; i < 4; i++) {
1335     unsigned Idx = dyn_cast<ConstantSDNode>(Swz[i])->getZExtValue();
1336     if (SwizzleRemap.find(Idx) != SwizzleRemap.end())
1337       Swz[i] = DAG.getConstant(SwizzleRemap[Idx], MVT::i32);
1338   }
1339
1340   return BuildVector;
1341 }
1342
1343
1344 //===----------------------------------------------------------------------===//
1345 // Custom DAG Optimizations
1346 //===----------------------------------------------------------------------===//
1347
1348 SDValue R600TargetLowering::PerformDAGCombine(SDNode *N,
1349                                               DAGCombinerInfo &DCI) const {
1350   SelectionDAG &DAG = DCI.DAG;
1351
1352   switch (N->getOpcode()) {
1353   // (f32 fp_round (f64 uint_to_fp a)) -> (f32 uint_to_fp a)
1354   case ISD::FP_ROUND: {
1355       SDValue Arg = N->getOperand(0);
1356       if (Arg.getOpcode() == ISD::UINT_TO_FP && Arg.getValueType() == MVT::f64) {
1357         return DAG.getNode(ISD::UINT_TO_FP, SDLoc(N), N->getValueType(0),
1358                            Arg.getOperand(0));
1359       }
1360       break;
1361     }
1362
1363   // (i32 fp_to_sint (fneg (select_cc f32, f32, 1.0, 0.0 cc))) ->
1364   // (i32 select_cc f32, f32, -1, 0 cc)
1365   //
1366   // Mesa's GLSL frontend generates the above pattern a lot and we can lower
1367   // this to one of the SET*_DX10 instructions.
1368   case ISD::FP_TO_SINT: {
1369     SDValue FNeg = N->getOperand(0);
1370     if (FNeg.getOpcode() != ISD::FNEG) {
1371       return SDValue();
1372     }
1373     SDValue SelectCC = FNeg.getOperand(0);
1374     if (SelectCC.getOpcode() != ISD::SELECT_CC ||
1375         SelectCC.getOperand(0).getValueType() != MVT::f32 || // LHS
1376         SelectCC.getOperand(2).getValueType() != MVT::f32 || // True
1377         !isHWTrueValue(SelectCC.getOperand(2)) ||
1378         !isHWFalseValue(SelectCC.getOperand(3))) {
1379       return SDValue();
1380     }
1381
1382     return DAG.getNode(ISD::SELECT_CC, SDLoc(N), N->getValueType(0),
1383                            SelectCC.getOperand(0), // LHS
1384                            SelectCC.getOperand(1), // RHS
1385                            DAG.getConstant(-1, MVT::i32), // True
1386                            DAG.getConstant(0, MVT::i32),  // Flase
1387                            SelectCC.getOperand(4)); // CC
1388
1389     break;
1390   }
1391   // Extract_vec (Build_vector) generated by custom lowering
1392   // also needs to be customly combined
1393   case ISD::EXTRACT_VECTOR_ELT: {
1394     SDValue Arg = N->getOperand(0);
1395     if (Arg.getOpcode() == ISD::BUILD_VECTOR) {
1396       if (ConstantSDNode *Const = dyn_cast<ConstantSDNode>(N->getOperand(1))) {
1397         unsigned Element = Const->getZExtValue();
1398         return Arg->getOperand(Element);
1399       }
1400     }
1401     if (Arg.getOpcode() == ISD::BITCAST &&
1402         Arg.getOperand(0).getOpcode() == ISD::BUILD_VECTOR) {
1403       if (ConstantSDNode *Const = dyn_cast<ConstantSDNode>(N->getOperand(1))) {
1404         unsigned Element = Const->getZExtValue();
1405         return DAG.getNode(ISD::BITCAST, SDLoc(N), N->getVTList(),
1406             Arg->getOperand(0).getOperand(Element));
1407       }
1408     }
1409   }
1410
1411   case ISD::SELECT_CC: {
1412     // fold selectcc (selectcc x, y, a, b, cc), b, a, b, seteq ->
1413     //      selectcc x, y, a, b, inv(cc)
1414     //
1415     // fold selectcc (selectcc x, y, a, b, cc), b, a, b, setne ->
1416     //      selectcc x, y, a, b, cc
1417     SDValue LHS = N->getOperand(0);
1418     if (LHS.getOpcode() != ISD::SELECT_CC) {
1419       return SDValue();
1420     }
1421
1422     SDValue RHS = N->getOperand(1);
1423     SDValue True = N->getOperand(2);
1424     SDValue False = N->getOperand(3);
1425     ISD::CondCode NCC = cast<CondCodeSDNode>(N->getOperand(4))->get();
1426
1427     if (LHS.getOperand(2).getNode() != True.getNode() ||
1428         LHS.getOperand(3).getNode() != False.getNode() ||
1429         RHS.getNode() != False.getNode()) {
1430       return SDValue();
1431     }
1432
1433     switch (NCC) {
1434     default: return SDValue();
1435     case ISD::SETNE: return LHS;
1436     case ISD::SETEQ: {
1437       ISD::CondCode LHSCC = cast<CondCodeSDNode>(LHS.getOperand(4))->get();
1438       LHSCC = ISD::getSetCCInverse(LHSCC,
1439                                   LHS.getOperand(0).getValueType().isInteger());
1440       return DAG.getSelectCC(SDLoc(N),
1441                              LHS.getOperand(0),
1442                              LHS.getOperand(1),
1443                              LHS.getOperand(2),
1444                              LHS.getOperand(3),
1445                              LHSCC);
1446     }
1447     }
1448   }
1449   case AMDGPUISD::EXPORT: {
1450     SDValue Arg = N->getOperand(1);
1451     if (Arg.getOpcode() != ISD::BUILD_VECTOR)
1452       break;
1453
1454     SDValue NewArgs[8] = {
1455       N->getOperand(0), // Chain
1456       SDValue(),
1457       N->getOperand(2), // ArrayBase
1458       N->getOperand(3), // Type
1459       N->getOperand(4), // SWZ_X
1460       N->getOperand(5), // SWZ_Y
1461       N->getOperand(6), // SWZ_Z
1462       N->getOperand(7) // SWZ_W
1463     };
1464     SDLoc DL(N);
1465     NewArgs[1] = OptimizeSwizzle(N->getOperand(1), &NewArgs[4], DAG);
1466     return DAG.getNode(AMDGPUISD::EXPORT, DL, N->getVTList(), NewArgs, 8);
1467   }
1468   case AMDGPUISD::TEXTURE_FETCH: {
1469     SDValue Arg = N->getOperand(1);
1470     if (Arg.getOpcode() != ISD::BUILD_VECTOR)
1471       break;
1472
1473     SDValue NewArgs[19] = {
1474       N->getOperand(0),
1475       N->getOperand(1),
1476       N->getOperand(2),
1477       N->getOperand(3),
1478       N->getOperand(4),
1479       N->getOperand(5),
1480       N->getOperand(6),
1481       N->getOperand(7),
1482       N->getOperand(8),
1483       N->getOperand(9),
1484       N->getOperand(10),
1485       N->getOperand(11),
1486       N->getOperand(12),
1487       N->getOperand(13),
1488       N->getOperand(14),
1489       N->getOperand(15),
1490       N->getOperand(16),
1491       N->getOperand(17),
1492       N->getOperand(18),
1493     };
1494     NewArgs[1] = OptimizeSwizzle(N->getOperand(1), &NewArgs[2], DAG);
1495     return DAG.getNode(AMDGPUISD::TEXTURE_FETCH, SDLoc(N), N->getVTList(),
1496         NewArgs, 19);
1497   }
1498   }
1499   return SDValue();
1500 }