lib/Target/X86/X86FastISel.cpp

   1 //===-- X86FastISel.cpp - X86 FastISel implementation ---------------------===//\r
   2 //\r
   3 //                     The LLVM Compiler Infrastructure\r
   4 //\r
   5 // This file is distributed under the University of Illinois Open Source\r
   6 // License. See LICENSE.TXT for details.\r
   7 //\r
   8 //===----------------------------------------------------------------------===//\r
   9 //\r
  10 // This file defines the X86-specific support for the FastISel class. Much\r
  11 // of the target-specific code is generated by tablegen in the file\r
  12 // X86GenFastISel.inc, which is #included here.\r
  13 //\r
  14 //===----------------------------------------------------------------------===//\r
  15 \r
  16 #include "X86.h"\r
  17 #include "X86CallingConv.h"\r
  18 #include "X86InstrBuilder.h"\r
  19 #include "X86InstrInfo.h"\r
  20 #include "X86MachineFunctionInfo.h"\r
  21 #include "X86RegisterInfo.h"\r
  22 #include "X86Subtarget.h"\r
  23 #include "X86TargetMachine.h"\r
  24 #include "llvm/Analysis/BranchProbabilityInfo.h"\r
  25 #include "llvm/CodeGen/Analysis.h"\r
  26 #include "llvm/CodeGen/FastISel.h"\r
  27 #include "llvm/CodeGen/FunctionLoweringInfo.h"\r
  28 #include "llvm/CodeGen/MachineConstantPool.h"\r
  29 #include "llvm/CodeGen/MachineFrameInfo.h"\r
  30 #include "llvm/CodeGen/MachineRegisterInfo.h"\r
  31 #include "llvm/IR/CallSite.h"\r
  32 #include "llvm/IR/CallingConv.h"\r
  33 #include "llvm/IR/DerivedTypes.h"\r
  34 #include "llvm/IR/GetElementPtrTypeIterator.h"\r
  35 #include "llvm/IR/GlobalAlias.h"\r
  36 #include "llvm/IR/GlobalVariable.h"\r
  37 #include "llvm/IR/Instructions.h"\r
  38 #include "llvm/IR/IntrinsicInst.h"\r
  39 #include "llvm/IR/Operator.h"\r
  40 #include "llvm/Support/ErrorHandling.h"\r
  41 #include "llvm/Target/TargetOptions.h"\r
  42 using namespace llvm;\r
  43 \r
  44 namespace {\r
  45 \r
  46 class X86FastISel final : public FastISel {\r
  47   /// Subtarget - Keep a pointer to the X86Subtarget around so that we can\r
  48   /// make the right decision when generating code for different targets.\r
  49   const X86Subtarget *Subtarget;\r
  50 \r
  51   /// X86ScalarSSEf32, X86ScalarSSEf64 - Select between SSE or x87\r
  52   /// floating point ops.\r
  53   /// When SSE is available, use it for f32 operations.\r
  54   /// When SSE2 is available, use it for f64 operations.\r
  55   bool X86ScalarSSEf64;\r
  56   bool X86ScalarSSEf32;\r
  57 \r
  58 public:\r
  59   explicit X86FastISel(FunctionLoweringInfo &funcInfo,\r
  60                        const TargetLibraryInfo *libInfo)\r
  61     : FastISel(funcInfo, libInfo) {\r
  62     Subtarget = &TM.getSubtarget<X86Subtarget>();\r
  63     X86ScalarSSEf64 = Subtarget->hasSSE2();\r
  64     X86ScalarSSEf32 = Subtarget->hasSSE1();\r
  65   }\r
  66 \r
  67   bool fastSelectInstruction(const Instruction *I) override;\r
  68 \r
  69   /// \brief The specified machine instr operand is a vreg, and that\r
  70   /// vreg is being provided by the specified load instruction.  If possible,\r
  71   /// try to fold the load as an operand to the instruction, returning true if\r
  72   /// possible.\r
  73   bool tryToFoldLoadIntoMI(MachineInstr *MI, unsigned OpNo,\r
  74                            const LoadInst *LI) override;\r
  75 \r
  76   bool fastLowerArguments() override;\r
  77   bool fastLowerCall(CallLoweringInfo &CLI) override;\r
  78   bool fastLowerIntrinsicCall(const IntrinsicInst *II) override;\r
  79 \r
  80 #include "X86GenFastISel.inc"\r
  81 \r
  82 private:\r
  83   bool X86FastEmitCompare(const Value *LHS, const Value *RHS, EVT VT, DebugLoc DL);\r
  84 \r
  85   bool X86FastEmitLoad(EVT VT, const X86AddressMode &AM, MachineMemOperand *MMO,\r
  86                        unsigned &ResultReg);\r
  87 \r
  88   bool X86FastEmitStore(EVT VT, const Value *Val, const X86AddressMode &AM,\r
  89                         MachineMemOperand *MMO = nullptr, bool Aligned = false);\r
  90   bool X86FastEmitStore(EVT VT, unsigned ValReg, bool ValIsKill,\r
  91                         const X86AddressMode &AM,\r
  92                         MachineMemOperand *MMO = nullptr, bool Aligned = false);\r
  93 \r
  94   bool X86FastEmitExtend(ISD::NodeType Opc, EVT DstVT, unsigned Src, EVT SrcVT,\r
  95                          unsigned &ResultReg);\r
  96 \r
  97   bool X86SelectAddress(const Value *V, X86AddressMode &AM);\r
  98   bool X86SelectCallAddress(const Value *V, X86AddressMode &AM);\r
  99 \r
 100   bool X86SelectLoad(const Instruction *I);\r
 101 \r
 102   bool X86SelectStore(const Instruction *I);\r
 103 \r
 104   bool X86SelectRet(const Instruction *I);\r
 105 \r
 106   bool X86SelectCmp(const Instruction *I);\r
 107 \r
 108   bool X86SelectZExt(const Instruction *I);\r
 109 \r
 110   bool X86SelectBranch(const Instruction *I);\r
 111 \r
 112   bool X86SelectShift(const Instruction *I);\r
 113 \r
 114   bool X86SelectDivRem(const Instruction *I);\r
 115 \r
 116   bool X86FastEmitCMoveSelect(MVT RetVT, const Instruction *I);\r
 117 \r
 118   bool X86FastEmitSSESelect(MVT RetVT, const Instruction *I);\r
 119 \r
 120   bool X86FastEmitPseudoSelect(MVT RetVT, const Instruction *I);\r
 121 \r
 122   bool X86SelectSelect(const Instruction *I);\r
 123 \r
 124   bool X86SelectTrunc(const Instruction *I);\r
 125 \r
 126   bool X86SelectFPExt(const Instruction *I);\r
 127   bool X86SelectFPTrunc(const Instruction *I);\r
 128 \r
 129   const X86InstrInfo *getInstrInfo() const {\r
 130     return getTargetMachine()->getSubtargetImpl()->getInstrInfo();\r
 131   }\r
 132   const X86TargetMachine *getTargetMachine() const {\r
 133     return static_cast<const X86TargetMachine *>(&TM);\r
 134   }\r
 135 \r
 136   bool handleConstantAddresses(const Value *V, X86AddressMode &AM);\r
 137 \r
 138   unsigned X86MaterializeInt(const ConstantInt *CI, MVT VT);\r
 139   unsigned X86MaterializeFP(const ConstantFP *CFP, MVT VT);\r
 140   unsigned X86MaterializeGV(const GlobalValue *GV, MVT VT);\r
 141   unsigned fastMaterializeConstant(const Constant *C) override;\r
 142 \r
 143   unsigned fastMaterializeAlloca(const AllocaInst *C) override;\r
 144 \r
 145   unsigned fastMaterializeFloatZero(const ConstantFP *CF) override;\r
 146 \r
 147   /// isScalarFPTypeInSSEReg - Return true if the specified scalar FP type is\r
 148   /// computed in an SSE register, not on the X87 floating point stack.\r
 149   bool isScalarFPTypeInSSEReg(EVT VT) const {\r
 150     return (VT == MVT::f64 && X86ScalarSSEf64) || // f64 is when SSE2\r
 151       (VT == MVT::f32 && X86ScalarSSEf32);   // f32 is when SSE1\r
 152   }\r
 153 \r
 154   bool isTypeLegal(Type *Ty, MVT &VT, bool AllowI1 = false);\r
 155 \r
 156   bool IsMemcpySmall(uint64_t Len);\r
 157 \r
 158   bool TryEmitSmallMemcpy(X86AddressMode DestAM,\r
 159                           X86AddressMode SrcAM, uint64_t Len);\r
 160 \r
 161   bool foldX86XALUIntrinsic(X86::CondCode &CC, const Instruction *I,\r
 162                             const Value *Cond);\r
 163 };\r
 164 \r
 165 } // end anonymous namespace.\r
 166 \r
 167 static std::pair<X86::CondCode, bool>\r
 168 getX86ConditionCode(CmpInst::Predicate Predicate) {\r
 169   X86::CondCode CC = X86::COND_INVALID;\r
 170   bool NeedSwap = false;\r
 171   switch (Predicate) {\r
 172   default: break;\r
 173   // Floating-point Predicates\r
 174   case CmpInst::FCMP_UEQ: CC = X86::COND_E;       break;\r
 175   case CmpInst::FCMP_OLT: NeedSwap = true; // fall-through\r
 176   case CmpInst::FCMP_OGT: CC = X86::COND_A;       break;\r
 177   case CmpInst::FCMP_OLE: NeedSwap = true; // fall-through\r
 178   case CmpInst::FCMP_OGE: CC = X86::COND_AE;      break;\r
 179   case CmpInst::FCMP_UGT: NeedSwap = true; // fall-through\r
 180   case CmpInst::FCMP_ULT: CC = X86::COND_B;       break;\r
 181   case CmpInst::FCMP_UGE: NeedSwap = true; // fall-through\r
 182   case CmpInst::FCMP_ULE: CC = X86::COND_BE;      break;\r
 183   case CmpInst::FCMP_ONE: CC = X86::COND_NE;      break;\r
 184   case CmpInst::FCMP_UNO: CC = X86::COND_P;       break;\r
 185   case CmpInst::FCMP_ORD: CC = X86::COND_NP;      break;\r
 186   case CmpInst::FCMP_OEQ: // fall-through\r
 187   case CmpInst::FCMP_UNE: CC = X86::COND_INVALID; break;\r
 188 \r
 189   // Integer Predicates\r
 190   case CmpInst::ICMP_EQ:  CC = X86::COND_E;       break;\r
 191   case CmpInst::ICMP_NE:  CC = X86::COND_NE;      break;\r
 192   case CmpInst::ICMP_UGT: CC = X86::COND_A;       break;\r
 193   case CmpInst::ICMP_UGE: CC = X86::COND_AE;      break;\r
 194   case CmpInst::ICMP_ULT: CC = X86::COND_B;       break;\r
 195   case CmpInst::ICMP_ULE: CC = X86::COND_BE;      break;\r
 196   case CmpInst::ICMP_SGT: CC = X86::COND_G;       break;\r
 197   case CmpInst::ICMP_SGE: CC = X86::COND_GE;      break;\r
 198   case CmpInst::ICMP_SLT: CC = X86::COND_L;       break;\r
 199   case CmpInst::ICMP_SLE: CC = X86::COND_LE;      break;\r
 200   }\r
 201 \r
 202   return std::make_pair(CC, NeedSwap);\r
 203 }\r
 204 \r
 205 static std::pair<unsigned, bool>\r
 206 getX86SSEConditionCode(CmpInst::Predicate Predicate) {\r
 207   unsigned CC;\r
 208   bool NeedSwap = false;\r
 209 \r
 210   // SSE Condition code mapping:\r
 211   //  0 - EQ\r
 212   //  1 - LT\r
 213   //  2 - LE\r
 214   //  3 - UNORD\r
 215   //  4 - NEQ\r
 216   //  5 - NLT\r
 217   //  6 - NLE\r
 218   //  7 - ORD\r
 219   switch (Predicate) {\r
 220   default: llvm_unreachable("Unexpected predicate");\r
 221   case CmpInst::FCMP_OEQ: CC = 0;          break;\r
 222   case CmpInst::FCMP_OGT: NeedSwap = true; // fall-through\r
 223   case CmpInst::FCMP_OLT: CC = 1;          break;\r
 224   case CmpInst::FCMP_OGE: NeedSwap = true; // fall-through\r
 225   case CmpInst::FCMP_OLE: CC = 2;          break;\r
 226   case CmpInst::FCMP_UNO: CC = 3;          break;\r
 227   case CmpInst::FCMP_UNE: CC = 4;          break;\r
 228   case CmpInst::FCMP_ULE: NeedSwap = true; // fall-through\r
 229   case CmpInst::FCMP_UGE: CC = 5;          break;\r
 230   case CmpInst::FCMP_ULT: NeedSwap = true; // fall-through\r
 231   case CmpInst::FCMP_UGT: CC = 6;          break;\r
 232   case CmpInst::FCMP_ORD: CC = 7;          break;\r
 233   case CmpInst::FCMP_UEQ:\r
 234   case CmpInst::FCMP_ONE: CC = 8;          break;\r
 235   }\r
 236 \r
 237   return std::make_pair(CC, NeedSwap);\r
 238 }\r
 239 \r
 240 /// \brief Check if it is possible to fold the condition from the XALU intrinsic\r
 241 /// into the user. The condition code will only be updated on success.\r
 242 bool X86FastISel::foldX86XALUIntrinsic(X86::CondCode &CC, const Instruction *I,\r
 243                                        const Value *Cond) {\r
 244   if (!isa<ExtractValueInst>(Cond))\r
 245     return false;\r
 246 \r
 247   const auto *EV = cast<ExtractValueInst>(Cond);\r
 248   if (!isa<IntrinsicInst>(EV->getAggregateOperand()))\r
 249     return false;\r
 250 \r
 251   const auto *II = cast<IntrinsicInst>(EV->getAggregateOperand());\r
 252   MVT RetVT;\r
 253   const Function *Callee = II->getCalledFunction();\r
 254   Type *RetTy =\r
 255     cast<StructType>(Callee->getReturnType())->getTypeAtIndex(0U);\r
 256   if (!isTypeLegal(RetTy, RetVT))\r
 257     return false;\r
 258 \r
 259   if (RetVT != MVT::i32 && RetVT != MVT::i64)\r
 260     return false;\r
 261 \r
 262   X86::CondCode TmpCC;\r
 263   switch (II->getIntrinsicID()) {\r
 264   default: return false;\r
 265   case Intrinsic::sadd_with_overflow:\r
 266   case Intrinsic::ssub_with_overflow:\r
 267   case Intrinsic::smul_with_overflow:\r
 268   case Intrinsic::umul_with_overflow: TmpCC = X86::COND_O; break;\r
 269   case Intrinsic::uadd_with_overflow:\r
 270   case Intrinsic::usub_with_overflow: TmpCC = X86::COND_B; break;\r
 271   }\r
 272 \r
 273   // Check if both instructions are in the same basic block.\r
 274   if (II->getParent() != I->getParent())\r
 275     return false;\r
 276 \r
 277   // Make sure nothing is in the way\r
 278   BasicBlock::const_iterator Start = I;\r
 279   BasicBlock::const_iterator End = II;\r
 280   for (auto Itr = std::prev(Start); Itr != End; --Itr) {\r
 281     // We only expect extractvalue instructions between the intrinsic and the\r
 282     // instruction to be selected.\r
 283     if (!isa<ExtractValueInst>(Itr))\r
 284       return false;\r
 285 \r
 286     // Check that the extractvalue operand comes from the intrinsic.\r
 287     const auto *EVI = cast<ExtractValueInst>(Itr);\r
 288     if (EVI->getAggregateOperand() != II)\r
 289       return false;\r
 290   }\r
 291 \r
 292   CC = TmpCC;\r
 293   return true;\r
 294 }\r
 295 \r
 296 bool X86FastISel::isTypeLegal(Type *Ty, MVT &VT, bool AllowI1) {\r
 297   EVT evt = TLI.getValueType(Ty, /*HandleUnknown=*/true);\r
 298   if (evt == MVT::Other || !evt.isSimple())\r
 299     // Unhandled type. Halt "fast" selection and bail.\r
 300     return false;\r
 301 \r
 302   VT = evt.getSimpleVT();\r
 303   // For now, require SSE/SSE2 for performing floating-point operations,\r
 304   // since x87 requires additional work.\r
 305   if (VT == MVT::f64 && !X86ScalarSSEf64)\r
 306     return false;\r
 307   if (VT == MVT::f32 && !X86ScalarSSEf32)\r
 308     return false;\r
 309   // Similarly, no f80 support yet.\r
 310   if (VT == MVT::f80)\r
 311     return false;\r
 312   // We only handle legal types. For example, on x86-32 the instruction\r
 313   // selector contains all of the 64-bit instructions from x86-64,\r
 314   // under the assumption that i64 won't be used if the target doesn't\r
 315   // support it.\r
 316   return (AllowI1 && VT == MVT::i1) || TLI.isTypeLegal(VT);\r
 317 }\r
 318 \r
 319 #include "X86GenCallingConv.inc"\r
 320 \r
 321 /// X86FastEmitLoad - Emit a machine instruction to load a value of type VT.\r
 322 /// The address is either pre-computed, i.e. Ptr, or a GlobalAddress, i.e. GV.\r
 323 /// Return true and the result register by reference if it is possible.\r
 324 bool X86FastISel::X86FastEmitLoad(EVT VT, const X86AddressMode &AM,\r
 325                                   MachineMemOperand *MMO, unsigned &ResultReg) {\r
 326   // Get opcode and regclass of the output for the given load instruction.\r
 327   unsigned Opc = 0;\r
 328   const TargetRegisterClass *RC = nullptr;\r
 329   switch (VT.getSimpleVT().SimpleTy) {\r
 330   default: return false;\r
 331   case MVT::i1:\r
 332   case MVT::i8:\r
 333     Opc = X86::MOV8rm;\r
 334     RC  = &X86::GR8RegClass;\r
 335     break;\r
 336   case MVT::i16:\r
 337     Opc = X86::MOV16rm;\r
 338     RC  = &X86::GR16RegClass;\r
 339     break;\r
 340   case MVT::i32:\r
 341     Opc = X86::MOV32rm;\r
 342     RC  = &X86::GR32RegClass;\r
 343     break;\r
 344   case MVT::i64:\r
 345     // Must be in x86-64 mode.\r
 346     Opc = X86::MOV64rm;\r
 347     RC  = &X86::GR64RegClass;\r
 348     break;\r
 349   case MVT::f32:\r
 350     if (X86ScalarSSEf32) {\r
 351       Opc = Subtarget->hasAVX() ? X86::VMOVSSrm : X86::MOVSSrm;\r
 352       RC  = &X86::FR32RegClass;\r
 353     } else {\r
 354       Opc = X86::LD_Fp32m;\r
 355       RC  = &X86::RFP32RegClass;\r
 356     }\r
 357     break;\r
 358   case MVT::f64:\r
 359     if (X86ScalarSSEf64) {\r
 360       Opc = Subtarget->hasAVX() ? X86::VMOVSDrm : X86::MOVSDrm;\r
 361       RC  = &X86::FR64RegClass;\r
 362     } else {\r
 363       Opc = X86::LD_Fp64m;\r
 364       RC  = &X86::RFP64RegClass;\r
 365     }\r
 366     break;\r
 367   case MVT::f80:\r
 368     // No f80 support yet.\r
 369     return false;\r
 370   }\r
 371 \r
 372   ResultReg = createResultReg(RC);\r
 373   MachineInstrBuilder MIB =\r
 374     BuildMI(*FuncInfo.MBB, FuncInfo.InsertPt, DbgLoc, TII.get(Opc), ResultReg);\r
 375   addFullAddress(MIB, AM);\r
 376   if (MMO)\r
 377     MIB->addMemOperand(*FuncInfo.MF, MMO);\r
 378   return true;\r
 379 }\r
 380 \r
 381 /// X86FastEmitStore - Emit a machine instruction to store a value Val of\r
 382 /// type VT. The address is either pre-computed, consisted of a base ptr, Ptr\r
 383 /// and a displacement offset, or a GlobalAddress,\r
 384 /// i.e. V. Return true if it is possible.\r
 385 bool X86FastISel::X86FastEmitStore(EVT VT, unsigned ValReg, bool ValIsKill,\r
 386                                    const X86AddressMode &AM,\r
 387                                    MachineMemOperand *MMO, bool Aligned) {\r
 388   // Get opcode and regclass of the output for the given store instruction.\r
 389   unsigned Opc = 0;\r
 390   switch (VT.getSimpleVT().SimpleTy) {\r
 391   case MVT::f80: // No f80 support yet.\r
 392   default: return false;\r
 393   case MVT::i1: {\r
 394     // Mask out all but lowest bit.\r
 395     unsigned AndResult = createResultReg(&X86::GR8RegClass);\r
 396     BuildMI(*FuncInfo.MBB, FuncInfo.InsertPt, DbgLoc,\r
 397             TII.get(X86::AND8ri), AndResult)\r
 398       .addReg(ValReg, getKillRegState(ValIsKill)).addImm(1);\r
 399     ValReg = AndResult;\r
 400   }\r
 401   // FALLTHROUGH, handling i1 as i8.\r
 402   case MVT::i8:  Opc = X86::MOV8mr;  break;\r
 403   case MVT::i16: Opc = X86::MOV16mr; break;\r
 404   case MVT::i32: Opc = X86::MOV32mr; break;\r
 405   case MVT::i64: Opc = X86::MOV64mr; break; // Must be in x86-64 mode.\r
 406   case MVT::f32:\r
 407     Opc = X86ScalarSSEf32 ?\r
 408           (Subtarget->hasAVX() ? X86::VMOVSSmr : X86::MOVSSmr) : X86::ST_Fp32m;\r
 409     break;\r
 410   case MVT::f64:\r
 411     Opc = X86ScalarSSEf64 ?\r
 412           (Subtarget->hasAVX() ? X86::VMOVSDmr : X86::MOVSDmr) : X86::ST_Fp64m;\r
 413     break;\r
 414   case MVT::v4f32:\r
 415     if (Aligned)\r
 416       Opc = Subtarget->hasAVX() ? X86::VMOVAPSmr : X86::MOVAPSmr;\r
 417     else\r
 418       Opc = Subtarget->hasAVX() ? X86::VMOVUPSmr : X86::MOVUPSmr;\r
 419     break;\r
 420   case MVT::v2f64:\r
 421     if (Aligned)\r
 422       Opc = Subtarget->hasAVX() ? X86::VMOVAPDmr : X86::MOVAPDmr;\r
 423     else\r
 424       Opc = Subtarget->hasAVX() ? X86::VMOVUPDmr : X86::MOVUPDmr;\r
 425     break;\r
 426   case MVT::v4i32:\r
 427   case MVT::v2i64:\r
 428   case MVT::v8i16:\r
 429   case MVT::v16i8:\r
 430     if (Aligned)\r
 431       Opc = Subtarget->hasAVX() ? X86::VMOVDQAmr : X86::MOVDQAmr;\r
 432     else\r
 433       Opc = Subtarget->hasAVX() ? X86::VMOVDQUmr : X86::MOVDQUmr;\r
 434     break;\r
 435   }\r
 436 \r
 437   MachineInstrBuilder MIB =\r
 438     BuildMI(*FuncInfo.MBB, FuncInfo.InsertPt, DbgLoc, TII.get(Opc));\r
 439   addFullAddress(MIB, AM).addReg(ValReg, getKillRegState(ValIsKill));\r
 440   if (MMO)\r
 441     MIB->addMemOperand(*FuncInfo.MF, MMO);\r
 442 \r
 443   return true;\r
 444 }\r
 445 \r
 446 bool X86FastISel::X86FastEmitStore(EVT VT, const Value *Val,\r
 447                                    const X86AddressMode &AM,\r
 448                                    MachineMemOperand *MMO, bool Aligned) {\r
 449   // Handle 'null' like i32/i64 0.\r
 450   if (isa<ConstantPointerNull>(Val))\r
 451     Val = Constant::getNullValue(DL.getIntPtrType(Val->getContext()));\r
 452 \r
 453   // If this is a store of a simple constant, fold the constant into the store.\r
 454   if (const ConstantInt *CI = dyn_cast<ConstantInt>(Val)) {\r
 455     unsigned Opc = 0;\r
 456     bool Signed = true;\r
 457     switch (VT.getSimpleVT().SimpleTy) {\r
 458     default: break;\r
 459     case MVT::i1:  Signed = false;     // FALLTHROUGH to handle as i8.\r
 460     case MVT::i8:  Opc = X86::MOV8mi;  break;\r
 461     case MVT::i16: Opc = X86::MOV16mi; break;\r
 462     case MVT::i32: Opc = X86::MOV32mi; break;\r
 463     case MVT::i64:\r
 464       // Must be a 32-bit sign extended value.\r
 465       if (isInt<32>(CI->getSExtValue()))\r
 466         Opc = X86::MOV64mi32;\r
 467       break;\r
 468     }\r
 469 \r
 470     if (Opc) {\r
 471       MachineInstrBuilder MIB =\r
 472         BuildMI(*FuncInfo.MBB, FuncInfo.InsertPt, DbgLoc, TII.get(Opc));\r
 473       addFullAddress(MIB, AM).addImm(Signed ? (uint64_t) CI->getSExtValue()\r
 474                                             : CI->getZExtValue());\r
 475       if (MMO)\r
 476         MIB->addMemOperand(*FuncInfo.MF, MMO);\r
 477       return true;\r
 478     }\r
 479   }\r
 480 \r
 481   unsigned ValReg = getRegForValue(Val);\r
 482   if (ValReg == 0)\r
 483     return false;\r
 484 \r
 485   bool ValKill = hasTrivialKill(Val);\r
 486   return X86FastEmitStore(VT, ValReg, ValKill, AM, MMO, Aligned);\r
 487 }\r
 488 \r
 489 /// X86FastEmitExtend - Emit a machine instruction to extend a value Src of\r
 490 /// type SrcVT to type DstVT using the specified extension opcode Opc (e.g.\r
 491 /// ISD::SIGN_EXTEND).\r
 492 bool X86FastISel::X86FastEmitExtend(ISD::NodeType Opc, EVT DstVT,\r
 493                                     unsigned Src, EVT SrcVT,\r
 494                                     unsigned &ResultReg) {\r
 495   unsigned RR = fastEmit_r(SrcVT.getSimpleVT(), DstVT.getSimpleVT(), Opc,\r
 496                            Src, /*TODO: Kill=*/false);\r
 497   if (RR == 0)\r
 498     return false;\r
 499 \r
 500   ResultReg = RR;\r
 501   return true;\r
 502 }\r
 503 \r
 504 bool X86FastISel::handleConstantAddresses(const Value *V, X86AddressMode &AM) {\r
 505   // Handle constant address.\r
 506   if (const GlobalValue *GV = dyn_cast<GlobalValue>(V)) {\r
 507     // Can't handle alternate code models yet.\r
 508     if (TM.getCodeModel() != CodeModel::Small)\r
 509       return false;\r
 510 \r
 511     // Can't handle TLS yet.\r
 512     if (GV->isThreadLocal())\r
 513       return false;\r
 514 \r
 515     // RIP-relative addresses can't have additional register operands, so if\r
 516     // we've already folded stuff into the addressing mode, just force the\r
 517     // global value into its own register, which we can use as the basereg.\r
 518     if (!Subtarget->isPICStyleRIPRel() ||\r
 519         (AM.Base.Reg == 0 && AM.IndexReg == 0)) {\r
 520       // Okay, we've committed to selecting this global. Set up the address.\r
 521       AM.GV = GV;\r
 522 \r
 523       // Allow the subtarget to classify the global.\r
 524       unsigned char GVFlags = Subtarget->ClassifyGlobalReference(GV, TM);\r
 525 \r
 526       // If this reference is relative to the pic base, set it now.\r
 527       if (isGlobalRelativeToPICBase(GVFlags)) {\r
 528         // FIXME: How do we know Base.Reg is free??\r
 529         AM.Base.Reg = getInstrInfo()->getGlobalBaseReg(FuncInfo.MF);\r
 530       }\r
 531 \r
 532       // Unless the ABI requires an extra load, return a direct reference to\r
 533       // the global.\r
 534       if (!isGlobalStubReference(GVFlags)) {\r
 535         if (Subtarget->isPICStyleRIPRel()) {\r
 536           // Use rip-relative addressing if we can.  Above we verified that the\r
 537           // base and index registers are unused.\r
 538           assert(AM.Base.Reg == 0 && AM.IndexReg == 0);\r
 539           AM.Base.Reg = X86::RIP;\r
 540         }\r
 541         AM.GVOpFlags = GVFlags;\r
 542         return true;\r
 543       }\r
 544 \r
 545       // Ok, we need to do a load from a stub.  If we've already loaded from\r
 546       // this stub, reuse the loaded pointer, otherwise emit the load now.\r
 547       DenseMap<const Value *, unsigned>::iterator I = LocalValueMap.find(V);\r
 548       unsigned LoadReg;\r
 549       if (I != LocalValueMap.end() && I->second != 0) {\r
 550         LoadReg = I->second;\r
 551       } else {\r
 552         // Issue load from stub.\r
 553         unsigned Opc = 0;\r
 554         const TargetRegisterClass *RC = nullptr;\r
 555         X86AddressMode StubAM;\r
 556         StubAM.Base.Reg = AM.Base.Reg;\r
 557         StubAM.GV = GV;\r
 558         StubAM.GVOpFlags = GVFlags;\r
 559 \r
 560         // Prepare for inserting code in the local-value area.\r
 561         SavePoint SaveInsertPt = enterLocalValueArea();\r
 562 \r
 563         if (TLI.getPointerTy() == MVT::i64) {\r
 564           Opc = X86::MOV64rm;\r
 565           RC  = &X86::GR64RegClass;\r
 566 \r
 567           if (Subtarget->isPICStyleRIPRel())\r
 568             StubAM.Base.Reg = X86::RIP;\r
 569         } else {\r
 570           Opc = X86::MOV32rm;\r
 571           RC  = &X86::GR32RegClass;\r
 572         }\r
 573 \r
 574         LoadReg = createResultReg(RC);\r
 575         MachineInstrBuilder LoadMI =\r
 576           BuildMI(*FuncInfo.MBB, FuncInfo.InsertPt, DbgLoc, TII.get(Opc), LoadReg);\r
 577         addFullAddress(LoadMI, StubAM);\r
 578 \r
 579         // Ok, back to normal mode.\r
 580         leaveLocalValueArea(SaveInsertPt);\r
 581 \r
 582         // Prevent loading GV stub multiple times in same MBB.\r
 583         LocalValueMap[V] = LoadReg;\r
 584       }\r
 585 \r
 586       // Now construct the final address. Note that the Disp, Scale,\r
 587       // and Index values may already be set here.\r
 588       AM.Base.Reg = LoadReg;\r
 589       AM.GV = nullptr;\r
 590       return true;\r
 591     }\r
 592   }\r
 593 \r
 594   // If all else fails, try to materialize the value in a register.\r
 595   if (!AM.GV || !Subtarget->isPICStyleRIPRel()) {\r
 596     if (AM.Base.Reg == 0) {\r
 597       AM.Base.Reg = getRegForValue(V);\r
 598       return AM.Base.Reg != 0;\r
 599     }\r
 600     if (AM.IndexReg == 0) {\r
 601       assert(AM.Scale == 1 && "Scale with no index!");\r
 602       AM.IndexReg = getRegForValue(V);\r
 603       return AM.IndexReg != 0;\r
 604     }\r
 605   }\r
 606 \r
 607   return false;\r
 608 }\r
 609 \r
 610 /// X86SelectAddress - Attempt to fill in an address from the given value.\r
 611 ///\r
 612 bool X86FastISel::X86SelectAddress(const Value *V, X86AddressMode &AM) {\r
 613   SmallVector<const Value *, 32> GEPs;\r
 614 redo_gep:\r
 615   const User *U = nullptr;\r
 616   unsigned Opcode = Instruction::UserOp1;\r
 617   if (const Instruction *I = dyn_cast<Instruction>(V)) {\r
 618     // Don't walk into other basic blocks; it's possible we haven't\r
 619     // visited them yet, so the instructions may not yet be assigned\r
 620     // virtual registers.\r
 621     if (FuncInfo.StaticAllocaMap.count(static_cast<const AllocaInst *>(V)) ||\r
 622         FuncInfo.MBBMap[I->getParent()] == FuncInfo.MBB) {\r
 623       Opcode = I->getOpcode();\r
 624       U = I;\r
 625     }\r
 626   } else if (const ConstantExpr *C = dyn_cast<ConstantExpr>(V)) {\r
 627     Opcode = C->getOpcode();\r
 628     U = C;\r
 629   }\r
 630 \r
 631   if (PointerType *Ty = dyn_cast<PointerType>(V->getType()))\r
 632     if (Ty->getAddressSpace() > 255)\r
 633       // Fast instruction selection doesn't support the special\r
 634       // address spaces.\r
 635       return false;\r
 636 \r
 637   switch (Opcode) {\r
 638   default: break;\r
 639   case Instruction::BitCast:\r
 640     // Look past bitcasts.\r
 641     return X86SelectAddress(U->getOperand(0), AM);\r
 642 \r
 643   case Instruction::IntToPtr:\r
 644     // Look past no-op inttoptrs.\r
 645     if (TLI.getValueType(U->getOperand(0)->getType()) == TLI.getPointerTy())\r
 646       return X86SelectAddress(U->getOperand(0), AM);\r
 647     break;\r
 648 \r
 649   case Instruction::PtrToInt:\r
 650     // Look past no-op ptrtoints.\r
 651     if (TLI.getValueType(U->getType()) == TLI.getPointerTy())\r
 652       return X86SelectAddress(U->getOperand(0), AM);\r
 653     break;\r
 654 \r
 655   case Instruction::Alloca: {\r
 656     // Do static allocas.\r
 657     const AllocaInst *A = cast<AllocaInst>(V);\r
 658     DenseMap<const AllocaInst *, int>::iterator SI =\r
 659       FuncInfo.StaticAllocaMap.find(A);\r
 660     if (SI != FuncInfo.StaticAllocaMap.end()) {\r
 661       AM.BaseType = X86AddressMode::FrameIndexBase;\r
 662       AM.Base.FrameIndex = SI->second;\r
 663       return true;\r
 664     }\r
 665     break;\r
 666   }\r
 667 \r
 668   case Instruction::Add: {\r
 669     // Adds of constants are common and easy enough.\r
 670     if (const ConstantInt *CI = dyn_cast<ConstantInt>(U->getOperand(1))) {\r
 671       uint64_t Disp = (int32_t)AM.Disp + (uint64_t)CI->getSExtValue();\r
 672       // They have to fit in the 32-bit signed displacement field though.\r
 673       if (isInt<32>(Disp)) {\r
 674         AM.Disp = (uint32_t)Disp;\r
 675         return X86SelectAddress(U->getOperand(0), AM);\r
 676       }\r
 677     }\r
 678     break;\r
 679   }\r
 680 \r
 681   case Instruction::GetElementPtr: {\r
 682     X86AddressMode SavedAM = AM;\r
 683 \r
 684     // Pattern-match simple GEPs.\r
 685     uint64_t Disp = (int32_t)AM.Disp;\r
 686     unsigned IndexReg = AM.IndexReg;\r
 687     unsigned Scale = AM.Scale;\r
 688     gep_type_iterator GTI = gep_type_begin(U);\r
 689     // Iterate through the indices, folding what we can. Constants can be\r
 690     // folded, and one dynamic index can be handled, if the scale is supported.\r
 691     for (User::const_op_iterator i = U->op_begin() + 1, e = U->op_end();\r
 692          i != e; ++i, ++GTI) {\r
 693       const Value *Op = *i;\r
 694       if (StructType *STy = dyn_cast<StructType>(*GTI)) {\r
 695         const StructLayout *SL = DL.getStructLayout(STy);\r
 696         Disp += SL->getElementOffset(cast<ConstantInt>(Op)->getZExtValue());\r
 697         continue;\r
 698       }\r
 699 \r
 700       // A array/variable index is always of the form i*S where S is the\r
 701       // constant scale size.  See if we can push the scale into immediates.\r
 702       uint64_t S = DL.getTypeAllocSize(GTI.getIndexedType());\r
 703       for (;;) {\r
 704         if (const ConstantInt *CI = dyn_cast<ConstantInt>(Op)) {\r
 705           // Constant-offset addressing.\r
 706           Disp += CI->getSExtValue() * S;\r
 707           break;\r
 708         }\r
 709         if (canFoldAddIntoGEP(U, Op)) {\r
 710           // A compatible add with a constant operand. Fold the constant.\r
 711           ConstantInt *CI =\r
 712             cast<ConstantInt>(cast<AddOperator>(Op)->getOperand(1));\r
 713           Disp += CI->getSExtValue() * S;\r
 714           // Iterate on the other operand.\r
 715           Op = cast<AddOperator>(Op)->getOperand(0);\r
 716           continue;\r
 717         }\r
 718         if (IndexReg == 0 &&\r
 719             (!AM.GV || !Subtarget->isPICStyleRIPRel()) &&\r
 720             (S == 1 || S == 2 || S == 4 || S == 8)) {\r
 721           // Scaled-index addressing.\r
 722           Scale = S;\r
 723           IndexReg = getRegForGEPIndex(Op).first;\r
 724           if (IndexReg == 0)\r
 725             return false;\r
 726           break;\r
 727         }\r
 728         // Unsupported.\r
 729         goto unsupported_gep;\r
 730       }\r
 731     }\r
 732 \r
 733     // Check for displacement overflow.\r
 734     if (!isInt<32>(Disp))\r
 735       break;\r
 736 \r
 737     AM.IndexReg = IndexReg;\r
 738     AM.Scale = Scale;\r
 739     AM.Disp = (uint32_t)Disp;\r
 740     GEPs.push_back(V);\r
 741 \r
 742     if (const GetElementPtrInst *GEP =\r
 743           dyn_cast<GetElementPtrInst>(U->getOperand(0))) {\r
 744       // Ok, the GEP indices were covered by constant-offset and scaled-index\r
 745       // addressing. Update the address state and move on to examining the base.\r
 746       V = GEP;\r
 747       goto redo_gep;\r
 748     } else if (X86SelectAddress(U->getOperand(0), AM)) {\r
 749       return true;\r
 750     }\r
 751 \r
 752     // If we couldn't merge the gep value into this addr mode, revert back to\r
 753     // our address and just match the value instead of completely failing.\r
 754     AM = SavedAM;\r
 755 \r
 756     for (SmallVectorImpl<const Value *>::reverse_iterator\r
 757            I = GEPs.rbegin(), E = GEPs.rend(); I != E; ++I)\r
 758       if (handleConstantAddresses(*I, AM))\r
 759         return true;\r
 760 \r
 761     return false;\r
 762   unsupported_gep:\r
 763     // Ok, the GEP indices weren't all covered.\r
 764     break;\r
 765   }\r
 766   }\r
 767 \r
 768   return handleConstantAddresses(V, AM);\r
 769 }\r
 770 \r
 771 /// X86SelectCallAddress - Attempt to fill in an address from the given value.\r
 772 ///\r
 773 bool X86FastISel::X86SelectCallAddress(const Value *V, X86AddressMode &AM) {\r
 774   const User *U = nullptr;\r
 775   unsigned Opcode = Instruction::UserOp1;\r
 776   const Instruction *I = dyn_cast<Instruction>(V);\r
 777   // Record if the value is defined in the same basic block.\r
 778   //\r
 779   // This information is crucial to know whether or not folding an\r
 780   // operand is valid.\r
 781   // Indeed, FastISel generates or reuses a virtual register for all\r
 782   // operands of all instructions it selects. Obviously, the definition and\r
 783   // its uses must use the same virtual register otherwise the produced\r
 784   // code is incorrect.\r
 785   // Before instruction selection, FunctionLoweringInfo::set sets the virtual\r
 786   // registers for values that are alive across basic blocks. This ensures\r
 787   // that the values are consistently set between across basic block, even\r
 788   // if different instruction selection mechanisms are used (e.g., a mix of\r
 789   // SDISel and FastISel).\r
 790   // For values local to a basic block, the instruction selection process\r
 791   // generates these virtual registers with whatever method is appropriate\r
 792   // for its needs. In particular, FastISel and SDISel do not share the way\r
 793   // local virtual registers are set.\r
 794   // Therefore, this is impossible (or at least unsafe) to share values\r
 795   // between basic blocks unless they use the same instruction selection\r
 796   // method, which is not guarantee for X86.\r
 797   // Moreover, things like hasOneUse could not be used accurately, if we\r
 798   // allow to reference values across basic blocks whereas they are not\r
 799   // alive across basic blocks initially.\r
 800   bool InMBB = true;\r
 801   if (I) {\r
 802     Opcode = I->getOpcode();\r
 803     U = I;\r
 804     InMBB = I->getParent() == FuncInfo.MBB->getBasicBlock();\r
 805   } else if (const ConstantExpr *C = dyn_cast<ConstantExpr>(V)) {\r
 806     Opcode = C->getOpcode();\r
 807     U = C;\r
 808   }\r
 809 \r
 810   switch (Opcode) {\r
 811   default: break;\r
 812   case Instruction::BitCast:\r
 813     // Look past bitcasts if its operand is in the same BB.\r
 814     if (InMBB)\r
 815       return X86SelectCallAddress(U->getOperand(0), AM);\r
 816     break;\r
 817 \r
 818   case Instruction::IntToPtr:\r
 819     // Look past no-op inttoptrs if its operand is in the same BB.\r
 820     if (InMBB &&\r
 821         TLI.getValueType(U->getOperand(0)->getType()) == TLI.getPointerTy())\r
 822       return X86SelectCallAddress(U->getOperand(0), AM);\r
 823     break;\r
 824 \r
 825   case Instruction::PtrToInt:\r
 826     // Look past no-op ptrtoints if its operand is in the same BB.\r
 827     if (InMBB &&\r
 828         TLI.getValueType(U->getType()) == TLI.getPointerTy())\r
 829       return X86SelectCallAddress(U->getOperand(0), AM);\r
 830     break;\r
 831   }\r
 832 \r
 833   // Handle constant address.\r
 834   if (const GlobalValue *GV = dyn_cast<GlobalValue>(V)) {\r
 835     // Can't handle alternate code models yet.\r
 836     if (TM.getCodeModel() != CodeModel::Small)\r
 837       return false;\r
 838 \r
 839     // RIP-relative addresses can't have additional register operands.\r
 840     if (Subtarget->isPICStyleRIPRel() &&\r
 841         (AM.Base.Reg != 0 || AM.IndexReg != 0))\r
 842       return false;\r
 843 \r
 844     // Can't handle DLL Import.\r
 845     if (GV->hasDLLImportStorageClass())\r
 846       return false;\r
 847 \r
 848     // Can't handle TLS.\r
 849     if (const GlobalVariable *GVar = dyn_cast<GlobalVariable>(GV))\r
 850       if (GVar->isThreadLocal())\r
 851         return false;\r
 852 \r
 853     // Okay, we've committed to selecting this global. Set up the basic address.\r
 854     AM.GV = GV;\r
 855 \r
 856     // No ABI requires an extra load for anything other than DLLImport, which\r
 857     // we rejected above. Return a direct reference to the global.\r
 858     if (Subtarget->isPICStyleRIPRel()) {\r
 859       // Use rip-relative addressing if we can.  Above we verified that the\r
 860       // base and index registers are unused.\r
 861       assert(AM.Base.Reg == 0 && AM.IndexReg == 0);\r
 862       AM.Base.Reg = X86::RIP;\r
 863     } else if (Subtarget->isPICStyleStubPIC()) {\r
 864       AM.GVOpFlags = X86II::MO_PIC_BASE_OFFSET;\r
 865     } else if (Subtarget->isPICStyleGOT()) {\r
 866       AM.GVOpFlags = X86II::MO_GOTOFF;\r
 867     }\r
 868 \r
 869     return true;\r
 870   }\r
 871 \r
 872   // If all else fails, try to materialize the value in a register.\r
 873   if (!AM.GV || !Subtarget->isPICStyleRIPRel()) {\r
 874     if (AM.Base.Reg == 0) {\r
 875       AM.Base.Reg = getRegForValue(V);\r
 876       return AM.Base.Reg != 0;\r
 877     }\r
 878     if (AM.IndexReg == 0) {\r
 879       assert(AM.Scale == 1 && "Scale with no index!");\r
 880       AM.IndexReg = getRegForValue(V);\r
 881       return AM.IndexReg != 0;\r
 882     }\r
 883   }\r
 884 \r
 885   return false;\r
 886 }\r
 887 \r
 888 \r
 889 /// X86SelectStore - Select and emit code to implement store instructions.\r
 890 bool X86FastISel::X86SelectStore(const Instruction *I) {\r
 891   // Atomic stores need special handling.\r
 892   const StoreInst *S = cast<StoreInst>(I);\r
 893 \r
 894   if (S->isAtomic())\r
 895     return false;\r
 896 \r
 897   const Value *Val = S->getValueOperand();\r
 898   const Value *Ptr = S->getPointerOperand();\r
 899 \r
 900   MVT VT;\r
 901   if (!isTypeLegal(Val->getType(), VT, /*AllowI1=*/true))\r
 902     return false;\r
 903 \r
 904   unsigned Alignment = S->getAlignment();\r
 905   unsigned ABIAlignment = DL.getABITypeAlignment(Val->getType());\r
 906   if (Alignment == 0) // Ensure that codegen never sees alignment 0\r
 907     Alignment = ABIAlignment;\r
 908   bool Aligned = Alignment >= ABIAlignment;\r
 909 \r
 910   X86AddressMode AM;\r
 911   if (!X86SelectAddress(Ptr, AM))\r
 912     return false;\r
 913 \r
 914   return X86FastEmitStore(VT, Val, AM, createMachineMemOperandFor(I), Aligned);\r
 915 }\r
 916 \r
 917 /// X86SelectRet - Select and emit code to implement ret instructions.\r
 918 bool X86FastISel::X86SelectRet(const Instruction *I) {\r
 919   const ReturnInst *Ret = cast<ReturnInst>(I);\r
 920   const Function &F = *I->getParent()->getParent();\r
 921   const X86MachineFunctionInfo *X86MFInfo =\r
 922       FuncInfo.MF->getInfo<X86MachineFunctionInfo>();\r
 923 \r
 924   if (!FuncInfo.CanLowerReturn)\r
 925     return false;\r
 926 \r
 927   CallingConv::ID CC = F.getCallingConv();\r
 928   if (CC != CallingConv::C &&\r
 929       CC != CallingConv::Fast &&\r
 930       CC != CallingConv::X86_FastCall &&\r
 931       CC != CallingConv::X86_64_SysV)\r
 932     return false;\r
 933 \r
 934   if (Subtarget->isCallingConvWin64(CC))\r
 935     return false;\r
 936 \r
 937   // Don't handle popping bytes on return for now.\r
 938   if (X86MFInfo->getBytesToPopOnReturn() != 0)\r
 939     return false;\r
 940 \r
 941   // fastcc with -tailcallopt is intended to provide a guaranteed\r
 942   // tail call optimization. Fastisel doesn't know how to do that.\r
 943   if (CC == CallingConv::Fast && TM.Options.GuaranteedTailCallOpt)\r
 944     return false;\r
 945 \r
 946   // Let SDISel handle vararg functions.\r
 947   if (F.isVarArg())\r
 948     return false;\r
 949 \r
 950   // Build a list of return value registers.\r
 951   SmallVector<unsigned, 4> RetRegs;\r
 952 \r
 953   if (Ret->getNumOperands() > 0) {\r
 954     SmallVector<ISD::OutputArg, 4> Outs;\r
 955     GetReturnInfo(F.getReturnType(), F.getAttributes(), Outs, TLI);\r
 956 \r
 957     // Analyze operands of the call, assigning locations to each operand.\r
 958     SmallVector<CCValAssign, 16> ValLocs;\r
 959     CCState CCInfo(CC, F.isVarArg(), *FuncInfo.MF, ValLocs, I->getContext());\r
 960     CCInfo.AnalyzeReturn(Outs, RetCC_X86);\r
 961 \r
 962     const Value *RV = Ret->getOperand(0);\r
 963     unsigned Reg = getRegForValue(RV);\r
 964     if (Reg == 0)\r
 965       return false;\r
 966 \r
 967     // Only handle a single return value for now.\r
 968     if (ValLocs.size() != 1)\r
 969       return false;\r
 970 \r
 971     CCValAssign &VA = ValLocs[0];\r
 972 \r
 973     // Don't bother handling odd stuff for now.\r
 974     if (VA.getLocInfo() != CCValAssign::Full)\r
 975       return false;\r
 976     // Only handle register returns for now.\r
 977     if (!VA.isRegLoc())\r
 978       return false;\r
 979 \r
 980     // The calling-convention tables for x87 returns don't tell\r
 981     // the whole story.\r
 982     if (VA.getLocReg() == X86::FP0 || VA.getLocReg() == X86::FP1)\r
 983       return false;\r
 984 \r
 985     unsigned SrcReg = Reg + VA.getValNo();\r
 986     EVT SrcVT = TLI.getValueType(RV->getType());\r
 987     EVT DstVT = VA.getValVT();\r
 988     // Special handling for extended integers.\r
 989     if (SrcVT != DstVT) {\r
 990       if (SrcVT != MVT::i1 && SrcVT != MVT::i8 && SrcVT != MVT::i16)\r
 991         return false;\r
 992 \r
 993       if (!Outs[0].Flags.isZExt() && !Outs[0].Flags.isSExt())\r
 994         return false;\r
 995 \r
 996       assert(DstVT == MVT::i32 && "X86 should always ext to i32");\r
 997 \r
 998       if (SrcVT == MVT::i1) {\r
 999         if (Outs[0].Flags.isSExt())\r
1000           return false;\r
1001         SrcReg = fastEmitZExtFromI1(MVT::i8, SrcReg, /*TODO: Kill=*/false);\r
1002         SrcVT = MVT::i8;\r
1003       }\r
1004       unsigned Op = Outs[0].Flags.isZExt() ? ISD::ZERO_EXTEND :\r
1005                                              ISD::SIGN_EXTEND;\r
1006       SrcReg = fastEmit_r(SrcVT.getSimpleVT(), DstVT.getSimpleVT(), Op,\r
1007                           SrcReg, /*TODO: Kill=*/false);\r
1008     }\r
1009 \r
1010     // Make the copy.\r
1011     unsigned DstReg = VA.getLocReg();\r
1012     const TargetRegisterClass *SrcRC = MRI.getRegClass(SrcReg);\r
1013     // Avoid a cross-class copy. This is very unlikely.\r
1014     if (!SrcRC->contains(DstReg))\r
1015       return false;\r
1016     BuildMI(*FuncInfo.MBB, FuncInfo.InsertPt, DbgLoc,\r
1017             TII.get(TargetOpcode::COPY), DstReg).addReg(SrcReg);\r
1018 \r
1019     // Add register to return instruction.\r
1020     RetRegs.push_back(VA.getLocReg());\r
1021   }\r
1022 \r
1023   // The x86-64 ABI for returning structs by value requires that we copy\r
1024   // the sret argument into %rax for the return. We saved the argument into\r
1025   // a virtual register in the entry block, so now we copy the value out\r
1026   // and into %rax. We also do the same with %eax for Win32.\r
1027   if (F.hasStructRetAttr() &&\r
1028       (Subtarget->is64Bit() || Subtarget->isTargetKnownWindowsMSVC())) {\r
1029     unsigned Reg = X86MFInfo->getSRetReturnReg();\r
1030     assert(Reg &&\r
1031            "SRetReturnReg should have been set in LowerFormalArguments()!");\r
1032     unsigned RetReg = Subtarget->is64Bit() ? X86::RAX : X86::EAX;\r
1033     BuildMI(*FuncInfo.MBB, FuncInfo.InsertPt, DbgLoc,\r
1034             TII.get(TargetOpcode::COPY), RetReg).addReg(Reg);\r
1035     RetRegs.push_back(RetReg);\r
1036   }\r
1037 \r
1038   // Now emit the RET.\r
1039   MachineInstrBuilder MIB =\r
1040     BuildMI(*FuncInfo.MBB, FuncInfo.InsertPt, DbgLoc,\r
1041             TII.get(Subtarget->is64Bit() ? X86::RETQ : X86::RETL));\r
1042   for (unsigned i = 0, e = RetRegs.size(); i != e; ++i)\r
1043     MIB.addReg(RetRegs[i], RegState::Implicit);\r
1044   return true;\r
1045 }\r
1046 \r
1047 /// X86SelectLoad - Select and emit code to implement load instructions.\r
1048 ///\r
1049 bool X86FastISel::X86SelectLoad(const Instruction *I) {\r
1050   const LoadInst *LI = cast<LoadInst>(I);\r
1051 \r
1052   // Atomic loads need special handling.\r
1053   if (LI->isAtomic())\r
1054     return false;\r
1055 \r
1056   MVT VT;\r
1057   if (!isTypeLegal(LI->getType(), VT, /*AllowI1=*/true))\r
1058     return false;\r
1059 \r
1060   const Value *Ptr = LI->getPointerOperand();\r
1061 \r
1062   X86AddressMode AM;\r
1063   if (!X86SelectAddress(Ptr, AM))\r
1064     return false;\r
1065 \r
1066   unsigned ResultReg = 0;\r
1067   if (!X86FastEmitLoad(VT, AM, createMachineMemOperandFor(LI), ResultReg))\r
1068     return false;\r
1069 \r
1070   updateValueMap(I, ResultReg);\r
1071   return true;\r
1072 }\r
1073 \r
1074 static unsigned X86ChooseCmpOpcode(EVT VT, const X86Subtarget *Subtarget) {\r
1075   bool HasAVX = Subtarget->hasAVX();\r
1076   bool X86ScalarSSEf32 = Subtarget->hasSSE1();\r
1077   bool X86ScalarSSEf64 = Subtarget->hasSSE2();\r
1078 \r
1079   switch (VT.getSimpleVT().SimpleTy) {\r
1080   default:       return 0;\r
1081   case MVT::i8:  return X86::CMP8rr;\r
1082   case MVT::i16: return X86::CMP16rr;\r
1083   case MVT::i32: return X86::CMP32rr;\r
1084   case MVT::i64: return X86::CMP64rr;\r
1085   case MVT::f32:\r
1086     return X86ScalarSSEf32 ? (HasAVX ? X86::VUCOMISSrr : X86::UCOMISSrr) : 0;\r
1087   case MVT::f64:\r
1088     return X86ScalarSSEf64 ? (HasAVX ? X86::VUCOMISDrr : X86::UCOMISDrr) : 0;\r
1089   }\r
1090 }\r
1091 \r
1092 /// X86ChooseCmpImmediateOpcode - If we have a comparison with RHS as the RHS\r
1093 /// of the comparison, return an opcode that works for the compare (e.g.\r
1094 /// CMP32ri) otherwise return 0.\r
1095 static unsigned X86ChooseCmpImmediateOpcode(EVT VT, const ConstantInt *RHSC) {\r
1096   switch (VT.getSimpleVT().SimpleTy) {\r
1097   // Otherwise, we can't fold the immediate into this comparison.\r
1098   default: return 0;\r
1099   case MVT::i8: return X86::CMP8ri;\r
1100   case MVT::i16: return X86::CMP16ri;\r
1101   case MVT::i32: return X86::CMP32ri;\r
1102   case MVT::i64:\r
1103     // 64-bit comparisons are only valid if the immediate fits in a 32-bit sext\r
1104     // field.\r
1105     if ((int)RHSC->getSExtValue() == RHSC->getSExtValue())\r
1106       return X86::CMP64ri32;\r
1107     return 0;\r
1108   }\r
1109 }\r
1110 \r
1111 bool X86FastISel::X86FastEmitCompare(const Value *Op0, const Value *Op1,\r
1112                                      EVT VT, DebugLoc CurDbgLoc) {\r
1113   unsigned Op0Reg = getRegForValue(Op0);\r
1114   if (Op0Reg == 0) return false;\r
1115 \r
1116   // Handle 'null' like i32/i64 0.\r
1117   if (isa<ConstantPointerNull>(Op1))\r
1118     Op1 = Constant::getNullValue(DL.getIntPtrType(Op0->getContext()));\r
1119 \r
1120   // We have two options: compare with register or immediate.  If the RHS of\r
1121   // the compare is an immediate that we can fold into this compare, use\r
1122   // CMPri, otherwise use CMPrr.\r
1123   if (const ConstantInt *Op1C = dyn_cast<ConstantInt>(Op1)) {\r
1124     if (unsigned CompareImmOpc = X86ChooseCmpImmediateOpcode(VT, Op1C)) {\r
1125       BuildMI(*FuncInfo.MBB, FuncInfo.InsertPt, CurDbgLoc, TII.get(CompareImmOpc))\r
1126         .addReg(Op0Reg)\r
1127         .addImm(Op1C->getSExtValue());\r
1128       return true;\r
1129     }\r
1130   }\r
1131 \r
1132   unsigned CompareOpc = X86ChooseCmpOpcode(VT, Subtarget);\r
1133   if (CompareOpc == 0) return false;\r
1134 \r
1135   unsigned Op1Reg = getRegForValue(Op1);\r
1136   if (Op1Reg == 0) return false;\r
1137   BuildMI(*FuncInfo.MBB, FuncInfo.InsertPt, CurDbgLoc, TII.get(CompareOpc))\r
1138     .addReg(Op0Reg)\r
1139     .addReg(Op1Reg);\r
1140 \r
1141   return true;\r
1142 }\r
1143 \r
1144 bool X86FastISel::X86SelectCmp(const Instruction *I) {\r
1145   const CmpInst *CI = cast<CmpInst>(I);\r
1146 \r
1147   MVT VT;\r
1148   if (!isTypeLegal(I->getOperand(0)->getType(), VT))\r
1149     return false;\r
1150 \r
1151   // Try to optimize or fold the cmp.\r
1152   CmpInst::Predicate Predicate = optimizeCmpPredicate(CI);\r
1153   unsigned ResultReg = 0;\r
1154   switch (Predicate) {\r
1155   default: break;\r
1156   case CmpInst::FCMP_FALSE: {\r
1157     ResultReg = createResultReg(&X86::GR32RegClass);\r
1158     BuildMI(*FuncInfo.MBB, FuncInfo.InsertPt, DbgLoc, TII.get(X86::MOV32r0),\r
1159             ResultReg);\r
1160     ResultReg = fastEmitInst_extractsubreg(MVT::i8, ResultReg, /*Kill=*/true,\r
1161                                            X86::sub_8bit);\r
1162     if (!ResultReg)\r
1163       return false;\r
1164     break;\r
1165   }\r
1166   case CmpInst::FCMP_TRUE: {\r
1167     ResultReg = createResultReg(&X86::GR8RegClass);\r
1168     BuildMI(*FuncInfo.MBB, FuncInfo.InsertPt, DbgLoc, TII.get(X86::MOV8ri),\r
1169             ResultReg).addImm(1);\r
1170     break;\r
1171   }\r
1172   }\r
1173 \r
1174   if (ResultReg) {\r
1175     updateValueMap(I, ResultReg);\r
1176     return true;\r
1177   }\r
1178 \r
1179   const Value *LHS = CI->getOperand(0);\r
1180   const Value *RHS = CI->getOperand(1);\r
1181 \r
1182   // The optimizer might have replaced fcmp oeq %x, %x with fcmp ord %x, 0.0.\r
1183   // We don't have to materialize a zero constant for this case and can just use\r
1184   // %x again on the RHS.\r
1185   if (Predicate == CmpInst::FCMP_ORD || Predicate == CmpInst::FCMP_UNO) {\r
1186     const auto *RHSC = dyn_cast<ConstantFP>(RHS);\r
1187     if (RHSC && RHSC->isNullValue())\r
1188       RHS = LHS;\r
1189   }\r
1190 \r
1191   // FCMP_OEQ and FCMP_UNE cannot be checked with a single instruction.\r
1192   static unsigned SETFOpcTable[2][3] = {\r
1193     { X86::SETEr,  X86::SETNPr, X86::AND8rr },\r
1194     { X86::SETNEr, X86::SETPr,  X86::OR8rr  }\r
1195   };\r
1196   unsigned *SETFOpc = nullptr;\r
1197   switch (Predicate) {\r
1198   default: break;\r
1199   case CmpInst::FCMP_OEQ: SETFOpc = &SETFOpcTable[0][0]; break;\r
1200   case CmpInst::FCMP_UNE: SETFOpc = &SETFOpcTable[1][0]; break;\r
1201   }\r
1202 \r
1203   ResultReg = createResultReg(&X86::GR8RegClass);\r
1204   if (SETFOpc) {\r
1205     if (!X86FastEmitCompare(LHS, RHS, VT, I->getDebugLoc()))\r
1206       return false;\r
1207 \r
1208     unsigned FlagReg1 = createResultReg(&X86::GR8RegClass);\r
1209     unsigned FlagReg2 = createResultReg(&X86::GR8RegClass);\r
1210     BuildMI(*FuncInfo.MBB, FuncInfo.InsertPt, DbgLoc, TII.get(SETFOpc[0]),\r
1211             FlagReg1);\r
1212     BuildMI(*FuncInfo.MBB, FuncInfo.InsertPt, DbgLoc, TII.get(SETFOpc[1]),\r
1213             FlagReg2);\r
1214     BuildMI(*FuncInfo.MBB, FuncInfo.InsertPt, DbgLoc, TII.get(SETFOpc[2]),\r
1215             ResultReg).addReg(FlagReg1).addReg(FlagReg2);\r
1216     updateValueMap(I, ResultReg);\r
1217     return true;\r
1218   }\r
1219 \r
1220   X86::CondCode CC;\r
1221   bool SwapArgs;\r
1222   std::tie(CC, SwapArgs) = getX86ConditionCode(Predicate);\r
1223   assert(CC <= X86::LAST_VALID_COND && "Unexpected condition code.");\r
1224   unsigned Opc = X86::getSETFromCond(CC);\r
1225 \r
1226   if (SwapArgs)\r
1227     std::swap(LHS, RHS);\r
1228 \r
1229   // Emit a compare of LHS/RHS.\r
1230   if (!X86FastEmitCompare(LHS, RHS, VT, I->getDebugLoc()))\r
1231     return false;\r
1232 \r
1233   BuildMI(*FuncInfo.MBB, FuncInfo.InsertPt, DbgLoc, TII.get(Opc), ResultReg);\r
1234   updateValueMap(I, ResultReg);\r
1235   return true;\r
1236 }\r
1237 \r
1238 bool X86FastISel::X86SelectZExt(const Instruction *I) {\r
1239   EVT DstVT = TLI.getValueType(I->getType());\r
1240   if (!TLI.isTypeLegal(DstVT))\r
1241     return false;\r
1242 \r
1243   unsigned ResultReg = getRegForValue(I->getOperand(0));\r
1244   if (ResultReg == 0)\r
1245     return false;\r
1246 \r
1247   // Handle zero-extension from i1 to i8, which is common.\r
1248   MVT SrcVT = TLI.getSimpleValueType(I->getOperand(0)->getType());\r
1249   if (SrcVT.SimpleTy == MVT::i1) {\r
1250     // Set the high bits to zero.\r
1251     ResultReg = fastEmitZExtFromI1(MVT::i8, ResultReg, /*TODO: Kill=*/false);\r
1252     SrcVT = MVT::i8;\r
1253 \r
1254     if (ResultReg == 0)\r
1255       return false;\r
1256   }\r
1257 \r
1258   if (DstVT == MVT::i64) {\r
1259     // Handle extension to 64-bits via sub-register shenanigans.\r
1260     unsigned MovInst;\r
1261 \r
1262     switch (SrcVT.SimpleTy) {\r
1263     case MVT::i8:  MovInst = X86::MOVZX32rr8;  break;\r
1264     case MVT::i16: MovInst = X86::MOVZX32rr16; break;\r
1265     case MVT::i32: MovInst = X86::MOV32rr;     break;\r
1266     default: llvm_unreachable("Unexpected zext to i64 source type");\r
1267     }\r
1268 \r
1269     unsigned Result32 = createResultReg(&X86::GR32RegClass);\r
1270     BuildMI(*FuncInfo.MBB, FuncInfo.InsertPt, DbgLoc, TII.get(MovInst), Result32)\r
1271       .addReg(ResultReg);\r
1272 \r
1273     ResultReg = createResultReg(&X86::GR64RegClass);\r
1274     BuildMI(*FuncInfo.MBB, FuncInfo.InsertPt, DbgLoc, TII.get(TargetOpcode::SUBREG_TO_REG),\r
1275             ResultReg)\r
1276       .addImm(0).addReg(Result32).addImm(X86::sub_32bit);\r
1277   } else if (DstVT != MVT::i8) {\r
1278     ResultReg = fastEmit_r(MVT::i8, DstVT.getSimpleVT(), ISD::ZERO_EXTEND,\r
1279                            ResultReg, /*Kill=*/true);\r
1280     if (ResultReg == 0)\r
1281       return false;\r
1282   }\r
1283 \r
1284   updateValueMap(I, ResultReg);\r
1285   return true;\r
1286 }\r
1287 \r
1288 bool X86FastISel::X86SelectBranch(const Instruction *I) {\r
1289   // Unconditional branches are selected by tablegen-generated code.\r
1290   // Handle a conditional branch.\r
1291   const BranchInst *BI = cast<BranchInst>(I);\r
1292   MachineBasicBlock *TrueMBB = FuncInfo.MBBMap[BI->getSuccessor(0)];\r
1293   MachineBasicBlock *FalseMBB = FuncInfo.MBBMap[BI->getSuccessor(1)];\r
1294 \r
1295   // Fold the common case of a conditional branch with a comparison\r
1296   // in the same block (values defined on other blocks may not have\r
1297   // initialized registers).\r
1298   X86::CondCode CC;\r
1299   if (const CmpInst *CI = dyn_cast<CmpInst>(BI->getCondition())) {\r
1300     if (CI->hasOneUse() && CI->getParent() == I->getParent()) {\r
1301       EVT VT = TLI.getValueType(CI->getOperand(0)->getType());\r
1302 \r
1303       // Try to optimize or fold the cmp.\r
1304       CmpInst::Predicate Predicate = optimizeCmpPredicate(CI);\r
1305       switch (Predicate) {\r
1306       default: break;\r
1307       case CmpInst::FCMP_FALSE: fastEmitBranch(FalseMBB, DbgLoc); return true;\r
1308       case CmpInst::FCMP_TRUE:  fastEmitBranch(TrueMBB, DbgLoc); return true;\r
1309       }\r
1310 \r
1311       const Value *CmpLHS = CI->getOperand(0);\r
1312       const Value *CmpRHS = CI->getOperand(1);\r
1313 \r
1314       // The optimizer might have replaced fcmp oeq %x, %x with fcmp ord %x,\r
1315       // 0.0.\r
1316       // We don't have to materialize a zero constant for this case and can just\r
1317       // use %x again on the RHS.\r
1318       if (Predicate == CmpInst::FCMP_ORD || Predicate == CmpInst::FCMP_UNO) {\r
1319         const auto *CmpRHSC = dyn_cast<ConstantFP>(CmpRHS);\r
1320         if (CmpRHSC && CmpRHSC->isNullValue())\r
1321           CmpRHS = CmpLHS;\r
1322       }\r
1323 \r
1324       // Try to take advantage of fallthrough opportunities.\r
1325       if (FuncInfo.MBB->isLayoutSuccessor(TrueMBB)) {\r
1326         std::swap(TrueMBB, FalseMBB);\r
1327         Predicate = CmpInst::getInversePredicate(Predicate);\r
1328       }\r
1329 \r
1330       // FCMP_OEQ and FCMP_UNE cannot be expressed with a single flag/condition\r
1331       // code check. Instead two branch instructions are required to check all\r
1332       // the flags. First we change the predicate to a supported condition code,\r
1333       // which will be the first branch. Later one we will emit the second\r
1334       // branch.\r
1335       bool NeedExtraBranch = false;\r
1336       switch (Predicate) {\r
1337       default: break;\r
1338       case CmpInst::FCMP_OEQ:\r
1339         std::swap(TrueMBB, FalseMBB); // fall-through\r
1340       case CmpInst::FCMP_UNE:\r
1341         NeedExtraBranch = true;\r
1342         Predicate = CmpInst::FCMP_ONE;\r
1343         break;\r
1344       }\r
1345 \r
1346       bool SwapArgs;\r
1347       unsigned BranchOpc;\r
1348       std::tie(CC, SwapArgs) = getX86ConditionCode(Predicate);\r
1349       assert(CC <= X86::LAST_VALID_COND && "Unexpected condition code.");\r
1350 \r
1351       BranchOpc = X86::GetCondBranchFromCond(CC);\r
1352       if (SwapArgs)\r
1353         std::swap(CmpLHS, CmpRHS);\r
1354 \r
1355       // Emit a compare of the LHS and RHS, setting the flags.\r
1356       if (!X86FastEmitCompare(CmpLHS, CmpRHS, VT, CI->getDebugLoc()))\r
1357         return false;\r
1358 \r
1359       BuildMI(*FuncInfo.MBB, FuncInfo.InsertPt, DbgLoc, TII.get(BranchOpc))\r
1360         .addMBB(TrueMBB);\r
1361 \r
1362       // X86 requires a second branch to handle UNE (and OEQ, which is mapped\r
1363       // to UNE above).\r
1364       if (NeedExtraBranch) {\r
1365         BuildMI(*FuncInfo.MBB, FuncInfo.InsertPt, DbgLoc, TII.get(X86::JP_1))\r
1366           .addMBB(TrueMBB);\r
1367       }\r
1368 \r
1369       // Obtain the branch weight and add the TrueBB to the successor list.\r
1370       uint32_t BranchWeight = 0;\r
1371       if (FuncInfo.BPI)\r
1372         BranchWeight = FuncInfo.BPI->getEdgeWeight(BI->getParent(),\r
1373                                                    TrueMBB->getBasicBlock());\r
1374       FuncInfo.MBB->addSuccessor(TrueMBB, BranchWeight);\r
1375 \r
1376       // Emits an unconditional branch to the FalseBB, obtains the branch\r
1377       // weight, and adds it to the successor list.\r
1378       fastEmitBranch(FalseMBB, DbgLoc);\r
1379 \r
1380       return true;\r
1381     }\r
1382   } else if (TruncInst *TI = dyn_cast<TruncInst>(BI->getCondition())) {\r
1383     // Handle things like "%cond = trunc i32 %X to i1 / br i1 %cond", which\r
1384     // typically happen for _Bool and C++ bools.\r
1385     MVT SourceVT;\r
1386     if (TI->hasOneUse() && TI->getParent() == I->getParent() &&\r
1387         isTypeLegal(TI->getOperand(0)->getType(), SourceVT)) {\r
1388       unsigned TestOpc = 0;\r
1389       switch (SourceVT.SimpleTy) {\r
1390       default: break;\r
1391       case MVT::i8:  TestOpc = X86::TEST8ri; break;\r
1392       case MVT::i16: TestOpc = X86::TEST16ri; break;\r
1393       case MVT::i32: TestOpc = X86::TEST32ri; break;\r
1394       case MVT::i64: TestOpc = X86::TEST64ri32; break;\r
1395       }\r
1396       if (TestOpc) {\r
1397         unsigned OpReg = getRegForValue(TI->getOperand(0));\r
1398         if (OpReg == 0) return false;\r
1399         BuildMI(*FuncInfo.MBB, FuncInfo.InsertPt, DbgLoc, TII.get(TestOpc))\r
1400           .addReg(OpReg).addImm(1);\r
1401 \r
1402         unsigned JmpOpc = X86::JNE_1;\r
1403         if (FuncInfo.MBB->isLayoutSuccessor(TrueMBB)) {\r
1404           std::swap(TrueMBB, FalseMBB);\r
1405           JmpOpc = X86::JE_1;\r
1406         }\r
1407 \r
1408         BuildMI(*FuncInfo.MBB, FuncInfo.InsertPt, DbgLoc, TII.get(JmpOpc))\r
1409           .addMBB(TrueMBB);\r
1410         fastEmitBranch(FalseMBB, DbgLoc);\r
1411         uint32_t BranchWeight = 0;\r
1412         if (FuncInfo.BPI)\r
1413           BranchWeight = FuncInfo.BPI->getEdgeWeight(BI->getParent(),\r
1414                                                      TrueMBB->getBasicBlock());\r
1415         FuncInfo.MBB->addSuccessor(TrueMBB, BranchWeight);\r
1416         return true;\r
1417       }\r
1418     }\r
1419   } else if (foldX86XALUIntrinsic(CC, BI, BI->getCondition())) {\r
1420     // Fake request the condition, otherwise the intrinsic might be completely\r
1421     // optimized away.\r
1422     unsigned TmpReg = getRegForValue(BI->getCondition());\r
1423     if (TmpReg == 0)\r
1424       return false;\r
1425 \r
1426     unsigned BranchOpc = X86::GetCondBranchFromCond(CC);\r
1427 \r
1428     BuildMI(*FuncInfo.MBB, FuncInfo.InsertPt, DbgLoc, TII.get(BranchOpc))\r
1429       .addMBB(TrueMBB);\r
1430     fastEmitBranch(FalseMBB, DbgLoc);\r
1431     uint32_t BranchWeight = 0;\r
1432     if (FuncInfo.BPI)\r
1433       BranchWeight = FuncInfo.BPI->getEdgeWeight(BI->getParent(),\r
1434                                                  TrueMBB->getBasicBlock());\r
1435     FuncInfo.MBB->addSuccessor(TrueMBB, BranchWeight);\r
1436     return true;\r
1437   }\r
1438 \r
1439   // Otherwise do a clumsy setcc and re-test it.\r
1440   // Note that i1 essentially gets ANY_EXTEND'ed to i8 where it isn't used\r
1441   // in an explicit cast, so make sure to handle that correctly.\r
1442   unsigned OpReg = getRegForValue(BI->getCondition());\r
1443   if (OpReg == 0) return false;\r
1444 \r
1445   BuildMI(*FuncInfo.MBB, FuncInfo.InsertPt, DbgLoc, TII.get(X86::TEST8ri))\r
1446     .addReg(OpReg).addImm(1);\r
1447   BuildMI(*FuncInfo.MBB, FuncInfo.InsertPt, DbgLoc, TII.get(X86::JNE_1))\r
1448     .addMBB(TrueMBB);\r
1449   fastEmitBranch(FalseMBB, DbgLoc);\r
1450   uint32_t BranchWeight = 0;\r
1451   if (FuncInfo.BPI)\r
1452     BranchWeight = FuncInfo.BPI->getEdgeWeight(BI->getParent(),\r
1453                                                TrueMBB->getBasicBlock());\r
1454   FuncInfo.MBB->addSuccessor(TrueMBB, BranchWeight);\r
1455   return true;\r
1456 }\r
1457 \r
1458 bool X86FastISel::X86SelectShift(const Instruction *I) {\r
1459   unsigned CReg = 0, OpReg = 0;\r
1460   const TargetRegisterClass *RC = nullptr;\r
1461   if (I->getType()->isIntegerTy(8)) {\r
1462     CReg = X86::CL;\r
1463     RC = &X86::GR8RegClass;\r
1464     switch (I->getOpcode()) {\r
1465     case Instruction::LShr: OpReg = X86::SHR8rCL; break;\r
1466     case Instruction::AShr: OpReg = X86::SAR8rCL; break;\r
1467     case Instruction::Shl:  OpReg = X86::SHL8rCL; break;\r
1468     default: return false;\r
1469     }\r
1470   } else if (I->getType()->isIntegerTy(16)) {\r
1471     CReg = X86::CX;\r
1472     RC = &X86::GR16RegClass;\r
1473     switch (I->getOpcode()) {\r
1474     case Instruction::LShr: OpReg = X86::SHR16rCL; break;\r
1475     case Instruction::AShr: OpReg = X86::SAR16rCL; break;\r
1476     case Instruction::Shl:  OpReg = X86::SHL16rCL; break;\r
1477     default: return false;\r
1478     }\r
1479   } else if (I->getType()->isIntegerTy(32)) {\r
1480     CReg = X86::ECX;\r
1481     RC = &X86::GR32RegClass;\r
1482     switch (I->getOpcode()) {\r
1483     case Instruction::LShr: OpReg = X86::SHR32rCL; break;\r
1484     case Instruction::AShr: OpReg = X86::SAR32rCL; break;\r
1485     case Instruction::Shl:  OpReg = X86::SHL32rCL; break;\r
1486     default: return false;\r
1487     }\r
1488   } else if (I->getType()->isIntegerTy(64)) {\r
1489     CReg = X86::RCX;\r
1490     RC = &X86::GR64RegClass;\r
1491     switch (I->getOpcode()) {\r
1492     case Instruction::LShr: OpReg = X86::SHR64rCL; break;\r
1493     case Instruction::AShr: OpReg = X86::SAR64rCL; break;\r
1494     case Instruction::Shl:  OpReg = X86::SHL64rCL; break;\r
1495     default: return false;\r
1496     }\r
1497   } else {\r
1498     return false;\r
1499   }\r
1500 \r
1501   MVT VT;\r
1502   if (!isTypeLegal(I->getType(), VT))\r
1503     return false;\r
1504 \r
1505   unsigned Op0Reg = getRegForValue(I->getOperand(0));\r
1506   if (Op0Reg == 0) return false;\r
1507 \r
1508   unsigned Op1Reg = getRegForValue(I->getOperand(1));\r
1509   if (Op1Reg == 0) return false;\r
1510   BuildMI(*FuncInfo.MBB, FuncInfo.InsertPt, DbgLoc, TII.get(TargetOpcode::COPY),\r
1511           CReg).addReg(Op1Reg);\r
1512 \r
1513   // The shift instruction uses X86::CL. If we defined a super-register\r
1514   // of X86::CL, emit a subreg KILL to precisely describe what we're doing here.\r
1515   if (CReg != X86::CL)\r
1516     BuildMI(*FuncInfo.MBB, FuncInfo.InsertPt, DbgLoc,\r
1517             TII.get(TargetOpcode::KILL), X86::CL)\r
1518       .addReg(CReg, RegState::Kill);\r
1519 \r
1520   unsigned ResultReg = createResultReg(RC);\r
1521   BuildMI(*FuncInfo.MBB, FuncInfo.InsertPt, DbgLoc, TII.get(OpReg), ResultReg)\r
1522     .addReg(Op0Reg);\r
1523   updateValueMap(I, ResultReg);\r
1524   return true;\r
1525 }\r
1526 \r
1527 bool X86FastISel::X86SelectDivRem(const Instruction *I) {\r
1528   const static unsigned NumTypes = 4; // i8, i16, i32, i64\r
1529   const static unsigned NumOps   = 4; // SDiv, SRem, UDiv, URem\r
1530   const static bool S = true;  // IsSigned\r
1531   const static bool U = false; // !IsSigned\r
1532   const static unsigned Copy = TargetOpcode::COPY;\r
1533   // For the X86 DIV/IDIV instruction, in most cases the dividend\r
1534   // (numerator) must be in a specific register pair highreg:lowreg,\r
1535   // producing the quotient in lowreg and the remainder in highreg.\r
1536   // For most data types, to set up the instruction, the dividend is\r
1537   // copied into lowreg, and lowreg is sign-extended or zero-extended\r
1538   // into highreg.  The exception is i8, where the dividend is defined\r
1539   // as a single register rather than a register pair, and we\r
1540   // therefore directly sign-extend or zero-extend the dividend into\r
1541   // lowreg, instead of copying, and ignore the highreg.\r
1542   const static struct DivRemEntry {\r
1543     // The following portion depends only on the data type.\r
1544     const TargetRegisterClass *RC;\r
1545     unsigned LowInReg;  // low part of the register pair\r
1546     unsigned HighInReg; // high part of the register pair\r
1547     // The following portion depends on both the data type and the operation.\r
1548     struct DivRemResult {\r
1549     unsigned OpDivRem;        // The specific DIV/IDIV opcode to use.\r
1550     unsigned OpSignExtend;    // Opcode for sign-extending lowreg into\r
1551                               // highreg, or copying a zero into highreg.\r
1552     unsigned OpCopy;          // Opcode for copying dividend into lowreg, or\r
1553                               // zero/sign-extending into lowreg for i8.\r
1554     unsigned DivRemResultReg; // Register containing the desired result.\r
1555     bool IsOpSigned;          // Whether to use signed or unsigned form.\r
1556     } ResultTable[NumOps];\r
1557   } OpTable[NumTypes] = {\r
1558     { &X86::GR8RegClass,  X86::AX,  0, {\r
1559         { X86::IDIV8r,  0,            X86::MOVSX16rr8, X86::AL,  S }, // SDiv\r
1560         { X86::IDIV8r,  0,            X86::MOVSX16rr8, X86::AH,  S }, // SRem\r
1561         { X86::DIV8r,   0,            X86::MOVZX16rr8, X86::AL,  U }, // UDiv\r
1562         { X86::DIV8r,   0,            X86::MOVZX16rr8, X86::AH,  U }, // URem\r
1563       }\r
1564     }, // i8\r
1565     { &X86::GR16RegClass, X86::AX,  X86::DX, {\r
1566         { X86::IDIV16r, X86::CWD,     Copy,            X86::AX,  S }, // SDiv\r
1567         { X86::IDIV16r, X86::CWD,     Copy,            X86::DX,  S }, // SRem\r
1568         { X86::DIV16r,  X86::MOV32r0, Copy,            X86::AX,  U }, // UDiv\r
1569         { X86::DIV16r,  X86::MOV32r0, Copy,            X86::DX,  U }, // URem\r
1570       }\r
1571     }, // i16\r
1572     { &X86::GR32RegClass, X86::EAX, X86::EDX, {\r
1573         { X86::IDIV32r, X86::CDQ,     Copy,            X86::EAX, S }, // SDiv\r
1574         { X86::IDIV32r, X86::CDQ,     Copy,            X86::EDX, S }, // SRem\r
1575         { X86::DIV32r,  X86::MOV32r0, Copy,            X86::EAX, U }, // UDiv\r
1576         { X86::DIV32r,  X86::MOV32r0, Copy,            X86::EDX, U }, // URem\r
1577       }\r
1578     }, // i32\r
1579     { &X86::GR64RegClass, X86::RAX, X86::RDX, {\r
1580         { X86::IDIV64r, X86::CQO,     Copy,            X86::RAX, S }, // SDiv\r
1581         { X86::IDIV64r, X86::CQO,     Copy,            X86::RDX, S }, // SRem\r
1582         { X86::DIV64r,  X86::MOV32r0, Copy,            X86::RAX, U }, // UDiv\r
1583         { X86::DIV64r,  X86::MOV32r0, Copy,            X86::RDX, U }, // URem\r
1584       }\r
1585     }, // i64\r
1586   };\r
1587 \r
1588   MVT VT;\r
1589   if (!isTypeLegal(I->getType(), VT))\r
1590     return false;\r
1591 \r
1592   unsigned TypeIndex, OpIndex;\r
1593   switch (VT.SimpleTy) {\r
1594   default: return false;\r
1595   case MVT::i8:  TypeIndex = 0; break;\r
1596   case MVT::i16: TypeIndex = 1; break;\r
1597   case MVT::i32: TypeIndex = 2; break;\r
1598   case MVT::i64: TypeIndex = 3;\r
1599     if (!Subtarget->is64Bit())\r
1600       return false;\r
1601     break;\r
1602   }\r
1603 \r
1604   switch (I->getOpcode()) {\r
1605   default: llvm_unreachable("Unexpected div/rem opcode");\r
1606   case Instruction::SDiv: OpIndex = 0; break;\r
1607   case Instruction::SRem: OpIndex = 1; break;\r
1608   case Instruction::UDiv: OpIndex = 2; break;\r
1609   case Instruction::URem: OpIndex = 3; break;\r
1610   }\r
1611 \r
1612   const DivRemEntry &TypeEntry = OpTable[TypeIndex];\r
1613   const DivRemEntry::DivRemResult &OpEntry = TypeEntry.ResultTable[OpIndex];\r
1614   unsigned Op0Reg = getRegForValue(I->getOperand(0));\r
1615   if (Op0Reg == 0)\r
1616     return false;\r
1617   unsigned Op1Reg = getRegForValue(I->getOperand(1));\r
1618   if (Op1Reg == 0)\r
1619     return false;\r
1620 \r
1621   // Move op0 into low-order input register.\r
1622   BuildMI(*FuncInfo.MBB, FuncInfo.InsertPt, DbgLoc,\r
1623           TII.get(OpEntry.OpCopy), TypeEntry.LowInReg).addReg(Op0Reg);\r
1624   // Zero-extend or sign-extend into high-order input register.\r
1625   if (OpEntry.OpSignExtend) {\r
1626     if (OpEntry.IsOpSigned)\r
1627       BuildMI(*FuncInfo.MBB, FuncInfo.InsertPt, DbgLoc,\r
1628               TII.get(OpEntry.OpSignExtend));\r
1629     else {\r
1630       unsigned Zero32 = createResultReg(&X86::GR32RegClass);\r
1631       BuildMI(*FuncInfo.MBB, FuncInfo.InsertPt, DbgLoc,\r
1632               TII.get(X86::MOV32r0), Zero32);\r
1633 \r
1634       // Copy the zero into the appropriate sub/super/identical physical\r
1635       // register. Unfortunately the operations needed are not uniform enough\r
1636       // to fit neatly into the table above.\r
1637       if (VT.SimpleTy == MVT::i16) {\r
1638         BuildMI(*FuncInfo.MBB, FuncInfo.InsertPt, DbgLoc,\r
1639                 TII.get(Copy), TypeEntry.HighInReg)\r
1640           .addReg(Zero32, 0, X86::sub_16bit);\r
1641       } else if (VT.SimpleTy == MVT::i32) {\r
1642         BuildMI(*FuncInfo.MBB, FuncInfo.InsertPt, DbgLoc,\r
1643                 TII.get(Copy), TypeEntry.HighInReg)\r
1644             .addReg(Zero32);\r
1645       } else if (VT.SimpleTy == MVT::i64) {\r
1646         BuildMI(*FuncInfo.MBB, FuncInfo.InsertPt, DbgLoc,\r
1647                 TII.get(TargetOpcode::SUBREG_TO_REG), TypeEntry.HighInReg)\r
1648             .addImm(0).addReg(Zero32).addImm(X86::sub_32bit);\r
1649       }\r
1650     }\r
1651   }\r
1652   // Generate the DIV/IDIV instruction.\r
1653   BuildMI(*FuncInfo.MBB, FuncInfo.InsertPt, DbgLoc,\r
1654           TII.get(OpEntry.OpDivRem)).addReg(Op1Reg);\r
1655   // For i8 remainder, we can't reference AH directly, as we'll end\r
1656   // up with bogus copies like %R9B = COPY %AH. Reference AX\r
1657   // instead to prevent AH references in a REX instruction.\r
1658   //\r
1659   // The current assumption of the fast register allocator is that isel\r
1660   // won't generate explicit references to the GPR8_NOREX registers. If\r
1661   // the allocator and/or the backend get enhanced to be more robust in\r
1662   // that regard, this can be, and should be, removed.\r
1663   unsigned ResultReg = 0;\r
1664   if ((I->getOpcode() == Instruction::SRem ||\r
1665        I->getOpcode() == Instruction::URem) &&\r
1666       OpEntry.DivRemResultReg == X86::AH && Subtarget->is64Bit()) {\r
1667     unsigned SourceSuperReg = createResultReg(&X86::GR16RegClass);\r
1668     unsigned ResultSuperReg = createResultReg(&X86::GR16RegClass);\r
1669     BuildMI(*FuncInfo.MBB, FuncInfo.InsertPt, DbgLoc,\r
1670             TII.get(Copy), SourceSuperReg).addReg(X86::AX);\r
1671 \r
1672     // Shift AX right by 8 bits instead of using AH.\r
1673     BuildMI(*FuncInfo.MBB, FuncInfo.InsertPt, DbgLoc, TII.get(X86::SHR16ri),\r
1674             ResultSuperReg).addReg(SourceSuperReg).addImm(8);\r
1675 \r
1676     // Now reference the 8-bit subreg of the result.\r
1677     ResultReg = fastEmitInst_extractsubreg(MVT::i8, ResultSuperReg,\r
1678                                            /*Kill=*/true, X86::sub_8bit);\r
1679   }\r
1680   // Copy the result out of the physreg if we haven't already.\r
1681   if (!ResultReg) {\r
1682     ResultReg = createResultReg(TypeEntry.RC);\r
1683     BuildMI(*FuncInfo.MBB, FuncInfo.InsertPt, DbgLoc, TII.get(Copy), ResultReg)\r
1684         .addReg(OpEntry.DivRemResultReg);\r
1685   }\r
1686   updateValueMap(I, ResultReg);\r
1687 \r
1688   return true;\r
1689 }\r
1690 \r
1691 /// \brief Emit a conditional move instruction (if the are supported) to lower\r
1692 /// the select.\r
1693 bool X86FastISel::X86FastEmitCMoveSelect(MVT RetVT, const Instruction *I) {\r
1694   // Check if the subtarget supports these instructions.\r
1695   if (!Subtarget->hasCMov())\r
1696     return false;\r
1697 \r
1698   // FIXME: Add support for i8.\r
1699   if (RetVT < MVT::i16 || RetVT > MVT::i64)\r
1700     return false;\r
1701 \r
1702   const Value *Cond = I->getOperand(0);\r
1703   const TargetRegisterClass *RC = TLI.getRegClassFor(RetVT);\r
1704   bool NeedTest = true;\r
1705   X86::CondCode CC = X86::COND_NE;\r
1706 \r
1707   // Optimize conditions coming from a compare if both instructions are in the\r
1708   // same basic block (values defined in other basic blocks may not have\r
1709   // initialized registers).\r
1710   const auto *CI = dyn_cast<CmpInst>(Cond);\r
1711   if (CI && (CI->getParent() == I->getParent())) {\r
1712     CmpInst::Predicate Predicate = optimizeCmpPredicate(CI);\r
1713 \r
1714     // FCMP_OEQ and FCMP_UNE cannot be checked with a single instruction.\r
1715     static unsigned SETFOpcTable[2][3] = {\r
1716       { X86::SETNPr, X86::SETEr , X86::TEST8rr },\r
1717       { X86::SETPr,  X86::SETNEr, X86::OR8rr   }\r
1718     };\r
1719     unsigned *SETFOpc = nullptr;\r
1720     switch (Predicate) {\r
1721     default: break;\r
1722     case CmpInst::FCMP_OEQ:\r
1723       SETFOpc = &SETFOpcTable[0][0];\r
1724       Predicate = CmpInst::ICMP_NE;\r
1725       break;\r
1726     case CmpInst::FCMP_UNE:\r
1727       SETFOpc = &SETFOpcTable[1][0];\r
1728       Predicate = CmpInst::ICMP_NE;\r
1729       break;\r
1730     }\r
1731 \r
1732     bool NeedSwap;\r
1733     std::tie(CC, NeedSwap) = getX86ConditionCode(Predicate);\r
1734     assert(CC <= X86::LAST_VALID_COND && "Unexpected condition code.");\r
1735 \r
1736     const Value *CmpLHS = CI->getOperand(0);\r
1737     const Value *CmpRHS = CI->getOperand(1);\r
1738     if (NeedSwap)\r
1739       std::swap(CmpLHS, CmpRHS);\r
1740 \r
1741     EVT CmpVT = TLI.getValueType(CmpLHS->getType());\r
1742     // Emit a compare of the LHS and RHS, setting the flags.\r
1743     if (!X86FastEmitCompare(CmpLHS, CmpRHS, CmpVT, CI->getDebugLoc()))\r
1744       return false;\r
1745 \r
1746     if (SETFOpc) {\r
1747       unsigned FlagReg1 = createResultReg(&X86::GR8RegClass);\r
1748       unsigned FlagReg2 = createResultReg(&X86::GR8RegClass);\r
1749       BuildMI(*FuncInfo.MBB, FuncInfo.InsertPt, DbgLoc, TII.get(SETFOpc[0]),\r
1750               FlagReg1);\r
1751       BuildMI(*FuncInfo.MBB, FuncInfo.InsertPt, DbgLoc, TII.get(SETFOpc[1]),\r
1752               FlagReg2);\r
1753       auto const &II = TII.get(SETFOpc[2]);\r
1754       if (II.getNumDefs()) {\r
1755         unsigned TmpReg = createResultReg(&X86::GR8RegClass);\r
1756         BuildMI(*FuncInfo.MBB, FuncInfo.InsertPt, DbgLoc, II, TmpReg)\r
1757           .addReg(FlagReg2).addReg(FlagReg1);\r
1758       } else {\r
1759         BuildMI(*FuncInfo.MBB, FuncInfo.InsertPt, DbgLoc, II)\r
1760           .addReg(FlagReg2).addReg(FlagReg1);\r
1761       }\r
1762     }\r
1763     NeedTest = false;\r
1764   } else if (foldX86XALUIntrinsic(CC, I, Cond)) {\r
1765     // Fake request the condition, otherwise the intrinsic might be completely\r
1766     // optimized away.\r
1767     unsigned TmpReg = getRegForValue(Cond);\r
1768     if (TmpReg == 0)\r
1769       return false;\r
1770 \r
1771     NeedTest = false;\r
1772   }\r
1773 \r
1774   if (NeedTest) {\r
1775     // Selects operate on i1, however, CondReg is 8 bits width and may contain\r
1776     // garbage. Indeed, only the less significant bit is supposed to be\r
1777     // accurate. If we read more than the lsb, we may see non-zero values\r
1778     // whereas lsb is zero. Therefore, we have to truncate Op0Reg to i1 for\r
1779     // the select. This is achieved by performing TEST against 1.\r
1780     unsigned CondReg = getRegForValue(Cond);\r
1781     if (CondReg == 0)\r
1782       return false;\r
1783     bool CondIsKill = hasTrivialKill(Cond);\r
1784 \r
1785     BuildMI(*FuncInfo.MBB, FuncInfo.InsertPt, DbgLoc, TII.get(X86::TEST8ri))\r
1786       .addReg(CondReg, getKillRegState(CondIsKill)).addImm(1);\r
1787   }\r
1788 \r
1789   const Value *LHS = I->getOperand(1);\r
1790   const Value *RHS = I->getOperand(2);\r
1791 \r
1792   unsigned RHSReg = getRegForValue(RHS);\r
1793   bool RHSIsKill = hasTrivialKill(RHS);\r
1794 \r
1795   unsigned LHSReg = getRegForValue(LHS);\r
1796   bool LHSIsKill = hasTrivialKill(LHS);\r
1797 \r
1798   if (!LHSReg || !RHSReg)\r
1799     return false;\r
1800 \r
1801   unsigned Opc = X86::getCMovFromCond(CC, RC->getSize());\r
1802   unsigned ResultReg = fastEmitInst_rr(Opc, RC, RHSReg, RHSIsKill,\r
1803                                        LHSReg, LHSIsKill);\r
1804   updateValueMap(I, ResultReg);\r
1805   return true;\r
1806 }\r
1807 \r
1808 /// \brief Emit SSE instructions to lower the select.\r
1809 ///\r
1810 /// Try to use SSE1/SSE2 instructions to simulate a select without branches.\r
1811 /// This lowers fp selects into a CMP/AND/ANDN/OR sequence when the necessary\r
1812 /// SSE instructions are available.\r
1813 bool X86FastISel::X86FastEmitSSESelect(MVT RetVT, const Instruction *I) {\r
1814   // Optimize conditions coming from a compare if both instructions are in the\r
1815   // same basic block (values defined in other basic blocks may not have\r
1816   // initialized registers).\r
1817   const auto *CI = dyn_cast<FCmpInst>(I->getOperand(0));\r
1818   if (!CI || (CI->getParent() != I->getParent()))\r
1819     return false;\r
1820 \r
1821   if (I->getType() != CI->getOperand(0)->getType() ||\r
1822       !((Subtarget->hasSSE1() && RetVT == MVT::f32) ||\r
1823         (Subtarget->hasSSE2() && RetVT == MVT::f64)))\r
1824     return false;\r
1825 \r
1826   const Value *CmpLHS = CI->getOperand(0);\r
1827   const Value *CmpRHS = CI->getOperand(1);\r
1828   CmpInst::Predicate Predicate = optimizeCmpPredicate(CI);\r
1829 \r
1830   // The optimizer might have replaced fcmp oeq %x, %x with fcmp ord %x, 0.0.\r
1831   // We don't have to materialize a zero constant for this case and can just use\r
1832   // %x again on the RHS.\r
1833   if (Predicate == CmpInst::FCMP_ORD || Predicate == CmpInst::FCMP_UNO) {\r
1834     const auto *CmpRHSC = dyn_cast<ConstantFP>(CmpRHS);\r
1835     if (CmpRHSC && CmpRHSC->isNullValue())\r
1836       CmpRHS = CmpLHS;\r
1837   }\r
1838 \r
1839   unsigned CC;\r
1840   bool NeedSwap;\r
1841   std::tie(CC, NeedSwap) = getX86SSEConditionCode(Predicate);\r
1842   if (CC > 7)\r
1843     return false;\r
1844 \r
1845   if (NeedSwap)\r
1846     std::swap(CmpLHS, CmpRHS);\r
1847 \r
1848   static unsigned OpcTable[2][2][4] = {\r
1849     { { X86::CMPSSrr,  X86::FsANDPSrr,  X86::FsANDNPSrr,  X86::FsORPSrr  },\r
1850       { X86::VCMPSSrr, X86::VFsANDPSrr, X86::VFsANDNPSrr, X86::VFsORPSrr }  },\r
1851     { { X86::CMPSDrr,  X86::FsANDPDrr,  X86::FsANDNPDrr,  X86::FsORPDrr  },\r
1852       { X86::VCMPSDrr, X86::VFsANDPDrr, X86::VFsANDNPDrr, X86::VFsORPDrr }  }\r
1853   };\r
1854 \r
1855   bool HasAVX = Subtarget->hasAVX();\r
1856   unsigned *Opc = nullptr;\r
1857   switch (RetVT.SimpleTy) {\r
1858   default: return false;\r
1859   case MVT::f32: Opc = &OpcTable[0][HasAVX][0]; break;\r
1860   case MVT::f64: Opc = &OpcTable[1][HasAVX][0]; break;\r
1861   }\r
1862 \r
1863   const Value *LHS = I->getOperand(1);\r
1864   const Value *RHS = I->getOperand(2);\r
1865 \r
1866   unsigned LHSReg = getRegForValue(LHS);\r
1867   bool LHSIsKill = hasTrivialKill(LHS);\r
1868 \r
1869   unsigned RHSReg = getRegForValue(RHS);\r
1870   bool RHSIsKill = hasTrivialKill(RHS);\r
1871 \r
1872   unsigned CmpLHSReg = getRegForValue(CmpLHS);\r
1873   bool CmpLHSIsKill = hasTrivialKill(CmpLHS);\r
1874 \r
1875   unsigned CmpRHSReg = getRegForValue(CmpRHS);\r
1876   bool CmpRHSIsKill = hasTrivialKill(CmpRHS);\r
1877 \r
1878   if (!LHSReg || !RHSReg || !CmpLHS || !CmpRHS)\r
1879     return false;\r
1880 \r
1881   const TargetRegisterClass *RC = TLI.getRegClassFor(RetVT);\r
1882   unsigned CmpReg = fastEmitInst_rri(Opc[0], RC, CmpLHSReg, CmpLHSIsKill,\r
1883                                      CmpRHSReg, CmpRHSIsKill, CC);\r
1884   unsigned AndReg = fastEmitInst_rr(Opc[1], RC, CmpReg, /*IsKill=*/false,\r
1885                                     LHSReg, LHSIsKill);\r
1886   unsigned AndNReg = fastEmitInst_rr(Opc[2], RC, CmpReg, /*IsKill=*/true,\r
1887                                      RHSReg, RHSIsKill);\r
1888   unsigned ResultReg = fastEmitInst_rr(Opc[3], RC, AndNReg, /*IsKill=*/true,\r
1889                                        AndReg, /*IsKill=*/true);\r
1890   updateValueMap(I, ResultReg);\r
1891   return true;\r
1892 }\r
1893 \r
1894 bool X86FastISel::X86FastEmitPseudoSelect(MVT RetVT, const Instruction *I) {\r
1895   // These are pseudo CMOV instructions and will be later expanded into control-\r
1896   // flow.\r
1897   unsigned Opc;\r
1898   switch (RetVT.SimpleTy) {\r
1899   default: return false;\r
1900   case MVT::i8:  Opc = X86::CMOV_GR8;  break;\r
1901   case MVT::i16: Opc = X86::CMOV_GR16; break;\r
1902   case MVT::i32: Opc = X86::CMOV_GR32; break;\r
1903   case MVT::f32: Opc = X86::CMOV_FR32; break;\r
1904   case MVT::f64: Opc = X86::CMOV_FR64; break;\r
1905   }\r
1906 \r
1907   const Value *Cond = I->getOperand(0);\r
1908   X86::CondCode CC = X86::COND_NE;\r
1909 \r
1910   // Optimize conditions coming from a compare if both instructions are in the\r
1911   // same basic block (values defined in other basic blocks may not have\r
1912   // initialized registers).\r
1913   const auto *CI = dyn_cast<CmpInst>(Cond);\r
1914   if (CI && (CI->getParent() == I->getParent())) {\r
1915     bool NeedSwap;\r
1916     std::tie(CC, NeedSwap) = getX86ConditionCode(CI->getPredicate());\r
1917     if (CC > X86::LAST_VALID_COND)\r
1918       return false;\r
1919 \r
1920     const Value *CmpLHS = CI->getOperand(0);\r
1921     const Value *CmpRHS = CI->getOperand(1);\r
1922 \r
1923     if (NeedSwap)\r
1924       std::swap(CmpLHS, CmpRHS);\r
1925 \r
1926     EVT CmpVT = TLI.getValueType(CmpLHS->getType());\r
1927     if (!X86FastEmitCompare(CmpLHS, CmpRHS, CmpVT, CI->getDebugLoc()))\r
1928       return false;\r
1929   } else {\r
1930     unsigned CondReg = getRegForValue(Cond);\r
1931     if (CondReg == 0)\r
1932       return false;\r
1933     bool CondIsKill = hasTrivialKill(Cond);\r
1934     BuildMI(*FuncInfo.MBB, FuncInfo.InsertPt, DbgLoc, TII.get(X86::TEST8ri))\r
1935       .addReg(CondReg, getKillRegState(CondIsKill)).addImm(1);\r
1936   }\r
1937 \r
1938   const Value *LHS = I->getOperand(1);\r
1939   const Value *RHS = I->getOperand(2);\r
1940 \r
1941   unsigned LHSReg = getRegForValue(LHS);\r
1942   bool LHSIsKill = hasTrivialKill(LHS);\r
1943 \r
1944   unsigned RHSReg = getRegForValue(RHS);\r
1945   bool RHSIsKill = hasTrivialKill(RHS);\r
1946 \r
1947   if (!LHSReg || !RHSReg)\r
1948     return false;\r
1949 \r
1950   const TargetRegisterClass *RC = TLI.getRegClassFor(RetVT);\r
1951 \r
1952   unsigned ResultReg =\r
1953     fastEmitInst_rri(Opc, RC, RHSReg, RHSIsKill, LHSReg, LHSIsKill, CC);\r
1954   updateValueMap(I, ResultReg);\r
1955   return true;\r
1956 }\r
1957 \r
1958 bool X86FastISel::X86SelectSelect(const Instruction *I) {\r
1959   MVT RetVT;\r
1960   if (!isTypeLegal(I->getType(), RetVT))\r
1961     return false;\r
1962 \r
1963   // Check if we can fold the select.\r
1964   if (const auto *CI = dyn_cast<CmpInst>(I->getOperand(0))) {\r
1965     CmpInst::Predicate Predicate = optimizeCmpPredicate(CI);\r
1966     const Value *Opnd = nullptr;\r
1967     switch (Predicate) {\r
1968     default:                              break;\r
1969     case CmpInst::FCMP_FALSE: Opnd = I->getOperand(2); break;\r
1970     case CmpInst::FCMP_TRUE:  Opnd = I->getOperand(1); break;\r
1971     }\r
1972     // No need for a select anymore - this is an unconditional move.\r
1973     if (Opnd) {\r
1974       unsigned OpReg = getRegForValue(Opnd);\r
1975       if (OpReg == 0)\r
1976         return false;\r
1977       bool OpIsKill = hasTrivialKill(Opnd);\r
1978       const TargetRegisterClass *RC = TLI.getRegClassFor(RetVT);\r
1979       unsigned ResultReg = createResultReg(RC);\r
1980       BuildMI(*FuncInfo.MBB, FuncInfo.InsertPt, DbgLoc,\r
1981               TII.get(TargetOpcode::COPY), ResultReg)\r
1982         .addReg(OpReg, getKillRegState(OpIsKill));\r
1983       updateValueMap(I, ResultReg);\r
1984       return true;\r
1985     }\r
1986   }\r
1987 \r
1988   // First try to use real conditional move instructions.\r
1989   if (X86FastEmitCMoveSelect(RetVT, I))\r
1990     return true;\r
1991 \r
1992   // Try to use a sequence of SSE instructions to simulate a conditional move.\r
1993   if (X86FastEmitSSESelect(RetVT, I))\r
1994     return true;\r
1995 \r
1996   // Fall-back to pseudo conditional move instructions, which will be later\r
1997   // converted to control-flow.\r
1998   if (X86FastEmitPseudoSelect(RetVT, I))\r
1999     return true;\r
2000 \r
2001   return false;\r
2002 }\r
2003 \r
2004 bool X86FastISel::X86SelectFPExt(const Instruction *I) {\r
2005   // fpext from float to double.\r
2006   if (X86ScalarSSEf64 &&\r
2007       I->getType()->isDoubleTy()) {\r
2008     const Value *V = I->getOperand(0);\r
2009     if (V->getType()->isFloatTy()) {\r
2010       unsigned OpReg = getRegForValue(V);\r
2011       if (OpReg == 0) return false;\r
2012       unsigned ResultReg = createResultReg(&X86::FR64RegClass);\r
2013       BuildMI(*FuncInfo.MBB, FuncInfo.InsertPt, DbgLoc,\r
2014               TII.get(X86::CVTSS2SDrr), ResultReg)\r
2015         .addReg(OpReg);\r
2016       updateValueMap(I, ResultReg);\r
2017       return true;\r
2018     }\r
2019   }\r
2020 \r
2021   return false;\r
2022 }\r
2023 \r
2024 bool X86FastISel::X86SelectFPTrunc(const Instruction *I) {\r
2025   if (X86ScalarSSEf64) {\r
2026     if (I->getType()->isFloatTy()) {\r
2027       const Value *V = I->getOperand(0);\r
2028       if (V->getType()->isDoubleTy()) {\r
2029         unsigned OpReg = getRegForValue(V);\r
2030         if (OpReg == 0) return false;\r
2031         unsigned ResultReg = createResultReg(&X86::FR32RegClass);\r
2032         BuildMI(*FuncInfo.MBB, FuncInfo.InsertPt, DbgLoc,\r
2033                 TII.get(X86::CVTSD2SSrr), ResultReg)\r
2034           .addReg(OpReg);\r
2035         updateValueMap(I, ResultReg);\r
2036         return true;\r
2037       }\r
2038     }\r
2039   }\r
2040 \r
2041   return false;\r
2042 }\r
2043 \r
2044 bool X86FastISel::X86SelectTrunc(const Instruction *I) {\r
2045   EVT SrcVT = TLI.getValueType(I->getOperand(0)->getType());\r
2046   EVT DstVT = TLI.getValueType(I->getType());\r
2047 \r
2048   // This code only handles truncation to byte.\r
2049   if (DstVT != MVT::i8 && DstVT != MVT::i1)\r
2050     return false;\r
2051   if (!TLI.isTypeLegal(SrcVT))\r
2052     return false;\r
2053 \r
2054   unsigned InputReg = getRegForValue(I->getOperand(0));\r
2055   if (!InputReg)\r
2056     // Unhandled operand.  Halt "fast" selection and bail.\r
2057     return false;\r
2058 \r
2059   if (SrcVT == MVT::i8) {\r
2060     // Truncate from i8 to i1; no code needed.\r
2061     updateValueMap(I, InputReg);\r
2062     return true;\r
2063   }\r
2064 \r
2065   if (!Subtarget->is64Bit()) {\r
2066     // If we're on x86-32; we can't extract an i8 from a general register.\r
2067     // First issue a copy to GR16_ABCD or GR32_ABCD.\r
2068     const TargetRegisterClass *CopyRC =\r
2069       (SrcVT == MVT::i16) ? &X86::GR16_ABCDRegClass : &X86::GR32_ABCDRegClass;\r
2070     unsigned CopyReg = createResultReg(CopyRC);\r
2071     BuildMI(*FuncInfo.MBB, FuncInfo.InsertPt, DbgLoc,\r
2072             TII.get(TargetOpcode::COPY), CopyReg).addReg(InputReg);\r
2073     InputReg = CopyReg;\r
2074   }\r
2075 \r
2076   // Issue an extract_subreg.\r
2077   unsigned ResultReg = fastEmitInst_extractsubreg(MVT::i8,\r
2078                                                   InputReg, /*Kill=*/true,\r
2079                                                   X86::sub_8bit);\r
2080   if (!ResultReg)\r
2081     return false;\r
2082 \r
2083   updateValueMap(I, ResultReg);\r
2084   return true;\r
2085 }\r
2086 \r
2087 bool X86FastISel::IsMemcpySmall(uint64_t Len) {\r
2088   return Len <= (Subtarget->is64Bit() ? 32 : 16);\r
2089 }\r
2090 \r
2091 bool X86FastISel::TryEmitSmallMemcpy(X86AddressMode DestAM,\r
2092                                      X86AddressMode SrcAM, uint64_t Len) {\r
2093 \r
2094   // Make sure we don't bloat code by inlining very large memcpy's.\r
2095   if (!IsMemcpySmall(Len))\r
2096     return false;\r
2097 \r
2098   bool i64Legal = Subtarget->is64Bit();\r
2099 \r
2100   // We don't care about alignment here since we just emit integer accesses.\r
2101   while (Len) {\r
2102     MVT VT;\r
2103     if (Len >= 8 && i64Legal)\r
2104       VT = MVT::i64;\r
2105     else if (Len >= 4)\r
2106       VT = MVT::i32;\r
2107     else if (Len >= 2)\r
2108       VT = MVT::i16;\r
2109     else\r
2110       VT = MVT::i8;\r
2111 \r
2112     unsigned Reg;\r
2113     bool RV = X86FastEmitLoad(VT, SrcAM, nullptr, Reg);\r
2114     RV &= X86FastEmitStore(VT, Reg, /*Kill=*/true, DestAM);\r
2115     assert(RV && "Failed to emit load or store??");\r
2116 \r
2117     unsigned Size = VT.getSizeInBits()/8;\r
2118     Len -= Size;\r
2119     DestAM.Disp += Size;\r
2120     SrcAM.Disp += Size;\r
2121   }\r
2122 \r
2123   return true;\r
2124 }\r
2125 \r
2126 bool X86FastISel::fastLowerIntrinsicCall(const IntrinsicInst *II) {\r
2127   // FIXME: Handle more intrinsics.\r
2128   switch (II->getIntrinsicID()) {\r
2129   default: return false;\r
2130   case Intrinsic::frameaddress: {\r
2131     Type *RetTy = II->getCalledFunction()->getReturnType();\r
2132 \r
2133     MVT VT;\r
2134     if (!isTypeLegal(RetTy, VT))\r
2135       return false;\r
2136 \r
2137     unsigned Opc;\r
2138     const TargetRegisterClass *RC = nullptr;\r
2139 \r
2140     switch (VT.SimpleTy) {\r
2141     default: llvm_unreachable("Invalid result type for frameaddress.");\r
2142     case MVT::i32: Opc = X86::MOV32rm; RC = &X86::GR32RegClass; break;\r
2143     case MVT::i64: Opc = X86::MOV64rm; RC = &X86::GR64RegClass; break;\r
2144     }\r
2145 \r
2146     // This needs to be set before we call getPtrSizedFrameRegister, otherwise\r
2147     // we get the wrong frame register.\r
2148     MachineFrameInfo *MFI = FuncInfo.MF->getFrameInfo();\r
2149     MFI->setFrameAddressIsTaken(true);\r
2150 \r
2151     const X86RegisterInfo *RegInfo = static_cast<const X86RegisterInfo *>(\r
2152         TM.getSubtargetImpl()->getRegisterInfo());\r
2153     unsigned FrameReg = RegInfo->getPtrSizedFrameRegister(*(FuncInfo.MF));\r
2154     assert(((FrameReg == X86::RBP && VT == MVT::i64) ||\r
2155             (FrameReg == X86::EBP && VT == MVT::i32)) &&\r
2156            "Invalid Frame Register!");\r
2157 \r
2158     // Always make a copy of the frame register to to a vreg first, so that we\r
2159     // never directly reference the frame register (the TwoAddressInstruction-\r
2160     // Pass doesn't like that).\r
2161     unsigned SrcReg = createResultReg(RC);\r
2162     BuildMI(*FuncInfo.MBB, FuncInfo.InsertPt, DbgLoc,\r
2163             TII.get(TargetOpcode::COPY), SrcReg).addReg(FrameReg);\r
2164 \r
2165     // Now recursively load from the frame address.\r
2166     // movq (%rbp), %rax\r
2167     // movq (%rax), %rax\r
2168     // movq (%rax), %rax\r
2169     // ...\r
2170     unsigned DestReg;\r
2171     unsigned Depth = cast<ConstantInt>(II->getOperand(0))->getZExtValue();\r
2172     while (Depth--) {\r
2173       DestReg = createResultReg(RC);\r
2174       addDirectMem(BuildMI(*FuncInfo.MBB, FuncInfo.InsertPt, DbgLoc,\r
2175                            TII.get(Opc), DestReg), SrcReg);\r
2176       SrcReg = DestReg;\r
2177     }\r
2178 \r
2179     updateValueMap(II, SrcReg);\r
2180     return true;\r
2181   }\r
2182   case Intrinsic::memcpy: {\r
2183     const MemCpyInst *MCI = cast<MemCpyInst>(II);\r
2184     // Don't handle volatile or variable length memcpys.\r
2185     if (MCI->isVolatile())\r
2186       return false;\r
2187 \r
2188     if (isa<ConstantInt>(MCI->getLength())) {\r
2189       // Small memcpy's are common enough that we want to do them\r
2190       // without a call if possible.\r
2191       uint64_t Len = cast<ConstantInt>(MCI->getLength())->getZExtValue();\r
2192       if (IsMemcpySmall(Len)) {\r
2193         X86AddressMode DestAM, SrcAM;\r
2194         if (!X86SelectAddress(MCI->getRawDest(), DestAM) ||\r
2195             !X86SelectAddress(MCI->getRawSource(), SrcAM))\r
2196           return false;\r
2197         TryEmitSmallMemcpy(DestAM, SrcAM, Len);\r
2198         return true;\r
2199       }\r
2200     }\r
2201 \r
2202     unsigned SizeWidth = Subtarget->is64Bit() ? 64 : 32;\r
2203     if (!MCI->getLength()->getType()->isIntegerTy(SizeWidth))\r
2204       return false;\r
2205 \r
2206     if (MCI->getSourceAddressSpace() > 255 || MCI->getDestAddressSpace() > 255)\r
2207       return false;\r
2208 \r
2209     return lowerCallTo(II, "memcpy", II->getNumArgOperands() - 2);\r
2210   }\r
2211   case Intrinsic::memset: {\r
2212     const MemSetInst *MSI = cast<MemSetInst>(II);\r
2213 \r
2214     if (MSI->isVolatile())\r
2215       return false;\r
2216 \r
2217     unsigned SizeWidth = Subtarget->is64Bit() ? 64 : 32;\r
2218     if (!MSI->getLength()->getType()->isIntegerTy(SizeWidth))\r
2219       return false;\r
2220 \r
2221     if (MSI->getDestAddressSpace() > 255)\r
2222       return false;\r
2223 \r
2224     return lowerCallTo(II, "memset", II->getNumArgOperands() - 2);\r
2225   }\r
2226   case Intrinsic::stackprotector: {\r
2227     // Emit code to store the stack guard onto the stack.\r
2228     EVT PtrTy = TLI.getPointerTy();\r
2229 \r
2230     const Value *Op1 = II->getArgOperand(0); // The guard's value.\r
2231     const AllocaInst *Slot = cast<AllocaInst>(II->getArgOperand(1));\r
2232 \r
2233     MFI.setStackProtectorIndex(FuncInfo.StaticAllocaMap[Slot]);\r
2234 \r
2235     // Grab the frame index.\r
2236     X86AddressMode AM;\r
2237     if (!X86SelectAddress(Slot, AM)) return false;\r
2238     if (!X86FastEmitStore(PtrTy, Op1, AM)) return false;\r
2239     return true;\r
2240   }\r
2241   case Intrinsic::dbg_declare: {\r
2242     const DbgDeclareInst *DI = cast<DbgDeclareInst>(II);\r
2243     X86AddressMode AM;\r
2244     assert(DI->getAddress() && "Null address should be checked earlier!");\r
2245     if (!X86SelectAddress(DI->getAddress(), AM))\r
2246       return false;\r
2247     const MCInstrDesc &II = TII.get(TargetOpcode::DBG_VALUE);\r
2248     // FIXME may need to add RegState::Debug to any registers produced,\r
2249     // although ESP/EBP should be the only ones at the moment.\r
2250     addFullAddress(BuildMI(*FuncInfo.MBB, FuncInfo.InsertPt, DbgLoc, II), AM)\r
2251         .addImm(0)\r
2252         .addMetadata(DI->getVariable())\r
2253         .addMetadata(DI->getExpression());\r
2254     return true;\r
2255   }\r
2256   case Intrinsic::trap: {\r
2257     BuildMI(*FuncInfo.MBB, FuncInfo.InsertPt, DbgLoc, TII.get(X86::TRAP));\r
2258     return true;\r
2259   }\r
2260   case Intrinsic::sqrt: {\r
2261     if (!Subtarget->hasSSE1())\r
2262       return false;\r
2263 \r
2264     Type *RetTy = II->getCalledFunction()->getReturnType();\r
2265 \r
2266     MVT VT;\r
2267     if (!isTypeLegal(RetTy, VT))\r
2268       return false;\r
2269 \r
2270     // Unfortunately we can't use fastEmit_r, because the AVX version of FSQRT\r
2271     // is not generated by FastISel yet.\r
2272     // FIXME: Update this code once tablegen can handle it.\r
2273     static const unsigned SqrtOpc[2][2] = {\r
2274       {X86::SQRTSSr, X86::VSQRTSSr},\r
2275       {X86::SQRTSDr, X86::VSQRTSDr}\r
2276     };\r
2277     bool HasAVX = Subtarget->hasAVX();\r
2278     unsigned Opc;\r
2279     const TargetRegisterClass *RC;\r
2280     switch (VT.SimpleTy) {\r
2281     default: return false;\r
2282     case MVT::f32: Opc = SqrtOpc[0][HasAVX]; RC = &X86::FR32RegClass; break;\r
2283     case MVT::f64: Opc = SqrtOpc[1][HasAVX]; RC = &X86::FR64RegClass; break;\r
2284     }\r
2285 \r
2286     const Value *SrcVal = II->getArgOperand(0);\r
2287     unsigned SrcReg = getRegForValue(SrcVal);\r
2288 \r
2289     if (SrcReg == 0)\r
2290       return false;\r
2291 \r
2292     unsigned ImplicitDefReg = 0;\r
2293     if (HasAVX) {\r
2294       ImplicitDefReg = createResultReg(RC);\r
2295       BuildMI(*FuncInfo.MBB, FuncInfo.InsertPt, DbgLoc,\r
2296               TII.get(TargetOpcode::IMPLICIT_DEF), ImplicitDefReg);\r
2297     }\r
2298 \r
2299     unsigned ResultReg = createResultReg(RC);\r
2300     MachineInstrBuilder MIB;\r
2301     MIB = BuildMI(*FuncInfo.MBB, FuncInfo.InsertPt, DbgLoc, TII.get(Opc),\r
2302                   ResultReg);\r
2303 \r
2304     if (ImplicitDefReg)\r
2305       MIB.addReg(ImplicitDefReg);\r
2306 \r
2307     MIB.addReg(SrcReg);\r
2308 \r
2309     updateValueMap(II, ResultReg);\r
2310     return true;\r
2311   }\r
2312   case Intrinsic::sadd_with_overflow:\r
2313   case Intrinsic::uadd_with_overflow:\r
2314   case Intrinsic::ssub_with_overflow:\r
2315   case Intrinsic::usub_with_overflow:\r
2316   case Intrinsic::smul_with_overflow:\r
2317   case Intrinsic::umul_with_overflow: {\r
2318     // This implements the basic lowering of the xalu with overflow intrinsics\r
2319     // into add/sub/mul followed by either seto or setb.\r
2320     const Function *Callee = II->getCalledFunction();\r
2321     auto *Ty = cast<StructType>(Callee->getReturnType());\r
2322     Type *RetTy = Ty->getTypeAtIndex(0U);\r
2323     Type *CondTy = Ty->getTypeAtIndex(1);\r
2324 \r
2325     MVT VT;\r
2326     if (!isTypeLegal(RetTy, VT))\r
2327       return false;\r
2328 \r
2329     if (VT < MVT::i8 || VT > MVT::i64)\r
2330       return false;\r
2331 \r
2332     const Value *LHS = II->getArgOperand(0);\r
2333     const Value *RHS = II->getArgOperand(1);\r
2334 \r
2335     // Canonicalize immediate to the RHS.\r
2336     if (isa<ConstantInt>(LHS) && !isa<ConstantInt>(RHS) &&\r
2337         isCommutativeIntrinsic(II))\r
2338       std::swap(LHS, RHS);\r
2339 \r
2340     bool UseIncDec = false;\r
2341     if (isa<ConstantInt>(RHS) && cast<ConstantInt>(RHS)->isOne())\r
2342       UseIncDec = true;\r
2343 \r
2344     unsigned BaseOpc, CondOpc;\r
2345     switch (II->getIntrinsicID()) {\r
2346     default: llvm_unreachable("Unexpected intrinsic!");\r
2347     case Intrinsic::sadd_with_overflow:\r
2348       BaseOpc = UseIncDec ? unsigned(X86ISD::INC) : unsigned(ISD::ADD);\r
2349       CondOpc = X86::SETOr;\r
2350       break;\r
2351     case Intrinsic::uadd_with_overflow:\r
2352       BaseOpc = ISD::ADD; CondOpc = X86::SETBr; break;\r
2353     case Intrinsic::ssub_with_overflow:\r
2354       BaseOpc = UseIncDec ? unsigned(X86ISD::DEC) : unsigned(ISD::SUB);\r
2355       CondOpc = X86::SETOr;\r
2356       break;\r
2357     case Intrinsic::usub_with_overflow:\r
2358       BaseOpc = ISD::SUB; CondOpc = X86::SETBr; break;\r
2359     case Intrinsic::smul_with_overflow:\r
2360       BaseOpc = X86ISD::SMUL; CondOpc = X86::SETOr; break;\r
2361     case Intrinsic::umul_with_overflow:\r
2362       BaseOpc = X86ISD::UMUL; CondOpc = X86::SETOr; break;\r
2363     }\r
2364 \r
2365     unsigned LHSReg = getRegForValue(LHS);\r
2366     if (LHSReg == 0)\r
2367       return false;\r
2368     bool LHSIsKill = hasTrivialKill(LHS);\r
2369 \r
2370     unsigned ResultReg = 0;\r
2371     // Check if we have an immediate version.\r
2372     if (const auto *CI = dyn_cast<ConstantInt>(RHS)) {\r
2373       static const unsigned Opc[2][4] = {\r
2374         { X86::INC8r, X86::INC16r, X86::INC32r, X86::INC64r },\r
2375         { X86::DEC8r, X86::DEC16r, X86::DEC32r, X86::DEC64r }\r
2376       };\r
2377 \r
2378       if (BaseOpc == X86ISD::INC || BaseOpc == X86ISD::DEC) {\r
2379         ResultReg = createResultReg(TLI.getRegClassFor(VT));\r
2380         bool IsDec = BaseOpc == X86ISD::DEC;\r
2381         BuildMI(*FuncInfo.MBB, FuncInfo.InsertPt, DbgLoc,\r
2382                 TII.get(Opc[IsDec][VT.SimpleTy-MVT::i8]), ResultReg)\r
2383           .addReg(LHSReg, getKillRegState(LHSIsKill));\r
2384       } else\r
2385         ResultReg = fastEmit_ri(VT, VT, BaseOpc, LHSReg, LHSIsKill,\r
2386                                 CI->getZExtValue());\r
2387     }\r
2388 \r
2389     unsigned RHSReg;\r
2390     bool RHSIsKill;\r
2391     if (!ResultReg) {\r
2392       RHSReg = getRegForValue(RHS);\r
2393       if (RHSReg == 0)\r
2394         return false;\r
2395       RHSIsKill = hasTrivialKill(RHS);\r
2396       ResultReg = fastEmit_rr(VT, VT, BaseOpc, LHSReg, LHSIsKill, RHSReg,\r
2397                               RHSIsKill);\r
2398     }\r
2399 \r
2400     // FastISel doesn't have a pattern for all X86::MUL*r and X86::IMUL*r. Emit\r
2401     // it manually.\r
2402     if (BaseOpc == X86ISD::UMUL && !ResultReg) {\r
2403       static const unsigned MULOpc[] =\r
2404         { X86::MUL8r, X86::MUL16r, X86::MUL32r, X86::MUL64r };\r
2405       static const unsigned Reg[] = { X86::AL, X86::AX, X86::EAX, X86::RAX };\r
2406       // First copy the first operand into RAX, which is an implicit input to\r
2407       // the X86::MUL*r instruction.\r
2408       BuildMI(*FuncInfo.MBB, FuncInfo.InsertPt, DbgLoc,\r
2409               TII.get(TargetOpcode::COPY), Reg[VT.SimpleTy-MVT::i8])\r
2410         .addReg(LHSReg, getKillRegState(LHSIsKill));\r
2411       ResultReg = fastEmitInst_r(MULOpc[VT.SimpleTy-MVT::i8],\r
2412                                  TLI.getRegClassFor(VT), RHSReg, RHSIsKill);\r
2413     } else if (BaseOpc == X86ISD::SMUL && !ResultReg) {\r
2414       static const unsigned MULOpc[] =\r
2415         { X86::IMUL8r, X86::IMUL16rr, X86::IMUL32rr, X86::IMUL64rr };\r
2416       if (VT == MVT::i8) {\r
2417         // Copy the first operand into AL, which is an implicit input to the\r
2418         // X86::IMUL8r instruction.\r
2419         BuildMI(*FuncInfo.MBB, FuncInfo.InsertPt, DbgLoc,\r
2420                TII.get(TargetOpcode::COPY), X86::AL)\r
2421           .addReg(LHSReg, getKillRegState(LHSIsKill));\r
2422         ResultReg = fastEmitInst_r(MULOpc[0], TLI.getRegClassFor(VT), RHSReg,\r
2423                                    RHSIsKill);\r
2424       } else\r
2425         ResultReg = fastEmitInst_rr(MULOpc[VT.SimpleTy-MVT::i8],\r
2426                                     TLI.getRegClassFor(VT), LHSReg, LHSIsKill,\r
2427                                     RHSReg, RHSIsKill);\r
2428     }\r
2429 \r
2430     if (!ResultReg)\r
2431       return false;\r
2432 \r
2433     unsigned ResultReg2 = FuncInfo.CreateRegs(CondTy);\r
2434     assert((ResultReg+1) == ResultReg2 && "Nonconsecutive result registers.");\r
2435     BuildMI(*FuncInfo.MBB, FuncInfo.InsertPt, DbgLoc, TII.get(CondOpc),\r
2436             ResultReg2);\r
2437 \r
2438     updateValueMap(II, ResultReg, 2);\r
2439     return true;\r
2440   }\r
2441   case Intrinsic::x86_sse_cvttss2si:\r
2442   case Intrinsic::x86_sse_cvttss2si64:\r
2443   case Intrinsic::x86_sse2_cvttsd2si:\r
2444   case Intrinsic::x86_sse2_cvttsd2si64: {\r
2445     bool IsInputDouble;\r
2446     switch (II->getIntrinsicID()) {\r
2447     default: llvm_unreachable("Unexpected intrinsic.");\r
2448     case Intrinsic::x86_sse_cvttss2si:\r
2449     case Intrinsic::x86_sse_cvttss2si64:\r
2450       if (!Subtarget->hasSSE1())\r
2451         return false;\r
2452       IsInputDouble = false;\r
2453       break;\r
2454     case Intrinsic::x86_sse2_cvttsd2si:\r
2455     case Intrinsic::x86_sse2_cvttsd2si64:\r
2456       if (!Subtarget->hasSSE2())\r
2457         return false;\r
2458       IsInputDouble = true;\r
2459       break;\r
2460     }\r
2461 \r
2462     Type *RetTy = II->getCalledFunction()->getReturnType();\r
2463     MVT VT;\r
2464     if (!isTypeLegal(RetTy, VT))\r
2465       return false;\r
2466 \r
2467     static const unsigned CvtOpc[2][2][2] = {\r
2468       { { X86::CVTTSS2SIrr,   X86::VCVTTSS2SIrr   },\r
2469         { X86::CVTTSS2SI64rr, X86::VCVTTSS2SI64rr }  },\r
2470       { { X86::CVTTSD2SIrr,   X86::VCVTTSD2SIrr   },\r
2471         { X86::CVTTSD2SI64rr, X86::VCVTTSD2SI64rr }  }\r
2472     };\r
2473     bool HasAVX = Subtarget->hasAVX();\r
2474     unsigned Opc;\r
2475     switch (VT.SimpleTy) {\r
2476     default: llvm_unreachable("Unexpected result type.");\r
2477     case MVT::i32: Opc = CvtOpc[IsInputDouble][0][HasAVX]; break;\r
2478     case MVT::i64: Opc = CvtOpc[IsInputDouble][1][HasAVX]; break;\r
2479     }\r
2480 \r
2481     // Check if we can fold insertelement instructions into the convert.\r
2482     const Value *Op = II->getArgOperand(0);\r
2483     while (auto *IE = dyn_cast<InsertElementInst>(Op)) {\r
2484       const Value *Index = IE->getOperand(2);\r
2485       if (!isa<ConstantInt>(Index))\r
2486         break;\r
2487       unsigned Idx = cast<ConstantInt>(Index)->getZExtValue();\r
2488 \r
2489       if (Idx == 0) {\r
2490         Op = IE->getOperand(1);\r
2491         break;\r
2492       }\r
2493       Op = IE->getOperand(0);\r
2494     }\r
2495 \r
2496     unsigned Reg = getRegForValue(Op);\r
2497     if (Reg == 0)\r
2498       return false;\r
2499 \r
2500     unsigned ResultReg = createResultReg(TLI.getRegClassFor(VT));\r
2501     BuildMI(*FuncInfo.MBB, FuncInfo.InsertPt, DbgLoc, TII.get(Opc), ResultReg)\r
2502       .addReg(Reg);\r
2503 \r
2504     updateValueMap(II, ResultReg);\r
2505     return true;\r
2506   }\r
2507   }\r
2508 }\r
2509 \r
2510 bool X86FastISel::fastLowerArguments() {\r
2511   if (!FuncInfo.CanLowerReturn)\r
2512     return false;\r
2513 \r
2514   const Function *F = FuncInfo.Fn;\r
2515   if (F->isVarArg())\r
2516     return false;\r
2517 \r
2518   CallingConv::ID CC = F->getCallingConv();\r
2519   if (CC != CallingConv::C)\r
2520     return false;\r
2521 \r
2522   if (Subtarget->isCallingConvWin64(CC))\r
2523     return false;\r
2524 \r
2525   if (!Subtarget->is64Bit())\r
2526     return false;\r
2527 \r
2528   // Only handle simple cases. i.e. Up to 6 i32/i64 scalar arguments.\r
2529   unsigned GPRCnt = 0;\r
2530   unsigned FPRCnt = 0;\r
2531   unsigned Idx = 0;\r
2532   for (auto const &Arg : F->args()) {\r
2533     // The first argument is at index 1.\r
2534     ++Idx;\r
2535     if (F->getAttributes().hasAttribute(Idx, Attribute::ByVal) ||\r
2536         F->getAttributes().hasAttribute(Idx, Attribute::InReg) ||\r
2537         F->getAttributes().hasAttribute(Idx, Attribute::StructRet) ||\r
2538         F->getAttributes().hasAttribute(Idx, Attribute::Nest))\r
2539       return false;\r
2540 \r
2541     Type *ArgTy = Arg.getType();\r
2542     if (ArgTy->isStructTy() || ArgTy->isArrayTy() || ArgTy->isVectorTy())\r
2543       return false;\r
2544 \r
2545     EVT ArgVT = TLI.getValueType(ArgTy);\r
2546     if (!ArgVT.isSimple()) return false;\r
2547     switch (ArgVT.getSimpleVT().SimpleTy) {\r
2548     default: return false;\r
2549     case MVT::i32:\r
2550     case MVT::i64:\r
2551       ++GPRCnt;\r
2552       break;\r
2553     case MVT::f32:\r
2554     case MVT::f64:\r
2555       if (!Subtarget->hasSSE1())\r
2556         return false;\r
2557       ++FPRCnt;\r
2558       break;\r
2559     }\r
2560 \r
2561     if (GPRCnt > 6)\r
2562       return false;\r
2563 \r
2564     if (FPRCnt > 8)\r
2565       return false;\r
2566   }\r
2567 \r
2568   static const MCPhysReg GPR32ArgRegs[] = {\r
2569     X86::EDI, X86::ESI, X86::EDX, X86::ECX, X86::R8D, X86::R9D\r
2570   };\r
2571   static const MCPhysReg GPR64ArgRegs[] = {\r
2572     X86::RDI, X86::RSI, X86::RDX, X86::RCX, X86::R8 , X86::R9\r
2573   };\r
2574   static const MCPhysReg XMMArgRegs[] = {\r
2575     X86::XMM0, X86::XMM1, X86::XMM2, X86::XMM3,\r
2576     X86::XMM4, X86::XMM5, X86::XMM6, X86::XMM7\r
2577   };\r
2578 \r
2579   unsigned GPRIdx = 0;\r
2580   unsigned FPRIdx = 0;\r
2581   for (auto const &Arg : F->args()) {\r
2582     MVT VT = TLI.getSimpleValueType(Arg.getType());\r
2583     const TargetRegisterClass *RC = TLI.getRegClassFor(VT);\r
2584     unsigned SrcReg;\r
2585     switch (VT.SimpleTy) {\r
2586     default: llvm_unreachable("Unexpected value type.");\r
2587     case MVT::i32: SrcReg = GPR32ArgRegs[GPRIdx++]; break;\r
2588     case MVT::i64: SrcReg = GPR64ArgRegs[GPRIdx++]; break;\r
2589     case MVT::f32: // fall-through\r
2590     case MVT::f64: SrcReg = XMMArgRegs[FPRIdx++]; break;\r
2591     }\r
2592     unsigned DstReg = FuncInfo.MF->addLiveIn(SrcReg, RC);\r
2593     // FIXME: Unfortunately it's necessary to emit a copy from the livein copy.\r
2594     // Without this, EmitLiveInCopies may eliminate the livein if its only\r
2595     // use is a bitcast (which isn't turned into an instruction).\r
2596     unsigned ResultReg = createResultReg(RC);\r
2597     BuildMI(*FuncInfo.MBB, FuncInfo.InsertPt, DbgLoc,\r
2598             TII.get(TargetOpcode::COPY), ResultReg)\r
2599       .addReg(DstReg, getKillRegState(true));\r
2600     updateValueMap(&Arg, ResultReg);\r
2601   }\r
2602   return true;\r
2603 }\r
2604 \r
2605 static unsigned computeBytesPoppedByCallee(const X86Subtarget *Subtarget,\r
2606                                            CallingConv::ID CC,\r
2607                                            ImmutableCallSite *CS) {\r
2608   if (Subtarget->is64Bit())\r
2609     return 0;\r
2610   if (Subtarget->getTargetTriple().isOSMSVCRT())\r
2611     return 0;\r
2612   if (CC == CallingConv::Fast || CC == CallingConv::GHC ||\r
2613       CC == CallingConv::HiPE)\r
2614     return 0;\r
2615   if (CS && !CS->paramHasAttr(1, Attribute::StructRet))\r
2616     return 0;\r
2617   if (CS && CS->paramHasAttr(1, Attribute::InReg))\r
2618     return 0;\r
2619   return 4;\r
2620 }\r
2621 \r
2622 bool X86FastISel::fastLowerCall(CallLoweringInfo &CLI) {\r
2623   auto &OutVals       = CLI.OutVals;\r
2624   auto &OutFlags      = CLI.OutFlags;\r
2625   auto &OutRegs       = CLI.OutRegs;\r
2626   auto &Ins           = CLI.Ins;\r
2627   auto &InRegs        = CLI.InRegs;\r
2628   CallingConv::ID CC  = CLI.CallConv;\r
2629   bool &IsTailCall    = CLI.IsTailCall;\r
2630   bool IsVarArg       = CLI.IsVarArg;\r
2631   const Value *Callee = CLI.Callee;\r
2632   const char *SymName = CLI.SymName;\r
2633 \r
2634   bool Is64Bit        = Subtarget->is64Bit();\r
2635   bool IsWin64        = Subtarget->isCallingConvWin64(CC);\r
2636 \r
2637   // Handle only C, fastcc, and webkit_js calling conventions for now.\r
2638   switch (CC) {\r
2639   default: return false;\r
2640   case CallingConv::C:\r
2641   case CallingConv::Fast:\r
2642   case CallingConv::WebKit_JS:\r
2643   case CallingConv::X86_FastCall:\r
2644   case CallingConv::X86_64_Win64:\r
2645   case CallingConv::X86_64_SysV:\r
2646     break;\r
2647   }\r
2648 \r
2649   // Allow SelectionDAG isel to handle tail calls.\r
2650   if (IsTailCall)\r
2651     return false;\r
2652 \r
2653   // fastcc with -tailcallopt is intended to provide a guaranteed\r
2654   // tail call optimization. Fastisel doesn't know how to do that.\r
2655   if (CC == CallingConv::Fast && TM.Options.GuaranteedTailCallOpt)\r
2656     return false;\r
2657 \r
2658   // Don't know how to handle Win64 varargs yet.  Nothing special needed for\r
2659   // x86-32. Special handling for x86-64 is implemented.\r
2660   if (IsVarArg && IsWin64)\r
2661     return false;\r
2662 \r
2663   // Don't know about inalloca yet.\r
2664   if (CLI.CS && CLI.CS->hasInAllocaArgument())\r
2665     return false;\r
2666 \r
2667   // Fast-isel doesn't know about callee-pop yet.\r
2668   if (X86::isCalleePop(CC, Subtarget->is64Bit(), IsVarArg,\r
2669                        TM.Options.GuaranteedTailCallOpt))\r
2670     return false;\r
2671 \r
2672   SmallVector<MVT, 16> OutVTs;\r
2673   SmallVector<unsigned, 16> ArgRegs;\r
2674 \r
2675   // If this is a constant i1/i8/i16 argument, promote to i32 to avoid an extra\r
2676   // instruction. This is safe because it is common to all FastISel supported\r
2677   // calling conventions on x86.\r
2678   for (int i = 0, e = OutVals.size(); i != e; ++i) {\r
2679     Value *&Val = OutVals[i];\r
2680     ISD::ArgFlagsTy Flags = OutFlags[i];\r
2681     if (auto *CI = dyn_cast<ConstantInt>(Val)) {\r
2682       if (CI->getBitWidth() < 32) {\r
2683         if (Flags.isSExt())\r
2684           Val = ConstantExpr::getSExt(CI, Type::getInt32Ty(CI->getContext()));\r
2685         else\r
2686           Val = ConstantExpr::getZExt(CI, Type::getInt32Ty(CI->getContext()));\r
2687       }\r
2688     }\r
2689 \r
2690     // Passing bools around ends up doing a trunc to i1 and passing it.\r
2691     // Codegen this as an argument + "and 1".\r
2692     MVT VT;\r
2693     auto *TI = dyn_cast<TruncInst>(Val);\r
2694     unsigned ResultReg;\r
2695     if (TI && TI->getType()->isIntegerTy(1) && CLI.CS &&\r
2696               (TI->getParent() == CLI.CS->getInstruction()->getParent()) &&\r
2697               TI->hasOneUse()) {\r
2698       Value *PrevVal = TI->getOperand(0);\r
2699       ResultReg = getRegForValue(PrevVal);\r
2700 \r
2701       if (!ResultReg)\r
2702         return false;\r
2703 \r
2704       if (!isTypeLegal(PrevVal->getType(), VT))\r
2705         return false;\r
2706 \r
2707       ResultReg =\r
2708         fastEmit_ri(VT, VT, ISD::AND, ResultReg, hasTrivialKill(PrevVal), 1);\r
2709     } else {\r
2710       if (!isTypeLegal(Val->getType(), VT))\r
2711         return false;\r
2712       ResultReg = getRegForValue(Val);\r
2713     }\r
2714 \r
2715     if (!ResultReg)\r
2716       return false;\r
2717 \r
2718     ArgRegs.push_back(ResultReg);\r
2719     OutVTs.push_back(VT);\r
2720   }\r
2721 \r
2722   // Analyze operands of the call, assigning locations to each operand.\r
2723   SmallVector<CCValAssign, 16> ArgLocs;\r
2724   CCState CCInfo(CC, IsVarArg, *FuncInfo.MF, ArgLocs, CLI.RetTy->getContext());\r
2725 \r
2726   // Allocate shadow area for Win64\r
2727   if (IsWin64)\r
2728     CCInfo.AllocateStack(32, 8);\r
2729 \r
2730   CCInfo.AnalyzeCallOperands(OutVTs, OutFlags, CC_X86);\r
2731 \r
2732   // Get a count of how many bytes are to be pushed on the stack.\r
2733   unsigned NumBytes = CCInfo.getNextStackOffset();\r
2734 \r
2735   // Issue CALLSEQ_START\r
2736   unsigned AdjStackDown = TII.getCallFrameSetupOpcode();\r
2737   BuildMI(*FuncInfo.MBB, FuncInfo.InsertPt, DbgLoc, TII.get(AdjStackDown))\r
2738     .addImm(NumBytes).addImm(0);\r
2739 \r
2740   // Walk the register/memloc assignments, inserting copies/loads.\r
2741   const X86RegisterInfo *RegInfo = static_cast<const X86RegisterInfo *>(\r
2742       TM.getSubtargetImpl()->getRegisterInfo());\r
2743   for (unsigned i = 0, e = ArgLocs.size(); i != e; ++i) {\r
2744     CCValAssign const &VA = ArgLocs[i];\r
2745     const Value *ArgVal = OutVals[VA.getValNo()];\r
2746     MVT ArgVT = OutVTs[VA.getValNo()];\r
2747 \r
2748     if (ArgVT == MVT::x86mmx)\r
2749       return false;\r
2750 \r
2751     unsigned ArgReg = ArgRegs[VA.getValNo()];\r
2752 \r
2753     // Promote the value if needed.\r
2754     switch (VA.getLocInfo()) {\r
2755     case CCValAssign::Full: break;\r
2756     case CCValAssign::SExt: {\r
2757       assert(VA.getLocVT().isInteger() && !VA.getLocVT().isVector() &&\r
2758              "Unexpected extend");\r
2759       bool Emitted = X86FastEmitExtend(ISD::SIGN_EXTEND, VA.getLocVT(), ArgReg,\r
2760                                        ArgVT, ArgReg);\r
2761       assert(Emitted && "Failed to emit a sext!"); (void)Emitted;\r
2762       ArgVT = VA.getLocVT();\r
2763       break;\r
2764     }\r
2765     case CCValAssign::ZExt: {\r
2766       assert(VA.getLocVT().isInteger() && !VA.getLocVT().isVector() &&\r
2767              "Unexpected extend");\r
2768       bool Emitted = X86FastEmitExtend(ISD::ZERO_EXTEND, VA.getLocVT(), ArgReg,\r
2769                                        ArgVT, ArgReg);\r
2770       assert(Emitted && "Failed to emit a zext!"); (void)Emitted;\r
2771       ArgVT = VA.getLocVT();\r
2772       break;\r
2773     }\r
2774     case CCValAssign::AExt: {\r
2775       assert(VA.getLocVT().isInteger() && !VA.getLocVT().isVector() &&\r
2776              "Unexpected extend");\r
2777       bool Emitted = X86FastEmitExtend(ISD::ANY_EXTEND, VA.getLocVT(), ArgReg,\r
2778                                        ArgVT, ArgReg);\r
2779       if (!Emitted)\r
2780         Emitted = X86FastEmitExtend(ISD::ZERO_EXTEND, VA.getLocVT(), ArgReg,\r
2781                                     ArgVT, ArgReg);\r
2782       if (!Emitted)\r
2783         Emitted = X86FastEmitExtend(ISD::SIGN_EXTEND, VA.getLocVT(), ArgReg,\r
2784                                     ArgVT, ArgReg);\r
2785 \r
2786       assert(Emitted && "Failed to emit a aext!"); (void)Emitted;\r
2787       ArgVT = VA.getLocVT();\r
2788       break;\r
2789     }\r
2790     case CCValAssign::BCvt: {\r
2791       ArgReg = fastEmit_r(ArgVT, VA.getLocVT(), ISD::BITCAST, ArgReg,\r
2792                           /*TODO: Kill=*/false);\r
2793       assert(ArgReg && "Failed to emit a bitcast!");\r
2794       ArgVT = VA.getLocVT();\r
2795       break;\r
2796     }\r
2797     case CCValAssign::VExt:\r
2798       // VExt has not been implemented, so this should be impossible to reach\r
2799       // for now.  However, fallback to Selection DAG isel once implemented.\r
2800       return false;\r
2801     case CCValAssign::AExtUpper:\r
2802     case CCValAssign::SExtUpper:\r
2803     case CCValAssign::ZExtUpper:\r
2804     case CCValAssign::FPExt:\r
2805       llvm_unreachable("Unexpected loc info!");\r
2806     case CCValAssign::Indirect:\r
2807       // FIXME: Indirect doesn't need extending, but fast-isel doesn't fully\r
2808       // support this.\r
2809       return false;\r
2810     }\r
2811 \r
2812     if (VA.isRegLoc()) {\r
2813       BuildMI(*FuncInfo.MBB, FuncInfo.InsertPt, DbgLoc,\r
2814               TII.get(TargetOpcode::COPY), VA.getLocReg()).addReg(ArgReg);\r
2815       OutRegs.push_back(VA.getLocReg());\r
2816     } else {\r
2817       assert(VA.isMemLoc());\r
2818 \r
2819       // Don't emit stores for undef values.\r
2820       if (isa<UndefValue>(ArgVal))\r
2821         continue;\r
2822 \r
2823       unsigned LocMemOffset = VA.getLocMemOffset();\r
2824       X86AddressMode AM;\r
2825       AM.Base.Reg = RegInfo->getStackRegister();\r
2826       AM.Disp = LocMemOffset;\r
2827       ISD::ArgFlagsTy Flags = OutFlags[VA.getValNo()];\r
2828       unsigned Alignment = DL.getABITypeAlignment(ArgVal->getType());\r
2829       MachineMemOperand *MMO = FuncInfo.MF->getMachineMemOperand(\r
2830         MachinePointerInfo::getStack(LocMemOffset), MachineMemOperand::MOStore,\r
2831         ArgVT.getStoreSize(), Alignment);\r
2832       if (Flags.isByVal()) {\r
2833         X86AddressMode SrcAM;\r
2834         SrcAM.Base.Reg = ArgReg;\r
2835         if (!TryEmitSmallMemcpy(AM, SrcAM, Flags.getByValSize()))\r
2836           return false;\r
2837       } else if (isa<ConstantInt>(ArgVal) || isa<ConstantPointerNull>(ArgVal)) {\r
2838         // If this is a really simple value, emit this with the Value* version\r
2839         // of X86FastEmitStore.  If it isn't simple, we don't want to do this,\r
2840         // as it can cause us to reevaluate the argument.\r
2841         if (!X86FastEmitStore(ArgVT, ArgVal, AM, MMO))\r
2842           return false;\r
2843       } else {\r
2844         bool ValIsKill = hasTrivialKill(ArgVal);\r
2845         if (!X86FastEmitStore(ArgVT, ArgReg, ValIsKill, AM, MMO))\r
2846           return false;\r
2847       }\r
2848     }\r
2849   }\r
2850 \r
2851   // ELF / PIC requires GOT in the EBX register before function calls via PLT\r
2852   // GOT pointer.\r
2853   if (Subtarget->isPICStyleGOT()) {\r
2854     unsigned Base = getInstrInfo()->getGlobalBaseReg(FuncInfo.MF);\r
2855     BuildMI(*FuncInfo.MBB, FuncInfo.InsertPt, DbgLoc,\r
2856             TII.get(TargetOpcode::COPY), X86::EBX).addReg(Base);\r
2857   }\r
2858 \r
2859   if (Is64Bit && IsVarArg && !IsWin64) {\r
2860     // From AMD64 ABI document:\r
2861     // For calls that may call functions that use varargs or stdargs\r
2862     // (prototype-less calls or calls to functions containing ellipsis (...) in\r
2863     // the declaration) %al is used as hidden argument to specify the number\r
2864     // of SSE registers used. The contents of %al do not need to match exactly\r
2865     // the number of registers, but must be an ubound on the number of SSE\r
2866     // registers used and is in the range 0 - 8 inclusive.\r
2867 \r
2868     // Count the number of XMM registers allocated.\r
2869     static const MCPhysReg XMMArgRegs[] = {\r
2870       X86::XMM0, X86::XMM1, X86::XMM2, X86::XMM3,\r
2871       X86::XMM4, X86::XMM5, X86::XMM6, X86::XMM7\r
2872     };\r
2873     unsigned NumXMMRegs = CCInfo.getFirstUnallocated(XMMArgRegs, 8);\r
2874     assert((Subtarget->hasSSE1() || !NumXMMRegs)\r
2875            && "SSE registers cannot be used when SSE is disabled");\r
2876     BuildMI(*FuncInfo.MBB, FuncInfo.InsertPt, DbgLoc, TII.get(X86::MOV8ri),\r
2877             X86::AL).addImm(NumXMMRegs);\r
2878   }\r
2879 \r
2880   // Materialize callee address in a register. FIXME: GV address can be\r
2881   // handled with a CALLpcrel32 instead.\r
2882   X86AddressMode CalleeAM;\r
2883   if (!X86SelectCallAddress(Callee, CalleeAM))\r
2884     return false;\r
2885 \r
2886   unsigned CalleeOp = 0;\r
2887   const GlobalValue *GV = nullptr;\r
2888   if (CalleeAM.GV != nullptr) {\r
2889     GV = CalleeAM.GV;\r
2890   } else if (CalleeAM.Base.Reg != 0) {\r
2891     CalleeOp = CalleeAM.Base.Reg;\r
2892   } else\r
2893     return false;\r
2894 \r
2895   // Issue the call.\r
2896   MachineInstrBuilder MIB;\r
2897   if (CalleeOp) {\r
2898     // Register-indirect call.\r
2899     unsigned CallOpc = Is64Bit ? X86::CALL64r : X86::CALL32r;\r
2900     MIB = BuildMI(*FuncInfo.MBB, FuncInfo.InsertPt, DbgLoc, TII.get(CallOpc))\r
2901       .addReg(CalleeOp);\r
2902   } else {\r
2903     // Direct call.\r
2904     assert(GV && "Not a direct call");\r
2905     unsigned CallOpc = Is64Bit ? X86::CALL64pcrel32 : X86::CALLpcrel32;\r
2906 \r
2907     // See if we need any target-specific flags on the GV operand.\r
2908     unsigned char OpFlags = 0;\r
2909 \r
2910     // On ELF targets, in both X86-64 and X86-32 mode, direct calls to\r
2911     // external symbols most go through the PLT in PIC mode.  If the symbol\r
2912     // has hidden or protected visibility, or if it is static or local, then\r
2913     // we don't need to use the PLT - we can directly call it.\r
2914     if (Subtarget->isTargetELF() &&\r
2915         TM.getRelocationModel() == Reloc::PIC_ &&\r
2916         GV->hasDefaultVisibility() && !GV->hasLocalLinkage()) {\r
2917       OpFlags = X86II::MO_PLT;\r
2918     } else if (Subtarget->isPICStyleStubAny() &&\r
2919                (GV->isDeclaration() || GV->isWeakForLinker()) &&\r
2920                (!Subtarget->getTargetTriple().isMacOSX() ||\r
2921                 Subtarget->getTargetTriple().isMacOSXVersionLT(10, 5))) {\r
2922       // PC-relative references to external symbols should go through $stub,\r
2923       // unless we're building with the leopard linker or later, which\r
2924       // automatically synthesizes these stubs.\r
2925       OpFlags = X86II::MO_DARWIN_STUB;\r
2926     }\r
2927 \r
2928     MIB = BuildMI(*FuncInfo.MBB, FuncInfo.InsertPt, DbgLoc, TII.get(CallOpc));\r
2929     if (SymName)\r
2930       MIB.addExternalSymbol(SymName, OpFlags);\r
2931     else\r
2932       MIB.addGlobalAddress(GV, 0, OpFlags);\r
2933   }\r
2934 \r
2935   // Add a register mask operand representing the call-preserved registers.\r
2936   // Proper defs for return values will be added by setPhysRegsDeadExcept().\r
2937   MIB.addRegMask(TRI.getCallPreservedMask(CC));\r
2938 \r
2939   // Add an implicit use GOT pointer in EBX.\r
2940   if (Subtarget->isPICStyleGOT())\r
2941     MIB.addReg(X86::EBX, RegState::Implicit);\r
2942 \r
2943   if (Is64Bit && IsVarArg && !IsWin64)\r
2944     MIB.addReg(X86::AL, RegState::Implicit);\r
2945 \r
2946   // Add implicit physical register uses to the call.\r
2947   for (auto Reg : OutRegs)\r
2948     MIB.addReg(Reg, RegState::Implicit);\r
2949 \r
2950   // Issue CALLSEQ_END\r
2951   unsigned NumBytesForCalleeToPop =\r
2952     computeBytesPoppedByCallee(Subtarget, CC, CLI.CS);\r
2953   unsigned AdjStackUp = TII.getCallFrameDestroyOpcode();\r
2954   BuildMI(*FuncInfo.MBB, FuncInfo.InsertPt, DbgLoc, TII.get(AdjStackUp))\r
2955     .addImm(NumBytes).addImm(NumBytesForCalleeToPop);\r
2956 \r
2957   // Now handle call return values.\r
2958   SmallVector<CCValAssign, 16> RVLocs;\r
2959   CCState CCRetInfo(CC, IsVarArg, *FuncInfo.MF, RVLocs,\r
2960                     CLI.RetTy->getContext());\r
2961   CCRetInfo.AnalyzeCallResult(Ins, RetCC_X86);\r
2962 \r
2963   // Copy all of the result registers out of their specified physreg.\r
2964   unsigned ResultReg = FuncInfo.CreateRegs(CLI.RetTy);\r
2965   for (unsigned i = 0; i != RVLocs.size(); ++i) {\r
2966     CCValAssign &VA = RVLocs[i];\r
2967     EVT CopyVT = VA.getValVT();\r
2968     unsigned CopyReg = ResultReg + i;\r
2969 \r
2970     // If this is x86-64, and we disabled SSE, we can't return FP values\r
2971     if ((CopyVT == MVT::f32 || CopyVT == MVT::f64) &&\r
2972         ((Is64Bit || Ins[i].Flags.isInReg()) && !Subtarget->hasSSE1())) {\r
2973       report_fatal_error("SSE register return with SSE disabled");\r
2974     }\r
2975 \r
2976     // If we prefer to use the value in xmm registers, copy it out as f80 and\r
2977     // use a truncate to move it from fp stack reg to xmm reg.\r
2978     if ((VA.getLocReg() == X86::FP0 || VA.getLocReg() == X86::FP1) &&\r
2979         isScalarFPTypeInSSEReg(VA.getValVT())) {\r
2980       CopyVT = MVT::f80;\r
2981       CopyReg = createResultReg(&X86::RFP80RegClass);\r
2982     }\r
2983 \r
2984     // Copy out the result.\r
2985     BuildMI(*FuncInfo.MBB, FuncInfo.InsertPt, DbgLoc,\r
2986             TII.get(TargetOpcode::COPY), CopyReg).addReg(VA.getLocReg());\r
2987     InRegs.push_back(VA.getLocReg());\r
2988 \r
2989     // Round the f80 to the right size, which also moves it to the appropriate\r
2990     // xmm register. This is accomplished by storing the f80 value in memory\r
2991     // and then loading it back.\r
2992     if (CopyVT != VA.getValVT()) {\r
2993       EVT ResVT = VA.getValVT();\r
2994       unsigned Opc = ResVT == MVT::f32 ? X86::ST_Fp80m32 : X86::ST_Fp80m64;\r
2995       unsigned MemSize = ResVT.getSizeInBits()/8;\r
2996       int FI = MFI.CreateStackObject(MemSize, MemSize, false);\r
2997       addFrameReference(BuildMI(*FuncInfo.MBB, FuncInfo.InsertPt, DbgLoc,\r
2998                                 TII.get(Opc)), FI)\r
2999         .addReg(CopyReg);\r
3000       Opc = ResVT == MVT::f32 ? X86::MOVSSrm : X86::MOVSDrm;\r
3001       addFrameReference(BuildMI(*FuncInfo.MBB, FuncInfo.InsertPt, DbgLoc,\r
3002                                 TII.get(Opc), ResultReg + i), FI);\r
3003     }\r
3004   }\r
3005 \r
3006   CLI.ResultReg = ResultReg;\r
3007   CLI.NumResultRegs = RVLocs.size();\r
3008   CLI.Call = MIB;\r
3009 \r
3010   return true;\r
3011 }\r
3012 \r
3013 bool\r
3014 X86FastISel::fastSelectInstruction(const Instruction *I)  {\r
3015   switch (I->getOpcode()) {\r
3016   default: break;\r
3017   case Instruction::Load:\r
3018     return X86SelectLoad(I);\r
3019   case Instruction::Store:\r
3020     return X86SelectStore(I);\r
3021   case Instruction::Ret:\r
3022     return X86SelectRet(I);\r
3023   case Instruction::ICmp:\r
3024   case Instruction::FCmp:\r
3025     return X86SelectCmp(I);\r
3026   case Instruction::ZExt:\r
3027     return X86SelectZExt(I);\r
3028   case Instruction::Br:\r
3029     return X86SelectBranch(I);\r
3030   case Instruction::LShr:\r
3031   case Instruction::AShr:\r
3032   case Instruction::Shl:\r
3033     return X86SelectShift(I);\r
3034   case Instruction::SDiv:\r
3035   case Instruction::UDiv:\r
3036   case Instruction::SRem:\r
3037   case Instruction::URem:\r
3038     return X86SelectDivRem(I);\r
3039   case Instruction::Select:\r
3040     return X86SelectSelect(I);\r
3041   case Instruction::Trunc:\r
3042     return X86SelectTrunc(I);\r
3043   case Instruction::FPExt:\r
3044     return X86SelectFPExt(I);\r
3045   case Instruction::FPTrunc:\r
3046     return X86SelectFPTrunc(I);\r
3047   case Instruction::IntToPtr: // Deliberate fall-through.\r
3048   case Instruction::PtrToInt: {\r
3049     EVT SrcVT = TLI.getValueType(I->getOperand(0)->getType());\r
3050     EVT DstVT = TLI.getValueType(I->getType());\r
3051     if (DstVT.bitsGT(SrcVT))\r
3052       return X86SelectZExt(I);\r
3053     if (DstVT.bitsLT(SrcVT))\r
3054       return X86SelectTrunc(I);\r
3055     unsigned Reg = getRegForValue(I->getOperand(0));\r
3056     if (Reg == 0) return false;\r
3057     updateValueMap(I, Reg);\r
3058     return true;\r
3059   }\r
3060   }\r
3061 \r
3062   return false;\r
3063 }\r
3064 \r
3065 unsigned X86FastISel::X86MaterializeInt(const ConstantInt *CI, MVT VT) {\r
3066   if (VT > MVT::i64)\r
3067     return 0;\r
3068 \r
3069   uint64_t Imm = CI->getZExtValue();\r
3070   if (Imm == 0) {\r
3071     unsigned SrcReg = fastEmitInst_(X86::MOV32r0, &X86::GR32RegClass);\r
3072     switch (VT.SimpleTy) {\r
3073     default: llvm_unreachable("Unexpected value type");\r
3074     case MVT::i1:\r
3075     case MVT::i8:\r
3076       return fastEmitInst_extractsubreg(MVT::i8, SrcReg, /*Kill=*/true,\r
3077                                         X86::sub_8bit);\r
3078     case MVT::i16:\r
3079       return fastEmitInst_extractsubreg(MVT::i16, SrcReg, /*Kill=*/true,\r
3080                                         X86::sub_16bit);\r
3081     case MVT::i32:\r
3082       return SrcReg;\r
3083     case MVT::i64: {\r
3084       unsigned ResultReg = createResultReg(&X86::GR64RegClass);\r
3085       BuildMI(*FuncInfo.MBB, FuncInfo.InsertPt, DbgLoc,\r
3086               TII.get(TargetOpcode::SUBREG_TO_REG), ResultReg)\r
3087         .addImm(0).addReg(SrcReg).addImm(X86::sub_32bit);\r
3088       return ResultReg;\r
3089     }\r
3090     }\r
3091   }\r
3092 \r
3093   unsigned Opc = 0;\r
3094   switch (VT.SimpleTy) {\r
3095   default: llvm_unreachable("Unexpected value type");\r
3096   case MVT::i1:  VT = MVT::i8; // fall-through\r
3097   case MVT::i8:  Opc = X86::MOV8ri;  break;\r
3098   case MVT::i16: Opc = X86::MOV16ri; break;\r
3099   case MVT::i32: Opc = X86::MOV32ri; break;\r
3100   case MVT::i64: {\r
3101     if (isUInt<32>(Imm))\r
3102       Opc = X86::MOV32ri;\r
3103     else if (isInt<32>(Imm))\r
3104       Opc = X86::MOV64ri32;\r
3105     else\r
3106       Opc = X86::MOV64ri;\r
3107     break;\r
3108   }\r
3109   }\r
3110   if (VT == MVT::i64 && Opc == X86::MOV32ri) {\r
3111     unsigned SrcReg = fastEmitInst_i(Opc, &X86::GR32RegClass, Imm);\r
3112     unsigned ResultReg = createResultReg(&X86::GR64RegClass);\r
3113     BuildMI(*FuncInfo.MBB, FuncInfo.InsertPt, DbgLoc,\r
3114             TII.get(TargetOpcode::SUBREG_TO_REG), ResultReg)\r
3115       .addImm(0).addReg(SrcReg).addImm(X86::sub_32bit);\r
3116     return ResultReg;\r
3117   }\r
3118   return fastEmitInst_i(Opc, TLI.getRegClassFor(VT), Imm);\r
3119 }\r
3120 \r
3121 unsigned X86FastISel::X86MaterializeFP(const ConstantFP *CFP, MVT VT) {\r
3122   if (CFP->isNullValue())\r
3123     return fastMaterializeFloatZero(CFP);\r
3124 \r
3125   // Can't handle alternate code models yet.\r
3126   CodeModel::Model CM = TM.getCodeModel();\r
3127   if (CM != CodeModel::Small && CM != CodeModel::Large)\r
3128     return 0;\r
3129 \r
3130   // Get opcode and regclass of the output for the given load instruction.\r
3131   unsigned Opc = 0;\r
3132   const TargetRegisterClass *RC = nullptr;\r
3133   switch (VT.SimpleTy) {\r
3134   default: return 0;\r
3135   case MVT::f32:\r
3136     if (X86ScalarSSEf32) {\r
3137       Opc = Subtarget->hasAVX() ? X86::VMOVSSrm : X86::MOVSSrm;\r
3138       RC  = &X86::FR32RegClass;\r
3139     } else {\r
3140       Opc = X86::LD_Fp32m;\r
3141       RC  = &X86::RFP32RegClass;\r
3142     }\r
3143     break;\r
3144   case MVT::f64:\r
3145     if (X86ScalarSSEf64) {\r
3146       Opc = Subtarget->hasAVX() ? X86::VMOVSDrm : X86::MOVSDrm;\r
3147       RC  = &X86::FR64RegClass;\r
3148     } else {\r
3149       Opc = X86::LD_Fp64m;\r
3150       RC  = &X86::RFP64RegClass;\r
3151     }\r
3152     break;\r
3153   case MVT::f80:\r
3154     // No f80 support yet.\r
3155     return 0;\r
3156   }\r
3157 \r
3158   // MachineConstantPool wants an explicit alignment.\r
3159   unsigned Align = DL.getPrefTypeAlignment(CFP->getType());\r
3160   if (Align == 0) {\r
3161     // Alignment of vector types. FIXME!\r
3162     Align = DL.getTypeAllocSize(CFP->getType());\r
3163   }\r
3164 \r
3165   // x86-32 PIC requires a PIC base register for constant pools.\r
3166   unsigned PICBase = 0;\r
3167   unsigned char OpFlag = 0;\r
3168   if (Subtarget->isPICStyleStubPIC()) { // Not dynamic-no-pic\r
3169     OpFlag = X86II::MO_PIC_BASE_OFFSET;\r
3170     PICBase = getInstrInfo()->getGlobalBaseReg(FuncInfo.MF);\r
3171   } else if (Subtarget->isPICStyleGOT()) {\r
3172     OpFlag = X86II::MO_GOTOFF;\r
3173     PICBase = getInstrInfo()->getGlobalBaseReg(FuncInfo.MF);\r
3174   } else if (Subtarget->isPICStyleRIPRel() &&\r
3175              TM.getCodeModel() == CodeModel::Small) {\r
3176     PICBase = X86::RIP;\r
3177   }\r
3178 \r
3179   // Create the load from the constant pool.\r
3180   unsigned CPI = MCP.getConstantPoolIndex(CFP, Align);\r
3181   unsigned ResultReg = createResultReg(RC);\r
3182 \r
3183   if (CM == CodeModel::Large) {\r
3184     unsigned AddrReg = createResultReg(&X86::GR64RegClass);\r
3185     BuildMI(*FuncInfo.MBB, FuncInfo.InsertPt, DbgLoc, TII.get(X86::MOV64ri),\r
3186             AddrReg)\r
3187       .addConstantPoolIndex(CPI, 0, OpFlag);\r
3188     MachineInstrBuilder MIB = BuildMI(*FuncInfo.MBB, FuncInfo.InsertPt, DbgLoc,\r
3189                                       TII.get(Opc), ResultReg);\r
3190     addDirectMem(MIB, AddrReg);\r
3191     MachineMemOperand *MMO = FuncInfo.MF->getMachineMemOperand(\r
3192         MachinePointerInfo::getConstantPool(), MachineMemOperand::MOLoad,\r
3193         TM.getDataLayout()->getPointerSize(), Align);\r
3194     MIB->addMemOperand(*FuncInfo.MF, MMO);\r
3195     return ResultReg;\r
3196   }\r
3197 \r
3198   addConstantPoolReference(BuildMI(*FuncInfo.MBB, FuncInfo.InsertPt, DbgLoc,\r
3199                                    TII.get(Opc), ResultReg),\r
3200                            CPI, PICBase, OpFlag);\r
3201   return ResultReg;\r
3202 }\r
3203 \r
3204 unsigned X86FastISel::X86MaterializeGV(const GlobalValue *GV, MVT VT) {\r
3205   // Can't handle alternate code models yet.\r
3206   if (TM.getCodeModel() != CodeModel::Small)\r
3207     return 0;\r
3208 \r
3209   // Materialize addresses with LEA/MOV instructions.\r
3210   X86AddressMode AM;\r
3211   if (X86SelectAddress(GV, AM)) {\r
3212     // If the expression is just a basereg, then we're done, otherwise we need\r
3213     // to emit an LEA.\r
3214     if (AM.BaseType == X86AddressMode::RegBase &&\r
3215         AM.IndexReg == 0 && AM.Disp == 0 && AM.GV == nullptr)\r
3216       return AM.Base.Reg;\r
3217 \r
3218     unsigned ResultReg = createResultReg(TLI.getRegClassFor(VT));\r
3219     if (TM.getRelocationModel() == Reloc::Static &&\r
3220         TLI.getPointerTy() == MVT::i64) {\r
3221       // The displacement code could be more than 32 bits away so we need to use\r
3222       // an instruction with a 64 bit immediate\r
3223       BuildMI(*FuncInfo.MBB, FuncInfo.InsertPt, DbgLoc, TII.get(X86::MOV64ri),\r
3224               ResultReg)\r
3225         .addGlobalAddress(GV);\r
3226     } else {\r
3227       unsigned Opc = TLI.getPointerTy() == MVT::i32\r
3228                      ? (Subtarget->isTarget64BitILP32()\r
3229                         ? X86::LEA64_32r : X86::LEA32r)\r
3230                      : X86::LEA64r;\r
3231       addFullAddress(BuildMI(*FuncInfo.MBB, FuncInfo.InsertPt, DbgLoc,\r
3232                              TII.get(Opc), ResultReg), AM);\r
3233     }\r
3234     return ResultReg;\r
3235   }\r
3236   return 0;\r
3237 }\r
3238 \r
3239 unsigned X86FastISel::fastMaterializeConstant(const Constant *C) {\r
3240   EVT CEVT = TLI.getValueType(C->getType(), true);\r
3241 \r
3242   // Only handle simple types.\r
3243   if (!CEVT.isSimple())\r
3244     return 0;\r
3245   MVT VT = CEVT.getSimpleVT();\r
3246 \r
3247   if (const auto *CI = dyn_cast<ConstantInt>(C))\r
3248     return X86MaterializeInt(CI, VT);\r
3249   else if (const ConstantFP *CFP = dyn_cast<ConstantFP>(C))\r
3250     return X86MaterializeFP(CFP, VT);\r
3251   else if (const GlobalValue *GV = dyn_cast<GlobalValue>(C))\r
3252     return X86MaterializeGV(GV, VT);\r
3253 \r
3254   return 0;\r
3255 }\r
3256 \r
3257 unsigned X86FastISel::fastMaterializeAlloca(const AllocaInst *C) {\r
3258   // Fail on dynamic allocas. At this point, getRegForValue has already\r
3259   // checked its CSE maps, so if we're here trying to handle a dynamic\r
3260   // alloca, we're not going to succeed. X86SelectAddress has a\r
3261   // check for dynamic allocas, because it's called directly from\r
3262   // various places, but targetMaterializeAlloca also needs a check\r
3263   // in order to avoid recursion between getRegForValue,\r
3264   // X86SelectAddrss, and targetMaterializeAlloca.\r
3265   if (!FuncInfo.StaticAllocaMap.count(C))\r
3266     return 0;\r
3267   assert(C->isStaticAlloca() && "dynamic alloca in the static alloca map?");\r
3268 \r
3269   X86AddressMode AM;\r
3270   if (!X86SelectAddress(C, AM))\r
3271     return 0;\r
3272   unsigned Opc = TLI.getPointerTy() == MVT::i32\r
3273                  ? (Subtarget->isTarget64BitILP32()\r
3274                     ? X86::LEA64_32r : X86::LEA32r)\r
3275                  : X86::LEA64r;\r
3276   const TargetRegisterClass* RC = TLI.getRegClassFor(TLI.getPointerTy());\r
3277   unsigned ResultReg = createResultReg(RC);\r
3278   addFullAddress(BuildMI(*FuncInfo.MBB, FuncInfo.InsertPt, DbgLoc,\r
3279                          TII.get(Opc), ResultReg), AM);\r
3280   return ResultReg;\r
3281 }\r
3282 \r
3283 unsigned X86FastISel::fastMaterializeFloatZero(const ConstantFP *CF) {\r
3284   MVT VT;\r
3285   if (!isTypeLegal(CF->getType(), VT))\r
3286     return 0;\r
3287 \r
3288   // Get opcode and regclass for the given zero.\r
3289   unsigned Opc = 0;\r
3290   const TargetRegisterClass *RC = nullptr;\r
3291   switch (VT.SimpleTy) {\r
3292   default: return 0;\r
3293   case MVT::f32:\r
3294     if (X86ScalarSSEf32) {\r
3295       Opc = X86::FsFLD0SS;\r
3296       RC  = &X86::FR32RegClass;\r
3297     } else {\r
3298       Opc = X86::LD_Fp032;\r
3299       RC  = &X86::RFP32RegClass;\r
3300     }\r
3301     break;\r
3302   case MVT::f64:\r
3303     if (X86ScalarSSEf64) {\r
3304       Opc = X86::FsFLD0SD;\r
3305       RC  = &X86::FR64RegClass;\r
3306     } else {\r
3307       Opc = X86::LD_Fp064;\r
3308       RC  = &X86::RFP64RegClass;\r
3309     }\r
3310     break;\r
3311   case MVT::f80:\r
3312     // No f80 support yet.\r
3313     return 0;\r
3314   }\r
3315 \r
3316   unsigned ResultReg = createResultReg(RC);\r
3317   BuildMI(*FuncInfo.MBB, FuncInfo.InsertPt, DbgLoc, TII.get(Opc), ResultReg);\r
3318   return ResultReg;\r
3319 }\r
3320 \r
3321 \r
3322 bool X86FastISel::tryToFoldLoadIntoMI(MachineInstr *MI, unsigned OpNo,\r
3323                                       const LoadInst *LI) {\r
3324   const Value *Ptr = LI->getPointerOperand();\r
3325   X86AddressMode AM;\r
3326   if (!X86SelectAddress(Ptr, AM))\r
3327     return false;\r
3328 \r
3329   const X86InstrInfo &XII = (const X86InstrInfo &)TII;\r
3330 \r
3331   unsigned Size = DL.getTypeAllocSize(LI->getType());\r
3332   unsigned Alignment = LI->getAlignment();\r
3333 \r
3334   if (Alignment == 0)  // Ensure that codegen never sees alignment 0\r
3335     Alignment = DL.getABITypeAlignment(LI->getType());\r
3336 \r
3337   SmallVector<MachineOperand, 8> AddrOps;\r
3338   AM.getFullAddress(AddrOps);\r
3339 \r
3340   MachineInstr *Result =\r
3341     XII.foldMemoryOperandImpl(*FuncInfo.MF, MI, OpNo, AddrOps,\r
3342                               Size, Alignment, /*AllowCommute=*/true);\r
3343   if (!Result)\r
3344     return false;\r
3345 \r
3346   Result->addMemOperand(*FuncInfo.MF, createMachineMemOperandFor(LI));\r
3347   FuncInfo.MBB->insert(FuncInfo.InsertPt, Result);\r
3348   MI->eraseFromParent();\r
3349   return true;\r
3350 }\r
3351 \r
3352 \r
3353 namespace llvm {\r
3354   FastISel *X86::createFastISel(FunctionLoweringInfo &funcInfo,\r
3355                                 const TargetLibraryInfo *libInfo) {\r
3356     return new X86FastISel(funcInfo, libInfo);\r
3357   }\r
3358 }\r