lib/CodeGen/SelectionDAG/FastISel.cpp

   1 ///===-- FastISel.cpp - Implementation of the FastISel class --------------===//
   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 // This file contains the implementation of the FastISel class.
  11 //
  12 //===----------------------------------------------------------------------===//
  13
  14 #include "llvm/Instructions.h"
  15 #include "llvm/CodeGen/FastISel.h"
  16 #include "llvm/CodeGen/MachineInstrBuilder.h"
  17 #include "llvm/CodeGen/MachineRegisterInfo.h"
  18 #include "llvm/Target/TargetData.h"
  19 #include "llvm/Target/TargetInstrInfo.h"
  20 #include "llvm/Target/TargetLowering.h"
  21 #include "llvm/Target/TargetMachine.h"
  22 using namespace llvm;
  23
  24 unsigned FastISel::getRegForValue(Value *V) {
  25   // Look up the value to see if we already have a register for it. We
  26   // cache values defined by Instructions across blocks, and other values
  27   // only locally. This is because Instructions already have the SSA
  28   // def-dominatess-use requirement enforced.
  29   if (ValueMap.count(V))
  30     return ValueMap[V];
  31   unsigned Reg = LocalValueMap[V];
  32   if (Reg != 0)
  33     return Reg;
  34
  35   MVT::SimpleValueType VT = TLI.getValueType(V->getType()).getSimpleVT();
  36   if (ConstantInt *CI = dyn_cast<ConstantInt>(V)) {
  37     if (CI->getValue().getActiveBits() > 64)
  38       return 0;
  39     // Don't cache constant materializations.  To do so would require
  40     // tracking what uses they dominate.
  41     Reg = FastEmit_i(VT, VT, ISD::Constant, CI->getZExtValue());
  42   } else if (isa<ConstantPointerNull>(V)) {
  43     Reg = FastEmit_i(VT, VT, ISD::Constant, 0);
  44   } else if (ConstantFP *CF = dyn_cast<ConstantFP>(V)) {
  45     Reg = FastEmit_f(VT, VT, ISD::ConstantFP, CF);
  46
  47     if (!Reg) {
  48       const APFloat &Flt = CF->getValueAPF();
  49       MVT IntVT = TLI.getPointerTy();
  50
  51       uint64_t x[2];
  52       uint32_t IntBitWidth = IntVT.getSizeInBits();
  53       if (Flt.convertToInteger(x, IntBitWidth, /*isSigned=*/true,
  54                                APFloat::rmTowardZero) != APFloat::opOK)
  55         return 0;
  56       APInt IntVal(IntBitWidth, 2, x);
  57
  58       unsigned IntegerReg = FastEmit_i(IntVT.getSimpleVT(), IntVT.getSimpleVT(),
  59                                        ISD::Constant, IntVal.getZExtValue());
  60       if (IntegerReg == 0)
  61         return 0;
  62       Reg = FastEmit_r(IntVT.getSimpleVT(), VT, ISD::SINT_TO_FP, IntegerReg);
  63       if (Reg == 0)
  64         return 0;
  65     }
  66   } else if (isa<UndefValue>(V)) {
  67     Reg = createResultReg(TLI.getRegClassFor(VT));
  68     BuildMI(MBB, TII.get(TargetInstrInfo::IMPLICIT_DEF), Reg);
  69   } else {
  70     return 0;
  71   }
  72
  73   LocalValueMap[V] = Reg;
  74   return Reg;
  75 }
  76
  77 /// UpdateValueMap - Update the value map to include the new mapping for this
  78 /// instruction, or insert an extra copy to get the result in a previous
  79 /// determined register.
  80 /// NOTE: This is only necessary because we might select a block that uses
  81 /// a value before we select the block that defines the value.  It might be
  82 /// possible to fix this by selecting blocks in reverse postorder.
  83 void FastISel::UpdateValueMap(Value* I, unsigned Reg) {
  84   if (!ValueMap.count(I))
  85     ValueMap[I] = Reg;
  86   else
  87      TII.copyRegToReg(*MBB, MBB->end(), ValueMap[I],
  88                       Reg, MRI.getRegClass(Reg), MRI.getRegClass(Reg));
  89 }
  90
  91 /// SelectBinaryOp - Select and emit code for a binary operator instruction,
  92 /// which has an opcode which directly corresponds to the given ISD opcode.
  93 ///
  94 bool FastISel::SelectBinaryOp(Instruction *I, ISD::NodeType ISDOpcode) {
  95   MVT VT = MVT::getMVT(I->getType(), /*HandleUnknown=*/true);
  96   if (VT == MVT::Other || !VT.isSimple())
  97     // Unhandled type. Halt "fast" selection and bail.
  98     return false;
  99   // We only handle legal types. For example, on x86-32 the instruction
 100   // selector contains all of the 64-bit instructions from x86-64,
 101   // under the assumption that i64 won't be used if the target doesn't
 102   // support it.
 103   if (!TLI.isTypeLegal(VT))
 104     return false;
 105
 106   unsigned Op0 = getRegForValue(I->getOperand(0));
 107   if (Op0 == 0)
 108     // Unhandled operand. Halt "fast" selection and bail.
 109     return false;
 110
 111   // Check if the second operand is a constant and handle it appropriately.
 112   if (ConstantInt *CI = dyn_cast<ConstantInt>(I->getOperand(1))) {
 113     unsigned ResultReg = FastEmit_ri(VT.getSimpleVT(), VT.getSimpleVT(),
 114                                      ISDOpcode, Op0, CI->getZExtValue());
 115     if (ResultReg != 0) {
 116       // We successfully emitted code for the given LLVM Instruction.
 117       UpdateValueMap(I, ResultReg);
 118       return true;
 119     }
 120   }
 121
 122   // Check if the second operand is a constant float.
 123   if (ConstantFP *CF = dyn_cast<ConstantFP>(I->getOperand(1))) {
 124     unsigned ResultReg = FastEmit_rf(VT.getSimpleVT(), VT.getSimpleVT(),
 125                                      ISDOpcode, Op0, CF);
 126     if (ResultReg != 0) {
 127       // We successfully emitted code for the given LLVM Instruction.
 128       UpdateValueMap(I, ResultReg);
 129       return true;
 130     }
 131   }
 132
 133   unsigned Op1 = getRegForValue(I->getOperand(1));
 134   if (Op1 == 0)
 135     // Unhandled operand. Halt "fast" selection and bail.
 136     return false;
 137
 138   // Now we have both operands in registers. Emit the instruction.
 139   unsigned ResultReg = FastEmit_rr(VT.getSimpleVT(), VT.getSimpleVT(),
 140                                    ISDOpcode, Op0, Op1);
 141   if (ResultReg == 0)
 142     // Target-specific code wasn't able to find a machine opcode for
 143     // the given ISD opcode and type. Halt "fast" selection and bail.
 144     return false;
 145
 146   // We successfully emitted code for the given LLVM Instruction.
 147   UpdateValueMap(I, ResultReg);
 148   return true;
 149 }
 150
 151 bool FastISel::SelectGetElementPtr(Instruction *I) {
 152   unsigned N = getRegForValue(I->getOperand(0));
 153   if (N == 0)
 154     // Unhandled operand. Halt "fast" selection and bail.
 155     return false;
 156
 157   const Type *Ty = I->getOperand(0)->getType();
 158   MVT::SimpleValueType VT = TLI.getPointerTy().getSimpleVT();
 159   for (GetElementPtrInst::op_iterator OI = I->op_begin()+1, E = I->op_end();
 160        OI != E; ++OI) {
 161     Value *Idx = *OI;
 162     if (const StructType *StTy = dyn_cast<StructType>(Ty)) {
 163       unsigned Field = cast<ConstantInt>(Idx)->getZExtValue();
 164       if (Field) {
 165         // N = N + Offset
 166         uint64_t Offs = TD.getStructLayout(StTy)->getElementOffset(Field);
 167         // FIXME: This can be optimized by combining the add with a
 168         // subsequent one.
 169         N = FastEmit_ri_(VT, ISD::ADD, N, Offs, VT);
 170         if (N == 0)
 171           // Unhandled operand. Halt "fast" selection and bail.
 172           return false;
 173       }
 174       Ty = StTy->getElementType(Field);
 175     } else {
 176       Ty = cast<SequentialType>(Ty)->getElementType();
 177
 178       // If this is a constant subscript, handle it quickly.
 179       if (ConstantInt *CI = dyn_cast<ConstantInt>(Idx)) {
 180         if (CI->getZExtValue() == 0) continue;
 181         uint64_t Offs =
 182           TD.getABITypeSize(Ty)*cast<ConstantInt>(CI)->getSExtValue();
 183         N = FastEmit_ri_(VT, ISD::ADD, N, Offs, VT);
 184         if (N == 0)
 185           // Unhandled operand. Halt "fast" selection and bail.
 186           return false;
 187         continue;
 188       }
 189
 190       // N = N + Idx * ElementSize;
 191       uint64_t ElementSize = TD.getABITypeSize(Ty);
 192       unsigned IdxN = getRegForValue(Idx);
 193       if (IdxN == 0)
 194         // Unhandled operand. Halt "fast" selection and bail.
 195         return false;
 196
 197       // If the index is smaller or larger than intptr_t, truncate or extend
 198       // it.
 199       MVT IdxVT = MVT::getMVT(Idx->getType(), /*HandleUnknown=*/false);
 200       if (IdxVT.bitsLT(VT))
 201         IdxN = FastEmit_r(IdxVT.getSimpleVT(), VT, ISD::SIGN_EXTEND, IdxN);
 202       else if (IdxVT.bitsGT(VT))
 203         IdxN = FastEmit_r(IdxVT.getSimpleVT(), VT, ISD::TRUNCATE, IdxN);
 204       if (IdxN == 0)
 205         // Unhandled operand. Halt "fast" selection and bail.
 206         return false;
 207
 208       if (ElementSize != 1) {
 209         IdxN = FastEmit_ri_(VT, ISD::MUL, IdxN, ElementSize, VT);
 210         if (IdxN == 0)
 211           // Unhandled operand. Halt "fast" selection and bail.
 212           return false;
 213       }
 214       N = FastEmit_rr(VT, VT, ISD::ADD, N, IdxN);
 215       if (N == 0)
 216         // Unhandled operand. Halt "fast" selection and bail.
 217         return false;
 218     }
 219   }
 220
 221   // We successfully emitted code for the given LLVM Instruction.
 222   UpdateValueMap(I, N);
 223   return true;
 224 }
 225
 226 bool FastISel::SelectCast(Instruction *I, ISD::NodeType Opcode) {
 227   MVT SrcVT = TLI.getValueType(I->getOperand(0)->getType());
 228   MVT DstVT = TLI.getValueType(I->getType());
 229
 230   if (SrcVT == MVT::Other || !SrcVT.isSimple() ||
 231       DstVT == MVT::Other || !DstVT.isSimple() ||
 232       !TLI.isTypeLegal(SrcVT) || !TLI.isTypeLegal(DstVT))
 233     // Unhandled type. Halt "fast" selection and bail.
 234     return false;
 235
 236   unsigned InputReg = getRegForValue(I->getOperand(0));
 237   if (!InputReg)
 238     // Unhandled operand.  Halt "fast" selection and bail.
 239     return false;
 240
 241   unsigned ResultReg = FastEmit_r(SrcVT.getSimpleVT(),
 242                                   DstVT.getSimpleVT(),
 243                                   Opcode,
 244                                   InputReg);
 245   if (!ResultReg)
 246     return false;
 247
 248   UpdateValueMap(I, ResultReg);
 249   return true;
 250 }
 251
 252 bool FastISel::SelectBitCast(Instruction *I) {
 253   // If the bitcast doesn't change the type, just use the operand value.
 254   if (I->getType() == I->getOperand(0)->getType()) {
 255     unsigned Reg = getRegForValue(I->getOperand(0));
 256     if (Reg == 0)
 257       return false;
 258     UpdateValueMap(I, Reg);
 259     return true;
 260   }
 261
 262   // Bitcasts of other values become reg-reg copies or BIT_CONVERT operators.
 263   MVT SrcVT = TLI.getValueType(I->getOperand(0)->getType());
 264   MVT DstVT = TLI.getValueType(I->getType());
 265
 266   if (SrcVT == MVT::Other || !SrcVT.isSimple() ||
 267       DstVT == MVT::Other || !DstVT.isSimple() ||
 268       !TLI.isTypeLegal(SrcVT) || !TLI.isTypeLegal(DstVT))
 269     // Unhandled type. Halt "fast" selection and bail.
 270     return false;
 271
 272   unsigned Op0 = getRegForValue(I->getOperand(0));
 273   if (Op0 == 0)
 274     // Unhandled operand. Halt "fast" selection and bail.
 275     return false;
 276
 277   // First, try to perform the bitcast by inserting a reg-reg copy.
 278   unsigned ResultReg = 0;
 279   if (SrcVT.getSimpleVT() == DstVT.getSimpleVT()) {
 280     TargetRegisterClass* SrcClass = TLI.getRegClassFor(SrcVT);
 281     TargetRegisterClass* DstClass = TLI.getRegClassFor(DstVT);
 282     ResultReg = createResultReg(DstClass);
 283
 284     bool InsertedCopy = TII.copyRegToReg(*MBB, MBB->end(), ResultReg,
 285                                          Op0, DstClass, SrcClass);
 286     if (!InsertedCopy)
 287       ResultReg = 0;
 288   }
 289
 290   // If the reg-reg copy failed, select a BIT_CONVERT opcode.
 291   if (!ResultReg)
 292     ResultReg = FastEmit_r(SrcVT.getSimpleVT(), DstVT.getSimpleVT(),
 293                            ISD::BIT_CONVERT, Op0);
 294
 295   if (!ResultReg)
 296     return false;
 297
 298   UpdateValueMap(I, ResultReg);
 299   return true;
 300 }
 301
 302 bool
 303 FastISel::SelectInstruction(Instruction *I) {
 304   switch (I->getOpcode()) {
 305   case Instruction::Add: {
 306     ISD::NodeType Opc = I->getType()->isFPOrFPVector() ? ISD::FADD : ISD::ADD;
 307     return SelectBinaryOp(I, Opc);
 308   }
 309   case Instruction::Sub: {
 310     ISD::NodeType Opc = I->getType()->isFPOrFPVector() ? ISD::FSUB : ISD::SUB;
 311     return SelectBinaryOp(I, Opc);
 312   }
 313   case Instruction::Mul: {
 314     ISD::NodeType Opc = I->getType()->isFPOrFPVector() ? ISD::FMUL : ISD::MUL;
 315     return SelectBinaryOp(I, Opc);
 316   }
 317   case Instruction::SDiv:
 318     return SelectBinaryOp(I, ISD::SDIV);
 319   case Instruction::UDiv:
 320     return SelectBinaryOp(I, ISD::UDIV);
 321   case Instruction::FDiv:
 322     return SelectBinaryOp(I, ISD::FDIV);
 323   case Instruction::SRem:
 324     return SelectBinaryOp(I, ISD::SREM);
 325   case Instruction::URem:
 326     return SelectBinaryOp(I, ISD::UREM);
 327   case Instruction::FRem:
 328     return SelectBinaryOp(I, ISD::FREM);
 329   case Instruction::Shl:
 330     return SelectBinaryOp(I, ISD::SHL);
 331   case Instruction::LShr:
 332     return SelectBinaryOp(I, ISD::SRL);
 333   case Instruction::AShr:
 334     return SelectBinaryOp(I, ISD::SRA);
 335   case Instruction::And:
 336     return SelectBinaryOp(I, ISD::AND);
 337   case Instruction::Or:
 338     return SelectBinaryOp(I, ISD::OR);
 339   case Instruction::Xor:
 340     return SelectBinaryOp(I, ISD::XOR);
 341
 342   case Instruction::GetElementPtr:
 343     return SelectGetElementPtr(I);
 344
 345   case Instruction::Br: {
 346     BranchInst *BI = cast<BranchInst>(I);
 347
 348     if (BI->isUnconditional()) {
 349       MachineFunction::iterator NextMBB =
 350          next(MachineFunction::iterator(MBB));
 351       BasicBlock *LLVMSucc = BI->getSuccessor(0);
 352       MachineBasicBlock *MSucc = MBBMap[LLVMSucc];
 353
 354       if (NextMBB != MF.end() && MSucc == NextMBB) {
 355         // The unconditional fall-through case, which needs no instructions.
 356       } else {
 357         // The unconditional branch case.
 358         TII.InsertBranch(*MBB, MSucc, NULL, SmallVector<MachineOperand, 0>());
 359       }
 360       MBB->addSuccessor(MSucc);
 361       return true;
 362     }
 363
 364     // Conditional branches are not handed yet.
 365     // Halt "fast" selection and bail.
 366     return false;
 367   }
 368
 369   case Instruction::Unreachable:
 370     // Nothing to emit.
 371     return true;
 372
 373   case Instruction::PHI:
 374     // PHI nodes are already emitted.
 375     return true;
 376
 377   case Instruction::BitCast:
 378     return SelectBitCast(I);
 379
 380   case Instruction::FPToSI:
 381     return SelectCast(I, ISD::FP_TO_SINT);
 382   case Instruction::ZExt:
 383     return SelectCast(I, ISD::ZERO_EXTEND);
 384   case Instruction::SExt:
 385     return SelectCast(I, ISD::SIGN_EXTEND);
 386   case Instruction::Trunc:
 387     return SelectCast(I, ISD::TRUNCATE);
 388   case Instruction::SIToFP:
 389     return SelectCast(I, ISD::SINT_TO_FP);
 390
 391   case Instruction::IntToPtr: // Deliberate fall-through.
 392   case Instruction::PtrToInt: {
 393     MVT SrcVT = TLI.getValueType(I->getOperand(0)->getType());
 394     MVT DstVT = TLI.getValueType(I->getType());
 395     if (DstVT.bitsGT(SrcVT))
 396       return SelectCast(I, ISD::ZERO_EXTEND);
 397     if (DstVT.bitsLT(SrcVT))
 398       return SelectCast(I, ISD::TRUNCATE);
 399     unsigned Reg = getRegForValue(I->getOperand(0));
 400     if (Reg == 0) return false;
 401     UpdateValueMap(I, Reg);
 402     return true;
 403   }
 404
 405   default:
 406     // Unhandled instruction. Halt "fast" selection and bail.
 407     return false;
 408   }
 409 }
 410
 411 FastISel::FastISel(MachineFunction &mf,
 412                    DenseMap<const Value *, unsigned> &vm,
 413                    DenseMap<const BasicBlock *, MachineBasicBlock *> &bm)
 414   : MBB(0),
 415     ValueMap(vm),
 416     MBBMap(bm),
 417     MF(mf),
 418     MRI(MF.getRegInfo()),
 419     TM(MF.getTarget()),
 420     TD(*TM.getTargetData()),
 421     TII(*TM.getInstrInfo()),
 422     TLI(*TM.getTargetLowering()) {
 423 }
 424
 425 FastISel::~FastISel() {}
 426
 427 unsigned FastISel::FastEmit_(MVT::SimpleValueType, MVT::SimpleValueType,
 428                              ISD::NodeType) {
 429   return 0;
 430 }
 431
 432 unsigned FastISel::FastEmit_r(MVT::SimpleValueType, MVT::SimpleValueType,
 433                               ISD::NodeType, unsigned /*Op0*/) {
 434   return 0;
 435 }
 436
 437 unsigned FastISel::FastEmit_rr(MVT::SimpleValueType, MVT::SimpleValueType,
 438                                ISD::NodeType, unsigned /*Op0*/,
 439                                unsigned /*Op0*/) {
 440   return 0;
 441 }
 442
 443 unsigned FastISel::FastEmit_i(MVT::SimpleValueType, MVT::SimpleValueType,
 444                               ISD::NodeType, uint64_t /*Imm*/) {
 445   return 0;
 446 }
 447
 448 unsigned FastISel::FastEmit_f(MVT::SimpleValueType, MVT::SimpleValueType,
 449                               ISD::NodeType, ConstantFP * /*FPImm*/) {
 450   return 0;
 451 }
 452
 453 unsigned FastISel::FastEmit_ri(MVT::SimpleValueType, MVT::SimpleValueType,
 454                                ISD::NodeType, unsigned /*Op0*/,
 455                                uint64_t /*Imm*/) {
 456   return 0;
 457 }
 458
 459 unsigned FastISel::FastEmit_rf(MVT::SimpleValueType, MVT::SimpleValueType,
 460                                ISD::NodeType, unsigned /*Op0*/,
 461                                ConstantFP * /*FPImm*/) {
 462   return 0;
 463 }
 464
 465 unsigned FastISel::FastEmit_rri(MVT::SimpleValueType, MVT::SimpleValueType,
 466                                 ISD::NodeType,
 467                                 unsigned /*Op0*/, unsigned /*Op1*/,
 468                                 uint64_t /*Imm*/) {
 469   return 0;
 470 }
 471
 472 /// FastEmit_ri_ - This method is a wrapper of FastEmit_ri. It first tries
 473 /// to emit an instruction with an immediate operand using FastEmit_ri.
 474 /// If that fails, it materializes the immediate into a register and try
 475 /// FastEmit_rr instead.
 476 unsigned FastISel::FastEmit_ri_(MVT::SimpleValueType VT, ISD::NodeType Opcode,
 477                                 unsigned Op0, uint64_t Imm,
 478                                 MVT::SimpleValueType ImmType) {
 479   // First check if immediate type is legal. If not, we can't use the ri form.
 480   unsigned ResultReg = FastEmit_ri(VT, VT, Opcode, Op0, Imm);
 481   if (ResultReg != 0)
 482     return ResultReg;
 483   unsigned MaterialReg = FastEmit_i(ImmType, ImmType, ISD::Constant, Imm);
 484   if (MaterialReg == 0)
 485     return 0;
 486   return FastEmit_rr(VT, VT, Opcode, Op0, MaterialReg);
 487 }
 488
 489 /// FastEmit_rf_ - This method is a wrapper of FastEmit_ri. It first tries
 490 /// to emit an instruction with a floating-point immediate operand using
 491 /// FastEmit_rf. If that fails, it materializes the immediate into a register
 492 /// and try FastEmit_rr instead.
 493 unsigned FastISel::FastEmit_rf_(MVT::SimpleValueType VT, ISD::NodeType Opcode,
 494                                 unsigned Op0, ConstantFP *FPImm,
 495                                 MVT::SimpleValueType ImmType) {
 496   // First check if immediate type is legal. If not, we can't use the rf form.
 497   unsigned ResultReg = FastEmit_rf(VT, VT, Opcode, Op0, FPImm);
 498   if (ResultReg != 0)
 499     return ResultReg;
 500
 501   // Materialize the constant in a register.
 502   unsigned MaterialReg = FastEmit_f(ImmType, ImmType, ISD::ConstantFP, FPImm);
 503   if (MaterialReg == 0) {
 504     // If the target doesn't have a way to directly enter a floating-point
 505     // value into a register, use an alternate approach.
 506     // TODO: The current approach only supports floating-point constants
 507     // that can be constructed by conversion from integer values. This should
 508     // be replaced by code that creates a load from a constant-pool entry,
 509     // which will require some target-specific work.
 510     const APFloat &Flt = FPImm->getValueAPF();
 511     MVT IntVT = TLI.getPointerTy();
 512
 513     uint64_t x[2];
 514     uint32_t IntBitWidth = IntVT.getSizeInBits();
 515     if (Flt.convertToInteger(x, IntBitWidth, /*isSigned=*/true,
 516                              APFloat::rmTowardZero) != APFloat::opOK)
 517       return 0;
 518     APInt IntVal(IntBitWidth, 2, x);
 519
 520     unsigned IntegerReg = FastEmit_i(IntVT.getSimpleVT(), IntVT.getSimpleVT(),
 521                                      ISD::Constant, IntVal.getZExtValue());
 522     if (IntegerReg == 0)
 523       return 0;
 524     MaterialReg = FastEmit_r(IntVT.getSimpleVT(), VT,
 525                              ISD::SINT_TO_FP, IntegerReg);
 526     if (MaterialReg == 0)
 527       return 0;
 528   }
 529   return FastEmit_rr(VT, VT, Opcode, Op0, MaterialReg);
 530 }
 531
 532 unsigned FastISel::createResultReg(const TargetRegisterClass* RC) {
 533   return MRI.createVirtualRegister(RC);
 534 }
 535
 536 unsigned FastISel::FastEmitInst_(unsigned MachineInstOpcode,
 537                                  const TargetRegisterClass* RC) {
 538   unsigned ResultReg = createResultReg(RC);
 539   const TargetInstrDesc &II = TII.get(MachineInstOpcode);
 540
 541   BuildMI(MBB, II, ResultReg);
 542   return ResultReg;
 543 }
 544
 545 unsigned FastISel::FastEmitInst_r(unsigned MachineInstOpcode,
 546                                   const TargetRegisterClass *RC,
 547                                   unsigned Op0) {
 548   unsigned ResultReg = createResultReg(RC);
 549   const TargetInstrDesc &II = TII.get(MachineInstOpcode);
 550
 551   BuildMI(MBB, II, ResultReg).addReg(Op0);
 552   return ResultReg;
 553 }
 554
 555 unsigned FastISel::FastEmitInst_rr(unsigned MachineInstOpcode,
 556                                    const TargetRegisterClass *RC,
 557                                    unsigned Op0, unsigned Op1) {
 558   unsigned ResultReg = createResultReg(RC);
 559   const TargetInstrDesc &II = TII.get(MachineInstOpcode);
 560
 561   BuildMI(MBB, II, ResultReg).addReg(Op0).addReg(Op1);
 562   return ResultReg;
 563 }
 564
 565 unsigned FastISel::FastEmitInst_ri(unsigned MachineInstOpcode,
 566                                    const TargetRegisterClass *RC,
 567                                    unsigned Op0, uint64_t Imm) {
 568   unsigned ResultReg = createResultReg(RC);
 569   const TargetInstrDesc &II = TII.get(MachineInstOpcode);
 570
 571   BuildMI(MBB, II, ResultReg).addReg(Op0).addImm(Imm);
 572   return ResultReg;
 573 }
 574
 575 unsigned FastISel::FastEmitInst_rf(unsigned MachineInstOpcode,
 576                                    const TargetRegisterClass *RC,
 577                                    unsigned Op0, ConstantFP *FPImm) {
 578   unsigned ResultReg = createResultReg(RC);
 579   const TargetInstrDesc &II = TII.get(MachineInstOpcode);
 580
 581   BuildMI(MBB, II, ResultReg).addReg(Op0).addFPImm(FPImm);
 582   return ResultReg;
 583 }
 584
 585 unsigned FastISel::FastEmitInst_rri(unsigned MachineInstOpcode,
 586                                     const TargetRegisterClass *RC,
 587                                     unsigned Op0, unsigned Op1, uint64_t Imm) {
 588   unsigned ResultReg = createResultReg(RC);
 589   const TargetInstrDesc &II = TII.get(MachineInstOpcode);
 590
 591   BuildMI(MBB, II, ResultReg).addReg(Op0).addReg(Op1).addImm(Imm);
 592   return ResultReg;
 593 }
 594
 595 unsigned FastISel::FastEmitInst_i(unsigned MachineInstOpcode,
 596                                   const TargetRegisterClass *RC,
 597                                   uint64_t Imm) {
 598   unsigned ResultReg = createResultReg(RC);
 599   const TargetInstrDesc &II = TII.get(MachineInstOpcode);
 600
 601   BuildMI(MBB, II, ResultReg).addImm(Imm);
 602   return ResultReg;
 603 }
 604
 605 unsigned FastISel::FastEmitInst_extractsubreg(unsigned Op0, uint32_t Idx) {
 606   const TargetRegisterClass* RC = MRI.getRegClass(Op0);
 607   const TargetRegisterClass* SRC = *(RC->subregclasses_begin()+Idx-1);
 608
 609   unsigned ResultReg = createResultReg(SRC);
 610   const TargetInstrDesc &II = TII.get(TargetInstrInfo::EXTRACT_SUBREG);
 611
 612   BuildMI(MBB, II, ResultReg).addReg(Op0).addImm(Idx);
 613   return ResultReg;
 614 }