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   setOperationAction(ISD::GlobalAddress, MVT::i32, Custom);
  96
  97   setBooleanContents(ZeroOrNegativeOneBooleanContent);
  98   setBooleanVectorContents(ZeroOrNegativeOneBooleanContent);
  99   setSchedulingPreference(Sched::VLIW);
 100 }
 101
 102 MachineBasicBlock * R600TargetLowering::EmitInstrWithCustomInserter(
 103     MachineInstr * MI, MachineBasicBlock * BB) const {
 104   MachineFunction * MF = BB->getParent();
 105   MachineRegisterInfo &MRI = MF->getRegInfo();
 106   MachineBasicBlock::iterator I = *MI;
 107   const R600InstrInfo *TII =
 108     static_cast<const R600InstrInfo*>(MF->getTarget().getInstrInfo());
 109
 110   switch (MI->getOpcode()) {
 111   default: return AMDGPUTargetLowering::EmitInstrWithCustomInserter(MI, BB);
 112   case AMDGPU::CLAMP_R600: {
 113     MachineInstr *NewMI = TII->buildDefaultInstruction(*BB, I,
 114                                                    AMDGPU::MOV,
 115                                                    MI->getOperand(0).getReg(),
 116                                                    MI->getOperand(1).getReg());
 117     TII->addFlag(NewMI, 0, MO_FLAG_CLAMP);
 118     break;
 119   }
 120
 121   case AMDGPU::FABS_R600: {
 122     MachineInstr *NewMI = TII->buildDefaultInstruction(*BB, I,
 123                                                     AMDGPU::MOV,
 124                                                     MI->getOperand(0).getReg(),
 125                                                     MI->getOperand(1).getReg());
 126     TII->addFlag(NewMI, 0, MO_FLAG_ABS);
 127     break;
 128   }
 129
 130   case AMDGPU::FNEG_R600: {
 131     MachineInstr *NewMI = TII->buildDefaultInstruction(*BB, I,
 132                                                     AMDGPU::MOV,
 133                                                     MI->getOperand(0).getReg(),
 134                                                     MI->getOperand(1).getReg());
 135     TII->addFlag(NewMI, 0, MO_FLAG_NEG);
 136     break;
 137   }
 138
 139   case AMDGPU::MASK_WRITE: {
 140     unsigned maskedRegister = MI->getOperand(0).getReg();
 141     assert(TargetRegisterInfo::isVirtualRegister(maskedRegister));
 142     MachineInstr * defInstr = MRI.getVRegDef(maskedRegister);
 143     TII->addFlag(defInstr, 0, MO_FLAG_MASK);
 144     break;
 145   }
 146
 147   case AMDGPU::LDS_READ_RET: {
 148     MachineInstrBuilder NewMI = BuildMI(*BB, I, BB->findDebugLoc(I),
 149                                         TII->get(MI->getOpcode()),
 150                                         AMDGPU::OQAP);
 151     for (unsigned i = 1, e = MI->getNumOperands(); i < e; ++i) {
 152       NewMI.addOperand(MI->getOperand(i));
 153     }
 154     TII->buildDefaultInstruction(*BB, I, AMDGPU::MOV,
 155                                  MI->getOperand(0).getReg(),
 156                                  AMDGPU::OQAP);
 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, AMDGPU::OpName::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 SDValue R600TargetLowering::LowerOperation(SDValue Op, SelectionDAG &DAG) const {
 478   MachineFunction &MF = DAG.getMachineFunction();
 479   R600MachineFunctionInfo *MFI = MF.getInfo<R600MachineFunctionInfo>();
 480   switch (Op.getOpcode()) {
 481   default: return AMDGPUTargetLowering::LowerOperation(Op, DAG);
 482   case ISD::FCOS:
 483   case ISD::FSIN: return LowerTrig(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::GlobalAddress: return LowerGlobalAddress(MFI, Op, DAG);
 490   case ISD::INTRINSIC_VOID: {
 491     SDValue Chain = Op.getOperand(0);
 492     unsigned IntrinsicID =
 493                          cast<ConstantSDNode>(Op.getOperand(1))->getZExtValue();
 494     switch (IntrinsicID) {
 495     case AMDGPUIntrinsic::AMDGPU_store_output: {
 496       int64_t RegIndex = cast<ConstantSDNode>(Op.getOperand(3))->getZExtValue();
 497       unsigned Reg = AMDGPU::R600_TReg32RegClass.getRegister(RegIndex);
 498       MFI->LiveOuts.push_back(Reg);
 499       return DAG.getCopyToReg(Chain, SDLoc(Op), Reg, Op.getOperand(2));
 500     }
 501     case AMDGPUIntrinsic::R600_store_swizzle: {
 502       const SDValue Args[8] = {
 503         Chain,
 504         Op.getOperand(2), // Export Value
 505         Op.getOperand(3), // ArrayBase
 506         Op.getOperand(4), // Type
 507         DAG.getConstant(0, MVT::i32), // SWZ_X
 508         DAG.getConstant(1, MVT::i32), // SWZ_Y
 509         DAG.getConstant(2, MVT::i32), // SWZ_Z
 510         DAG.getConstant(3, MVT::i32) // SWZ_W
 511       };
 512       return DAG.getNode(AMDGPUISD::EXPORT, SDLoc(Op), Op.getValueType(),
 513           Args, 8);
 514     }
 515
 516     // default for switch(IntrinsicID)
 517     default: break;
 518     }
 519     // break out of case ISD::INTRINSIC_VOID in switch(Op.getOpcode())
 520     break;
 521   }
 522   case ISD::INTRINSIC_WO_CHAIN: {
 523     unsigned IntrinsicID =
 524                          cast<ConstantSDNode>(Op.getOperand(0))->getZExtValue();
 525     EVT VT = Op.getValueType();
 526     SDLoc DL(Op);
 527     switch(IntrinsicID) {
 528     default: return AMDGPUTargetLowering::LowerOperation(Op, DAG);
 529     case AMDGPUIntrinsic::R600_load_input: {
 530       int64_t RegIndex = cast<ConstantSDNode>(Op.getOperand(1))->getZExtValue();
 531       unsigned Reg = AMDGPU::R600_TReg32RegClass.getRegister(RegIndex);
 532       MachineFunction &MF = DAG.getMachineFunction();
 533       MachineRegisterInfo &MRI = MF.getRegInfo();
 534       MRI.addLiveIn(Reg);
 535       return DAG.getCopyFromReg(DAG.getEntryNode(),
 536           SDLoc(DAG.getEntryNode()), Reg, VT);
 537     }
 538
 539     case AMDGPUIntrinsic::R600_interp_input: {
 540       int slot = cast<ConstantSDNode>(Op.getOperand(1))->getZExtValue();
 541       int ijb = cast<ConstantSDNode>(Op.getOperand(2))->getSExtValue();
 542       MachineSDNode *interp;
 543       if (ijb < 0) {
 544         const MachineFunction &MF = DAG.getMachineFunction();
 545         const R600InstrInfo *TII =
 546           static_cast<const R600InstrInfo*>(MF.getTarget().getInstrInfo());
 547         interp = DAG.getMachineNode(AMDGPU::INTERP_VEC_LOAD, DL,
 548             MVT::v4f32, DAG.getTargetConstant(slot / 4 , MVT::i32));
 549         return DAG.getTargetExtractSubreg(
 550             TII->getRegisterInfo().getSubRegFromChannel(slot % 4),
 551             DL, MVT::f32, SDValue(interp, 0));
 552       }
 553
 554       MachineFunction &MF = DAG.getMachineFunction();
 555       MachineRegisterInfo &MRI = MF.getRegInfo();
 556       unsigned RegisterI = AMDGPU::R600_TReg32RegClass.getRegister(2 * ijb);
 557       unsigned RegisterJ = AMDGPU::R600_TReg32RegClass.getRegister(2 * ijb + 1);
 558       MRI.addLiveIn(RegisterI);
 559       MRI.addLiveIn(RegisterJ);
 560       SDValue RegisterINode = DAG.getCopyFromReg(DAG.getEntryNode(),
 561           SDLoc(DAG.getEntryNode()), RegisterI, MVT::f32);
 562       SDValue RegisterJNode = DAG.getCopyFromReg(DAG.getEntryNode(),
 563           SDLoc(DAG.getEntryNode()), RegisterJ, MVT::f32);
 564
 565       if (slot % 4 < 2)
 566         interp = DAG.getMachineNode(AMDGPU::INTERP_PAIR_XY, DL,
 567             MVT::f32, MVT::f32, DAG.getTargetConstant(slot / 4 , MVT::i32),
 568             RegisterJNode, RegisterINode);
 569       else
 570         interp = DAG.getMachineNode(AMDGPU::INTERP_PAIR_ZW, DL,
 571             MVT::f32, MVT::f32, DAG.getTargetConstant(slot / 4 , MVT::i32),
 572             RegisterJNode, RegisterINode);
 573       return SDValue(interp, slot % 2);
 574     }
 575     case AMDGPUIntrinsic::R600_tex:
 576     case AMDGPUIntrinsic::R600_texc:
 577     case AMDGPUIntrinsic::R600_txl:
 578     case AMDGPUIntrinsic::R600_txlc:
 579     case AMDGPUIntrinsic::R600_txb:
 580     case AMDGPUIntrinsic::R600_txbc:
 581     case AMDGPUIntrinsic::R600_txf:
 582     case AMDGPUIntrinsic::R600_txq:
 583     case AMDGPUIntrinsic::R600_ddx:
 584     case AMDGPUIntrinsic::R600_ddy: {
 585       unsigned TextureOp;
 586       switch (IntrinsicID) {
 587       case AMDGPUIntrinsic::R600_tex:
 588         TextureOp = 0;
 589         break;
 590       case AMDGPUIntrinsic::R600_texc:
 591         TextureOp = 1;
 592         break;
 593       case AMDGPUIntrinsic::R600_txl:
 594         TextureOp = 2;
 595         break;
 596       case AMDGPUIntrinsic::R600_txlc:
 597         TextureOp = 3;
 598         break;
 599       case AMDGPUIntrinsic::R600_txb:
 600         TextureOp = 4;
 601         break;
 602       case AMDGPUIntrinsic::R600_txbc:
 603         TextureOp = 5;
 604         break;
 605       case AMDGPUIntrinsic::R600_txf:
 606         TextureOp = 6;
 607         break;
 608       case AMDGPUIntrinsic::R600_txq:
 609         TextureOp = 7;
 610         break;
 611       case AMDGPUIntrinsic::R600_ddx:
 612         TextureOp = 8;
 613         break;
 614       case AMDGPUIntrinsic::R600_ddy:
 615         TextureOp = 9;
 616         break;
 617       default:
 618         llvm_unreachable("Unknow Texture Operation");
 619       }
 620
 621       SDValue TexArgs[19] = {
 622         DAG.getConstant(TextureOp, MVT::i32),
 623         Op.getOperand(1),
 624         DAG.getConstant(0, MVT::i32),
 625         DAG.getConstant(1, MVT::i32),
 626         DAG.getConstant(2, MVT::i32),
 627         DAG.getConstant(3, MVT::i32),
 628         Op.getOperand(2),
 629         Op.getOperand(3),
 630         Op.getOperand(4),
 631         DAG.getConstant(0, MVT::i32),
 632         DAG.getConstant(1, MVT::i32),
 633         DAG.getConstant(2, MVT::i32),
 634         DAG.getConstant(3, MVT::i32),
 635         Op.getOperand(5),
 636         Op.getOperand(6),
 637         Op.getOperand(7),
 638         Op.getOperand(8),
 639         Op.getOperand(9),
 640         Op.getOperand(10)
 641       };
 642       return DAG.getNode(AMDGPUISD::TEXTURE_FETCH, DL, MVT::v4f32, TexArgs, 19);
 643     }
 644     case AMDGPUIntrinsic::AMDGPU_dp4: {
 645       SDValue Args[8] = {
 646       DAG.getNode(ISD::EXTRACT_VECTOR_ELT, DL, MVT::f32, Op.getOperand(1),
 647           DAG.getConstant(0, MVT::i32)),
 648       DAG.getNode(ISD::EXTRACT_VECTOR_ELT, DL, MVT::f32, Op.getOperand(2),
 649           DAG.getConstant(0, MVT::i32)),
 650       DAG.getNode(ISD::EXTRACT_VECTOR_ELT, DL, MVT::f32, Op.getOperand(1),
 651           DAG.getConstant(1, MVT::i32)),
 652       DAG.getNode(ISD::EXTRACT_VECTOR_ELT, DL, MVT::f32, Op.getOperand(2),
 653           DAG.getConstant(1, MVT::i32)),
 654       DAG.getNode(ISD::EXTRACT_VECTOR_ELT, DL, MVT::f32, Op.getOperand(1),
 655           DAG.getConstant(2, MVT::i32)),
 656       DAG.getNode(ISD::EXTRACT_VECTOR_ELT, DL, MVT::f32, Op.getOperand(2),
 657           DAG.getConstant(2, MVT::i32)),
 658       DAG.getNode(ISD::EXTRACT_VECTOR_ELT, DL, MVT::f32, Op.getOperand(1),
 659           DAG.getConstant(3, MVT::i32)),
 660       DAG.getNode(ISD::EXTRACT_VECTOR_ELT, DL, MVT::f32, Op.getOperand(2),
 661           DAG.getConstant(3, MVT::i32))
 662       };
 663       return DAG.getNode(AMDGPUISD::DOT4, DL, MVT::f32, Args, 8);
 664     }
 665
 666     case Intrinsic::r600_read_ngroups_x:
 667       return LowerImplicitParameter(DAG, VT, DL, 0);
 668     case Intrinsic::r600_read_ngroups_y:
 669       return LowerImplicitParameter(DAG, VT, DL, 1);
 670     case Intrinsic::r600_read_ngroups_z:
 671       return LowerImplicitParameter(DAG, VT, DL, 2);
 672     case Intrinsic::r600_read_global_size_x:
 673       return LowerImplicitParameter(DAG, VT, DL, 3);
 674     case Intrinsic::r600_read_global_size_y:
 675       return LowerImplicitParameter(DAG, VT, DL, 4);
 676     case Intrinsic::r600_read_global_size_z:
 677       return LowerImplicitParameter(DAG, VT, DL, 5);
 678     case Intrinsic::r600_read_local_size_x:
 679       return LowerImplicitParameter(DAG, VT, DL, 6);
 680     case Intrinsic::r600_read_local_size_y:
 681       return LowerImplicitParameter(DAG, VT, DL, 7);
 682     case Intrinsic::r600_read_local_size_z:
 683       return LowerImplicitParameter(DAG, VT, DL, 8);
 684
 685     case Intrinsic::r600_read_tgid_x:
 686       return CreateLiveInRegister(DAG, &AMDGPU::R600_TReg32RegClass,
 687                                   AMDGPU::T1_X, VT);
 688     case Intrinsic::r600_read_tgid_y:
 689       return CreateLiveInRegister(DAG, &AMDGPU::R600_TReg32RegClass,
 690                                   AMDGPU::T1_Y, VT);
 691     case Intrinsic::r600_read_tgid_z:
 692       return CreateLiveInRegister(DAG, &AMDGPU::R600_TReg32RegClass,
 693                                   AMDGPU::T1_Z, VT);
 694     case Intrinsic::r600_read_tidig_x:
 695       return CreateLiveInRegister(DAG, &AMDGPU::R600_TReg32RegClass,
 696                                   AMDGPU::T0_X, VT);
 697     case Intrinsic::r600_read_tidig_y:
 698       return CreateLiveInRegister(DAG, &AMDGPU::R600_TReg32RegClass,
 699                                   AMDGPU::T0_Y, VT);
 700     case Intrinsic::r600_read_tidig_z:
 701       return CreateLiveInRegister(DAG, &AMDGPU::R600_TReg32RegClass,
 702                                   AMDGPU::T0_Z, VT);
 703     }
 704     // break out of case ISD::INTRINSIC_WO_CHAIN in switch(Op.getOpcode())
 705     break;
 706   }
 707   } // end switch(Op.getOpcode())
 708   return SDValue();
 709 }
 710
 711 void R600TargetLowering::ReplaceNodeResults(SDNode *N,
 712                                             SmallVectorImpl<SDValue> &Results,
 713                                             SelectionDAG &DAG) const {
 714   switch (N->getOpcode()) {
 715   default: return;
 716   case ISD::FP_TO_UINT: Results.push_back(LowerFPTOUINT(N->getOperand(0), DAG));
 717     return;
 718   case ISD::LOAD: {
 719     SDNode *Node = LowerLOAD(SDValue(N, 0), DAG).getNode();
 720     Results.push_back(SDValue(Node, 0));
 721     Results.push_back(SDValue(Node, 1));
 722     // XXX: LLVM seems not to replace Chain Value inside CustomWidenLowerNode
 723     // function
 724     DAG.ReplaceAllUsesOfValueWith(SDValue(N,1), SDValue(Node, 1));
 725     return;
 726   }
 727   case ISD::STORE:
 728     SDNode *Node = LowerSTORE(SDValue(N, 0), DAG).getNode();
 729     Results.push_back(SDValue(Node, 0));
 730     return;
 731   }
 732 }
 733
 734 SDValue R600TargetLowering::LowerTrig(SDValue Op, SelectionDAG &DAG) const {
 735   // On hw >= R700, COS/SIN input must be between -1. and 1.
 736   // Thus we lower them to TRIG ( FRACT ( x / 2Pi + 0.5) - 0.5)
 737   EVT VT = Op.getValueType();
 738   SDValue Arg = Op.getOperand(0);
 739   SDValue FractPart = DAG.getNode(AMDGPUISD::FRACT, SDLoc(Op), VT,
 740       DAG.getNode(ISD::FADD, SDLoc(Op), VT,
 741         DAG.getNode(ISD::FMUL, SDLoc(Op), VT, Arg,
 742           DAG.getConstantFP(0.15915494309, MVT::f32)),
 743         DAG.getConstantFP(0.5, MVT::f32)));
 744   unsigned TrigNode;
 745   switch (Op.getOpcode()) {
 746   case ISD::FCOS:
 747     TrigNode = AMDGPUISD::COS_HW;
 748     break;
 749   case ISD::FSIN:
 750     TrigNode = AMDGPUISD::SIN_HW;
 751     break;
 752   default:
 753     llvm_unreachable("Wrong trig opcode");
 754   }
 755   SDValue TrigVal = DAG.getNode(TrigNode, SDLoc(Op), VT,
 756       DAG.getNode(ISD::FADD, SDLoc(Op), VT, FractPart,
 757         DAG.getConstantFP(-0.5, MVT::f32)));
 758   if (Gen >= AMDGPUSubtarget::R700)
 759     return TrigVal;
 760   // On R600 hw, COS/SIN input must be between -Pi and Pi.
 761   return DAG.getNode(ISD::FMUL, SDLoc(Op), VT, TrigVal,
 762       DAG.getConstantFP(3.14159265359, MVT::f32));
 763 }
 764
 765 SDValue R600TargetLowering::LowerFPTOUINT(SDValue Op, SelectionDAG &DAG) const {
 766   return DAG.getNode(
 767       ISD::SETCC,
 768       SDLoc(Op),
 769       MVT::i1,
 770       Op, DAG.getConstantFP(0.0f, MVT::f32),
 771       DAG.getCondCode(ISD::SETNE)
 772       );
 773 }
 774
 775 SDValue R600TargetLowering::LowerImplicitParameter(SelectionDAG &DAG, EVT VT,
 776                                                    SDLoc DL,
 777                                                    unsigned DwordOffset) const {
 778   unsigned ByteOffset = DwordOffset * 4;
 779   PointerType * PtrType = PointerType::get(VT.getTypeForEVT(*DAG.getContext()),
 780                                       AMDGPUAS::PARAM_I_ADDRESS);
 781
 782   // We shouldn't be using an offset wider than 16-bits for implicit parameters.
 783   assert(isInt<16>(ByteOffset));
 784
 785   return DAG.getLoad(VT, DL, DAG.getEntryNode(),
 786                      DAG.getConstant(ByteOffset, MVT::i32), // PTR
 787                      MachinePointerInfo(ConstantPointerNull::get(PtrType)),
 788                      false, false, false, 0);
 789 }
 790
 791 SDValue R600TargetLowering::LowerFrameIndex(SDValue Op, SelectionDAG &DAG) const {
 792
 793   MachineFunction &MF = DAG.getMachineFunction();
 794   const AMDGPUFrameLowering *TFL =
 795    static_cast<const AMDGPUFrameLowering*>(getTargetMachine().getFrameLowering());
 796
 797   FrameIndexSDNode *FIN = dyn_cast<FrameIndexSDNode>(Op);
 798   assert(FIN);
 799
 800   unsigned FrameIndex = FIN->getIndex();
 801   unsigned Offset = TFL->getFrameIndexOffset(MF, FrameIndex);
 802   return DAG.getConstant(Offset * 4 * TFL->getStackWidth(MF), MVT::i32);
 803 }
 804
 805 bool R600TargetLowering::isZero(SDValue Op) const {
 806   if(ConstantSDNode *Cst = dyn_cast<ConstantSDNode>(Op)) {
 807     return Cst->isNullValue();
 808   } else if(ConstantFPSDNode *CstFP = dyn_cast<ConstantFPSDNode>(Op)){
 809     return CstFP->isZero();
 810   } else {
 811     return false;
 812   }
 813 }
 814
 815 SDValue R600TargetLowering::LowerSELECT_CC(SDValue Op, SelectionDAG &DAG) const {
 816   SDLoc DL(Op);
 817   EVT VT = Op.getValueType();
 818
 819   SDValue LHS = Op.getOperand(0);
 820   SDValue RHS = Op.getOperand(1);
 821   SDValue True = Op.getOperand(2);
 822   SDValue False = Op.getOperand(3);
 823   SDValue CC = Op.getOperand(4);
 824   SDValue Temp;
 825
 826   // LHS and RHS are guaranteed to be the same value type
 827   EVT CompareVT = LHS.getValueType();
 828
 829   // Check if we can lower this to a native operation.
 830
 831   // Try to lower to a SET* instruction:
 832   //
 833   // SET* can match the following patterns:
 834   //
 835   // select_cc f32, f32, -1,  0, cc_any
 836   // select_cc f32, f32, 1.0f, 0.0f, cc_any
 837   // select_cc i32, i32, -1,  0, cc_any
 838   //
 839
 840   // Move hardware True/False values to the correct operand.
 841   if (isHWTrueValue(False) && isHWFalseValue(True)) {
 842     ISD::CondCode CCOpcode = cast<CondCodeSDNode>(CC)->get();
 843     std::swap(False, True);
 844     CC = DAG.getCondCode(ISD::getSetCCInverse(CCOpcode, CompareVT == MVT::i32));
 845   }
 846
 847   if (isHWTrueValue(True) && isHWFalseValue(False) &&
 848       (CompareVT == VT || VT == MVT::i32)) {
 849     // This can be matched by a SET* instruction.
 850     return DAG.getNode(ISD::SELECT_CC, DL, VT, LHS, RHS, True, False, CC);
 851   }
 852
 853   // Try to lower to a CND* instruction:
 854   //
 855   // CND* can match the following patterns:
 856   //
 857   // select_cc f32, 0.0, f32, f32, cc_any
 858   // select_cc f32, 0.0, i32, i32, cc_any
 859   // select_cc i32, 0,   f32, f32, cc_any
 860   // select_cc i32, 0,   i32, i32, cc_any
 861   //
 862   if (isZero(LHS) || isZero(RHS)) {
 863     SDValue Cond = (isZero(LHS) ? RHS : LHS);
 864     SDValue Zero = (isZero(LHS) ? LHS : RHS);
 865     ISD::CondCode CCOpcode = cast<CondCodeSDNode>(CC)->get();
 866     if (CompareVT != VT) {
 867       // Bitcast True / False to the correct types.  This will end up being
 868       // a nop, but it allows us to define only a single pattern in the
 869       // .TD files for each CND* instruction rather than having to have
 870       // one pattern for integer True/False and one for fp True/False
 871       True = DAG.getNode(ISD::BITCAST, DL, CompareVT, True);
 872       False = DAG.getNode(ISD::BITCAST, DL, CompareVT, False);
 873     }
 874     if (isZero(LHS)) {
 875       CCOpcode = ISD::getSetCCSwappedOperands(CCOpcode);
 876     }
 877
 878     switch (CCOpcode) {
 879     case ISD::SETONE:
 880     case ISD::SETUNE:
 881     case ISD::SETNE:
 882     case ISD::SETULE:
 883     case ISD::SETULT:
 884     case ISD::SETOLE:
 885     case ISD::SETOLT:
 886     case ISD::SETLE:
 887     case ISD::SETLT:
 888       CCOpcode = ISD::getSetCCInverse(CCOpcode, CompareVT == MVT::i32);
 889       Temp = True;
 890       True = False;
 891       False = Temp;
 892       break;
 893     default:
 894       break;
 895     }
 896     SDValue SelectNode = DAG.getNode(ISD::SELECT_CC, DL, CompareVT,
 897         Cond, Zero,
 898         True, False,
 899         DAG.getCondCode(CCOpcode));
 900     return DAG.getNode(ISD::BITCAST, DL, VT, SelectNode);
 901   }
 902
 903
 904   // Possible Min/Max pattern
 905   SDValue MinMax = LowerMinMax(Op, DAG);
 906   if (MinMax.getNode()) {
 907     return MinMax;
 908   }
 909
 910   // If we make it this for it means we have no native instructions to handle
 911   // this SELECT_CC, so we must lower it.
 912   SDValue HWTrue, HWFalse;
 913
 914   if (CompareVT == MVT::f32) {
 915     HWTrue = DAG.getConstantFP(1.0f, CompareVT);
 916     HWFalse = DAG.getConstantFP(0.0f, CompareVT);
 917   } else if (CompareVT == MVT::i32) {
 918     HWTrue = DAG.getConstant(-1, CompareVT);
 919     HWFalse = DAG.getConstant(0, CompareVT);
 920   }
 921   else {
 922     assert(!"Unhandled value type in LowerSELECT_CC");
 923   }
 924
 925   // Lower this unsupported SELECT_CC into a combination of two supported
 926   // SELECT_CC operations.
 927   SDValue Cond = DAG.getNode(ISD::SELECT_CC, DL, CompareVT, LHS, RHS, HWTrue, HWFalse, CC);
 928
 929   return DAG.getNode(ISD::SELECT_CC, DL, VT,
 930       Cond, HWFalse,
 931       True, False,
 932       DAG.getCondCode(ISD::SETNE));
 933 }
 934
 935 SDValue R600TargetLowering::LowerSELECT(SDValue Op, SelectionDAG &DAG) const {
 936   return DAG.getNode(ISD::SELECT_CC,
 937       SDLoc(Op),
 938       Op.getValueType(),
 939       Op.getOperand(0),
 940       DAG.getConstant(0, MVT::i32),
 941       Op.getOperand(1),
 942       Op.getOperand(2),
 943       DAG.getCondCode(ISD::SETNE));
 944 }
 945
 946 /// LLVM generates byte-addresed pointers.  For indirect addressing, we need to
 947 /// convert these pointers to a register index.  Each register holds
 948 /// 16 bytes, (4 x 32bit sub-register), but we need to take into account the
 949 /// \p StackWidth, which tells us how many of the 4 sub-registrers will be used
 950 /// for indirect addressing.
 951 SDValue R600TargetLowering::stackPtrToRegIndex(SDValue Ptr,
 952                                                unsigned StackWidth,
 953                                                SelectionDAG &DAG) const {
 954   unsigned SRLPad;
 955   switch(StackWidth) {
 956   case 1:
 957     SRLPad = 2;
 958     break;
 959   case 2:
 960     SRLPad = 3;
 961     break;
 962   case 4:
 963     SRLPad = 4;
 964     break;
 965   default: llvm_unreachable("Invalid stack width");
 966   }
 967
 968   return DAG.getNode(ISD::SRL, SDLoc(Ptr), Ptr.getValueType(), Ptr,
 969                      DAG.getConstant(SRLPad, MVT::i32));
 970 }
 971
 972 void R600TargetLowering::getStackAddress(unsigned StackWidth,
 973                                          unsigned ElemIdx,
 974                                          unsigned &Channel,
 975                                          unsigned &PtrIncr) const {
 976   switch (StackWidth) {
 977   default:
 978   case 1:
 979     Channel = 0;
 980     if (ElemIdx > 0) {
 981       PtrIncr = 1;
 982     } else {
 983       PtrIncr = 0;
 984     }
 985     break;
 986   case 2:
 987     Channel = ElemIdx % 2;
 988     if (ElemIdx == 2) {
 989       PtrIncr = 1;
 990     } else {
 991       PtrIncr = 0;
 992     }
 993     break;
 994   case 4:
 995     Channel = ElemIdx;
 996     PtrIncr = 0;
 997     break;
 998   }
 999 }
1000
1001 SDValue R600TargetLowering::LowerSTORE(SDValue Op, SelectionDAG &DAG) const {
1002   SDLoc DL(Op);
1003   StoreSDNode *StoreNode = cast<StoreSDNode>(Op);
1004   SDValue Chain = Op.getOperand(0);
1005   SDValue Value = Op.getOperand(1);
1006   SDValue Ptr = Op.getOperand(2);
1007
1008   if (StoreNode->getAddressSpace() == AMDGPUAS::GLOBAL_ADDRESS &&
1009       Ptr->getOpcode() != AMDGPUISD::DWORDADDR) {
1010     // Convert pointer from byte address to dword address.
1011     Ptr = DAG.getNode(AMDGPUISD::DWORDADDR, DL, Ptr.getValueType(),
1012                       DAG.getNode(ISD::SRL, DL, Ptr.getValueType(),
1013                                   Ptr, DAG.getConstant(2, MVT::i32)));
1014
1015     if (StoreNode->isTruncatingStore() || StoreNode->isIndexed()) {
1016       assert(!"Truncated and indexed stores not supported yet");
1017     } else {
1018       Chain = DAG.getStore(Chain, DL, Value, Ptr, StoreNode->getMemOperand());
1019     }
1020     return Chain;
1021   }
1022
1023   EVT ValueVT = Value.getValueType();
1024
1025   if (StoreNode->getAddressSpace() != AMDGPUAS::PRIVATE_ADDRESS) {
1026     return SDValue();
1027   }
1028
1029   // Lowering for indirect addressing
1030
1031   const MachineFunction &MF = DAG.getMachineFunction();
1032   const AMDGPUFrameLowering *TFL = static_cast<const AMDGPUFrameLowering*>(
1033                                          getTargetMachine().getFrameLowering());
1034   unsigned StackWidth = TFL->getStackWidth(MF);
1035
1036   Ptr = stackPtrToRegIndex(Ptr, StackWidth, DAG);
1037
1038   if (ValueVT.isVector()) {
1039     unsigned NumElemVT = ValueVT.getVectorNumElements();
1040     EVT ElemVT = ValueVT.getVectorElementType();
1041     SDValue Stores[4];
1042
1043     assert(NumElemVT >= StackWidth && "Stack width cannot be greater than "
1044                                       "vector width in load");
1045
1046     for (unsigned i = 0; i < NumElemVT; ++i) {
1047       unsigned Channel, PtrIncr;
1048       getStackAddress(StackWidth, i, Channel, PtrIncr);
1049       Ptr = DAG.getNode(ISD::ADD, DL, MVT::i32, Ptr,
1050                         DAG.getConstant(PtrIncr, MVT::i32));
1051       SDValue Elem = DAG.getNode(ISD::EXTRACT_VECTOR_ELT, DL, ElemVT,
1052                                  Value, DAG.getConstant(i, MVT::i32));
1053
1054       Stores[i] = DAG.getNode(AMDGPUISD::REGISTER_STORE, DL, MVT::Other,
1055                               Chain, Elem, Ptr,
1056                               DAG.getTargetConstant(Channel, MVT::i32));
1057     }
1058      Chain =  DAG.getNode(ISD::TokenFactor, DL, MVT::Other, Stores, NumElemVT);
1059    } else {
1060     if (ValueVT == MVT::i8) {
1061       Value = DAG.getNode(ISD::ZERO_EXTEND, DL, MVT::i32, Value);
1062     }
1063     Chain = DAG.getNode(AMDGPUISD::REGISTER_STORE, DL, MVT::Other, Chain, Value, Ptr,
1064     DAG.getTargetConstant(0, MVT::i32)); // Channel
1065   }
1066
1067   return Chain;
1068 }
1069
1070 // return (512 + (kc_bank << 12)
1071 static int
1072 ConstantAddressBlock(unsigned AddressSpace) {
1073   switch (AddressSpace) {
1074   case AMDGPUAS::CONSTANT_BUFFER_0:
1075     return 512;
1076   case AMDGPUAS::CONSTANT_BUFFER_1:
1077     return 512 + 4096;
1078   case AMDGPUAS::CONSTANT_BUFFER_2:
1079     return 512 + 4096 * 2;
1080   case AMDGPUAS::CONSTANT_BUFFER_3:
1081     return 512 + 4096 * 3;
1082   case AMDGPUAS::CONSTANT_BUFFER_4:
1083     return 512 + 4096 * 4;
1084   case AMDGPUAS::CONSTANT_BUFFER_5:
1085     return 512 + 4096 * 5;
1086   case AMDGPUAS::CONSTANT_BUFFER_6:
1087     return 512 + 4096 * 6;
1088   case AMDGPUAS::CONSTANT_BUFFER_7:
1089     return 512 + 4096 * 7;
1090   case AMDGPUAS::CONSTANT_BUFFER_8:
1091     return 512 + 4096 * 8;
1092   case AMDGPUAS::CONSTANT_BUFFER_9:
1093     return 512 + 4096 * 9;
1094   case AMDGPUAS::CONSTANT_BUFFER_10:
1095     return 512 + 4096 * 10;
1096   case AMDGPUAS::CONSTANT_BUFFER_11:
1097     return 512 + 4096 * 11;
1098   case AMDGPUAS::CONSTANT_BUFFER_12:
1099     return 512 + 4096 * 12;
1100   case AMDGPUAS::CONSTANT_BUFFER_13:
1101     return 512 + 4096 * 13;
1102   case AMDGPUAS::CONSTANT_BUFFER_14:
1103     return 512 + 4096 * 14;
1104   case AMDGPUAS::CONSTANT_BUFFER_15:
1105     return 512 + 4096 * 15;
1106   default:
1107     return -1;
1108   }
1109 }
1110
1111 SDValue R600TargetLowering::LowerLOAD(SDValue Op, SelectionDAG &DAG) const
1112 {
1113   EVT VT = Op.getValueType();
1114   SDLoc DL(Op);
1115   LoadSDNode *LoadNode = cast<LoadSDNode>(Op);
1116   SDValue Chain = Op.getOperand(0);
1117   SDValue Ptr = Op.getOperand(1);
1118   SDValue LoweredLoad;
1119
1120   int ConstantBlock = ConstantAddressBlock(LoadNode->getAddressSpace());
1121   if (ConstantBlock > -1) {
1122     SDValue Result;
1123     if (dyn_cast<ConstantExpr>(LoadNode->getSrcValue()) ||
1124         dyn_cast<Constant>(LoadNode->getSrcValue()) ||
1125         dyn_cast<ConstantSDNode>(Ptr)) {
1126       SDValue Slots[4];
1127       for (unsigned i = 0; i < 4; i++) {
1128         // We want Const position encoded with the following formula :
1129         // (((512 + (kc_bank << 12) + const_index) << 2) + chan)
1130         // const_index is Ptr computed by llvm using an alignment of 16.
1131         // Thus we add (((512 + (kc_bank << 12)) + chan ) * 4 here and
1132         // then div by 4 at the ISel step
1133         SDValue NewPtr = DAG.getNode(ISD::ADD, DL, Ptr.getValueType(), Ptr,
1134             DAG.getConstant(4 * i + ConstantBlock * 16, MVT::i32));
1135         Slots[i] = DAG.getNode(AMDGPUISD::CONST_ADDRESS, DL, MVT::i32, NewPtr);
1136       }
1137       Result = DAG.getNode(ISD::BUILD_VECTOR, DL, MVT::v4i32, Slots, 4);
1138     } else {
1139       // non constant ptr cant be folded, keeps it as a v4f32 load
1140       Result = DAG.getNode(AMDGPUISD::CONST_ADDRESS, DL, MVT::v4i32,
1141           DAG.getNode(ISD::SRL, DL, MVT::i32, Ptr, DAG.getConstant(4, MVT::i32)),
1142           DAG.getConstant(LoadNode->getAddressSpace() -
1143                           AMDGPUAS::CONSTANT_BUFFER_0, MVT::i32)
1144           );
1145     }
1146
1147     if (!VT.isVector()) {
1148       Result = DAG.getNode(ISD::EXTRACT_VECTOR_ELT, DL, MVT::i32, Result,
1149           DAG.getConstant(0, MVT::i32));
1150     }
1151
1152     SDValue MergedValues[2] = {
1153         Result,
1154         Chain
1155     };
1156     return DAG.getMergeValues(MergedValues, 2, DL);
1157   }
1158
1159   if (LoadNode->getAddressSpace() != AMDGPUAS::PRIVATE_ADDRESS) {
1160     return SDValue();
1161   }
1162
1163   // Lowering for indirect addressing
1164   const MachineFunction &MF = DAG.getMachineFunction();
1165   const AMDGPUFrameLowering *TFL = static_cast<const AMDGPUFrameLowering*>(
1166                                          getTargetMachine().getFrameLowering());
1167   unsigned StackWidth = TFL->getStackWidth(MF);
1168
1169   Ptr = stackPtrToRegIndex(Ptr, StackWidth, DAG);
1170
1171   if (VT.isVector()) {
1172     unsigned NumElemVT = VT.getVectorNumElements();
1173     EVT ElemVT = VT.getVectorElementType();
1174     SDValue Loads[4];
1175
1176     assert(NumElemVT >= StackWidth && "Stack width cannot be greater than "
1177                                       "vector width in load");
1178
1179     for (unsigned i = 0; i < NumElemVT; ++i) {
1180       unsigned Channel, PtrIncr;
1181       getStackAddress(StackWidth, i, Channel, PtrIncr);
1182       Ptr = DAG.getNode(ISD::ADD, DL, MVT::i32, Ptr,
1183                         DAG.getConstant(PtrIncr, MVT::i32));
1184       Loads[i] = DAG.getNode(AMDGPUISD::REGISTER_LOAD, DL, ElemVT,
1185                              Chain, Ptr,
1186                              DAG.getTargetConstant(Channel, MVT::i32),
1187                              Op.getOperand(2));
1188     }
1189     for (unsigned i = NumElemVT; i < 4; ++i) {
1190       Loads[i] = DAG.getUNDEF(ElemVT);
1191     }
1192     EVT TargetVT = EVT::getVectorVT(*DAG.getContext(), ElemVT, 4);
1193     LoweredLoad = DAG.getNode(ISD::BUILD_VECTOR, DL, TargetVT, Loads, 4);
1194   } else {
1195     LoweredLoad = DAG.getNode(AMDGPUISD::REGISTER_LOAD, DL, VT,
1196                               Chain, Ptr,
1197                               DAG.getTargetConstant(0, MVT::i32), // Channel
1198                               Op.getOperand(2));
1199   }
1200
1201   SDValue Ops[2];
1202   Ops[0] = LoweredLoad;
1203   Ops[1] = Chain;
1204
1205   return DAG.getMergeValues(Ops, 2, DL);
1206 }
1207
1208 /// XXX Only kernel functions are supported, so we can assume for now that
1209 /// every function is a kernel function, but in the future we should use
1210 /// separate calling conventions for kernel and non-kernel functions.
1211 SDValue R600TargetLowering::LowerFormalArguments(
1212                                       SDValue Chain,
1213                                       CallingConv::ID CallConv,
1214                                       bool isVarArg,
1215                                       const SmallVectorImpl<ISD::InputArg> &Ins,
1216                                       SDLoc DL, SelectionDAG &DAG,
1217                                       SmallVectorImpl<SDValue> &InVals) const {
1218   unsigned ParamOffsetBytes = 36;
1219   Function::const_arg_iterator FuncArg =
1220                             DAG.getMachineFunction().getFunction()->arg_begin();
1221   for (unsigned i = 0, e = Ins.size(); i < e; ++i, ++FuncArg) {
1222     EVT VT = Ins[i].VT;
1223     Type *ArgType = FuncArg->getType();
1224     unsigned ArgSizeInBits = ArgType->isPointerTy() ?
1225                              32 : ArgType->getPrimitiveSizeInBits();
1226     unsigned ArgBytes = ArgSizeInBits >> 3;
1227     EVT ArgVT;
1228     if (ArgSizeInBits < VT.getSizeInBits()) {
1229       assert(!ArgType->isFloatTy() &&
1230              "Extending floating point arguments not supported yet");
1231       ArgVT = MVT::getIntegerVT(ArgSizeInBits);
1232     } else {
1233       ArgVT = VT;
1234     }
1235     PointerType *PtrTy = PointerType::get(VT.getTypeForEVT(*DAG.getContext()),
1236                                                     AMDGPUAS::PARAM_I_ADDRESS);
1237     SDValue Arg = DAG.getExtLoad(ISD::ZEXTLOAD, DL, VT, DAG.getRoot(),
1238                                 DAG.getConstant(ParamOffsetBytes, MVT::i32),
1239                                        MachinePointerInfo(UndefValue::get(PtrTy)),
1240                                        ArgVT, false, false, ArgBytes);
1241     InVals.push_back(Arg);
1242     ParamOffsetBytes += ArgBytes;
1243   }
1244   return Chain;
1245 }
1246
1247 EVT R600TargetLowering::getSetCCResultType(LLVMContext &, EVT VT) const {
1248    if (!VT.isVector()) return MVT::i32;
1249    return VT.changeVectorElementTypeToInteger();
1250 }
1251
1252 static SDValue
1253 CompactSwizzlableVector(SelectionDAG &DAG, SDValue VectorEntry,
1254                         DenseMap<unsigned, unsigned> &RemapSwizzle) {
1255   assert(VectorEntry.getOpcode() == ISD::BUILD_VECTOR);
1256   assert(RemapSwizzle.empty());
1257   SDValue NewBldVec[4] = {
1258       VectorEntry.getOperand(0),
1259       VectorEntry.getOperand(1),
1260       VectorEntry.getOperand(2),
1261       VectorEntry.getOperand(3)
1262   };
1263
1264   for (unsigned i = 0; i < 4; i++) {
1265     if (ConstantFPSDNode *C = dyn_cast<ConstantFPSDNode>(NewBldVec[i])) {
1266       if (C->isZero()) {
1267         RemapSwizzle[i] = 4; // SEL_0
1268         NewBldVec[i] = DAG.getUNDEF(MVT::f32);
1269       } else if (C->isExactlyValue(1.0)) {
1270         RemapSwizzle[i] = 5; // SEL_1
1271         NewBldVec[i] = DAG.getUNDEF(MVT::f32);
1272       }
1273     }
1274
1275     if (NewBldVec[i].getOpcode() == ISD::UNDEF)
1276       continue;
1277     for (unsigned j = 0; j < i; j++) {
1278       if (NewBldVec[i] == NewBldVec[j]) {
1279         NewBldVec[i] = DAG.getUNDEF(NewBldVec[i].getValueType());
1280         RemapSwizzle[i] = j;
1281         break;
1282       }
1283     }
1284   }
1285
1286   return DAG.getNode(ISD::BUILD_VECTOR, SDLoc(VectorEntry),
1287       VectorEntry.getValueType(), NewBldVec, 4);
1288 }
1289
1290 static SDValue ReorganizeVector(SelectionDAG &DAG, SDValue VectorEntry,
1291                                 DenseMap<unsigned, unsigned> &RemapSwizzle) {
1292   assert(VectorEntry.getOpcode() == ISD::BUILD_VECTOR);
1293   assert(RemapSwizzle.empty());
1294   SDValue NewBldVec[4] = {
1295       VectorEntry.getOperand(0),
1296       VectorEntry.getOperand(1),
1297       VectorEntry.getOperand(2),
1298       VectorEntry.getOperand(3)
1299   };
1300   bool isUnmovable[4] = { false, false, false, false };
1301   for (unsigned i = 0; i < 4; i++)
1302     RemapSwizzle[i] = i;
1303
1304   for (unsigned i = 0; i < 4; i++) {
1305     if (NewBldVec[i].getOpcode() == ISD::EXTRACT_VECTOR_ELT) {
1306       unsigned Idx = dyn_cast<ConstantSDNode>(NewBldVec[i].getOperand(1))
1307           ->getZExtValue();
1308       if (!isUnmovable[Idx]) {
1309         // Swap i and Idx
1310         std::swap(NewBldVec[Idx], NewBldVec[i]);
1311         std::swap(RemapSwizzle[RemapSwizzle[Idx]], RemapSwizzle[RemapSwizzle[i]]);
1312       }
1313       isUnmovable[Idx] = true;
1314     }
1315   }
1316
1317   return DAG.getNode(ISD::BUILD_VECTOR, SDLoc(VectorEntry),
1318       VectorEntry.getValueType(), NewBldVec, 4);
1319 }
1320
1321
1322 SDValue R600TargetLowering::OptimizeSwizzle(SDValue BuildVector,
1323 SDValue Swz[4], SelectionDAG &DAG) const {
1324   assert(BuildVector.getOpcode() == ISD::BUILD_VECTOR);
1325   // Old -> New swizzle values
1326   DenseMap<unsigned, unsigned> SwizzleRemap;
1327
1328   BuildVector = CompactSwizzlableVector(DAG, BuildVector, SwizzleRemap);
1329   for (unsigned i = 0; i < 4; i++) {
1330     unsigned Idx = dyn_cast<ConstantSDNode>(Swz[i])->getZExtValue();
1331     if (SwizzleRemap.find(Idx) != SwizzleRemap.end())
1332       Swz[i] = DAG.getConstant(SwizzleRemap[Idx], MVT::i32);
1333   }
1334
1335   SwizzleRemap.clear();
1336   BuildVector = ReorganizeVector(DAG, BuildVector, SwizzleRemap);
1337   for (unsigned i = 0; i < 4; i++) {
1338     unsigned Idx = dyn_cast<ConstantSDNode>(Swz[i])->getZExtValue();
1339     if (SwizzleRemap.find(Idx) != SwizzleRemap.end())
1340       Swz[i] = DAG.getConstant(SwizzleRemap[Idx], MVT::i32);
1341   }
1342
1343   return BuildVector;
1344 }
1345
1346
1347 //===----------------------------------------------------------------------===//
1348 // Custom DAG Optimizations
1349 //===----------------------------------------------------------------------===//
1350
1351 SDValue R600TargetLowering::PerformDAGCombine(SDNode *N,
1352                                               DAGCombinerInfo &DCI) const {
1353   SelectionDAG &DAG = DCI.DAG;
1354
1355   switch (N->getOpcode()) {
1356   // (f32 fp_round (f64 uint_to_fp a)) -> (f32 uint_to_fp a)
1357   case ISD::FP_ROUND: {
1358       SDValue Arg = N->getOperand(0);
1359       if (Arg.getOpcode() == ISD::UINT_TO_FP && Arg.getValueType() == MVT::f64) {
1360         return DAG.getNode(ISD::UINT_TO_FP, SDLoc(N), N->getValueType(0),
1361                            Arg.getOperand(0));
1362       }
1363       break;
1364     }
1365
1366   // (i32 fp_to_sint (fneg (select_cc f32, f32, 1.0, 0.0 cc))) ->
1367   // (i32 select_cc f32, f32, -1, 0 cc)
1368   //
1369   // Mesa's GLSL frontend generates the above pattern a lot and we can lower
1370   // this to one of the SET*_DX10 instructions.
1371   case ISD::FP_TO_SINT: {
1372     SDValue FNeg = N->getOperand(0);
1373     if (FNeg.getOpcode() != ISD::FNEG) {
1374       return SDValue();
1375     }
1376     SDValue SelectCC = FNeg.getOperand(0);
1377     if (SelectCC.getOpcode() != ISD::SELECT_CC ||
1378         SelectCC.getOperand(0).getValueType() != MVT::f32 || // LHS
1379         SelectCC.getOperand(2).getValueType() != MVT::f32 || // True
1380         !isHWTrueValue(SelectCC.getOperand(2)) ||
1381         !isHWFalseValue(SelectCC.getOperand(3))) {
1382       return SDValue();
1383     }
1384
1385     return DAG.getNode(ISD::SELECT_CC, SDLoc(N), N->getValueType(0),
1386                            SelectCC.getOperand(0), // LHS
1387                            SelectCC.getOperand(1), // RHS
1388                            DAG.getConstant(-1, MVT::i32), // True
1389                            DAG.getConstant(0, MVT::i32),  // Flase
1390                            SelectCC.getOperand(4)); // CC
1391
1392     break;
1393   }
1394   // Extract_vec (Build_vector) generated by custom lowering
1395   // also needs to be customly combined
1396   case ISD::EXTRACT_VECTOR_ELT: {
1397     SDValue Arg = N->getOperand(0);
1398     if (Arg.getOpcode() == ISD::BUILD_VECTOR) {
1399       if (ConstantSDNode *Const = dyn_cast<ConstantSDNode>(N->getOperand(1))) {
1400         unsigned Element = Const->getZExtValue();
1401         return Arg->getOperand(Element);
1402       }
1403     }
1404     if (Arg.getOpcode() == ISD::BITCAST &&
1405         Arg.getOperand(0).getOpcode() == ISD::BUILD_VECTOR) {
1406       if (ConstantSDNode *Const = dyn_cast<ConstantSDNode>(N->getOperand(1))) {
1407         unsigned Element = Const->getZExtValue();
1408         return DAG.getNode(ISD::BITCAST, SDLoc(N), N->getVTList(),
1409             Arg->getOperand(0).getOperand(Element));
1410       }
1411     }
1412   }
1413
1414   case ISD::SELECT_CC: {
1415     // fold selectcc (selectcc x, y, a, b, cc), b, a, b, seteq ->
1416     //      selectcc x, y, a, b, inv(cc)
1417     //
1418     // fold selectcc (selectcc x, y, a, b, cc), b, a, b, setne ->
1419     //      selectcc x, y, a, b, cc
1420     SDValue LHS = N->getOperand(0);
1421     if (LHS.getOpcode() != ISD::SELECT_CC) {
1422       return SDValue();
1423     }
1424
1425     SDValue RHS = N->getOperand(1);
1426     SDValue True = N->getOperand(2);
1427     SDValue False = N->getOperand(3);
1428     ISD::CondCode NCC = cast<CondCodeSDNode>(N->getOperand(4))->get();
1429
1430     if (LHS.getOperand(2).getNode() != True.getNode() ||
1431         LHS.getOperand(3).getNode() != False.getNode() ||
1432         RHS.getNode() != False.getNode()) {
1433       return SDValue();
1434     }
1435
1436     switch (NCC) {
1437     default: return SDValue();
1438     case ISD::SETNE: return LHS;
1439     case ISD::SETEQ: {
1440       ISD::CondCode LHSCC = cast<CondCodeSDNode>(LHS.getOperand(4))->get();
1441       LHSCC = ISD::getSetCCInverse(LHSCC,
1442                                   LHS.getOperand(0).getValueType().isInteger());
1443       return DAG.getSelectCC(SDLoc(N),
1444                              LHS.getOperand(0),
1445                              LHS.getOperand(1),
1446                              LHS.getOperand(2),
1447                              LHS.getOperand(3),
1448                              LHSCC);
1449     }
1450     }
1451   }
1452   case AMDGPUISD::EXPORT: {
1453     SDValue Arg = N->getOperand(1);
1454     if (Arg.getOpcode() != ISD::BUILD_VECTOR)
1455       break;
1456
1457     SDValue NewArgs[8] = {
1458       N->getOperand(0), // Chain
1459       SDValue(),
1460       N->getOperand(2), // ArrayBase
1461       N->getOperand(3), // Type
1462       N->getOperand(4), // SWZ_X
1463       N->getOperand(5), // SWZ_Y
1464       N->getOperand(6), // SWZ_Z
1465       N->getOperand(7) // SWZ_W
1466     };
1467     SDLoc DL(N);
1468     NewArgs[1] = OptimizeSwizzle(N->getOperand(1), &NewArgs[4], DAG);
1469     return DAG.getNode(AMDGPUISD::EXPORT, DL, N->getVTList(), NewArgs, 8);
1470   }
1471   case AMDGPUISD::TEXTURE_FETCH: {
1472     SDValue Arg = N->getOperand(1);
1473     if (Arg.getOpcode() != ISD::BUILD_VECTOR)
1474       break;
1475
1476     SDValue NewArgs[19] = {
1477       N->getOperand(0),
1478       N->getOperand(1),
1479       N->getOperand(2),
1480       N->getOperand(3),
1481       N->getOperand(4),
1482       N->getOperand(5),
1483       N->getOperand(6),
1484       N->getOperand(7),
1485       N->getOperand(8),
1486       N->getOperand(9),
1487       N->getOperand(10),
1488       N->getOperand(11),
1489       N->getOperand(12),
1490       N->getOperand(13),
1491       N->getOperand(14),
1492       N->getOperand(15),
1493       N->getOperand(16),
1494       N->getOperand(17),
1495       N->getOperand(18),
1496     };
1497     NewArgs[1] = OptimizeSwizzle(N->getOperand(1), &NewArgs[2], DAG);
1498     return DAG.getNode(AMDGPUISD::TEXTURE_FETCH, SDLoc(N), N->getVTList(),
1499         NewArgs, 19);
1500   }
1501   }
1502   return SDValue();
1503 }