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