lib/Target/R600/R600InstrInfo.cpp

   1 //===-- R600InstrInfo.cpp - R600 Instruction Information ------------------===//
   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 R600 Implementation of TargetInstrInfo.
  12 //
  13 //===----------------------------------------------------------------------===//
  14
  15 #include "R600InstrInfo.h"
  16 #include "AMDGPUSubtarget.h"
  17 #include "AMDGPUTargetMachine.h"
  18 #include "R600Defines.h"
  19 #include "R600MachineFunctionInfo.h"
  20 #include "R600RegisterInfo.h"
  21 #include "llvm/CodeGen/MachineInstrBuilder.h"
  22 #include "llvm/CodeGen/MachineFrameInfo.h"
  23 #include "llvm/CodeGen/MachineRegisterInfo.h"
  24
  25 #define GET_INSTRINFO_CTOR
  26 #include "AMDGPUGenDFAPacketizer.inc"
  27
  28 using namespace llvm;
  29
  30 R600InstrInfo::R600InstrInfo(AMDGPUTargetMachine &tm)
  31   : AMDGPUInstrInfo(tm),
  32     RI(tm, *this)
  33   { }
  34
  35 const R600RegisterInfo &R600InstrInfo::getRegisterInfo() const {
  36   return RI;
  37 }
  38
  39 bool R600InstrInfo::isTrig(const MachineInstr &MI) const {
  40   return get(MI.getOpcode()).TSFlags & R600_InstFlag::TRIG;
  41 }
  42
  43 bool R600InstrInfo::isVector(const MachineInstr &MI) const {
  44   return get(MI.getOpcode()).TSFlags & R600_InstFlag::VECTOR;
  45 }
  46
  47 void
  48 R600InstrInfo::copyPhysReg(MachineBasicBlock &MBB,
  49                            MachineBasicBlock::iterator MI, DebugLoc DL,
  50                            unsigned DestReg, unsigned SrcReg,
  51                            bool KillSrc) const {
  52   if (AMDGPU::R600_Reg128RegClass.contains(DestReg)
  53       && AMDGPU::R600_Reg128RegClass.contains(SrcReg)) {
  54     for (unsigned I = 0; I < 4; I++) {
  55       unsigned SubRegIndex = RI.getSubRegFromChannel(I);
  56       buildDefaultInstruction(MBB, MI, AMDGPU::MOV,
  57                               RI.getSubReg(DestReg, SubRegIndex),
  58                               RI.getSubReg(SrcReg, SubRegIndex))
  59                               .addReg(DestReg,
  60                                       RegState::Define | RegState::Implicit);
  61     }
  62   } else {
  63
  64     // We can't copy vec4 registers
  65     assert(!AMDGPU::R600_Reg128RegClass.contains(DestReg)
  66            && !AMDGPU::R600_Reg128RegClass.contains(SrcReg));
  67
  68     MachineInstr *NewMI = buildDefaultInstruction(MBB, MI, AMDGPU::MOV,
  69                                                   DestReg, SrcReg);
  70     NewMI->getOperand(getOperandIdx(*NewMI, R600Operands::SRC0))
  71                                     .setIsKill(KillSrc);
  72   }
  73 }
  74
  75 MachineInstr * R600InstrInfo::getMovImmInstr(MachineFunction *MF,
  76                                              unsigned DstReg, int64_t Imm) const {
  77   MachineInstr * MI = MF->CreateMachineInstr(get(AMDGPU::MOV), DebugLoc());
  78   MachineInstrBuilder MIB(*MF, MI);
  79   MIB.addReg(DstReg, RegState::Define);
  80   MIB.addReg(AMDGPU::ALU_LITERAL_X);
  81   MIB.addImm(Imm);
  82   MIB.addReg(0); // PREDICATE_BIT
  83
  84   return MI;
  85 }
  86
  87 unsigned R600InstrInfo::getIEQOpcode() const {
  88   return AMDGPU::SETE_INT;
  89 }
  90
  91 bool R600InstrInfo::isMov(unsigned Opcode) const {
  92
  93
  94   switch(Opcode) {
  95   default: return false;
  96   case AMDGPU::MOV:
  97   case AMDGPU::MOV_IMM_F32:
  98   case AMDGPU::MOV_IMM_I32:
  99     return true;
 100   }
 101 }
 102
 103 // Some instructions act as place holders to emulate operations that the GPU
 104 // hardware does automatically. This function can be used to check if
 105 // an opcode falls into this category.
 106 bool R600InstrInfo::isPlaceHolderOpcode(unsigned Opcode) const {
 107   switch (Opcode) {
 108   default: return false;
 109   case AMDGPU::RETURN:
 110     return true;
 111   }
 112 }
 113
 114 bool R600InstrInfo::isReductionOp(unsigned Opcode) const {
 115   switch(Opcode) {
 116     default: return false;
 117     case AMDGPU::DOT4_r600_pseudo:
 118     case AMDGPU::DOT4_eg_pseudo:
 119       return true;
 120   }
 121 }
 122
 123 bool R600InstrInfo::isCubeOp(unsigned Opcode) const {
 124   switch(Opcode) {
 125     default: return false;
 126     case AMDGPU::CUBE_r600_pseudo:
 127     case AMDGPU::CUBE_r600_real:
 128     case AMDGPU::CUBE_eg_pseudo:
 129     case AMDGPU::CUBE_eg_real:
 130       return true;
 131   }
 132 }
 133
 134 bool R600InstrInfo::isALUInstr(unsigned Opcode) const {
 135   unsigned TargetFlags = get(Opcode).TSFlags;
 136
 137   return ((TargetFlags & R600_InstFlag::OP1) |
 138           (TargetFlags & R600_InstFlag::OP2) |
 139           (TargetFlags & R600_InstFlag::OP3));
 140 }
 141
 142 DFAPacketizer *R600InstrInfo::CreateTargetScheduleState(const TargetMachine *TM,
 143     const ScheduleDAG *DAG) const {
 144   const InstrItineraryData *II = TM->getInstrItineraryData();
 145   return TM->getSubtarget<AMDGPUSubtarget>().createDFAPacketizer(II);
 146 }
 147
 148 static bool
 149 isPredicateSetter(unsigned Opcode) {
 150   switch (Opcode) {
 151   case AMDGPU::PRED_X:
 152     return true;
 153   default:
 154     return false;
 155   }
 156 }
 157
 158 static MachineInstr *
 159 findFirstPredicateSetterFrom(MachineBasicBlock &MBB,
 160                              MachineBasicBlock::iterator I) {
 161   while (I != MBB.begin()) {
 162     --I;
 163     MachineInstr *MI = I;
 164     if (isPredicateSetter(MI->getOpcode()))
 165       return MI;
 166   }
 167
 168   return NULL;
 169 }
 170
 171 bool
 172 R600InstrInfo::AnalyzeBranch(MachineBasicBlock &MBB,
 173                              MachineBasicBlock *&TBB,
 174                              MachineBasicBlock *&FBB,
 175                              SmallVectorImpl<MachineOperand> &Cond,
 176                              bool AllowModify) const {
 177   // Most of the following comes from the ARM implementation of AnalyzeBranch
 178
 179   // If the block has no terminators, it just falls into the block after it.
 180   MachineBasicBlock::iterator I = MBB.end();
 181   if (I == MBB.begin())
 182     return false;
 183   --I;
 184   while (I->isDebugValue()) {
 185     if (I == MBB.begin())
 186       return false;
 187     --I;
 188   }
 189   if (static_cast<MachineInstr *>(I)->getOpcode() != AMDGPU::JUMP) {
 190     return false;
 191   }
 192
 193   // Get the last instruction in the block.
 194   MachineInstr *LastInst = I;
 195
 196   // If there is only one terminator instruction, process it.
 197   unsigned LastOpc = LastInst->getOpcode();
 198   if (I == MBB.begin() ||
 199       static_cast<MachineInstr *>(--I)->getOpcode() != AMDGPU::JUMP) {
 200     if (LastOpc == AMDGPU::JUMP) {
 201       if(!isPredicated(LastInst)) {
 202         TBB = LastInst->getOperand(0).getMBB();
 203         return false;
 204       } else {
 205         MachineInstr *predSet = I;
 206         while (!isPredicateSetter(predSet->getOpcode())) {
 207           predSet = --I;
 208         }
 209         TBB = LastInst->getOperand(0).getMBB();
 210         Cond.push_back(predSet->getOperand(1));
 211         Cond.push_back(predSet->getOperand(2));
 212         Cond.push_back(MachineOperand::CreateReg(AMDGPU::PRED_SEL_ONE, false));
 213         return false;
 214       }
 215     }
 216     return true;  // Can't handle indirect branch.
 217   }
 218
 219   // Get the instruction before it if it is a terminator.
 220   MachineInstr *SecondLastInst = I;
 221   unsigned SecondLastOpc = SecondLastInst->getOpcode();
 222
 223   // If the block ends with a B and a Bcc, handle it.
 224   if (SecondLastOpc == AMDGPU::JUMP &&
 225       isPredicated(SecondLastInst) &&
 226       LastOpc == AMDGPU::JUMP &&
 227       !isPredicated(LastInst)) {
 228     MachineInstr *predSet = --I;
 229     while (!isPredicateSetter(predSet->getOpcode())) {
 230       predSet = --I;
 231     }
 232     TBB = SecondLastInst->getOperand(0).getMBB();
 233     FBB = LastInst->getOperand(0).getMBB();
 234     Cond.push_back(predSet->getOperand(1));
 235     Cond.push_back(predSet->getOperand(2));
 236     Cond.push_back(MachineOperand::CreateReg(AMDGPU::PRED_SEL_ONE, false));
 237     return false;
 238   }
 239
 240   // Otherwise, can't handle this.
 241   return true;
 242 }
 243
 244 int R600InstrInfo::getBranchInstr(const MachineOperand &op) const {
 245   const MachineInstr *MI = op.getParent();
 246
 247   switch (MI->getDesc().OpInfo->RegClass) {
 248   default: // FIXME: fallthrough??
 249   case AMDGPU::GPRI32RegClassID: return AMDGPU::BRANCH_COND_i32;
 250   case AMDGPU::GPRF32RegClassID: return AMDGPU::BRANCH_COND_f32;
 251   };
 252 }
 253
 254 unsigned
 255 R600InstrInfo::InsertBranch(MachineBasicBlock &MBB,
 256                             MachineBasicBlock *TBB,
 257                             MachineBasicBlock *FBB,
 258                             const SmallVectorImpl<MachineOperand> &Cond,
 259                             DebugLoc DL) const {
 260   assert(TBB && "InsertBranch must not be told to insert a fallthrough");
 261
 262   if (FBB == 0) {
 263     if (Cond.empty()) {
 264       BuildMI(&MBB, DL, get(AMDGPU::JUMP)).addMBB(TBB).addReg(0);
 265       return 1;
 266     } else {
 267       MachineInstr *PredSet = findFirstPredicateSetterFrom(MBB, MBB.end());
 268       assert(PredSet && "No previous predicate !");
 269       addFlag(PredSet, 0, MO_FLAG_PUSH);
 270       PredSet->getOperand(2).setImm(Cond[1].getImm());
 271
 272       BuildMI(&MBB, DL, get(AMDGPU::JUMP))
 273              .addMBB(TBB)
 274              .addReg(AMDGPU::PREDICATE_BIT, RegState::Kill);
 275       return 1;
 276     }
 277   } else {
 278     MachineInstr *PredSet = findFirstPredicateSetterFrom(MBB, MBB.end());
 279     assert(PredSet && "No previous predicate !");
 280     addFlag(PredSet, 0, MO_FLAG_PUSH);
 281     PredSet->getOperand(2).setImm(Cond[1].getImm());
 282     BuildMI(&MBB, DL, get(AMDGPU::JUMP))
 283             .addMBB(TBB)
 284             .addReg(AMDGPU::PREDICATE_BIT, RegState::Kill);
 285     BuildMI(&MBB, DL, get(AMDGPU::JUMP)).addMBB(FBB).addReg(0);
 286     return 2;
 287   }
 288 }
 289
 290 unsigned
 291 R600InstrInfo::RemoveBranch(MachineBasicBlock &MBB) const {
 292
 293   // Note : we leave PRED* instructions there.
 294   // They may be needed when predicating instructions.
 295
 296   MachineBasicBlock::iterator I = MBB.end();
 297
 298   if (I == MBB.begin()) {
 299     return 0;
 300   }
 301   --I;
 302   switch (I->getOpcode()) {
 303   default:
 304     return 0;
 305   case AMDGPU::JUMP:
 306     if (isPredicated(I)) {
 307       MachineInstr *predSet = findFirstPredicateSetterFrom(MBB, I);
 308       clearFlag(predSet, 0, MO_FLAG_PUSH);
 309     }
 310     I->eraseFromParent();
 311     break;
 312   }
 313   I = MBB.end();
 314
 315   if (I == MBB.begin()) {
 316     return 1;
 317   }
 318   --I;
 319   switch (I->getOpcode()) {
 320     // FIXME: only one case??
 321   default:
 322     return 1;
 323   case AMDGPU::JUMP:
 324     if (isPredicated(I)) {
 325       MachineInstr *predSet = findFirstPredicateSetterFrom(MBB, I);
 326       clearFlag(predSet, 0, MO_FLAG_PUSH);
 327     }
 328     I->eraseFromParent();
 329     break;
 330   }
 331   return 2;
 332 }
 333
 334 bool
 335 R600InstrInfo::isPredicated(const MachineInstr *MI) const {
 336   int idx = MI->findFirstPredOperandIdx();
 337   if (idx < 0)
 338     return false;
 339
 340   unsigned Reg = MI->getOperand(idx).getReg();
 341   switch (Reg) {
 342   default: return false;
 343   case AMDGPU::PRED_SEL_ONE:
 344   case AMDGPU::PRED_SEL_ZERO:
 345   case AMDGPU::PREDICATE_BIT:
 346     return true;
 347   }
 348 }
 349
 350 bool
 351 R600InstrInfo::isPredicable(MachineInstr *MI) const {
 352   // XXX: KILL* instructions can be predicated, but they must be the last
 353   // instruction in a clause, so this means any instructions after them cannot
 354   // be predicated.  Until we have proper support for instruction clauses in the
 355   // backend, we will mark KILL* instructions as unpredicable.
 356
 357   if (MI->getOpcode() == AMDGPU::KILLGT) {
 358     return false;
 359   } else if (isVector(*MI)) {
 360     return false;
 361   } else {
 362     return AMDGPUInstrInfo::isPredicable(MI);
 363   }
 364 }
 365
 366
 367 bool
 368 R600InstrInfo::isProfitableToIfCvt(MachineBasicBlock &MBB,
 369                                    unsigned NumCyles,
 370                                    unsigned ExtraPredCycles,
 371                                    const BranchProbability &Probability) const{
 372   return true;
 373 }
 374
 375 bool
 376 R600InstrInfo::isProfitableToIfCvt(MachineBasicBlock &TMBB,
 377                                    unsigned NumTCycles,
 378                                    unsigned ExtraTCycles,
 379                                    MachineBasicBlock &FMBB,
 380                                    unsigned NumFCycles,
 381                                    unsigned ExtraFCycles,
 382                                    const BranchProbability &Probability) const {
 383   return true;
 384 }
 385
 386 bool
 387 R600InstrInfo::isProfitableToDupForIfCvt(MachineBasicBlock &MBB,
 388                                          unsigned NumCyles,
 389                                          const BranchProbability &Probability)
 390                                          const {
 391   return true;
 392 }
 393
 394 bool
 395 R600InstrInfo::isProfitableToUnpredicate(MachineBasicBlock &TMBB,
 396                                          MachineBasicBlock &FMBB) const {
 397   return false;
 398 }
 399
 400
 401 bool
 402 R600InstrInfo::ReverseBranchCondition(SmallVectorImpl<MachineOperand> &Cond) const {
 403   MachineOperand &MO = Cond[1];
 404   switch (MO.getImm()) {
 405   case OPCODE_IS_ZERO_INT:
 406     MO.setImm(OPCODE_IS_NOT_ZERO_INT);
 407     break;
 408   case OPCODE_IS_NOT_ZERO_INT:
 409     MO.setImm(OPCODE_IS_ZERO_INT);
 410     break;
 411   case OPCODE_IS_ZERO:
 412     MO.setImm(OPCODE_IS_NOT_ZERO);
 413     break;
 414   case OPCODE_IS_NOT_ZERO:
 415     MO.setImm(OPCODE_IS_ZERO);
 416     break;
 417   default:
 418     return true;
 419   }
 420
 421   MachineOperand &MO2 = Cond[2];
 422   switch (MO2.getReg()) {
 423   case AMDGPU::PRED_SEL_ZERO:
 424     MO2.setReg(AMDGPU::PRED_SEL_ONE);
 425     break;
 426   case AMDGPU::PRED_SEL_ONE:
 427     MO2.setReg(AMDGPU::PRED_SEL_ZERO);
 428     break;
 429   default:
 430     return true;
 431   }
 432   return false;
 433 }
 434
 435 bool
 436 R600InstrInfo::DefinesPredicate(MachineInstr *MI,
 437                                 std::vector<MachineOperand> &Pred) const {
 438   return isPredicateSetter(MI->getOpcode());
 439 }
 440
 441
 442 bool
 443 R600InstrInfo::SubsumesPredicate(const SmallVectorImpl<MachineOperand> &Pred1,
 444                        const SmallVectorImpl<MachineOperand> &Pred2) const {
 445   return false;
 446 }
 447
 448
 449 bool
 450 R600InstrInfo::PredicateInstruction(MachineInstr *MI,
 451                       const SmallVectorImpl<MachineOperand> &Pred) const {
 452   int PIdx = MI->findFirstPredOperandIdx();
 453
 454   if (PIdx != -1) {
 455     MachineOperand &PMO = MI->getOperand(PIdx);
 456     PMO.setReg(Pred[2].getReg());
 457     MachineInstrBuilder MIB(*MI->getParent()->getParent(), MI);
 458     MIB.addReg(AMDGPU::PREDICATE_BIT, RegState::Implicit);
 459     return true;
 460   }
 461
 462   return false;
 463 }
 464
 465 unsigned int R600InstrInfo::getInstrLatency(const InstrItineraryData *ItinData,
 466                                             const MachineInstr *MI,
 467                                             unsigned *PredCost) const {
 468   if (PredCost)
 469     *PredCost = 2;
 470   return 2;
 471 }
 472
 473 int R600InstrInfo::getIndirectIndexBegin(const MachineFunction &MF) const {
 474   const MachineRegisterInfo &MRI = MF.getRegInfo();
 475   const MachineFrameInfo *MFI = MF.getFrameInfo();
 476   int Offset = 0;
 477
 478   if (MFI->getNumObjects() == 0) {
 479     return -1;
 480   }
 481
 482   if (MRI.livein_empty()) {
 483     return 0;
 484   }
 485
 486   for (MachineRegisterInfo::livein_iterator LI = MRI.livein_begin(),
 487                                             LE = MRI.livein_end();
 488                                             LI != LE; ++LI) {
 489     Offset = std::max(Offset,
 490                       GET_REG_INDEX(RI.getEncodingValue(LI->first)));
 491   }
 492
 493   return Offset + 1;
 494 }
 495
 496 int R600InstrInfo::getIndirectIndexEnd(const MachineFunction &MF) const {
 497   int Offset = 0;
 498   const MachineFrameInfo *MFI = MF.getFrameInfo();
 499
 500   // Variable sized objects are not supported
 501   assert(!MFI->hasVarSizedObjects());
 502
 503   if (MFI->getNumObjects() == 0) {
 504     return -1;
 505   }
 506
 507   Offset = TM.getFrameLowering()->getFrameIndexOffset(MF, -1);
 508
 509   return getIndirectIndexBegin(MF) + Offset;
 510 }
 511
 512 std::vector<unsigned> R600InstrInfo::getIndirectReservedRegs(
 513                                              const MachineFunction &MF) const {
 514   const AMDGPUFrameLowering *TFL =
 515                  static_cast<const AMDGPUFrameLowering*>(TM.getFrameLowering());
 516   std::vector<unsigned> Regs;
 517
 518   unsigned StackWidth = TFL->getStackWidth(MF);
 519   int End = getIndirectIndexEnd(MF);
 520
 521   if (End == -1) {
 522     return Regs;
 523   }
 524
 525   for (int Index = getIndirectIndexBegin(MF); Index <= End; ++Index) {
 526     unsigned SuperReg = AMDGPU::R600_Reg128RegClass.getRegister(Index);
 527     Regs.push_back(SuperReg);
 528     for (unsigned Chan = 0; Chan < StackWidth; ++Chan) {
 529       unsigned Reg = AMDGPU::R600_TReg32RegClass.getRegister((4 * Index) + Chan);
 530       Regs.push_back(Reg);
 531     }
 532   }
 533   return Regs;
 534 }
 535
 536 unsigned R600InstrInfo::calculateIndirectAddress(unsigned RegIndex,
 537                                                  unsigned Channel) const {
 538   // XXX: Remove when we support a stack width > 2
 539   assert(Channel == 0);
 540   return RegIndex;
 541 }
 542
 543 const TargetRegisterClass * R600InstrInfo::getIndirectAddrStoreRegClass(
 544                                                      unsigned SourceReg) const {
 545   return &AMDGPU::R600_TReg32RegClass;
 546 }
 547
 548 const TargetRegisterClass *R600InstrInfo::getIndirectAddrLoadRegClass() const {
 549   return &AMDGPU::TRegMemRegClass;
 550 }
 551
 552 MachineInstrBuilder R600InstrInfo::buildIndirectWrite(MachineBasicBlock *MBB,
 553                                        MachineBasicBlock::iterator I,
 554                                        unsigned ValueReg, unsigned Address,
 555                                        unsigned OffsetReg) const {
 556   unsigned AddrReg = AMDGPU::R600_AddrRegClass.getRegister(Address);
 557   MachineInstr *MOVA = buildDefaultInstruction(*MBB, I, AMDGPU::MOVA_INT_eg,
 558                                                AMDGPU::AR_X, OffsetReg);
 559   setImmOperand(MOVA, R600Operands::WRITE, 0);
 560
 561   MachineInstrBuilder Mov = buildDefaultInstruction(*MBB, I, AMDGPU::MOV,
 562                                       AddrReg, ValueReg)
 563                                       .addReg(AMDGPU::AR_X, RegState::Implicit);
 564   setImmOperand(Mov, R600Operands::DST_REL, 1);
 565   return Mov;
 566 }
 567
 568 MachineInstrBuilder R600InstrInfo::buildIndirectRead(MachineBasicBlock *MBB,
 569                                        MachineBasicBlock::iterator I,
 570                                        unsigned ValueReg, unsigned Address,
 571                                        unsigned OffsetReg) const {
 572   unsigned AddrReg = AMDGPU::R600_AddrRegClass.getRegister(Address);
 573   MachineInstr *MOVA = buildDefaultInstruction(*MBB, I, AMDGPU::MOVA_INT_eg,
 574                                                        AMDGPU::AR_X,
 575                                                        OffsetReg);
 576   setImmOperand(MOVA, R600Operands::WRITE, 0);
 577   MachineInstrBuilder Mov = buildDefaultInstruction(*MBB, I, AMDGPU::MOV,
 578                                       ValueReg,
 579                                       AddrReg)
 580                                       .addReg(AMDGPU::AR_X, RegState::Implicit);
 581   setImmOperand(Mov, R600Operands::SRC0_REL, 1);
 582
 583   return Mov;
 584 }
 585
 586 const TargetRegisterClass *R600InstrInfo::getSuperIndirectRegClass() const {
 587   return &AMDGPU::IndirectRegRegClass;
 588 }
 589
 590
 591 MachineInstrBuilder R600InstrInfo::buildDefaultInstruction(MachineBasicBlock &MBB,
 592                                                   MachineBasicBlock::iterator I,
 593                                                   unsigned Opcode,
 594                                                   unsigned DstReg,
 595                                                   unsigned Src0Reg,
 596                                                   unsigned Src1Reg) const {
 597   MachineInstrBuilder MIB = BuildMI(MBB, I, MBB.findDebugLoc(I), get(Opcode),
 598     DstReg);           // $dst
 599
 600   if (Src1Reg) {
 601     MIB.addImm(0)     // $update_exec_mask
 602        .addImm(0);    // $update_predicate
 603   }
 604   MIB.addImm(1)        // $write
 605      .addImm(0)        // $omod
 606      .addImm(0)        // $dst_rel
 607      .addImm(0)        // $dst_clamp
 608      .addReg(Src0Reg)  // $src0
 609      .addImm(0)        // $src0_neg
 610      .addImm(0)        // $src0_rel
 611      .addImm(0)        // $src0_abs
 612      .addImm(-1);       // $src0_sel
 613
 614   if (Src1Reg) {
 615     MIB.addReg(Src1Reg) // $src1
 616        .addImm(0)       // $src1_neg
 617        .addImm(0)       // $src1_rel
 618        .addImm(0)       // $src1_abs
 619        .addImm(-1);      // $src1_sel
 620   }
 621
 622   //XXX: The r600g finalizer expects this to be 1, once we've moved the
 623   //scheduling to the backend, we can change the default to 0.
 624   MIB.addImm(1)        // $last
 625       .addReg(AMDGPU::PRED_SEL_OFF) // $pred_sel
 626       .addImm(0);        // $literal
 627
 628   return MIB;
 629 }
 630
 631 MachineInstr *R600InstrInfo::buildMovImm(MachineBasicBlock &BB,
 632                                          MachineBasicBlock::iterator I,
 633                                          unsigned DstReg,
 634                                          uint64_t Imm) const {
 635   MachineInstr *MovImm = buildDefaultInstruction(BB, I, AMDGPU::MOV, DstReg,
 636                                                   AMDGPU::ALU_LITERAL_X);
 637   setImmOperand(MovImm, R600Operands::IMM, Imm);
 638   return MovImm;
 639 }
 640
 641 int R600InstrInfo::getOperandIdx(const MachineInstr &MI,
 642                                  R600Operands::Ops Op) const {
 643   return getOperandIdx(MI.getOpcode(), Op);
 644 }
 645
 646 int R600InstrInfo::getOperandIdx(unsigned Opcode,
 647                                  R600Operands::Ops Op) const {
 648   unsigned TargetFlags = get(Opcode).TSFlags;
 649   unsigned OpTableIdx;
 650
 651   if (!HAS_NATIVE_OPERANDS(TargetFlags)) {
 652     switch (Op) {
 653     case R600Operands::DST: return 0;
 654     case R600Operands::SRC0: return 1;
 655     case R600Operands::SRC1: return 2;
 656     case R600Operands::SRC2: return 3;
 657     default:
 658       assert(!"Unknown operand type for instruction");
 659       return -1;
 660     }
 661   }
 662
 663   if (TargetFlags & R600_InstFlag::OP1) {
 664     OpTableIdx = 0;
 665   } else if (TargetFlags & R600_InstFlag::OP2) {
 666     OpTableIdx = 1;
 667   } else {
 668     assert((TargetFlags & R600_InstFlag::OP3) && "OP1, OP2, or OP3 not defined "
 669                                                  "for this instruction");
 670     OpTableIdx = 2;
 671   }
 672
 673   return R600Operands::ALUOpTable[OpTableIdx][Op];
 674 }
 675
 676 void R600InstrInfo::setImmOperand(MachineInstr *MI, R600Operands::Ops Op,
 677                                   int64_t Imm) const {
 678   int Idx = getOperandIdx(*MI, Op);
 679   assert(Idx != -1 && "Operand not supported for this instruction.");
 680   assert(MI->getOperand(Idx).isImm());
 681   MI->getOperand(Idx).setImm(Imm);
 682 }
 683
 684 //===----------------------------------------------------------------------===//
 685 // Instruction flag getters/setters
 686 //===----------------------------------------------------------------------===//
 687
 688 bool R600InstrInfo::hasFlagOperand(const MachineInstr &MI) const {
 689   return GET_FLAG_OPERAND_IDX(get(MI.getOpcode()).TSFlags) != 0;
 690 }
 691
 692 MachineOperand &R600InstrInfo::getFlagOp(MachineInstr *MI, unsigned SrcIdx,
 693                                          unsigned Flag) const {
 694   unsigned TargetFlags = get(MI->getOpcode()).TSFlags;
 695   int FlagIndex = 0;
 696   if (Flag != 0) {
 697     // If we pass something other than the default value of Flag to this
 698     // function, it means we are want to set a flag on an instruction
 699     // that uses native encoding.
 700     assert(HAS_NATIVE_OPERANDS(TargetFlags));
 701     bool IsOP3 = (TargetFlags & R600_InstFlag::OP3) == R600_InstFlag::OP3;
 702     switch (Flag) {
 703     case MO_FLAG_CLAMP:
 704       FlagIndex = getOperandIdx(*MI, R600Operands::CLAMP);
 705       break;
 706     case MO_FLAG_MASK:
 707       FlagIndex = getOperandIdx(*MI, R600Operands::WRITE);
 708       break;
 709     case MO_FLAG_NOT_LAST:
 710     case MO_FLAG_LAST:
 711       FlagIndex = getOperandIdx(*MI, R600Operands::LAST);
 712       break;
 713     case MO_FLAG_NEG:
 714       switch (SrcIdx) {
 715       case 0: FlagIndex = getOperandIdx(*MI, R600Operands::SRC0_NEG); break;
 716       case 1: FlagIndex = getOperandIdx(*MI, R600Operands::SRC1_NEG); break;
 717       case 2: FlagIndex = getOperandIdx(*MI, R600Operands::SRC2_NEG); break;
 718       }
 719       break;
 720
 721     case MO_FLAG_ABS:
 722       assert(!IsOP3 && "Cannot set absolute value modifier for OP3 "
 723                        "instructions.");
 724       (void)IsOP3;
 725       switch (SrcIdx) {
 726       case 0: FlagIndex = getOperandIdx(*MI, R600Operands::SRC0_ABS); break;
 727       case 1: FlagIndex = getOperandIdx(*MI, R600Operands::SRC1_ABS); break;
 728       }
 729       break;
 730
 731     default:
 732       FlagIndex = -1;
 733       break;
 734     }
 735     assert(FlagIndex != -1 && "Flag not supported for this instruction");
 736   } else {
 737       FlagIndex = GET_FLAG_OPERAND_IDX(TargetFlags);
 738       assert(FlagIndex != 0 &&
 739          "Instruction flags not supported for this instruction");
 740   }
 741
 742   MachineOperand &FlagOp = MI->getOperand(FlagIndex);
 743   assert(FlagOp.isImm());
 744   return FlagOp;
 745 }
 746
 747 void R600InstrInfo::addFlag(MachineInstr *MI, unsigned Operand,
 748                             unsigned Flag) const {
 749   unsigned TargetFlags = get(MI->getOpcode()).TSFlags;
 750   if (Flag == 0) {
 751     return;
 752   }
 753   if (HAS_NATIVE_OPERANDS(TargetFlags)) {
 754     MachineOperand &FlagOp = getFlagOp(MI, Operand, Flag);
 755     if (Flag == MO_FLAG_NOT_LAST) {
 756       clearFlag(MI, Operand, MO_FLAG_LAST);
 757     } else if (Flag == MO_FLAG_MASK) {
 758       clearFlag(MI, Operand, Flag);
 759     } else {
 760       FlagOp.setImm(1);
 761     }
 762   } else {
 763       MachineOperand &FlagOp = getFlagOp(MI, Operand);
 764       FlagOp.setImm(FlagOp.getImm() | (Flag << (NUM_MO_FLAGS * Operand)));
 765   }
 766 }
 767
 768 void R600InstrInfo::clearFlag(MachineInstr *MI, unsigned Operand,
 769                               unsigned Flag) const {
 770   unsigned TargetFlags = get(MI->getOpcode()).TSFlags;
 771   if (HAS_NATIVE_OPERANDS(TargetFlags)) {
 772     MachineOperand &FlagOp = getFlagOp(MI, Operand, Flag);
 773     FlagOp.setImm(0);
 774   } else {
 775     MachineOperand &FlagOp = getFlagOp(MI);
 776     unsigned InstFlags = FlagOp.getImm();
 777     InstFlags &= ~(Flag << (NUM_MO_FLAGS * Operand));
 778     FlagOp.setImm(InstFlags);
 779   }
 780 }