lib/Target/AArch64/AArch64FastISel.cpp

   1 //===-- AArch6464FastISel.cpp - AArch64 FastISel implementation -----------===//
   2 //
   3 //                     The LLVM Compiler Infrastructure
   4 //
   5 // This file is distributed under the University of Illinois Open Source
   6 // License. See LICENSE.TXT for details.
   7 //
   8 //===----------------------------------------------------------------------===//
   9 //
  10 // This file defines the AArch64-specific support for the FastISel class. Some
  11 // of the target-specific code is generated by tablegen in the file
  12 // AArch64GenFastISel.inc, which is #included here.
  13 //
  14 //===----------------------------------------------------------------------===//
  15
  16 #include "AArch64.h"
  17 #include "AArch64Subtarget.h"
  18 #include "AArch64TargetMachine.h"
  19 #include "MCTargetDesc/AArch64AddressingModes.h"
  20 #include "llvm/Analysis/BranchProbabilityInfo.h"
  21 #include "llvm/CodeGen/CallingConvLower.h"
  22 #include "llvm/CodeGen/FastISel.h"
  23 #include "llvm/CodeGen/FunctionLoweringInfo.h"
  24 #include "llvm/CodeGen/MachineConstantPool.h"
  25 #include "llvm/CodeGen/MachineFrameInfo.h"
  26 #include "llvm/CodeGen/MachineInstrBuilder.h"
  27 #include "llvm/CodeGen/MachineRegisterInfo.h"
  28 #include "llvm/IR/CallingConv.h"
  29 #include "llvm/IR/DataLayout.h"
  30 #include "llvm/IR/DerivedTypes.h"
  31 #include "llvm/IR/Function.h"
  32 #include "llvm/IR/GetElementPtrTypeIterator.h"
  33 #include "llvm/IR/GlobalAlias.h"
  34 #include "llvm/IR/GlobalVariable.h"
  35 #include "llvm/IR/Instructions.h"
  36 #include "llvm/IR/IntrinsicInst.h"
  37 #include "llvm/IR/Operator.h"
  38 #include "llvm/Support/CommandLine.h"
  39 using namespace llvm;
  40
  41 namespace {
  42
  43 class AArch64FastISel : public FastISel {
  44   class Address {
  45   public:
  46     typedef enum {
  47       RegBase,
  48       FrameIndexBase
  49     } BaseKind;
  50
  51   private:
  52     BaseKind Kind;
  53     AArch64_AM::ShiftExtendType ExtType;
  54     union {
  55       unsigned Reg;
  56       int FI;
  57     } Base;
  58     unsigned OffsetReg;
  59     unsigned Shift;
  60     int64_t Offset;
  61     const GlobalValue *GV;
  62
  63   public:
  64     Address() : Kind(RegBase), ExtType(AArch64_AM::InvalidShiftExtend),
  65       OffsetReg(0), Shift(0), Offset(0), GV(nullptr) { Base.Reg = 0; }
  66     void setKind(BaseKind K) { Kind = K; }
  67     BaseKind getKind() const { return Kind; }
  68     void setExtendType(AArch64_AM::ShiftExtendType E) { ExtType = E; }
  69     AArch64_AM::ShiftExtendType getExtendType() const { return ExtType; }
  70     bool isRegBase() const { return Kind == RegBase; }
  71     bool isFIBase() const { return Kind == FrameIndexBase; }
  72     void setReg(unsigned Reg) {
  73       assert(isRegBase() && "Invalid base register access!");
  74       Base.Reg = Reg;
  75     }
  76     unsigned getReg() const {
  77       assert(isRegBase() && "Invalid base register access!");
  78       return Base.Reg;
  79     }
  80     void setOffsetReg(unsigned Reg) {
  81       assert(isRegBase() && "Invalid offset register access!");
  82       OffsetReg = Reg;
  83     }
  84     unsigned getOffsetReg() const {
  85       assert(isRegBase() && "Invalid offset register access!");
  86       return OffsetReg;
  87     }
  88     void setFI(unsigned FI) {
  89       assert(isFIBase() && "Invalid base frame index  access!");
  90       Base.FI = FI;
  91     }
  92     unsigned getFI() const {
  93       assert(isFIBase() && "Invalid base frame index access!");
  94       return Base.FI;
  95     }
  96     void setOffset(int64_t O) { Offset = O; }
  97     int64_t getOffset() { return Offset; }
  98     void setShift(unsigned S) { Shift = S; }
  99     unsigned getShift() { return Shift; }
 100
 101     void setGlobalValue(const GlobalValue *G) { GV = G; }
 102     const GlobalValue *getGlobalValue() { return GV; }
 103   };
 104
 105   /// Subtarget - Keep a pointer to the AArch64Subtarget around so that we can
 106   /// make the right decision when generating code for different targets.
 107   const AArch64Subtarget *Subtarget;
 108   LLVMContext *Context;
 109
 110   bool FastLowerArguments() override;
 111   bool FastLowerCall(CallLoweringInfo &CLI) override;
 112   bool FastLowerIntrinsicCall(const IntrinsicInst *II) override;
 113
 114 private:
 115   // Selection routines.
 116   bool SelectLoad(const Instruction *I);
 117   bool SelectStore(const Instruction *I);
 118   bool SelectBranch(const Instruction *I);
 119   bool SelectIndirectBr(const Instruction *I);
 120   bool SelectCmp(const Instruction *I);
 121   bool SelectSelect(const Instruction *I);
 122   bool SelectFPExt(const Instruction *I);
 123   bool SelectFPTrunc(const Instruction *I);
 124   bool SelectFPToInt(const Instruction *I, bool Signed);
 125   bool SelectIntToFP(const Instruction *I, bool Signed);
 126   bool SelectRem(const Instruction *I, unsigned ISDOpcode);
 127   bool SelectRet(const Instruction *I);
 128   bool SelectTrunc(const Instruction *I);
 129   bool SelectIntExt(const Instruction *I);
 130   bool SelectMul(const Instruction *I);
 131   bool SelectShift(const Instruction *I);
 132   bool SelectBitCast(const Instruction *I);
 133
 134   // Utility helper routines.
 135   bool isTypeLegal(Type *Ty, MVT &VT);
 136   bool isLoadStoreTypeLegal(Type *Ty, MVT &VT);
 137   bool ComputeAddress(const Value *Obj, Address &Addr, Type *Ty = nullptr);
 138   bool ComputeCallAddress(const Value *V, Address &Addr);
 139   bool SimplifyAddress(Address &Addr, MVT VT);
 140   void AddLoadStoreOperands(Address &Addr, const MachineInstrBuilder &MIB,
 141                             unsigned Flags, unsigned ScaleFactor,
 142                             MachineMemOperand *MMO);
 143   bool IsMemCpySmall(uint64_t Len, unsigned Alignment);
 144   bool TryEmitSmallMemCpy(Address Dest, Address Src, uint64_t Len,
 145                           unsigned Alignment);
 146   bool foldXALUIntrinsic(AArch64CC::CondCode &CC, const Instruction *I,
 147                          const Value *Cond);
 148
 149   // Emit helper routines.
 150   unsigned emitAddsSubs(bool UseAdds, MVT RetVT, const Value *LHS,
 151                         const Value *RHS, bool IsZExt = false,
 152                         bool WantResult = true);
 153   unsigned emitAddsSubs_rr(bool UseAdds, MVT RetVT, unsigned LHSReg,
 154                            bool LHSIsKill, unsigned RHSReg, bool RHSIsKill,
 155                            bool WantResult = true);
 156   unsigned emitAddsSubs_ri(bool UseAdds, MVT RetVT, unsigned LHSReg,
 157                            bool LHSIsKill, uint64_t Imm,
 158                            bool WantResult = true);
 159   unsigned emitAddSub_rs(bool UseAdd, MVT RetVT, unsigned LHSReg,
 160                          bool LHSIsKill, unsigned RHSReg, bool RHSIsKill,
 161                          AArch64_AM::ShiftExtendType ShiftType,
 162                          uint64_t ShiftImm, bool WantResult = true);
 163   unsigned emitAddsSubs_rs(bool UseAdds, MVT RetVT, unsigned LHSReg,
 164                            bool LHSIsKill, unsigned RHSReg, bool RHSIsKill,
 165                            AArch64_AM::ShiftExtendType ShiftType,
 166                            uint64_t ShiftImm, bool WantResult = true);
 167   unsigned emitAddSub_rx(bool UseAdd, MVT RetVT, unsigned LHSReg,
 168                          bool LHSIsKill, unsigned RHSReg, bool RHSIsKill,
 169                           AArch64_AM::ShiftExtendType ExtType,
 170                           uint64_t ShiftImm, bool WantResult = true);
 171
 172   unsigned emitAddsSubs_rx(bool UseAdds, MVT RetVT, unsigned LHSReg,
 173                            bool LHSIsKill, unsigned RHSReg, bool RHSIsKill,
 174                            AArch64_AM::ShiftExtendType ExtType,
 175                            uint64_t ShiftImm, bool WantResult = true);
 176
 177   // Emit functions.
 178   bool emitCmp(const Value *LHS, const Value *RHS, bool IsZExt);
 179   bool emitICmp(MVT RetVT, const Value *LHS, const Value *RHS, bool IsZExt);
 180   bool emitICmp_ri(MVT RetVT, unsigned LHSReg, bool LHSIsKill, uint64_t Imm);
 181   bool emitFCmp(MVT RetVT, const Value *LHS, const Value *RHS);
 182   bool EmitLoad(MVT VT, unsigned &ResultReg, Address Addr,
 183                 MachineMemOperand *MMO = nullptr);
 184   bool EmitStore(MVT VT, unsigned SrcReg, Address Addr,
 185                  MachineMemOperand *MMO = nullptr);
 186   unsigned EmitIntExt(MVT SrcVT, unsigned SrcReg, MVT DestVT, bool isZExt);
 187   unsigned Emiti1Ext(unsigned SrcReg, MVT DestVT, bool isZExt);
 188   unsigned emitAdds(MVT RetVT, const Value *LHS, const Value *RHS,
 189                     bool IsZExt = false, bool WantResult = true);
 190   unsigned emitSubs(MVT RetVT, const Value *LHS, const Value *RHS,
 191                     bool IsZExt = false, bool WantResult = true);
 192   unsigned emitSubs_rr(MVT RetVT, unsigned LHSReg, bool LHSIsKill,
 193                        unsigned RHSReg, bool RHSIsKill, bool WantResult = true);
 194   unsigned emitSubs_rs(MVT RetVT, unsigned LHSReg, bool LHSIsKill,
 195                        unsigned RHSReg, bool RHSIsKill,
 196                        AArch64_AM::ShiftExtendType ShiftType, uint64_t ShiftImm,
 197                        bool WantResult = true);
 198   unsigned emitAND_ri(MVT RetVT, unsigned LHSReg, bool LHSIsKill, uint64_t Imm);
 199   unsigned Emit_MUL_rr(MVT RetVT, unsigned Op0, bool Op0IsKill,
 200                        unsigned Op1, bool Op1IsKill);
 201   unsigned Emit_SMULL_rr(MVT RetVT, unsigned Op0, bool Op0IsKill,
 202                          unsigned Op1, bool Op1IsKill);
 203   unsigned Emit_UMULL_rr(MVT RetVT, unsigned Op0, bool Op0IsKill,
 204                          unsigned Op1, bool Op1IsKill);
 205   unsigned emitLSL_rr(MVT RetVT, unsigned Op0Reg, bool Op0IsKill,
 206                       unsigned Op1Reg, bool Op1IsKill);
 207   unsigned emitLSL_ri(MVT RetVT, MVT SrcVT, unsigned Op0Reg, bool Op0IsKill,
 208                       uint64_t Imm, bool IsZExt = true);
 209   unsigned emitLSR_rr(MVT RetVT, unsigned Op0Reg, bool Op0IsKill,
 210                       unsigned Op1Reg, bool Op1IsKill);
 211   unsigned emitLSR_ri(MVT RetVT, MVT SrcVT, unsigned Op0Reg, bool Op0IsKill,
 212                       uint64_t Imm, bool IsZExt = true);
 213   unsigned emitASR_rr(MVT RetVT, unsigned Op0Reg, bool Op0IsKill,
 214                       unsigned Op1Reg, bool Op1IsKill);
 215   unsigned emitASR_ri(MVT RetVT, MVT SrcVT, unsigned Op0Reg, bool Op0IsKill,
 216                       uint64_t Imm, bool IsZExt = false);
 217
 218   unsigned AArch64MaterializeInt(const ConstantInt *CI, MVT VT);
 219   unsigned AArch64MaterializeFP(const ConstantFP *CFP, MVT VT);
 220   unsigned AArch64MaterializeGV(const GlobalValue *GV);
 221
 222   // Call handling routines.
 223 private:
 224   CCAssignFn *CCAssignFnForCall(CallingConv::ID CC) const;
 225   bool ProcessCallArgs(CallLoweringInfo &CLI, SmallVectorImpl<MVT> &ArgVTs,
 226                        unsigned &NumBytes);
 227   bool FinishCall(CallLoweringInfo &CLI, MVT RetVT, unsigned NumBytes);
 228
 229 public:
 230   // Backend specific FastISel code.
 231   unsigned TargetMaterializeAlloca(const AllocaInst *AI) override;
 232   unsigned TargetMaterializeConstant(const Constant *C) override;
 233   unsigned TargetMaterializeFloatZero(const ConstantFP* CF) override;
 234
 235   explicit AArch64FastISel(FunctionLoweringInfo &funcInfo,
 236                          const TargetLibraryInfo *libInfo)
 237       : FastISel(funcInfo, libInfo) {
 238     Subtarget = &TM.getSubtarget<AArch64Subtarget>();
 239     Context = &funcInfo.Fn->getContext();
 240   }
 241
 242   bool TargetSelectInstruction(const Instruction *I) override;
 243
 244 #include "AArch64GenFastISel.inc"
 245 };
 246
 247 } // end anonymous namespace
 248
 249 #include "AArch64GenCallingConv.inc"
 250
 251 CCAssignFn *AArch64FastISel::CCAssignFnForCall(CallingConv::ID CC) const {
 252   if (CC == CallingConv::WebKit_JS)
 253     return CC_AArch64_WebKit_JS;
 254   return Subtarget->isTargetDarwin() ? CC_AArch64_DarwinPCS : CC_AArch64_AAPCS;
 255 }
 256
 257 unsigned AArch64FastISel::TargetMaterializeAlloca(const AllocaInst *AI) {
 258   assert(TLI.getValueType(AI->getType(), true) == MVT::i64 &&
 259          "Alloca should always return a pointer.");
 260
 261   // Don't handle dynamic allocas.
 262   if (!FuncInfo.StaticAllocaMap.count(AI))
 263     return 0;
 264
 265   DenseMap<const AllocaInst *, int>::iterator SI =
 266       FuncInfo.StaticAllocaMap.find(AI);
 267
 268   if (SI != FuncInfo.StaticAllocaMap.end()) {
 269     unsigned ResultReg = createResultReg(&AArch64::GPR64spRegClass);
 270     BuildMI(*FuncInfo.MBB, FuncInfo.InsertPt, DbgLoc, TII.get(AArch64::ADDXri),
 271             ResultReg)
 272         .addFrameIndex(SI->second)
 273         .addImm(0)
 274         .addImm(0);
 275     return ResultReg;
 276   }
 277
 278   return 0;
 279 }
 280
 281 unsigned AArch64FastISel::AArch64MaterializeInt(const ConstantInt *CI, MVT VT) {
 282   if (VT > MVT::i64)
 283     return 0;
 284
 285   if (!CI->isZero())
 286     return FastEmit_i(VT, VT, ISD::Constant, CI->getZExtValue());
 287
 288   // Create a copy from the zero register to materialize a "0" value.
 289   const TargetRegisterClass *RC = (VT == MVT::i64) ? &AArch64::GPR64RegClass
 290                                                    : &AArch64::GPR32RegClass;
 291   unsigned ZeroReg = (VT == MVT::i64) ? AArch64::XZR : AArch64::WZR;
 292   unsigned ResultReg = createResultReg(RC);
 293   BuildMI(*FuncInfo.MBB, FuncInfo.InsertPt, DbgLoc, TII.get(TargetOpcode::COPY),
 294           ResultReg).addReg(ZeroReg, getKillRegState(true));
 295   return ResultReg;
 296 }
 297
 298 unsigned AArch64FastISel::AArch64MaterializeFP(const ConstantFP *CFP, MVT VT) {
 299   // Positive zero (+0.0) has to be materialized with a fmov from the zero
 300   // register, because the immediate version of fmov cannot encode zero.
 301   if (CFP->isNullValue())
 302     return TargetMaterializeFloatZero(CFP);
 303
 304   if (VT != MVT::f32 && VT != MVT::f64)
 305     return 0;
 306
 307   const APFloat Val = CFP->getValueAPF();
 308   bool Is64Bit = (VT == MVT::f64);
 309   // This checks to see if we can use FMOV instructions to materialize
 310   // a constant, otherwise we have to materialize via the constant pool.
 311   if (TLI.isFPImmLegal(Val, VT)) {
 312     int Imm =
 313         Is64Bit ? AArch64_AM::getFP64Imm(Val) : AArch64_AM::getFP32Imm(Val);
 314     assert((Imm != -1) && "Cannot encode floating-point constant.");
 315     unsigned Opc = Is64Bit ? AArch64::FMOVDi : AArch64::FMOVSi;
 316     return FastEmitInst_i(Opc, TLI.getRegClassFor(VT), Imm);
 317   }
 318
 319   // Materialize via constant pool.  MachineConstantPool wants an explicit
 320   // alignment.
 321   unsigned Align = DL.getPrefTypeAlignment(CFP->getType());
 322   if (Align == 0)
 323     Align = DL.getTypeAllocSize(CFP->getType());
 324
 325   unsigned CPI = MCP.getConstantPoolIndex(cast<Constant>(CFP), Align);
 326   unsigned ADRPReg = createResultReg(&AArch64::GPR64commonRegClass);
 327   BuildMI(*FuncInfo.MBB, FuncInfo.InsertPt, DbgLoc, TII.get(AArch64::ADRP),
 328           ADRPReg).addConstantPoolIndex(CPI, 0, AArch64II::MO_PAGE);
 329
 330   unsigned Opc = Is64Bit ? AArch64::LDRDui : AArch64::LDRSui;
 331   unsigned ResultReg = createResultReg(TLI.getRegClassFor(VT));
 332   BuildMI(*FuncInfo.MBB, FuncInfo.InsertPt, DbgLoc, TII.get(Opc), ResultReg)
 333       .addReg(ADRPReg)
 334       .addConstantPoolIndex(CPI, 0, AArch64II::MO_PAGEOFF | AArch64II::MO_NC);
 335   return ResultReg;
 336 }
 337
 338 unsigned AArch64FastISel::AArch64MaterializeGV(const GlobalValue *GV) {
 339   // We can't handle thread-local variables quickly yet.
 340   if (GV->isThreadLocal())
 341     return 0;
 342
 343   // MachO still uses GOT for large code-model accesses, but ELF requires
 344   // movz/movk sequences, which FastISel doesn't handle yet.
 345   if (TM.getCodeModel() != CodeModel::Small && !Subtarget->isTargetMachO())
 346     return 0;
 347
 348   unsigned char OpFlags = Subtarget->ClassifyGlobalReference(GV, TM);
 349
 350   EVT DestEVT = TLI.getValueType(GV->getType(), true);
 351   if (!DestEVT.isSimple())
 352     return 0;
 353
 354   unsigned ADRPReg = createResultReg(&AArch64::GPR64commonRegClass);
 355   unsigned ResultReg;
 356
 357   if (OpFlags & AArch64II::MO_GOT) {
 358     // ADRP + LDRX
 359     BuildMI(*FuncInfo.MBB, FuncInfo.InsertPt, DbgLoc, TII.get(AArch64::ADRP),
 360             ADRPReg)
 361       .addGlobalAddress(GV, 0, AArch64II::MO_GOT | AArch64II::MO_PAGE);
 362
 363     ResultReg = createResultReg(&AArch64::GPR64RegClass);
 364     BuildMI(*FuncInfo.MBB, FuncInfo.InsertPt, DbgLoc, TII.get(AArch64::LDRXui),
 365             ResultReg)
 366       .addReg(ADRPReg)
 367       .addGlobalAddress(GV, 0, AArch64II::MO_GOT | AArch64II::MO_PAGEOFF |
 368                         AArch64II::MO_NC);
 369   } else {
 370     // ADRP + ADDX
 371     BuildMI(*FuncInfo.MBB, FuncInfo.InsertPt, DbgLoc, TII.get(AArch64::ADRP),
 372             ADRPReg)
 373       .addGlobalAddress(GV, 0, AArch64II::MO_PAGE);
 374
 375     ResultReg = createResultReg(&AArch64::GPR64spRegClass);
 376     BuildMI(*FuncInfo.MBB, FuncInfo.InsertPt, DbgLoc, TII.get(AArch64::ADDXri),
 377             ResultReg)
 378       .addReg(ADRPReg)
 379       .addGlobalAddress(GV, 0, AArch64II::MO_PAGEOFF | AArch64II::MO_NC)
 380       .addImm(0);
 381   }
 382   return ResultReg;
 383 }
 384
 385 unsigned AArch64FastISel::TargetMaterializeConstant(const Constant *C) {
 386   EVT CEVT = TLI.getValueType(C->getType(), true);
 387
 388   // Only handle simple types.
 389   if (!CEVT.isSimple())
 390     return 0;
 391   MVT VT = CEVT.getSimpleVT();
 392
 393   if (const auto *CI = dyn_cast<ConstantInt>(C))
 394     return AArch64MaterializeInt(CI, VT);
 395   else if (const ConstantFP *CFP = dyn_cast<ConstantFP>(C))
 396     return AArch64MaterializeFP(CFP, VT);
 397   else if (const GlobalValue *GV = dyn_cast<GlobalValue>(C))
 398     return AArch64MaterializeGV(GV);
 399
 400   return 0;
 401 }
 402
 403 unsigned AArch64FastISel::TargetMaterializeFloatZero(const ConstantFP* CFP) {
 404   assert(CFP->isNullValue() &&
 405          "Floating-point constant is not a positive zero.");
 406   MVT VT;
 407   if (!isTypeLegal(CFP->getType(), VT))
 408     return 0;
 409
 410   if (VT != MVT::f32 && VT != MVT::f64)
 411     return 0;
 412
 413   bool Is64Bit = (VT == MVT::f64);
 414   unsigned ZReg = Is64Bit ? AArch64::XZR : AArch64::WZR;
 415   unsigned Opc = Is64Bit ? AArch64::FMOVXDr : AArch64::FMOVWSr;
 416   return FastEmitInst_r(Opc, TLI.getRegClassFor(VT), ZReg, /*IsKill=*/true);
 417 }
 418
 419 // Computes the address to get to an object.
 420 bool AArch64FastISel::ComputeAddress(const Value *Obj, Address &Addr, Type *Ty)
 421 {
 422   const User *U = nullptr;
 423   unsigned Opcode = Instruction::UserOp1;
 424   if (const Instruction *I = dyn_cast<Instruction>(Obj)) {
 425     // Don't walk into other basic blocks unless the object is an alloca from
 426     // another block, otherwise it may not have a virtual register assigned.
 427     if (FuncInfo.StaticAllocaMap.count(static_cast<const AllocaInst *>(Obj)) ||
 428         FuncInfo.MBBMap[I->getParent()] == FuncInfo.MBB) {
 429       Opcode = I->getOpcode();
 430       U = I;
 431     }
 432   } else if (const ConstantExpr *C = dyn_cast<ConstantExpr>(Obj)) {
 433     Opcode = C->getOpcode();
 434     U = C;
 435   }
 436
 437   if (const PointerType *Ty = dyn_cast<PointerType>(Obj->getType()))
 438     if (Ty->getAddressSpace() > 255)
 439       // Fast instruction selection doesn't support the special
 440       // address spaces.
 441       return false;
 442
 443   switch (Opcode) {
 444   default:
 445     break;
 446   case Instruction::BitCast: {
 447     // Look through bitcasts.
 448     return ComputeAddress(U->getOperand(0), Addr, Ty);
 449   }
 450   case Instruction::IntToPtr: {
 451     // Look past no-op inttoptrs.
 452     if (TLI.getValueType(U->getOperand(0)->getType()) == TLI.getPointerTy())
 453       return ComputeAddress(U->getOperand(0), Addr, Ty);
 454     break;
 455   }
 456   case Instruction::PtrToInt: {
 457     // Look past no-op ptrtoints.
 458     if (TLI.getValueType(U->getType()) == TLI.getPointerTy())
 459       return ComputeAddress(U->getOperand(0), Addr, Ty);
 460     break;
 461   }
 462   case Instruction::GetElementPtr: {
 463     Address SavedAddr = Addr;
 464     uint64_t TmpOffset = Addr.getOffset();
 465
 466     // Iterate through the GEP folding the constants into offsets where
 467     // we can.
 468     gep_type_iterator GTI = gep_type_begin(U);
 469     for (User::const_op_iterator i = U->op_begin() + 1, e = U->op_end(); i != e;
 470          ++i, ++GTI) {
 471       const Value *Op = *i;
 472       if (StructType *STy = dyn_cast<StructType>(*GTI)) {
 473         const StructLayout *SL = DL.getStructLayout(STy);
 474         unsigned Idx = cast<ConstantInt>(Op)->getZExtValue();
 475         TmpOffset += SL->getElementOffset(Idx);
 476       } else {
 477         uint64_t S = DL.getTypeAllocSize(GTI.getIndexedType());
 478         for (;;) {
 479           if (const ConstantInt *CI = dyn_cast<ConstantInt>(Op)) {
 480             // Constant-offset addressing.
 481             TmpOffset += CI->getSExtValue() * S;
 482             break;
 483           }
 484           if (canFoldAddIntoGEP(U, Op)) {
 485             // A compatible add with a constant operand. Fold the constant.
 486             ConstantInt *CI =
 487                 cast<ConstantInt>(cast<AddOperator>(Op)->getOperand(1));
 488             TmpOffset += CI->getSExtValue() * S;
 489             // Iterate on the other operand.
 490             Op = cast<AddOperator>(Op)->getOperand(0);
 491             continue;
 492           }
 493           // Unsupported
 494           goto unsupported_gep;
 495         }
 496       }
 497     }
 498
 499     // Try to grab the base operand now.
 500     Addr.setOffset(TmpOffset);
 501     if (ComputeAddress(U->getOperand(0), Addr, Ty))
 502       return true;
 503
 504     // We failed, restore everything and try the other options.
 505     Addr = SavedAddr;
 506
 507   unsupported_gep:
 508     break;
 509   }
 510   case Instruction::Alloca: {
 511     const AllocaInst *AI = cast<AllocaInst>(Obj);
 512     DenseMap<const AllocaInst *, int>::iterator SI =
 513         FuncInfo.StaticAllocaMap.find(AI);
 514     if (SI != FuncInfo.StaticAllocaMap.end()) {
 515       Addr.setKind(Address::FrameIndexBase);
 516       Addr.setFI(SI->second);
 517       return true;
 518     }
 519     break;
 520   }
 521   case Instruction::Add: {
 522     // Adds of constants are common and easy enough.
 523     const Value *LHS = U->getOperand(0);
 524     const Value *RHS = U->getOperand(1);
 525
 526     if (isa<ConstantInt>(LHS))
 527       std::swap(LHS, RHS);
 528
 529     if (const ConstantInt *CI = dyn_cast<ConstantInt>(RHS)) {
 530       Addr.setOffset(Addr.getOffset() + (uint64_t)CI->getSExtValue());
 531       return ComputeAddress(LHS, Addr, Ty);
 532     }
 533
 534     Address Backup = Addr;
 535     if (ComputeAddress(LHS, Addr, Ty) && ComputeAddress(RHS, Addr, Ty))
 536       return true;
 537     Addr = Backup;
 538
 539     break;
 540   }
 541   case Instruction::Shl:
 542     if (Addr.getOffsetReg())
 543       break;
 544
 545     if (const auto *CI = dyn_cast<ConstantInt>(U->getOperand(1))) {
 546       unsigned Val = CI->getZExtValue();
 547       if (Val < 1 || Val > 3)
 548         break;
 549
 550       uint64_t NumBytes = 0;
 551       if (Ty && Ty->isSized()) {
 552         uint64_t NumBits = DL.getTypeSizeInBits(Ty);
 553         NumBytes = NumBits / 8;
 554         if (!isPowerOf2_64(NumBits))
 555           NumBytes = 0;
 556       }
 557
 558       if (NumBytes != (1ULL << Val))
 559         break;
 560
 561       Addr.setShift(Val);
 562       Addr.setExtendType(AArch64_AM::LSL);
 563
 564       if (const auto *I = dyn_cast<Instruction>(U->getOperand(0)))
 565         if (FuncInfo.MBBMap[I->getParent()] == FuncInfo.MBB)
 566           U = I;
 567
 568       if (const auto *ZE = dyn_cast<ZExtInst>(U))
 569         if (ZE->getOperand(0)->getType()->isIntegerTy(32))
 570           Addr.setExtendType(AArch64_AM::UXTW);
 571
 572       if (const auto *SE = dyn_cast<SExtInst>(U))
 573         if (SE->getOperand(0)->getType()->isIntegerTy(32))
 574           Addr.setExtendType(AArch64_AM::SXTW);
 575
 576       unsigned Reg = getRegForValue(U->getOperand(0));
 577       if (!Reg)
 578         return false;
 579       Addr.setOffsetReg(Reg);
 580       return true;
 581     }
 582     break;
 583   }
 584
 585   if (Addr.getReg()) {
 586     if (!Addr.getOffsetReg()) {
 587       unsigned Reg = getRegForValue(Obj);
 588       if (!Reg)
 589         return false;
 590       Addr.setOffsetReg(Reg);
 591       return true;
 592     }
 593     return false;
 594   }
 595
 596   unsigned Reg = getRegForValue(Obj);
 597   if (!Reg)
 598     return false;
 599   Addr.setReg(Reg);
 600   return true;
 601 }
 602
 603 bool AArch64FastISel::ComputeCallAddress(const Value *V, Address &Addr) {
 604   const User *U = nullptr;
 605   unsigned Opcode = Instruction::UserOp1;
 606   bool InMBB = true;
 607
 608   if (const auto *I = dyn_cast<Instruction>(V)) {
 609     Opcode = I->getOpcode();
 610     U = I;
 611     InMBB = I->getParent() == FuncInfo.MBB->getBasicBlock();
 612   } else if (const auto *C = dyn_cast<ConstantExpr>(V)) {
 613     Opcode = C->getOpcode();
 614     U = C;
 615   }
 616
 617   switch (Opcode) {
 618   default: break;
 619   case Instruction::BitCast:
 620     // Look past bitcasts if its operand is in the same BB.
 621     if (InMBB)
 622       return ComputeCallAddress(U->getOperand(0), Addr);
 623     break;
 624   case Instruction::IntToPtr:
 625     // Look past no-op inttoptrs if its operand is in the same BB.
 626     if (InMBB &&
 627         TLI.getValueType(U->getOperand(0)->getType()) == TLI.getPointerTy())
 628       return ComputeCallAddress(U->getOperand(0), Addr);
 629     break;
 630   case Instruction::PtrToInt:
 631     // Look past no-op ptrtoints if its operand is in the same BB.
 632     if (InMBB &&
 633         TLI.getValueType(U->getType()) == TLI.getPointerTy())
 634       return ComputeCallAddress(U->getOperand(0), Addr);
 635     break;
 636   }
 637
 638   if (const GlobalValue *GV = dyn_cast<GlobalValue>(V)) {
 639     Addr.setGlobalValue(GV);
 640     return true;
 641   }
 642
 643   // If all else fails, try to materialize the value in a register.
 644   if (!Addr.getGlobalValue()) {
 645     Addr.setReg(getRegForValue(V));
 646     return Addr.getReg() != 0;
 647   }
 648
 649   return false;
 650 }
 651
 652
 653 bool AArch64FastISel::isTypeLegal(Type *Ty, MVT &VT) {
 654   EVT evt = TLI.getValueType(Ty, true);
 655
 656   // Only handle simple types.
 657   if (evt == MVT::Other || !evt.isSimple())
 658     return false;
 659   VT = evt.getSimpleVT();
 660
 661   // This is a legal type, but it's not something we handle in fast-isel.
 662   if (VT == MVT::f128)
 663     return false;
 664
 665   // Handle all other legal types, i.e. a register that will directly hold this
 666   // value.
 667   return TLI.isTypeLegal(VT);
 668 }
 669
 670 bool AArch64FastISel::isLoadStoreTypeLegal(Type *Ty, MVT &VT) {
 671   if (isTypeLegal(Ty, VT))
 672     return true;
 673
 674   // If this is a type than can be sign or zero-extended to a basic operation
 675   // go ahead and accept it now. For stores, this reflects truncation.
 676   if (VT == MVT::i1 || VT == MVT::i8 || VT == MVT::i16)
 677     return true;
 678
 679   return false;
 680 }
 681
 682 bool AArch64FastISel::SimplifyAddress(Address &Addr, MVT VT) {
 683   unsigned ScaleFactor;
 684   switch (VT.SimpleTy) {
 685   default: return false;
 686   case MVT::i1:  // fall-through
 687   case MVT::i8:  ScaleFactor = 1; break;
 688   case MVT::i16: ScaleFactor = 2; break;
 689   case MVT::i32: // fall-through
 690   case MVT::f32: ScaleFactor = 4; break;
 691   case MVT::i64: // fall-through
 692   case MVT::f64: ScaleFactor = 8; break;
 693   }
 694
 695   bool ImmediateOffsetNeedsLowering = false;
 696   bool RegisterOffsetNeedsLowering = false;
 697   int64_t Offset = Addr.getOffset();
 698   if (((Offset < 0) || (Offset & (ScaleFactor - 1))) && !isInt<9>(Offset))
 699     ImmediateOffsetNeedsLowering = true;
 700   else if (Offset > 0 && !(Offset & (ScaleFactor - 1)) &&
 701            !isUInt<12>(Offset / ScaleFactor))
 702     ImmediateOffsetNeedsLowering = true;
 703
 704   // Cannot encode an offset register and an immediate offset in the same
 705   // instruction. Fold the immediate offset into the load/store instruction and
 706   // emit an additonal add to take care of the offset register.
 707   if (!ImmediateOffsetNeedsLowering && Addr.getOffset() && Addr.isRegBase() &&
 708       Addr.getOffsetReg())
 709     RegisterOffsetNeedsLowering = true;
 710
 711   // If this is a stack pointer and the offset needs to be simplified then put
 712   // the alloca address into a register, set the base type back to register and
 713   // continue. This should almost never happen.
 714   if (ImmediateOffsetNeedsLowering && Addr.isFIBase()) {
 715     unsigned ResultReg = createResultReg(&AArch64::GPR64spRegClass);
 716     BuildMI(*FuncInfo.MBB, FuncInfo.InsertPt, DbgLoc, TII.get(AArch64::ADDXri),
 717             ResultReg)
 718       .addFrameIndex(Addr.getFI())
 719       .addImm(0)
 720       .addImm(0);
 721     Addr.setKind(Address::RegBase);
 722     Addr.setReg(ResultReg);
 723   }
 724
 725   if (RegisterOffsetNeedsLowering) {
 726     unsigned ResultReg = 0;
 727     if (Addr.getReg()) {
 728       if (Addr.getExtendType() == AArch64_AM::SXTW ||
 729           Addr.getExtendType() == AArch64_AM::UXTW   )
 730         ResultReg = emitAddSub_rx(/*UseAdd=*/true, MVT::i64, Addr.getReg(),
 731                                   /*TODO:IsKill=*/false, Addr.getOffsetReg(),
 732                                   /*TODO:IsKill=*/false, Addr.getExtendType(),
 733                                   Addr.getShift());
 734       else
 735         ResultReg = emitAddSub_rs(/*UseAdd=*/true, MVT::i64, Addr.getReg(),
 736                                   /*TODO:IsKill=*/false, Addr.getOffsetReg(),
 737                                   /*TODO:IsKill=*/false, AArch64_AM::LSL,
 738                                   Addr.getShift());
 739     } else {
 740       if (Addr.getExtendType() == AArch64_AM::UXTW)
 741         ResultReg = emitLSL_ri(MVT::i64, MVT::i32, Addr.getOffsetReg(),
 742                                /*Op0IsKill=*/false, Addr.getShift(),
 743                                /*IsZExt=*/true);
 744       else if (Addr.getExtendType() == AArch64_AM::SXTW)
 745         ResultReg = emitLSL_ri(MVT::i64, MVT::i32, Addr.getOffsetReg(),
 746                                /*Op0IsKill=*/false, Addr.getShift(),
 747                                /*IsZExt=*/false);
 748       else
 749         ResultReg = emitLSL_ri(MVT::i64, MVT::i64, Addr.getOffsetReg(),
 750                                /*Op0IsKill=*/false, Addr.getShift());
 751     }
 752     if (!ResultReg)
 753       return false;
 754
 755     Addr.setReg(ResultReg);
 756     Addr.setOffsetReg(0);
 757     Addr.setShift(0);
 758     Addr.setExtendType(AArch64_AM::InvalidShiftExtend);
 759   }
 760
 761   // Since the offset is too large for the load/store instruction get the
 762   // reg+offset into a register.
 763   if (ImmediateOffsetNeedsLowering) {
 764     unsigned ResultReg = 0;
 765     if (Addr.getReg())
 766       ResultReg = FastEmit_ri_(MVT::i64, ISD::ADD, Addr.getReg(),
 767                                /*IsKill=*/false, Offset, MVT::i64);
 768     else
 769       ResultReg = FastEmit_i(MVT::i64, MVT::i64, ISD::Constant, Offset);
 770
 771     if (!ResultReg)
 772       return false;
 773     Addr.setReg(ResultReg);
 774     Addr.setOffset(0);
 775   }
 776   return true;
 777 }
 778
 779 void AArch64FastISel::AddLoadStoreOperands(Address &Addr,
 780                                            const MachineInstrBuilder &MIB,
 781                                            unsigned Flags,
 782                                            unsigned ScaleFactor,
 783                                            MachineMemOperand *MMO) {
 784   int64_t Offset = Addr.getOffset() / ScaleFactor;
 785   // Frame base works a bit differently. Handle it separately.
 786   if (Addr.isFIBase()) {
 787     int FI = Addr.getFI();
 788     // FIXME: We shouldn't be using getObjectSize/getObjectAlignment.  The size
 789     // and alignment should be based on the VT.
 790     MMO = FuncInfo.MF->getMachineMemOperand(
 791       MachinePointerInfo::getFixedStack(FI, Offset), Flags,
 792       MFI.getObjectSize(FI), MFI.getObjectAlignment(FI));
 793     // Now add the rest of the operands.
 794     MIB.addFrameIndex(FI).addImm(Offset);
 795   } else {
 796     assert(Addr.isRegBase() && "Unexpected address kind.");
 797     const MCInstrDesc &II = MIB->getDesc();
 798     unsigned Idx = (Flags & MachineMemOperand::MOStore) ? 1 : 0;
 799     Addr.setReg(
 800       constrainOperandRegClass(II, Addr.getReg(), II.getNumDefs()+Idx));
 801     Addr.setOffsetReg(
 802       constrainOperandRegClass(II, Addr.getOffsetReg(), II.getNumDefs()+Idx+1));
 803     if (Addr.getOffsetReg()) {
 804       assert(Addr.getOffset() == 0 && "Unexpected offset");
 805       bool IsSigned = Addr.getExtendType() == AArch64_AM::SXTW ||
 806                       Addr.getExtendType() == AArch64_AM::SXTX;
 807       MIB.addReg(Addr.getReg());
 808       MIB.addReg(Addr.getOffsetReg());
 809       MIB.addImm(IsSigned);
 810       MIB.addImm(Addr.getShift() != 0);
 811     } else {
 812       MIB.addReg(Addr.getReg());
 813       MIB.addImm(Offset);
 814     }
 815   }
 816
 817   if (MMO)
 818     MIB.addMemOperand(MMO);
 819 }
 820
 821 unsigned AArch64FastISel::emitAddsSubs(bool UseAdds, MVT RetVT,
 822                                        const Value *LHS, const Value *RHS,
 823                                        bool IsZExt, bool WantResult) {
 824   AArch64_AM::ShiftExtendType ExtendType = AArch64_AM::InvalidShiftExtend;
 825   bool NeedExtend = false;
 826   switch (RetVT.SimpleTy) {
 827   default:
 828     return 0;
 829   case MVT::i1:
 830     NeedExtend = true;
 831     break;
 832   case MVT::i8:
 833     NeedExtend = true;
 834     ExtendType = IsZExt ? AArch64_AM::UXTB : AArch64_AM::SXTB;
 835     break;
 836   case MVT::i16:
 837     NeedExtend = true;
 838     ExtendType = IsZExt ? AArch64_AM::UXTH : AArch64_AM::SXTH;
 839     break;
 840   case MVT::i32:  // fall-through
 841   case MVT::i64:
 842     break;
 843   }
 844   MVT SrcVT = RetVT;
 845   RetVT.SimpleTy = std::max(RetVT.SimpleTy, MVT::i32);
 846
 847   // Canonicalize immediates to the RHS first.
 848   if (UseAdds && isa<ConstantInt>(LHS) && !isa<ConstantInt>(RHS))
 849     std::swap(LHS, RHS);
 850
 851   // Canonicalize shift immediate to the RHS.
 852   if (UseAdds)
 853     if (const auto *SI = dyn_cast<BinaryOperator>(LHS))
 854       if (isa<ConstantInt>(SI->getOperand(1)))
 855         if (SI->getOpcode() == Instruction::Shl  ||
 856             SI->getOpcode() == Instruction::LShr ||
 857             SI->getOpcode() == Instruction::AShr   )
 858           std::swap(LHS, RHS);
 859
 860   unsigned LHSReg = getRegForValue(LHS);
 861   if (!LHSReg)
 862     return 0;
 863   bool LHSIsKill = hasTrivialKill(LHS);
 864
 865   if (NeedExtend)
 866     LHSReg = EmitIntExt(SrcVT, LHSReg, RetVT, IsZExt);
 867
 868   unsigned ResultReg = 0;
 869   if (const auto *C = dyn_cast<ConstantInt>(RHS)) {
 870     uint64_t Imm = IsZExt ? C->getZExtValue() : C->getSExtValue();
 871     if (C->isNegative())
 872       ResultReg =
 873           emitAddsSubs_ri(!UseAdds, RetVT, LHSReg, LHSIsKill, -Imm, WantResult);
 874     else
 875       ResultReg =
 876           emitAddsSubs_ri(UseAdds, RetVT, LHSReg, LHSIsKill, Imm, WantResult);
 877   }
 878   if (ResultReg)
 879     return ResultReg;
 880
 881   // Only extend the RHS within the instruction if there is a valid extend type.
 882   if (ExtendType != AArch64_AM::InvalidShiftExtend) {
 883     if (const auto *SI = dyn_cast<BinaryOperator>(RHS))
 884       if (const auto *C = dyn_cast<ConstantInt>(SI->getOperand(1)))
 885         if ((SI->getOpcode() == Instruction::Shl) && (C->getZExtValue() < 4)) {
 886           unsigned RHSReg = getRegForValue(SI->getOperand(0));
 887           if (!RHSReg)
 888             return 0;
 889           bool RHSIsKill = hasTrivialKill(SI->getOperand(0));
 890           return emitAddsSubs_rx(UseAdds, RetVT, LHSReg, LHSIsKill, RHSReg,
 891                                  RHSIsKill, ExtendType, C->getZExtValue(),
 892                                  WantResult);
 893         }
 894     unsigned RHSReg = getRegForValue(RHS);
 895     if (!RHSReg)
 896       return 0;
 897     bool RHSIsKill = hasTrivialKill(RHS);
 898     return emitAddsSubs_rx(UseAdds, RetVT, LHSReg, LHSIsKill, RHSReg, RHSIsKill,
 899                            ExtendType, 0, WantResult);
 900   }
 901
 902   // Check if the shift can be folded into the instruction.
 903   if (const auto *SI = dyn_cast<BinaryOperator>(RHS)) {
 904     if (const auto *C = dyn_cast<ConstantInt>(SI->getOperand(1))) {
 905       AArch64_AM::ShiftExtendType ShiftType = AArch64_AM::InvalidShiftExtend;
 906       switch (SI->getOpcode()) {
 907       default: break;
 908       case Instruction::Shl:  ShiftType = AArch64_AM::LSL; break;
 909       case Instruction::LShr: ShiftType = AArch64_AM::LSR; break;
 910       case Instruction::AShr: ShiftType = AArch64_AM::ASR; break;
 911       }
 912       uint64_t ShiftVal = C->getZExtValue();
 913       if (ShiftType != AArch64_AM::InvalidShiftExtend) {
 914         unsigned RHSReg = getRegForValue(SI->getOperand(0));
 915         if (!RHSReg)
 916           return 0;
 917         bool RHSIsKill = hasTrivialKill(SI->getOperand(0));
 918         return emitAddsSubs_rs(UseAdds, RetVT, LHSReg, LHSIsKill, RHSReg,
 919                                RHSIsKill, ShiftType, ShiftVal, WantResult);
 920       }
 921     }
 922   }
 923
 924   unsigned RHSReg = getRegForValue(RHS);
 925   if (!RHSReg)
 926     return 0;
 927   bool RHSIsKill = hasTrivialKill(RHS);
 928
 929   if (NeedExtend)
 930     RHSReg = EmitIntExt(SrcVT, RHSReg, RetVT, IsZExt);
 931
 932   return emitAddsSubs_rr(UseAdds, RetVT, LHSReg, LHSIsKill, RHSReg, RHSIsKill,
 933                          WantResult);
 934 }
 935
 936 unsigned AArch64FastISel::emitAddsSubs_rr(bool UseAdds, MVT RetVT,
 937                                           unsigned LHSReg, bool LHSIsKill,
 938                                           unsigned RHSReg, bool RHSIsKill,
 939                                           bool WantResult) {
 940   assert(LHSReg && RHSReg && "Invalid register number.");
 941
 942   if (RetVT != MVT::i32 && RetVT != MVT::i64)
 943     return 0;
 944
 945   static const unsigned OpcTable[2][2] = {
 946     { AArch64::ADDSWrr, AArch64::ADDSXrr },
 947     { AArch64::SUBSWrr, AArch64::SUBSXrr }
 948   };
 949   unsigned Opc = OpcTable[!UseAdds][(RetVT == MVT::i64)];
 950   unsigned ResultReg;
 951   if (WantResult) {
 952     const TargetRegisterClass *RC =
 953         (RetVT == MVT::i64) ? &AArch64::GPR64RegClass : &AArch64::GPR32RegClass;
 954     ResultReg = createResultReg(RC);
 955   } else
 956     ResultReg = (RetVT == MVT::i64) ? AArch64::XZR : AArch64::WZR;
 957
 958   const MCInstrDesc &II = TII.get(Opc);
 959   LHSReg = constrainOperandRegClass(II, LHSReg, II.getNumDefs());
 960   RHSReg = constrainOperandRegClass(II, RHSReg, II.getNumDefs() + 1);
 961   BuildMI(*FuncInfo.MBB, FuncInfo.InsertPt, DbgLoc, II, ResultReg)
 962       .addReg(LHSReg, getKillRegState(LHSIsKill))
 963       .addReg(RHSReg, getKillRegState(RHSIsKill));
 964
 965   return ResultReg;
 966 }
 967
 968 unsigned AArch64FastISel::emitAddsSubs_ri(bool UseAdds, MVT RetVT,
 969                                           unsigned LHSReg, bool LHSIsKill,
 970                                           uint64_t Imm, bool WantResult) {
 971   assert(LHSReg && "Invalid register number.");
 972
 973   if (RetVT != MVT::i32 && RetVT != MVT::i64)
 974     return 0;
 975
 976   unsigned ShiftImm;
 977   if (isUInt<12>(Imm))
 978     ShiftImm = 0;
 979   else if ((Imm & 0xfff000) == Imm) {
 980     ShiftImm = 12;
 981     Imm >>= 12;
 982   } else
 983     return 0;
 984
 985   static const unsigned OpcTable[2][2] = {
 986     { AArch64::ADDSWri, AArch64::ADDSXri },
 987     { AArch64::SUBSWri, AArch64::SUBSXri }
 988   };
 989   unsigned Opc = OpcTable[!UseAdds][(RetVT == MVT::i64)];
 990   unsigned ResultReg;
 991   if (WantResult) {
 992     const TargetRegisterClass *RC =
 993         (RetVT == MVT::i64) ? &AArch64::GPR64RegClass : &AArch64::GPR32RegClass;
 994     ResultReg = createResultReg(RC);
 995   } else
 996     ResultReg = (RetVT == MVT::i64) ? AArch64::XZR : AArch64::WZR;
 997
 998   const MCInstrDesc &II = TII.get(Opc);
 999   LHSReg = constrainOperandRegClass(II, LHSReg, II.getNumDefs());
1000   BuildMI(*FuncInfo.MBB, FuncInfo.InsertPt, DbgLoc, II, ResultReg)
1001       .addReg(LHSReg, getKillRegState(LHSIsKill))
1002       .addImm(Imm)
1003       .addImm(getShifterImm(AArch64_AM::LSL, ShiftImm));
1004
1005   return ResultReg;
1006 }
1007
1008 unsigned AArch64FastISel::emitAddSub_rs(bool UseAdd, MVT RetVT,
1009                                         unsigned LHSReg, bool LHSIsKill,
1010                                         unsigned RHSReg, bool RHSIsKill,
1011                                         AArch64_AM::ShiftExtendType ShiftType,
1012                                         uint64_t ShiftImm, bool WantResult) {
1013   assert(LHSReg && RHSReg && "Invalid register number.");
1014
1015   if (RetVT != MVT::i32 && RetVT != MVT::i64)
1016     return 0;
1017
1018   static const unsigned OpcTable[2][2] = {
1019     { AArch64::ADDWrs, AArch64::ADDXrs },
1020     { AArch64::SUBWrs, AArch64::SUBXrs }
1021   };
1022   unsigned Opc = OpcTable[!UseAdd][(RetVT == MVT::i64)];
1023   unsigned ResultReg;
1024   if (WantResult) {
1025     const TargetRegisterClass *RC =
1026         (RetVT == MVT::i64) ? &AArch64::GPR64RegClass : &AArch64::GPR32RegClass;
1027     ResultReg = createResultReg(RC);
1028   } else
1029     ResultReg = (RetVT == MVT::i64) ? AArch64::XZR : AArch64::WZR;
1030
1031   const MCInstrDesc &II = TII.get(Opc);
1032   LHSReg = constrainOperandRegClass(II, LHSReg, II.getNumDefs());
1033   RHSReg = constrainOperandRegClass(II, RHSReg, II.getNumDefs() + 1);
1034   BuildMI(*FuncInfo.MBB, FuncInfo.InsertPt, DbgLoc, II, ResultReg)
1035       .addReg(LHSReg, getKillRegState(LHSIsKill))
1036       .addReg(RHSReg, getKillRegState(RHSIsKill))
1037       .addImm(getShifterImm(ShiftType, ShiftImm));
1038
1039   return ResultReg;
1040 }
1041
1042 unsigned AArch64FastISel::emitAddsSubs_rs(bool UseAdds, MVT RetVT,
1043                                           unsigned LHSReg, bool LHSIsKill,
1044                                           unsigned RHSReg, bool RHSIsKill,
1045                                           AArch64_AM::ShiftExtendType ShiftType,
1046                                           uint64_t ShiftImm, bool WantResult) {
1047   assert(LHSReg && RHSReg && "Invalid register number.");
1048
1049   if (RetVT != MVT::i32 && RetVT != MVT::i64)
1050     return 0;
1051
1052   static const unsigned OpcTable[2][2] = {
1053     { AArch64::ADDSWrs, AArch64::ADDSXrs },
1054     { AArch64::SUBSWrs, AArch64::SUBSXrs }
1055   };
1056   unsigned Opc = OpcTable[!UseAdds][(RetVT == MVT::i64)];
1057   unsigned ResultReg;
1058   if (WantResult) {
1059     const TargetRegisterClass *RC =
1060         (RetVT == MVT::i64) ? &AArch64::GPR64RegClass : &AArch64::GPR32RegClass;
1061     ResultReg = createResultReg(RC);
1062   } else
1063     ResultReg = (RetVT == MVT::i64) ? AArch64::XZR : AArch64::WZR;
1064
1065   const MCInstrDesc &II = TII.get(Opc);
1066   LHSReg = constrainOperandRegClass(II, LHSReg, II.getNumDefs());
1067   RHSReg = constrainOperandRegClass(II, RHSReg, II.getNumDefs() + 1);
1068   BuildMI(*FuncInfo.MBB, FuncInfo.InsertPt, DbgLoc, II, ResultReg)
1069       .addReg(LHSReg, getKillRegState(LHSIsKill))
1070       .addReg(RHSReg, getKillRegState(RHSIsKill))
1071       .addImm(getShifterImm(ShiftType, ShiftImm));
1072
1073   return ResultReg;
1074 }
1075
1076 unsigned AArch64FastISel::emitAddSub_rx(bool UseAdd, MVT RetVT,
1077                                         unsigned LHSReg, bool LHSIsKill,
1078                                         unsigned RHSReg, bool RHSIsKill,
1079                                         AArch64_AM::ShiftExtendType ExtType,
1080                                         uint64_t ShiftImm, bool WantResult) {
1081   assert(LHSReg && RHSReg && "Invalid register number.");
1082
1083   if (RetVT != MVT::i32 && RetVT != MVT::i64)
1084     return 0;
1085
1086   static const unsigned OpcTable[2][2] = {
1087     { AArch64::ADDWrx, AArch64::ADDXrx },
1088     { AArch64::SUBWrx, AArch64::SUBXrx }
1089   };
1090   unsigned Opc = OpcTable[!UseAdd][(RetVT == MVT::i64)];
1091   unsigned ResultReg;
1092   if (WantResult) {
1093     const TargetRegisterClass *RC =
1094         (RetVT == MVT::i64) ? &AArch64::GPR64RegClass : &AArch64::GPR32RegClass;
1095     ResultReg = createResultReg(RC);
1096   } else
1097     ResultReg = (RetVT == MVT::i64) ? AArch64::XZR : AArch64::WZR;
1098
1099   const MCInstrDesc &II = TII.get(Opc);
1100   LHSReg = constrainOperandRegClass(II, LHSReg, II.getNumDefs());
1101   RHSReg = constrainOperandRegClass(II, RHSReg, II.getNumDefs() + 1);
1102   BuildMI(*FuncInfo.MBB, FuncInfo.InsertPt, DbgLoc, II, ResultReg)
1103       .addReg(LHSReg, getKillRegState(LHSIsKill))
1104       .addReg(RHSReg, getKillRegState(RHSIsKill))
1105       .addImm(getArithExtendImm(ExtType, ShiftImm));
1106
1107   return ResultReg;
1108 }
1109
1110 unsigned AArch64FastISel::emitAddsSubs_rx(bool UseAdds, MVT RetVT,
1111                                           unsigned LHSReg, bool LHSIsKill,
1112                                           unsigned RHSReg, bool RHSIsKill,
1113                                           AArch64_AM::ShiftExtendType ExtType,
1114                                           uint64_t ShiftImm, bool WantResult) {
1115   assert(LHSReg && RHSReg && "Invalid register number.");
1116
1117   if (RetVT != MVT::i32 && RetVT != MVT::i64)
1118     return 0;
1119
1120   static const unsigned OpcTable[2][2] = {
1121     { AArch64::ADDSWrx, AArch64::ADDSXrx },
1122     { AArch64::SUBSWrx, AArch64::SUBSXrx }
1123   };
1124   unsigned Opc = OpcTable[!UseAdds][(RetVT == MVT::i64)];
1125   unsigned ResultReg;
1126   if (WantResult) {
1127     const TargetRegisterClass *RC =
1128         (RetVT == MVT::i64) ? &AArch64::GPR64RegClass : &AArch64::GPR32RegClass;
1129     ResultReg = createResultReg(RC);
1130   } else
1131     ResultReg = (RetVT == MVT::i64) ? AArch64::XZR : AArch64::WZR;
1132
1133   const MCInstrDesc &II = TII.get(Opc);
1134   LHSReg = constrainOperandRegClass(II, LHSReg, II.getNumDefs());
1135   RHSReg = constrainOperandRegClass(II, RHSReg, II.getNumDefs() + 1);
1136   BuildMI(*FuncInfo.MBB, FuncInfo.InsertPt, DbgLoc, II, ResultReg)
1137       .addReg(LHSReg, getKillRegState(LHSIsKill))
1138       .addReg(RHSReg, getKillRegState(RHSIsKill))
1139       .addImm(getArithExtendImm(ExtType, ShiftImm));
1140
1141   return ResultReg;
1142 }
1143
1144 bool AArch64FastISel::emitCmp(const Value *LHS, const Value *RHS, bool IsZExt) {
1145   Type *Ty = LHS->getType();
1146   EVT EVT = TLI.getValueType(Ty, true);
1147   if (!EVT.isSimple())
1148     return false;
1149   MVT VT = EVT.getSimpleVT();
1150
1151   switch (VT.SimpleTy) {
1152   default:
1153     return false;
1154   case MVT::i1:
1155   case MVT::i8:
1156   case MVT::i16:
1157   case MVT::i32:
1158   case MVT::i64:
1159     return emitICmp(VT, LHS, RHS, IsZExt);
1160   case MVT::f32:
1161   case MVT::f64:
1162     return emitFCmp(VT, LHS, RHS);
1163   }
1164 }
1165
1166 bool AArch64FastISel::emitICmp(MVT RetVT, const Value *LHS, const Value *RHS,
1167                                bool IsZExt) {
1168   return emitSubs(RetVT, LHS, RHS, IsZExt, /*WantResult=*/false) != 0;
1169 }
1170
1171 bool AArch64FastISel::emitICmp_ri(MVT RetVT, unsigned LHSReg, bool LHSIsKill,
1172                                   uint64_t Imm) {
1173   return emitAddsSubs_ri(false, RetVT, LHSReg, LHSIsKill, Imm,
1174                          /*WantResult=*/false) != 0;
1175 }
1176
1177 bool AArch64FastISel::emitFCmp(MVT RetVT, const Value *LHS, const Value *RHS) {
1178   if (RetVT != MVT::f32 && RetVT != MVT::f64)
1179     return false;
1180
1181   // Check to see if the 2nd operand is a constant that we can encode directly
1182   // in the compare.
1183   bool UseImm = false;
1184   if (const auto *CFP = dyn_cast<ConstantFP>(RHS))
1185     if (CFP->isZero() && !CFP->isNegative())
1186       UseImm = true;
1187
1188   unsigned LHSReg = getRegForValue(LHS);
1189   if (!LHSReg)
1190     return false;
1191   bool LHSIsKill = hasTrivialKill(LHS);
1192
1193   if (UseImm) {
1194     unsigned Opc = (RetVT == MVT::f64) ? AArch64::FCMPDri : AArch64::FCMPSri;
1195     BuildMI(*FuncInfo.MBB, FuncInfo.InsertPt, DbgLoc, TII.get(Opc))
1196         .addReg(LHSReg, getKillRegState(LHSIsKill));
1197     return true;
1198   }
1199
1200   unsigned RHSReg = getRegForValue(RHS);
1201   if (!RHSReg)
1202     return false;
1203   bool RHSIsKill = hasTrivialKill(RHS);
1204
1205   unsigned Opc = (RetVT == MVT::f64) ? AArch64::FCMPDrr : AArch64::FCMPSrr;
1206   BuildMI(*FuncInfo.MBB, FuncInfo.InsertPt, DbgLoc, TII.get(Opc))
1207       .addReg(LHSReg, getKillRegState(LHSIsKill))
1208       .addReg(RHSReg, getKillRegState(RHSIsKill));
1209   return true;
1210 }
1211
1212 unsigned AArch64FastISel::emitAdds(MVT RetVT, const Value *LHS,
1213                                    const Value *RHS, bool IsZExt,
1214                                    bool WantResult) {
1215   return emitAddsSubs(true, RetVT, LHS, RHS, IsZExt, WantResult);
1216 }
1217
1218 unsigned AArch64FastISel::emitSubs(MVT RetVT, const Value *LHS,
1219                                    const Value *RHS, bool IsZExt,
1220                                    bool WantResult) {
1221   return emitAddsSubs(false, RetVT, LHS, RHS, IsZExt, WantResult);
1222 }
1223
1224 unsigned AArch64FastISel::emitSubs_rr(MVT RetVT, unsigned LHSReg,
1225                                       bool LHSIsKill, unsigned RHSReg,
1226                                       bool RHSIsKill, bool WantResult) {
1227   return emitAddsSubs_rr(false, RetVT, LHSReg, LHSIsKill, RHSReg, RHSIsKill,
1228                          WantResult);
1229 }
1230
1231 unsigned AArch64FastISel::emitSubs_rs(MVT RetVT, unsigned LHSReg,
1232                                       bool LHSIsKill, unsigned RHSReg,
1233                                       bool RHSIsKill,
1234                                       AArch64_AM::ShiftExtendType ShiftType,
1235                                       uint64_t ShiftImm, bool WantResult) {
1236   return emitAddsSubs_rs(false, RetVT, LHSReg, LHSIsKill, RHSReg, RHSIsKill,
1237                          ShiftType, ShiftImm, WantResult);
1238 }
1239
1240 // FIXME: This should be eventually generated automatically by tblgen.
1241 unsigned AArch64FastISel::emitAND_ri(MVT RetVT, unsigned LHSReg, bool LHSIsKill,
1242                                      uint64_t Imm) {
1243   const TargetRegisterClass *RC = nullptr;
1244   unsigned Opc = 0;
1245   unsigned RegSize = 0;
1246   switch (RetVT.SimpleTy) {
1247   default:
1248     return 0;
1249   case MVT::i32:
1250     Opc = AArch64::ANDWri;
1251     RC = &AArch64::GPR32spRegClass;
1252     RegSize = 32;
1253     break;
1254   case MVT::i64:
1255     Opc = AArch64::ANDXri;
1256     RC = &AArch64::GPR64spRegClass;
1257     RegSize = 64;
1258     break;
1259   }
1260
1261   if (!AArch64_AM::isLogicalImmediate(Imm, RegSize))
1262     return 0;
1263
1264   return FastEmitInst_ri(Opc, RC, LHSReg, LHSIsKill,
1265                          AArch64_AM::encodeLogicalImmediate(Imm, RegSize));
1266 }
1267
1268 bool AArch64FastISel::EmitLoad(MVT VT, unsigned &ResultReg, Address Addr,
1269                                MachineMemOperand *MMO) {
1270   // Simplify this down to something we can handle.
1271   if (!SimplifyAddress(Addr, VT))
1272     return false;
1273
1274   unsigned ScaleFactor;
1275   switch (VT.SimpleTy) {
1276   default: llvm_unreachable("Unexpected value type.");
1277   case MVT::i1:  // fall-through
1278   case MVT::i8:  ScaleFactor = 1; break;
1279   case MVT::i16: ScaleFactor = 2; break;
1280   case MVT::i32: // fall-through
1281   case MVT::f32: ScaleFactor = 4; break;
1282   case MVT::i64: // fall-through
1283   case MVT::f64: ScaleFactor = 8; break;
1284   }
1285
1286   // Negative offsets require unscaled, 9-bit, signed immediate offsets.
1287   // Otherwise, we try using scaled, 12-bit, unsigned immediate offsets.
1288   bool UseScaled = true;
1289   if ((Addr.getOffset() < 0) || (Addr.getOffset() & (ScaleFactor - 1))) {
1290     UseScaled = false;
1291     ScaleFactor = 1;
1292   }
1293
1294   static const unsigned OpcTable[4][6] = {
1295     { AArch64::LDURBBi,  AArch64::LDURHHi,  AArch64::LDURWi,  AArch64::LDURXi,
1296       AArch64::LDURSi,   AArch64::LDURDi },
1297     { AArch64::LDRBBui,  AArch64::LDRHHui,  AArch64::LDRWui,  AArch64::LDRXui,
1298       AArch64::LDRSui,   AArch64::LDRDui },
1299     { AArch64::LDRBBroX, AArch64::LDRHHroX, AArch64::LDRWroX, AArch64::LDRXroX,
1300       AArch64::LDRSroX,  AArch64::LDRDroX },
1301     { AArch64::LDRBBroW, AArch64::LDRHHroW, AArch64::LDRWroW, AArch64::LDRXroW,
1302       AArch64::LDRSroW,  AArch64::LDRDroW }
1303   };
1304
1305   unsigned Opc;
1306   const TargetRegisterClass *RC;
1307   bool VTIsi1 = false;
1308   bool UseRegOffset = Addr.isRegBase() && !Addr.getOffset() && Addr.getReg() &&
1309                       Addr.getOffsetReg();
1310   unsigned Idx = UseRegOffset ? 2 : UseScaled ? 1 : 0;
1311   if (Addr.getExtendType() == AArch64_AM::UXTW ||
1312       Addr.getExtendType() == AArch64_AM::SXTW)
1313     Idx++;
1314
1315   switch (VT.SimpleTy) {
1316   default: llvm_unreachable("Unexpected value type.");
1317   case MVT::i1:  VTIsi1 = true; // Intentional fall-through.
1318   case MVT::i8:  Opc = OpcTable[Idx][0]; RC = &AArch64::GPR32RegClass; break;
1319   case MVT::i16: Opc = OpcTable[Idx][1]; RC = &AArch64::GPR32RegClass; break;
1320   case MVT::i32: Opc = OpcTable[Idx][2]; RC = &AArch64::GPR32RegClass; break;
1321   case MVT::i64: Opc = OpcTable[Idx][3]; RC = &AArch64::GPR64RegClass; break;
1322   case MVT::f32: Opc = OpcTable[Idx][4]; RC = &AArch64::FPR32RegClass; break;
1323   case MVT::f64: Opc = OpcTable[Idx][5]; RC = &AArch64::FPR64RegClass; break;
1324   }
1325
1326   // Create the base instruction, then add the operands.
1327   ResultReg = createResultReg(RC);
1328   MachineInstrBuilder MIB = BuildMI(*FuncInfo.MBB, FuncInfo.InsertPt, DbgLoc,
1329                                     TII.get(Opc), ResultReg);
1330   AddLoadStoreOperands(Addr, MIB, MachineMemOperand::MOLoad, ScaleFactor, MMO);
1331
1332   // Loading an i1 requires special handling.
1333   if (VTIsi1) {
1334     unsigned ANDReg = emitAND_ri(MVT::i32, ResultReg, /*IsKill=*/true, 1);
1335     assert(ANDReg && "Unexpected AND instruction emission failure.");
1336     ResultReg = ANDReg;
1337   }
1338   return true;
1339 }
1340
1341 bool AArch64FastISel::SelectLoad(const Instruction *I) {
1342   MVT VT;
1343   // Verify we have a legal type before going any further.  Currently, we handle
1344   // simple types that will directly fit in a register (i32/f32/i64/f64) or
1345   // those that can be sign or zero-extended to a basic operation (i1/i8/i16).
1346   if (!isLoadStoreTypeLegal(I->getType(), VT) || cast<LoadInst>(I)->isAtomic())
1347     return false;
1348
1349   // See if we can handle this address.
1350   Address Addr;
1351   if (!ComputeAddress(I->getOperand(0), Addr, I->getType()))
1352     return false;
1353
1354   unsigned ResultReg;
1355   if (!EmitLoad(VT, ResultReg, Addr, createMachineMemOperandFor(I)))
1356     return false;
1357
1358   UpdateValueMap(I, ResultReg);
1359   return true;
1360 }
1361
1362 bool AArch64FastISel::EmitStore(MVT VT, unsigned SrcReg, Address Addr,
1363                                 MachineMemOperand *MMO) {
1364   // Simplify this down to something we can handle.
1365   if (!SimplifyAddress(Addr, VT))
1366     return false;
1367
1368   unsigned ScaleFactor;
1369   switch (VT.SimpleTy) {
1370   default: llvm_unreachable("Unexpected value type.");
1371   case MVT::i1:  // fall-through
1372   case MVT::i8:  ScaleFactor = 1; break;
1373   case MVT::i16: ScaleFactor = 2; break;
1374   case MVT::i32: // fall-through
1375   case MVT::f32: ScaleFactor = 4; break;
1376   case MVT::i64: // fall-through
1377   case MVT::f64: ScaleFactor = 8; break;
1378   }
1379
1380   // Negative offsets require unscaled, 9-bit, signed immediate offsets.
1381   // Otherwise, we try using scaled, 12-bit, unsigned immediate offsets.
1382   bool UseScaled = true;
1383   if ((Addr.getOffset() < 0) || (Addr.getOffset() & (ScaleFactor - 1))) {
1384     UseScaled = false;
1385     ScaleFactor = 1;
1386   }
1387
1388
1389   static const unsigned OpcTable[4][6] = {
1390     { AArch64::STURBBi,  AArch64::STURHHi,  AArch64::STURWi,  AArch64::STURXi,
1391       AArch64::STURSi,   AArch64::STURDi },
1392     { AArch64::STRBBui,  AArch64::STRHHui,  AArch64::STRWui,  AArch64::STRXui,
1393       AArch64::STRSui,   AArch64::STRDui },
1394     { AArch64::STRBBroX, AArch64::STRHHroX, AArch64::STRWroX, AArch64::STRXroX,
1395       AArch64::STRSroX,  AArch64::STRDroX },
1396     { AArch64::STRBBroW, AArch64::STRHHroW, AArch64::STRWroW, AArch64::STRXroW,
1397       AArch64::STRSroW,  AArch64::STRDroW }
1398
1399   };
1400
1401   unsigned Opc;
1402   bool VTIsi1 = false;
1403   bool UseRegOffset = Addr.isRegBase() && !Addr.getOffset() && Addr.getReg() &&
1404                       Addr.getOffsetReg();
1405   unsigned Idx = UseRegOffset ? 2 : UseScaled ? 1 : 0;
1406   if (Addr.getExtendType() == AArch64_AM::UXTW ||
1407       Addr.getExtendType() == AArch64_AM::SXTW)
1408     Idx++;
1409
1410   switch (VT.SimpleTy) {
1411   default: llvm_unreachable("Unexpected value type.");
1412   case MVT::i1:  VTIsi1 = true;
1413   case MVT::i8:  Opc = OpcTable[Idx][0]; break;
1414   case MVT::i16: Opc = OpcTable[Idx][1]; break;
1415   case MVT::i32: Opc = OpcTable[Idx][2]; break;
1416   case MVT::i64: Opc = OpcTable[Idx][3]; break;
1417   case MVT::f32: Opc = OpcTable[Idx][4]; break;
1418   case MVT::f64: Opc = OpcTable[Idx][5]; break;
1419   }
1420
1421   // Storing an i1 requires special handling.
1422   if (VTIsi1) {
1423     unsigned ANDReg = emitAND_ri(MVT::i32, SrcReg, /*TODO:IsKill=*/false, 1);
1424     assert(ANDReg && "Unexpected AND instruction emission failure.");
1425     SrcReg = ANDReg;
1426   }
1427   // Create the base instruction, then add the operands.
1428   const MCInstrDesc &II = TII.get(Opc);
1429   SrcReg = constrainOperandRegClass(II, SrcReg, II.getNumDefs());
1430   MachineInstrBuilder MIB =
1431       BuildMI(*FuncInfo.MBB, FuncInfo.InsertPt, DbgLoc, II).addReg(SrcReg);
1432   AddLoadStoreOperands(Addr, MIB, MachineMemOperand::MOStore, ScaleFactor, MMO);
1433
1434   return true;
1435 }
1436
1437 bool AArch64FastISel::SelectStore(const Instruction *I) {
1438   MVT VT;
1439   Value *Op0 = I->getOperand(0);
1440   // Verify we have a legal type before going any further.  Currently, we handle
1441   // simple types that will directly fit in a register (i32/f32/i64/f64) or
1442   // those that can be sign or zero-extended to a basic operation (i1/i8/i16).
1443   if (!isLoadStoreTypeLegal(Op0->getType(), VT) ||
1444       cast<StoreInst>(I)->isAtomic())
1445     return false;
1446
1447   // Get the value to be stored into a register.
1448   unsigned SrcReg = getRegForValue(Op0);
1449   if (SrcReg == 0)
1450     return false;
1451
1452   // See if we can handle this address.
1453   Address Addr;
1454   if (!ComputeAddress(I->getOperand(1), Addr, I->getOperand(0)->getType()))
1455     return false;
1456
1457   if (!EmitStore(VT, SrcReg, Addr, createMachineMemOperandFor(I)))
1458     return false;
1459   return true;
1460 }
1461
1462 static AArch64CC::CondCode getCompareCC(CmpInst::Predicate Pred) {
1463   switch (Pred) {
1464   case CmpInst::FCMP_ONE:
1465   case CmpInst::FCMP_UEQ:
1466   default:
1467     // AL is our "false" for now. The other two need more compares.
1468     return AArch64CC::AL;
1469   case CmpInst::ICMP_EQ:
1470   case CmpInst::FCMP_OEQ:
1471     return AArch64CC::EQ;
1472   case CmpInst::ICMP_SGT:
1473   case CmpInst::FCMP_OGT:
1474     return AArch64CC::GT;
1475   case CmpInst::ICMP_SGE:
1476   case CmpInst::FCMP_OGE:
1477     return AArch64CC::GE;
1478   case CmpInst::ICMP_UGT:
1479   case CmpInst::FCMP_UGT:
1480     return AArch64CC::HI;
1481   case CmpInst::FCMP_OLT:
1482     return AArch64CC::MI;
1483   case CmpInst::ICMP_ULE:
1484   case CmpInst::FCMP_OLE:
1485     return AArch64CC::LS;
1486   case CmpInst::FCMP_ORD:
1487     return AArch64CC::VC;
1488   case CmpInst::FCMP_UNO:
1489     return AArch64CC::VS;
1490   case CmpInst::FCMP_UGE:
1491     return AArch64CC::PL;
1492   case CmpInst::ICMP_SLT:
1493   case CmpInst::FCMP_ULT:
1494     return AArch64CC::LT;
1495   case CmpInst::ICMP_SLE:
1496   case CmpInst::FCMP_ULE:
1497     return AArch64CC::LE;
1498   case CmpInst::FCMP_UNE:
1499   case CmpInst::ICMP_NE:
1500     return AArch64CC::NE;
1501   case CmpInst::ICMP_UGE:
1502     return AArch64CC::HS;
1503   case CmpInst::ICMP_ULT:
1504     return AArch64CC::LO;
1505   }
1506 }
1507
1508 bool AArch64FastISel::SelectBranch(const Instruction *I) {
1509   const BranchInst *BI = cast<BranchInst>(I);
1510   MachineBasicBlock *TBB = FuncInfo.MBBMap[BI->getSuccessor(0)];
1511   MachineBasicBlock *FBB = FuncInfo.MBBMap[BI->getSuccessor(1)];
1512
1513   AArch64CC::CondCode CC = AArch64CC::NE;
1514   if (const CmpInst *CI = dyn_cast<CmpInst>(BI->getCondition())) {
1515     if (CI->hasOneUse() && (CI->getParent() == I->getParent())) {
1516       // We may not handle every CC for now.
1517       CC = getCompareCC(CI->getPredicate());
1518       if (CC == AArch64CC::AL)
1519         return false;
1520
1521       // Emit the cmp.
1522       if (!emitCmp(CI->getOperand(0), CI->getOperand(1), CI->isUnsigned()))
1523         return false;
1524
1525       // Emit the branch.
1526       BuildMI(*FuncInfo.MBB, FuncInfo.InsertPt, DbgLoc, TII.get(AArch64::Bcc))
1527           .addImm(CC)
1528           .addMBB(TBB);
1529
1530       // Obtain the branch weight and add the TrueBB to the successor list.
1531       uint32_t BranchWeight = 0;
1532       if (FuncInfo.BPI)
1533         BranchWeight = FuncInfo.BPI->getEdgeWeight(BI->getParent(),
1534                                                   TBB->getBasicBlock());
1535       FuncInfo.MBB->addSuccessor(TBB, BranchWeight);
1536
1537       FastEmitBranch(FBB, DbgLoc);
1538       return true;
1539     }
1540   } else if (TruncInst *TI = dyn_cast<TruncInst>(BI->getCondition())) {
1541     MVT SrcVT;
1542     if (TI->hasOneUse() && TI->getParent() == I->getParent() &&
1543         (isLoadStoreTypeLegal(TI->getOperand(0)->getType(), SrcVT))) {
1544       unsigned CondReg = getRegForValue(TI->getOperand(0));
1545       if (!CondReg)
1546         return false;
1547       bool CondIsKill = hasTrivialKill(TI->getOperand(0));
1548
1549       // Issue an extract_subreg to get the lower 32-bits.
1550       if (SrcVT == MVT::i64) {
1551         CondReg = FastEmitInst_extractsubreg(MVT::i32, CondReg, CondIsKill,
1552                                              AArch64::sub_32);
1553         CondIsKill = true;
1554       }
1555
1556       unsigned ANDReg = emitAND_ri(MVT::i32, CondReg, CondIsKill, 1);
1557       assert(ANDReg && "Unexpected AND instruction emission failure.");
1558       emitICmp_ri(MVT::i32, ANDReg, /*IsKill=*/true, 0);
1559
1560       if (FuncInfo.MBB->isLayoutSuccessor(TBB)) {
1561         std::swap(TBB, FBB);
1562         CC = AArch64CC::EQ;
1563       }
1564       BuildMI(*FuncInfo.MBB, FuncInfo.InsertPt, DbgLoc, TII.get(AArch64::Bcc))
1565           .addImm(CC)
1566           .addMBB(TBB);
1567
1568       // Obtain the branch weight and add the TrueBB to the successor list.
1569       uint32_t BranchWeight = 0;
1570       if (FuncInfo.BPI)
1571         BranchWeight = FuncInfo.BPI->getEdgeWeight(BI->getParent(),
1572                                                   TBB->getBasicBlock());
1573       FuncInfo.MBB->addSuccessor(TBB, BranchWeight);
1574
1575       FastEmitBranch(FBB, DbgLoc);
1576       return true;
1577     }
1578   } else if (const ConstantInt *CI =
1579                  dyn_cast<ConstantInt>(BI->getCondition())) {
1580     uint64_t Imm = CI->getZExtValue();
1581     MachineBasicBlock *Target = (Imm == 0) ? FBB : TBB;
1582     BuildMI(*FuncInfo.MBB, FuncInfo.InsertPt, DbgLoc, TII.get(AArch64::B))
1583         .addMBB(Target);
1584
1585     // Obtain the branch weight and add the target to the successor list.
1586     uint32_t BranchWeight = 0;
1587     if (FuncInfo.BPI)
1588       BranchWeight = FuncInfo.BPI->getEdgeWeight(BI->getParent(),
1589                                                  Target->getBasicBlock());
1590     FuncInfo.MBB->addSuccessor(Target, BranchWeight);
1591     return true;
1592   } else if (foldXALUIntrinsic(CC, I, BI->getCondition())) {
1593     // Fake request the condition, otherwise the intrinsic might be completely
1594     // optimized away.
1595     unsigned CondReg = getRegForValue(BI->getCondition());
1596     if (!CondReg)
1597       return false;
1598
1599     // Emit the branch.
1600     BuildMI(*FuncInfo.MBB, FuncInfo.InsertPt, DbgLoc, TII.get(AArch64::Bcc))
1601       .addImm(CC)
1602       .addMBB(TBB);
1603
1604     // Obtain the branch weight and add the TrueBB to the successor list.
1605     uint32_t BranchWeight = 0;
1606     if (FuncInfo.BPI)
1607       BranchWeight = FuncInfo.BPI->getEdgeWeight(BI->getParent(),
1608                                                  TBB->getBasicBlock());
1609     FuncInfo.MBB->addSuccessor(TBB, BranchWeight);
1610
1611     FastEmitBranch(FBB, DbgLoc);
1612     return true;
1613   }
1614
1615   unsigned CondReg = getRegForValue(BI->getCondition());
1616   if (CondReg == 0)
1617     return false;
1618   bool CondRegIsKill = hasTrivialKill(BI->getCondition());
1619
1620   // We've been divorced from our compare!  Our block was split, and
1621   // now our compare lives in a predecessor block.  We musn't
1622   // re-compare here, as the children of the compare aren't guaranteed
1623   // live across the block boundary (we *could* check for this).
1624   // Regardless, the compare has been done in the predecessor block,
1625   // and it left a value for us in a virtual register.  Ergo, we test
1626   // the one-bit value left in the virtual register.
1627   emitICmp_ri(MVT::i32, CondReg, CondRegIsKill, 0);
1628
1629   if (FuncInfo.MBB->isLayoutSuccessor(TBB)) {
1630     std::swap(TBB, FBB);
1631     CC = AArch64CC::EQ;
1632   }
1633
1634   BuildMI(*FuncInfo.MBB, FuncInfo.InsertPt, DbgLoc, TII.get(AArch64::Bcc))
1635       .addImm(CC)
1636       .addMBB(TBB);
1637
1638   // Obtain the branch weight and add the TrueBB to the successor list.
1639   uint32_t BranchWeight = 0;
1640   if (FuncInfo.BPI)
1641     BranchWeight = FuncInfo.BPI->getEdgeWeight(BI->getParent(),
1642                                                TBB->getBasicBlock());
1643   FuncInfo.MBB->addSuccessor(TBB, BranchWeight);
1644
1645   FastEmitBranch(FBB, DbgLoc);
1646   return true;
1647 }
1648
1649 bool AArch64FastISel::SelectIndirectBr(const Instruction *I) {
1650   const IndirectBrInst *BI = cast<IndirectBrInst>(I);
1651   unsigned AddrReg = getRegForValue(BI->getOperand(0));
1652   if (AddrReg == 0)
1653     return false;
1654
1655   // Emit the indirect branch.
1656   const MCInstrDesc &II = TII.get(AArch64::BR);
1657   AddrReg = constrainOperandRegClass(II, AddrReg,  II.getNumDefs());
1658   BuildMI(*FuncInfo.MBB, FuncInfo.InsertPt, DbgLoc, II).addReg(AddrReg);
1659
1660   // Make sure the CFG is up-to-date.
1661   for (unsigned i = 0, e = BI->getNumSuccessors(); i != e; ++i)
1662     FuncInfo.MBB->addSuccessor(FuncInfo.MBBMap[BI->getSuccessor(i)]);
1663
1664   return true;
1665 }
1666
1667 bool AArch64FastISel::SelectCmp(const Instruction *I) {
1668   const CmpInst *CI = cast<CmpInst>(I);
1669
1670   // We may not handle every CC for now.
1671   AArch64CC::CondCode CC = getCompareCC(CI->getPredicate());
1672   if (CC == AArch64CC::AL)
1673     return false;
1674
1675   // Emit the cmp.
1676   if (!emitCmp(CI->getOperand(0), CI->getOperand(1), CI->isUnsigned()))
1677     return false;
1678
1679   // Now set a register based on the comparison.
1680   AArch64CC::CondCode invertedCC = getInvertedCondCode(CC);
1681   unsigned ResultReg = createResultReg(&AArch64::GPR32RegClass);
1682   BuildMI(*FuncInfo.MBB, FuncInfo.InsertPt, DbgLoc, TII.get(AArch64::CSINCWr),
1683           ResultReg)
1684       .addReg(AArch64::WZR)
1685       .addReg(AArch64::WZR)
1686       .addImm(invertedCC);
1687
1688   UpdateValueMap(I, ResultReg);
1689   return true;
1690 }
1691
1692 bool AArch64FastISel::SelectSelect(const Instruction *I) {
1693   const SelectInst *SI = cast<SelectInst>(I);
1694
1695   EVT DestEVT = TLI.getValueType(SI->getType(), true);
1696   if (!DestEVT.isSimple())
1697     return false;
1698
1699   MVT DestVT = DestEVT.getSimpleVT();
1700   if (DestVT != MVT::i32 && DestVT != MVT::i64 && DestVT != MVT::f32 &&
1701       DestVT != MVT::f64)
1702     return false;
1703
1704   unsigned SelectOpc;
1705   const TargetRegisterClass *RC = nullptr;
1706   switch (DestVT.SimpleTy) {
1707   default: return false;
1708   case MVT::i32:
1709     SelectOpc = AArch64::CSELWr;    RC = &AArch64::GPR32RegClass; break;
1710   case MVT::i64:
1711     SelectOpc = AArch64::CSELXr;    RC = &AArch64::GPR64RegClass; break;
1712   case MVT::f32:
1713     SelectOpc = AArch64::FCSELSrrr; RC = &AArch64::FPR32RegClass; break;
1714   case MVT::f64:
1715     SelectOpc = AArch64::FCSELDrrr; RC = &AArch64::FPR64RegClass; break;
1716   }
1717
1718   const Value *Cond = SI->getCondition();
1719   bool NeedTest = true;
1720   AArch64CC::CondCode CC = AArch64CC::NE;
1721   if (foldXALUIntrinsic(CC, I, Cond))
1722     NeedTest = false;
1723
1724   unsigned CondReg = getRegForValue(Cond);
1725   if (!CondReg)
1726     return false;
1727   bool CondIsKill = hasTrivialKill(Cond);
1728
1729   if (NeedTest) {
1730     unsigned ANDReg = emitAND_ri(MVT::i32, CondReg, CondIsKill, 1);
1731     assert(ANDReg && "Unexpected AND instruction emission failure.");
1732     emitICmp_ri(MVT::i32, ANDReg, /*IsKill=*/true, 0);
1733   }
1734
1735   unsigned TrueReg = getRegForValue(SI->getTrueValue());
1736   bool TrueIsKill = hasTrivialKill(SI->getTrueValue());
1737
1738   unsigned FalseReg = getRegForValue(SI->getFalseValue());
1739   bool FalseIsKill = hasTrivialKill(SI->getFalseValue());
1740
1741   if (!TrueReg || !FalseReg)
1742     return false;
1743
1744   unsigned ResultReg = FastEmitInst_rri(SelectOpc, RC, TrueReg, TrueIsKill,
1745                                         FalseReg, FalseIsKill, CC);
1746   UpdateValueMap(I, ResultReg);
1747   return true;
1748 }
1749
1750 bool AArch64FastISel::SelectFPExt(const Instruction *I) {
1751   Value *V = I->getOperand(0);
1752   if (!I->getType()->isDoubleTy() || !V->getType()->isFloatTy())
1753     return false;
1754
1755   unsigned Op = getRegForValue(V);
1756   if (Op == 0)
1757     return false;
1758
1759   unsigned ResultReg = createResultReg(&AArch64::FPR64RegClass);
1760   BuildMI(*FuncInfo.MBB, FuncInfo.InsertPt, DbgLoc, TII.get(AArch64::FCVTDSr),
1761           ResultReg).addReg(Op);
1762   UpdateValueMap(I, ResultReg);
1763   return true;
1764 }
1765
1766 bool AArch64FastISel::SelectFPTrunc(const Instruction *I) {
1767   Value *V = I->getOperand(0);
1768   if (!I->getType()->isFloatTy() || !V->getType()->isDoubleTy())
1769     return false;
1770
1771   unsigned Op = getRegForValue(V);
1772   if (Op == 0)
1773     return false;
1774
1775   unsigned ResultReg = createResultReg(&AArch64::FPR32RegClass);
1776   BuildMI(*FuncInfo.MBB, FuncInfo.InsertPt, DbgLoc, TII.get(AArch64::FCVTSDr),
1777           ResultReg).addReg(Op);
1778   UpdateValueMap(I, ResultReg);
1779   return true;
1780 }
1781
1782 // FPToUI and FPToSI
1783 bool AArch64FastISel::SelectFPToInt(const Instruction *I, bool Signed) {
1784   MVT DestVT;
1785   if (!isTypeLegal(I->getType(), DestVT) || DestVT.isVector())
1786     return false;
1787
1788   unsigned SrcReg = getRegForValue(I->getOperand(0));
1789   if (SrcReg == 0)
1790     return false;
1791
1792   EVT SrcVT = TLI.getValueType(I->getOperand(0)->getType(), true);
1793   if (SrcVT == MVT::f128)
1794     return false;
1795
1796   unsigned Opc;
1797   if (SrcVT == MVT::f64) {
1798     if (Signed)
1799       Opc = (DestVT == MVT::i32) ? AArch64::FCVTZSUWDr : AArch64::FCVTZSUXDr;
1800     else
1801       Opc = (DestVT == MVT::i32) ? AArch64::FCVTZUUWDr : AArch64::FCVTZUUXDr;
1802   } else {
1803     if (Signed)
1804       Opc = (DestVT == MVT::i32) ? AArch64::FCVTZSUWSr : AArch64::FCVTZSUXSr;
1805     else
1806       Opc = (DestVT == MVT::i32) ? AArch64::FCVTZUUWSr : AArch64::FCVTZUUXSr;
1807   }
1808   unsigned ResultReg = createResultReg(
1809       DestVT == MVT::i32 ? &AArch64::GPR32RegClass : &AArch64::GPR64RegClass);
1810   BuildMI(*FuncInfo.MBB, FuncInfo.InsertPt, DbgLoc, TII.get(Opc), ResultReg)
1811       .addReg(SrcReg);
1812   UpdateValueMap(I, ResultReg);
1813   return true;
1814 }
1815
1816 bool AArch64FastISel::SelectIntToFP(const Instruction *I, bool Signed) {
1817   MVT DestVT;
1818   if (!isTypeLegal(I->getType(), DestVT) || DestVT.isVector())
1819     return false;
1820   assert ((DestVT == MVT::f32 || DestVT == MVT::f64) &&
1821           "Unexpected value type.");
1822
1823   unsigned SrcReg = getRegForValue(I->getOperand(0));
1824   if (!SrcReg)
1825     return false;
1826   bool SrcIsKill = hasTrivialKill(I->getOperand(0));
1827
1828   EVT SrcVT = TLI.getValueType(I->getOperand(0)->getType(), true);
1829
1830   // Handle sign-extension.
1831   if (SrcVT == MVT::i16 || SrcVT == MVT::i8 || SrcVT == MVT::i1) {
1832     SrcReg =
1833         EmitIntExt(SrcVT.getSimpleVT(), SrcReg, MVT::i32, /*isZExt*/ !Signed);
1834     if (!SrcReg)
1835       return false;
1836     SrcIsKill = true;
1837   }
1838
1839   unsigned Opc;
1840   if (SrcVT == MVT::i64) {
1841     if (Signed)
1842       Opc = (DestVT == MVT::f32) ? AArch64::SCVTFUXSri : AArch64::SCVTFUXDri;
1843     else
1844       Opc = (DestVT == MVT::f32) ? AArch64::UCVTFUXSri : AArch64::UCVTFUXDri;
1845   } else {
1846     if (Signed)
1847       Opc = (DestVT == MVT::f32) ? AArch64::SCVTFUWSri : AArch64::SCVTFUWDri;
1848     else
1849       Opc = (DestVT == MVT::f32) ? AArch64::UCVTFUWSri : AArch64::UCVTFUWDri;
1850   }
1851
1852   unsigned ResultReg = FastEmitInst_r(Opc, TLI.getRegClassFor(DestVT), SrcReg,
1853                                       SrcIsKill);
1854   UpdateValueMap(I, ResultReg);
1855   return true;
1856 }
1857
1858 bool AArch64FastISel::FastLowerArguments() {
1859   if (!FuncInfo.CanLowerReturn)
1860     return false;
1861
1862   const Function *F = FuncInfo.Fn;
1863   if (F->isVarArg())
1864     return false;
1865
1866   CallingConv::ID CC = F->getCallingConv();
1867   if (CC != CallingConv::C)
1868     return false;
1869
1870   // Only handle simple cases like i1/i8/i16/i32/i64/f32/f64 of up to 8 GPR and
1871   // FPR each.
1872   unsigned GPRCnt = 0;
1873   unsigned FPRCnt = 0;
1874   unsigned Idx = 0;
1875   for (auto const &Arg : F->args()) {
1876     // The first argument is at index 1.
1877     ++Idx;
1878     if (F->getAttributes().hasAttribute(Idx, Attribute::ByVal) ||
1879         F->getAttributes().hasAttribute(Idx, Attribute::InReg) ||
1880         F->getAttributes().hasAttribute(Idx, Attribute::StructRet) ||
1881         F->getAttributes().hasAttribute(Idx, Attribute::Nest))
1882       return false;
1883
1884     Type *ArgTy = Arg.getType();
1885     if (ArgTy->isStructTy() || ArgTy->isArrayTy() || ArgTy->isVectorTy())
1886       return false;
1887
1888     EVT ArgVT = TLI.getValueType(ArgTy);
1889     if (!ArgVT.isSimple()) return false;
1890     switch (ArgVT.getSimpleVT().SimpleTy) {
1891     default: return false;
1892     case MVT::i1:
1893     case MVT::i8:
1894     case MVT::i16:
1895     case MVT::i32:
1896     case MVT::i64:
1897       ++GPRCnt;
1898       break;
1899     case MVT::f16:
1900     case MVT::f32:
1901     case MVT::f64:
1902       ++FPRCnt;
1903       break;
1904     }
1905
1906     if (GPRCnt > 8 || FPRCnt > 8)
1907       return false;
1908   }
1909
1910   static const MCPhysReg Registers[5][8] = {
1911     { AArch64::W0, AArch64::W1, AArch64::W2, AArch64::W3, AArch64::W4,
1912       AArch64::W5, AArch64::W6, AArch64::W7 },
1913     { AArch64::X0, AArch64::X1, AArch64::X2, AArch64::X3, AArch64::X4,
1914       AArch64::X5, AArch64::X6, AArch64::X7 },
1915     { AArch64::H0, AArch64::H1, AArch64::H2, AArch64::H3, AArch64::H4,
1916       AArch64::H5, AArch64::H6, AArch64::H7 },
1917     { AArch64::S0, AArch64::S1, AArch64::S2, AArch64::S3, AArch64::S4,
1918       AArch64::S5, AArch64::S6, AArch64::S7 },
1919     { AArch64::D0, AArch64::D1, AArch64::D2, AArch64::D3, AArch64::D4,
1920       AArch64::D5, AArch64::D6, AArch64::D7 }
1921   };
1922
1923   unsigned GPRIdx = 0;
1924   unsigned FPRIdx = 0;
1925   for (auto const &Arg : F->args()) {
1926     MVT VT = TLI.getSimpleValueType(Arg.getType());
1927     unsigned SrcReg;
1928     const TargetRegisterClass *RC = nullptr;
1929     switch (VT.SimpleTy) {
1930     default: llvm_unreachable("Unexpected value type.");
1931     case MVT::i1:
1932     case MVT::i8:
1933     case MVT::i16: VT = MVT::i32; // fall-through
1934     case MVT::i32:
1935       SrcReg = Registers[0][GPRIdx++]; RC = &AArch64::GPR32RegClass; break;
1936     case MVT::i64:
1937       SrcReg = Registers[1][GPRIdx++]; RC = &AArch64::GPR64RegClass; break;
1938     case MVT::f16:
1939       SrcReg = Registers[2][FPRIdx++]; RC = &AArch64::FPR16RegClass; break;
1940     case MVT::f32:
1941       SrcReg = Registers[3][FPRIdx++]; RC = &AArch64::FPR32RegClass; break;
1942     case MVT::f64:
1943       SrcReg = Registers[4][FPRIdx++]; RC = &AArch64::FPR64RegClass; break;
1944     }
1945
1946     // Skip unused arguments.
1947     if (Arg.use_empty()) {
1948       UpdateValueMap(&Arg, 0);
1949       continue;
1950     }
1951
1952     unsigned DstReg = FuncInfo.MF->addLiveIn(SrcReg, RC);
1953     // FIXME: Unfortunately it's necessary to emit a copy from the livein copy.
1954     // Without this, EmitLiveInCopies may eliminate the livein if its only
1955     // use is a bitcast (which isn't turned into an instruction).
1956     unsigned ResultReg = createResultReg(RC);
1957     BuildMI(*FuncInfo.MBB, FuncInfo.InsertPt, DbgLoc,
1958             TII.get(TargetOpcode::COPY), ResultReg)
1959         .addReg(DstReg, getKillRegState(true));
1960     UpdateValueMap(&Arg, ResultReg);
1961   }
1962   return true;
1963 }
1964
1965 bool AArch64FastISel::ProcessCallArgs(CallLoweringInfo &CLI,
1966                                       SmallVectorImpl<MVT> &OutVTs,
1967                                       unsigned &NumBytes) {
1968   CallingConv::ID CC = CLI.CallConv;
1969   SmallVector<CCValAssign, 16> ArgLocs;
1970   CCState CCInfo(CC, false, *FuncInfo.MF, ArgLocs, *Context);
1971   CCInfo.AnalyzeCallOperands(OutVTs, CLI.OutFlags, CCAssignFnForCall(CC));
1972
1973   // Get a count of how many bytes are to be pushed on the stack.
1974   NumBytes = CCInfo.getNextStackOffset();
1975
1976   // Issue CALLSEQ_START
1977   unsigned AdjStackDown = TII.getCallFrameSetupOpcode();
1978   BuildMI(*FuncInfo.MBB, FuncInfo.InsertPt, DbgLoc, TII.get(AdjStackDown))
1979     .addImm(NumBytes);
1980
1981   // Process the args.
1982   for (unsigned i = 0, e = ArgLocs.size(); i != e; ++i) {
1983     CCValAssign &VA = ArgLocs[i];
1984     const Value *ArgVal = CLI.OutVals[VA.getValNo()];
1985     MVT ArgVT = OutVTs[VA.getValNo()];
1986
1987     unsigned ArgReg = getRegForValue(ArgVal);
1988     if (!ArgReg)
1989       return false;
1990
1991     // Handle arg promotion: SExt, ZExt, AExt.
1992     switch (VA.getLocInfo()) {
1993     case CCValAssign::Full:
1994       break;
1995     case CCValAssign::SExt: {
1996       MVT DestVT = VA.getLocVT();
1997       MVT SrcVT = ArgVT;
1998       ArgReg = EmitIntExt(SrcVT, ArgReg, DestVT, /*isZExt=*/false);
1999       if (!ArgReg)
2000         return false;
2001       break;
2002     }
2003     case CCValAssign::AExt:
2004     // Intentional fall-through.
2005     case CCValAssign::ZExt: {
2006       MVT DestVT = VA.getLocVT();
2007       MVT SrcVT = ArgVT;
2008       ArgReg = EmitIntExt(SrcVT, ArgReg, DestVT, /*isZExt=*/true);
2009       if (!ArgReg)
2010         return false;
2011       break;
2012     }
2013     default:
2014       llvm_unreachable("Unknown arg promotion!");
2015     }
2016
2017     // Now copy/store arg to correct locations.
2018     if (VA.isRegLoc() && !VA.needsCustom()) {
2019       BuildMI(*FuncInfo.MBB, FuncInfo.InsertPt, DbgLoc,
2020               TII.get(TargetOpcode::COPY), VA.getLocReg()).addReg(ArgReg);
2021       CLI.OutRegs.push_back(VA.getLocReg());
2022     } else if (VA.needsCustom()) {
2023       // FIXME: Handle custom args.
2024       return false;
2025     } else {
2026       assert(VA.isMemLoc() && "Assuming store on stack.");
2027
2028       // Don't emit stores for undef values.
2029       if (isa<UndefValue>(ArgVal))
2030         continue;
2031
2032       // Need to store on the stack.
2033       unsigned ArgSize = (ArgVT.getSizeInBits() + 7) / 8;
2034
2035       unsigned BEAlign = 0;
2036       if (ArgSize < 8 && !Subtarget->isLittleEndian())
2037         BEAlign = 8 - ArgSize;
2038
2039       Address Addr;
2040       Addr.setKind(Address::RegBase);
2041       Addr.setReg(AArch64::SP);
2042       Addr.setOffset(VA.getLocMemOffset() + BEAlign);
2043
2044       unsigned Alignment = DL.getABITypeAlignment(ArgVal->getType());
2045       MachineMemOperand *MMO = FuncInfo.MF->getMachineMemOperand(
2046         MachinePointerInfo::getStack(Addr.getOffset()),
2047         MachineMemOperand::MOStore, ArgVT.getStoreSize(), Alignment);
2048
2049       if (!EmitStore(ArgVT, ArgReg, Addr, MMO))
2050         return false;
2051     }
2052   }
2053   return true;
2054 }
2055
2056 bool AArch64FastISel::FinishCall(CallLoweringInfo &CLI, MVT RetVT,
2057                                  unsigned NumBytes) {
2058   CallingConv::ID CC = CLI.CallConv;
2059
2060   // Issue CALLSEQ_END
2061   unsigned AdjStackUp = TII.getCallFrameDestroyOpcode();
2062   BuildMI(*FuncInfo.MBB, FuncInfo.InsertPt, DbgLoc, TII.get(AdjStackUp))
2063     .addImm(NumBytes).addImm(0);
2064
2065   // Now the return value.
2066   if (RetVT != MVT::isVoid) {
2067     SmallVector<CCValAssign, 16> RVLocs;
2068     CCState CCInfo(CC, false, *FuncInfo.MF, RVLocs, *Context);
2069     CCInfo.AnalyzeCallResult(RetVT, CCAssignFnForCall(CC));
2070
2071     // Only handle a single return value.
2072     if (RVLocs.size() != 1)
2073       return false;
2074
2075     // Copy all of the result registers out of their specified physreg.
2076     MVT CopyVT = RVLocs[0].getValVT();
2077     unsigned ResultReg = createResultReg(TLI.getRegClassFor(CopyVT));
2078     BuildMI(*FuncInfo.MBB, FuncInfo.InsertPt, DbgLoc,
2079             TII.get(TargetOpcode::COPY), ResultReg)
2080         .addReg(RVLocs[0].getLocReg());
2081     CLI.InRegs.push_back(RVLocs[0].getLocReg());
2082
2083     CLI.ResultReg = ResultReg;
2084     CLI.NumResultRegs = 1;
2085   }
2086
2087   return true;
2088 }
2089
2090 bool AArch64FastISel::FastLowerCall(CallLoweringInfo &CLI) {
2091   CallingConv::ID CC  = CLI.CallConv;
2092   bool IsTailCall     = CLI.IsTailCall;
2093   bool IsVarArg       = CLI.IsVarArg;
2094   const Value *Callee = CLI.Callee;
2095   const char *SymName = CLI.SymName;
2096
2097   // Allow SelectionDAG isel to handle tail calls.
2098   if (IsTailCall)
2099     return false;
2100
2101   CodeModel::Model CM = TM.getCodeModel();
2102   // Only support the small and large code model.
2103   if (CM != CodeModel::Small && CM != CodeModel::Large)
2104     return false;
2105
2106   // FIXME: Add large code model support for ELF.
2107   if (CM == CodeModel::Large && !Subtarget->isTargetMachO())
2108     return false;
2109
2110   // Let SDISel handle vararg functions.
2111   if (IsVarArg)
2112     return false;
2113
2114   // FIXME: Only handle *simple* calls for now.
2115   MVT RetVT;
2116   if (CLI.RetTy->isVoidTy())
2117     RetVT = MVT::isVoid;
2118   else if (!isTypeLegal(CLI.RetTy, RetVT))
2119     return false;
2120
2121   for (auto Flag : CLI.OutFlags)
2122     if (Flag.isInReg() || Flag.isSRet() || Flag.isNest() || Flag.isByVal())
2123       return false;
2124
2125   // Set up the argument vectors.
2126   SmallVector<MVT, 16> OutVTs;
2127   OutVTs.reserve(CLI.OutVals.size());
2128
2129   for (auto *Val : CLI.OutVals) {
2130     MVT VT;
2131     if (!isTypeLegal(Val->getType(), VT) &&
2132         !(VT == MVT::i1 || VT == MVT::i8 || VT == MVT::i16))
2133       return false;
2134
2135     // We don't handle vector parameters yet.
2136     if (VT.isVector() || VT.getSizeInBits() > 64)
2137       return false;
2138
2139     OutVTs.push_back(VT);
2140   }
2141
2142   Address Addr;
2143   if (!ComputeCallAddress(Callee, Addr))
2144     return false;
2145
2146   // Handle the arguments now that we've gotten them.
2147   unsigned NumBytes;
2148   if (!ProcessCallArgs(CLI, OutVTs, NumBytes))
2149     return false;
2150
2151   // Issue the call.
2152   MachineInstrBuilder MIB;
2153   if (CM == CodeModel::Small) {
2154     unsigned CallOpc = Addr.getReg() ? AArch64::BLR : AArch64::BL;
2155     MIB = BuildMI(*FuncInfo.MBB, FuncInfo.InsertPt, DbgLoc, TII.get(CallOpc));
2156     if (SymName)
2157       MIB.addExternalSymbol(SymName, 0);
2158     else if (Addr.getGlobalValue())
2159       MIB.addGlobalAddress(Addr.getGlobalValue(), 0, 0);
2160     else if (Addr.getReg())
2161       MIB.addReg(Addr.getReg());
2162     else
2163       return false;
2164   } else {
2165     unsigned CallReg = 0;
2166     if (SymName) {
2167       unsigned ADRPReg = createResultReg(&AArch64::GPR64commonRegClass);
2168       BuildMI(*FuncInfo.MBB, FuncInfo.InsertPt, DbgLoc, TII.get(AArch64::ADRP),
2169               ADRPReg)
2170         .addExternalSymbol(SymName, AArch64II::MO_GOT | AArch64II::MO_PAGE);
2171
2172       CallReg = createResultReg(&AArch64::GPR64RegClass);
2173       BuildMI(*FuncInfo.MBB, FuncInfo.InsertPt, DbgLoc, TII.get(AArch64::LDRXui),
2174               CallReg)
2175         .addReg(ADRPReg)
2176         .addExternalSymbol(SymName, AArch64II::MO_GOT | AArch64II::MO_PAGEOFF |
2177                            AArch64II::MO_NC);
2178     } else if (Addr.getGlobalValue()) {
2179       CallReg = AArch64MaterializeGV(Addr.getGlobalValue());
2180     } else if (Addr.getReg())
2181       CallReg = Addr.getReg();
2182
2183     if (!CallReg)
2184       return false;
2185
2186     MIB = BuildMI(*FuncInfo.MBB, FuncInfo.InsertPt, DbgLoc,
2187                   TII.get(AArch64::BLR)).addReg(CallReg);
2188   }
2189
2190   // Add implicit physical register uses to the call.
2191   for (auto Reg : CLI.OutRegs)
2192     MIB.addReg(Reg, RegState::Implicit);
2193
2194   // Add a register mask with the call-preserved registers.
2195   // Proper defs for return values will be added by setPhysRegsDeadExcept().
2196   MIB.addRegMask(TRI.getCallPreservedMask(CC));
2197
2198   CLI.Call = MIB;
2199
2200   // Finish off the call including any return values.
2201   return FinishCall(CLI, RetVT, NumBytes);
2202 }
2203
2204 bool AArch64FastISel::IsMemCpySmall(uint64_t Len, unsigned Alignment) {
2205   if (Alignment)
2206     return Len / Alignment <= 4;
2207   else
2208     return Len < 32;
2209 }
2210
2211 bool AArch64FastISel::TryEmitSmallMemCpy(Address Dest, Address Src,
2212                                          uint64_t Len, unsigned Alignment) {
2213   // Make sure we don't bloat code by inlining very large memcpy's.
2214   if (!IsMemCpySmall(Len, Alignment))
2215     return false;
2216
2217   int64_t UnscaledOffset = 0;
2218   Address OrigDest = Dest;
2219   Address OrigSrc = Src;
2220
2221   while (Len) {
2222     MVT VT;
2223     if (!Alignment || Alignment >= 8) {
2224       if (Len >= 8)
2225         VT = MVT::i64;
2226       else if (Len >= 4)
2227         VT = MVT::i32;
2228       else if (Len >= 2)
2229         VT = MVT::i16;
2230       else {
2231         VT = MVT::i8;
2232       }
2233     } else {
2234       // Bound based on alignment.
2235       if (Len >= 4 && Alignment == 4)
2236         VT = MVT::i32;
2237       else if (Len >= 2 && Alignment == 2)
2238         VT = MVT::i16;
2239       else {
2240         VT = MVT::i8;
2241       }
2242     }
2243
2244     bool RV;
2245     unsigned ResultReg;
2246     RV = EmitLoad(VT, ResultReg, Src);
2247     if (!RV)
2248       return false;
2249
2250     RV = EmitStore(VT, ResultReg, Dest);
2251     if (!RV)
2252       return false;
2253
2254     int64_t Size = VT.getSizeInBits() / 8;
2255     Len -= Size;
2256     UnscaledOffset += Size;
2257
2258     // We need to recompute the unscaled offset for each iteration.
2259     Dest.setOffset(OrigDest.getOffset() + UnscaledOffset);
2260     Src.setOffset(OrigSrc.getOffset() + UnscaledOffset);
2261   }
2262
2263   return true;
2264 }
2265
2266 /// \brief Check if it is possible to fold the condition from the XALU intrinsic
2267 /// into the user. The condition code will only be updated on success.
2268 bool AArch64FastISel::foldXALUIntrinsic(AArch64CC::CondCode &CC,
2269                                         const Instruction *I,
2270                                         const Value *Cond) {
2271   if (!isa<ExtractValueInst>(Cond))
2272     return false;
2273
2274   const auto *EV = cast<ExtractValueInst>(Cond);
2275   if (!isa<IntrinsicInst>(EV->getAggregateOperand()))
2276     return false;
2277
2278   const auto *II = cast<IntrinsicInst>(EV->getAggregateOperand());
2279   MVT RetVT;
2280   const Function *Callee = II->getCalledFunction();
2281   Type *RetTy =
2282   cast<StructType>(Callee->getReturnType())->getTypeAtIndex(0U);
2283   if (!isTypeLegal(RetTy, RetVT))
2284     return false;
2285
2286   if (RetVT != MVT::i32 && RetVT != MVT::i64)
2287     return false;
2288
2289   AArch64CC::CondCode TmpCC;
2290   switch (II->getIntrinsicID()) {
2291     default: return false;
2292     case Intrinsic::sadd_with_overflow:
2293     case Intrinsic::ssub_with_overflow: TmpCC = AArch64CC::VS; break;
2294     case Intrinsic::uadd_with_overflow: TmpCC = AArch64CC::HS; break;
2295     case Intrinsic::usub_with_overflow: TmpCC = AArch64CC::LO; break;
2296     case Intrinsic::smul_with_overflow:
2297     case Intrinsic::umul_with_overflow: TmpCC = AArch64CC::NE; break;
2298   }
2299
2300   // Check if both instructions are in the same basic block.
2301   if (II->getParent() != I->getParent())
2302     return false;
2303
2304   // Make sure nothing is in the way
2305   BasicBlock::const_iterator Start = I;
2306   BasicBlock::const_iterator End = II;
2307   for (auto Itr = std::prev(Start); Itr != End; --Itr) {
2308     // We only expect extractvalue instructions between the intrinsic and the
2309     // instruction to be selected.
2310     if (!isa<ExtractValueInst>(Itr))
2311       return false;
2312
2313     // Check that the extractvalue operand comes from the intrinsic.
2314     const auto *EVI = cast<ExtractValueInst>(Itr);
2315     if (EVI->getAggregateOperand() != II)
2316       return false;
2317   }
2318
2319   CC = TmpCC;
2320   return true;
2321 }
2322
2323 bool AArch64FastISel::FastLowerIntrinsicCall(const IntrinsicInst *II) {
2324   // FIXME: Handle more intrinsics.
2325   switch (II->getIntrinsicID()) {
2326   default: return false;
2327   case Intrinsic::frameaddress: {
2328     MachineFrameInfo *MFI = FuncInfo.MF->getFrameInfo();
2329     MFI->setFrameAddressIsTaken(true);
2330
2331     const AArch64RegisterInfo *RegInfo =
2332         static_cast<const AArch64RegisterInfo *>(
2333             TM.getSubtargetImpl()->getRegisterInfo());
2334     unsigned FramePtr = RegInfo->getFrameRegister(*(FuncInfo.MF));
2335     unsigned SrcReg = MRI.createVirtualRegister(&AArch64::GPR64RegClass);
2336     BuildMI(*FuncInfo.MBB, FuncInfo.InsertPt, DbgLoc,
2337             TII.get(TargetOpcode::COPY), SrcReg).addReg(FramePtr);
2338     // Recursively load frame address
2339     // ldr x0, [fp]
2340     // ldr x0, [x0]
2341     // ldr x0, [x0]
2342     // ...
2343     unsigned DestReg;
2344     unsigned Depth = cast<ConstantInt>(II->getOperand(0))->getZExtValue();
2345     while (Depth--) {
2346       DestReg = FastEmitInst_ri(AArch64::LDRXui, &AArch64::GPR64RegClass,
2347                                 SrcReg, /*IsKill=*/true, 0);
2348       assert(DestReg && "Unexpected LDR instruction emission failure.");
2349       SrcReg = DestReg;
2350     }
2351
2352     UpdateValueMap(II, SrcReg);
2353     return true;
2354   }
2355   case Intrinsic::memcpy:
2356   case Intrinsic::memmove: {
2357     const auto *MTI = cast<MemTransferInst>(II);
2358     // Don't handle volatile.
2359     if (MTI->isVolatile())
2360       return false;
2361
2362     // Disable inlining for memmove before calls to ComputeAddress.  Otherwise,
2363     // we would emit dead code because we don't currently handle memmoves.
2364     bool IsMemCpy = (II->getIntrinsicID() == Intrinsic::memcpy);
2365     if (isa<ConstantInt>(MTI->getLength()) && IsMemCpy) {
2366       // Small memcpy's are common enough that we want to do them without a call
2367       // if possible.
2368       uint64_t Len = cast<ConstantInt>(MTI->getLength())->getZExtValue();
2369       unsigned Alignment = MTI->getAlignment();
2370       if (IsMemCpySmall(Len, Alignment)) {
2371         Address Dest, Src;
2372         if (!ComputeAddress(MTI->getRawDest(), Dest) ||
2373             !ComputeAddress(MTI->getRawSource(), Src))
2374           return false;
2375         if (TryEmitSmallMemCpy(Dest, Src, Len, Alignment))
2376           return true;
2377       }
2378     }
2379
2380     if (!MTI->getLength()->getType()->isIntegerTy(64))
2381       return false;
2382
2383     if (MTI->getSourceAddressSpace() > 255 || MTI->getDestAddressSpace() > 255)
2384       // Fast instruction selection doesn't support the special
2385       // address spaces.
2386       return false;
2387
2388     const char *IntrMemName = isa<MemCpyInst>(II) ? "memcpy" : "memmove";
2389     return LowerCallTo(II, IntrMemName, II->getNumArgOperands() - 2);
2390   }
2391   case Intrinsic::memset: {
2392     const MemSetInst *MSI = cast<MemSetInst>(II);
2393     // Don't handle volatile.
2394     if (MSI->isVolatile())
2395       return false;
2396
2397     if (!MSI->getLength()->getType()->isIntegerTy(64))
2398       return false;
2399
2400     if (MSI->getDestAddressSpace() > 255)
2401       // Fast instruction selection doesn't support the special
2402       // address spaces.
2403       return false;
2404
2405     return LowerCallTo(II, "memset", II->getNumArgOperands() - 2);
2406   }
2407   case Intrinsic::trap: {
2408     BuildMI(*FuncInfo.MBB, FuncInfo.InsertPt, DbgLoc, TII.get(AArch64::BRK))
2409         .addImm(1);
2410     return true;
2411   }
2412   case Intrinsic::sqrt: {
2413     Type *RetTy = II->getCalledFunction()->getReturnType();
2414
2415     MVT VT;
2416     if (!isTypeLegal(RetTy, VT))
2417       return false;
2418
2419     unsigned Op0Reg = getRegForValue(II->getOperand(0));
2420     if (!Op0Reg)
2421       return false;
2422     bool Op0IsKill = hasTrivialKill(II->getOperand(0));
2423
2424     unsigned ResultReg = FastEmit_r(VT, VT, ISD::FSQRT, Op0Reg, Op0IsKill);
2425     if (!ResultReg)
2426       return false;
2427
2428     UpdateValueMap(II, ResultReg);
2429     return true;
2430   }
2431   case Intrinsic::sadd_with_overflow:
2432   case Intrinsic::uadd_with_overflow:
2433   case Intrinsic::ssub_with_overflow:
2434   case Intrinsic::usub_with_overflow:
2435   case Intrinsic::smul_with_overflow:
2436   case Intrinsic::umul_with_overflow: {
2437     // This implements the basic lowering of the xalu with overflow intrinsics.
2438     const Function *Callee = II->getCalledFunction();
2439     auto *Ty = cast<StructType>(Callee->getReturnType());
2440     Type *RetTy = Ty->getTypeAtIndex(0U);
2441
2442     MVT VT;
2443     if (!isTypeLegal(RetTy, VT))
2444       return false;
2445
2446     if (VT != MVT::i32 && VT != MVT::i64)
2447       return false;
2448
2449     const Value *LHS = II->getArgOperand(0);
2450     const Value *RHS = II->getArgOperand(1);
2451     // Canonicalize immediate to the RHS.
2452     if (isa<ConstantInt>(LHS) && !isa<ConstantInt>(RHS) &&
2453         isCommutativeIntrinsic(II))
2454       std::swap(LHS, RHS);
2455
2456     unsigned ResultReg1 = 0, ResultReg2 = 0, MulReg = 0;
2457     AArch64CC::CondCode CC = AArch64CC::Invalid;
2458     switch (II->getIntrinsicID()) {
2459     default: llvm_unreachable("Unexpected intrinsic!");
2460     case Intrinsic::sadd_with_overflow:
2461       ResultReg1 = emitAdds(VT, LHS, RHS); CC = AArch64CC::VS; break;
2462     case Intrinsic::uadd_with_overflow:
2463       ResultReg1 = emitAdds(VT, LHS, RHS); CC = AArch64CC::HS; break;
2464     case Intrinsic::ssub_with_overflow:
2465       ResultReg1 = emitSubs(VT, LHS, RHS); CC = AArch64CC::VS; break;
2466     case Intrinsic::usub_with_overflow:
2467       ResultReg1 = emitSubs(VT, LHS, RHS); CC = AArch64CC::LO; break;
2468     case Intrinsic::smul_with_overflow: {
2469       CC = AArch64CC::NE;
2470       unsigned LHSReg = getRegForValue(LHS);
2471       if (!LHSReg)
2472         return false;
2473       bool LHSIsKill = hasTrivialKill(LHS);
2474
2475       unsigned RHSReg = getRegForValue(RHS);
2476       if (!RHSReg)
2477         return false;
2478       bool RHSIsKill = hasTrivialKill(RHS);
2479
2480       if (VT == MVT::i32) {
2481         MulReg = Emit_SMULL_rr(MVT::i64, LHSReg, LHSIsKill, RHSReg, RHSIsKill);
2482         unsigned ShiftReg = emitLSR_ri(MVT::i64, MVT::i64, MulReg,
2483                                        /*IsKill=*/false, 32);
2484         MulReg = FastEmitInst_extractsubreg(VT, MulReg, /*IsKill=*/true,
2485                                             AArch64::sub_32);
2486         ShiftReg = FastEmitInst_extractsubreg(VT, ShiftReg, /*IsKill=*/true,
2487                                               AArch64::sub_32);
2488         emitSubs_rs(VT, ShiftReg, /*IsKill=*/true, MulReg, /*IsKill=*/false,
2489                     AArch64_AM::ASR, 31, /*WantResult=*/false);
2490       } else {
2491         assert(VT == MVT::i64 && "Unexpected value type.");
2492         MulReg = Emit_MUL_rr(VT, LHSReg, LHSIsKill, RHSReg, RHSIsKill);
2493         unsigned SMULHReg = FastEmit_rr(VT, VT, ISD::MULHS, LHSReg, LHSIsKill,
2494                                         RHSReg, RHSIsKill);
2495         emitSubs_rs(VT, SMULHReg, /*IsKill=*/true, MulReg, /*IsKill=*/false,
2496                     AArch64_AM::ASR, 63, /*WantResult=*/false);
2497       }
2498       break;
2499     }
2500     case Intrinsic::umul_with_overflow: {
2501       CC = AArch64CC::NE;
2502       unsigned LHSReg = getRegForValue(LHS);
2503       if (!LHSReg)
2504         return false;
2505       bool LHSIsKill = hasTrivialKill(LHS);
2506
2507       unsigned RHSReg = getRegForValue(RHS);
2508       if (!RHSReg)
2509         return false;
2510       bool RHSIsKill = hasTrivialKill(RHS);
2511
2512       if (VT == MVT::i32) {
2513         MulReg = Emit_UMULL_rr(MVT::i64, LHSReg, LHSIsKill, RHSReg, RHSIsKill);
2514         emitSubs_rs(MVT::i64, AArch64::XZR, /*IsKill=*/true, MulReg,
2515                     /*IsKill=*/false, AArch64_AM::LSR, 32,
2516                     /*WantResult=*/false);
2517         MulReg = FastEmitInst_extractsubreg(VT, MulReg, /*IsKill=*/true,
2518                                             AArch64::sub_32);
2519       } else {
2520         assert(VT == MVT::i64 && "Unexpected value type.");
2521         MulReg = Emit_MUL_rr(VT, LHSReg, LHSIsKill, RHSReg, RHSIsKill);
2522         unsigned UMULHReg = FastEmit_rr(VT, VT, ISD::MULHU, LHSReg, LHSIsKill,
2523                                         RHSReg, RHSIsKill);
2524         emitSubs_rr(VT, AArch64::XZR, /*IsKill=*/true, UMULHReg,
2525                     /*IsKill=*/false, /*WantResult=*/false);
2526       }
2527       break;
2528     }
2529     }
2530
2531     if (MulReg) {
2532       ResultReg1 = createResultReg(TLI.getRegClassFor(VT));
2533       BuildMI(*FuncInfo.MBB, FuncInfo.InsertPt, DbgLoc,
2534               TII.get(TargetOpcode::COPY), ResultReg1).addReg(MulReg);
2535     }
2536
2537     ResultReg2 = FastEmitInst_rri(AArch64::CSINCWr, &AArch64::GPR32RegClass,
2538                                   AArch64::WZR, /*IsKill=*/true, AArch64::WZR,
2539                                   /*IsKill=*/true, getInvertedCondCode(CC));
2540     assert((ResultReg1 + 1) == ResultReg2 &&
2541            "Nonconsecutive result registers.");
2542     UpdateValueMap(II, ResultReg1, 2);
2543     return true;
2544   }
2545   }
2546   return false;
2547 }
2548
2549 bool AArch64FastISel::SelectRet(const Instruction *I) {
2550   const ReturnInst *Ret = cast<ReturnInst>(I);
2551   const Function &F = *I->getParent()->getParent();
2552
2553   if (!FuncInfo.CanLowerReturn)
2554     return false;
2555
2556   if (F.isVarArg())
2557     return false;
2558
2559   // Build a list of return value registers.
2560   SmallVector<unsigned, 4> RetRegs;
2561
2562   if (Ret->getNumOperands() > 0) {
2563     CallingConv::ID CC = F.getCallingConv();
2564     SmallVector<ISD::OutputArg, 4> Outs;
2565     GetReturnInfo(F.getReturnType(), F.getAttributes(), Outs, TLI);
2566
2567     // Analyze operands of the call, assigning locations to each operand.
2568     SmallVector<CCValAssign, 16> ValLocs;
2569     CCState CCInfo(CC, F.isVarArg(), *FuncInfo.MF, ValLocs, I->getContext());
2570     CCAssignFn *RetCC = CC == CallingConv::WebKit_JS ? RetCC_AArch64_WebKit_JS
2571                                                      : RetCC_AArch64_AAPCS;
2572     CCInfo.AnalyzeReturn(Outs, RetCC);
2573
2574     // Only handle a single return value for now.
2575     if (ValLocs.size() != 1)
2576       return false;
2577
2578     CCValAssign &VA = ValLocs[0];
2579     const Value *RV = Ret->getOperand(0);
2580
2581     // Don't bother handling odd stuff for now.
2582     if (VA.getLocInfo() != CCValAssign::Full)
2583       return false;
2584     // Only handle register returns for now.
2585     if (!VA.isRegLoc())
2586       return false;
2587     unsigned Reg = getRegForValue(RV);
2588     if (Reg == 0)
2589       return false;
2590
2591     unsigned SrcReg = Reg + VA.getValNo();
2592     unsigned DestReg = VA.getLocReg();
2593     // Avoid a cross-class copy. This is very unlikely.
2594     if (!MRI.getRegClass(SrcReg)->contains(DestReg))
2595       return false;
2596
2597     EVT RVEVT = TLI.getValueType(RV->getType());
2598     if (!RVEVT.isSimple())
2599       return false;
2600
2601     // Vectors (of > 1 lane) in big endian need tricky handling.
2602     if (RVEVT.isVector() && RVEVT.getVectorNumElements() > 1)
2603       return false;
2604
2605     MVT RVVT = RVEVT.getSimpleVT();
2606     if (RVVT == MVT::f128)
2607       return false;
2608     MVT DestVT = VA.getValVT();
2609     // Special handling for extended integers.
2610     if (RVVT != DestVT) {
2611       if (RVVT != MVT::i1 && RVVT != MVT::i8 && RVVT != MVT::i16)
2612         return false;
2613
2614       if (!Outs[0].Flags.isZExt() && !Outs[0].Flags.isSExt())
2615         return false;
2616
2617       bool isZExt = Outs[0].Flags.isZExt();
2618       SrcReg = EmitIntExt(RVVT, SrcReg, DestVT, isZExt);
2619       if (SrcReg == 0)
2620         return false;
2621     }
2622
2623     // Make the copy.
2624     BuildMI(*FuncInfo.MBB, FuncInfo.InsertPt, DbgLoc,
2625             TII.get(TargetOpcode::COPY), DestReg).addReg(SrcReg);
2626
2627     // Add register to return instruction.
2628     RetRegs.push_back(VA.getLocReg());
2629   }
2630
2631   MachineInstrBuilder MIB = BuildMI(*FuncInfo.MBB, FuncInfo.InsertPt, DbgLoc,
2632                                     TII.get(AArch64::RET_ReallyLR));
2633   for (unsigned i = 0, e = RetRegs.size(); i != e; ++i)
2634     MIB.addReg(RetRegs[i], RegState::Implicit);
2635   return true;
2636 }
2637
2638 bool AArch64FastISel::SelectTrunc(const Instruction *I) {
2639   Type *DestTy = I->getType();
2640   Value *Op = I->getOperand(0);
2641   Type *SrcTy = Op->getType();
2642
2643   EVT SrcEVT = TLI.getValueType(SrcTy, true);
2644   EVT DestEVT = TLI.getValueType(DestTy, true);
2645   if (!SrcEVT.isSimple())
2646     return false;
2647   if (!DestEVT.isSimple())
2648     return false;
2649
2650   MVT SrcVT = SrcEVT.getSimpleVT();
2651   MVT DestVT = DestEVT.getSimpleVT();
2652
2653   if (SrcVT != MVT::i64 && SrcVT != MVT::i32 && SrcVT != MVT::i16 &&
2654       SrcVT != MVT::i8)
2655     return false;
2656   if (DestVT != MVT::i32 && DestVT != MVT::i16 && DestVT != MVT::i8 &&
2657       DestVT != MVT::i1)
2658     return false;
2659
2660   unsigned SrcReg = getRegForValue(Op);
2661   if (!SrcReg)
2662     return false;
2663   bool SrcIsKill = hasTrivialKill(Op);
2664
2665   // If we're truncating from i64 to a smaller non-legal type then generate an
2666   // AND.  Otherwise, we know the high bits are undefined and a truncate doesn't
2667   // generate any code.
2668   if (SrcVT == MVT::i64) {
2669     uint64_t Mask = 0;
2670     switch (DestVT.SimpleTy) {
2671     default:
2672       // Trunc i64 to i32 is handled by the target-independent fast-isel.
2673       return false;
2674     case MVT::i1:
2675       Mask = 0x1;
2676       break;
2677     case MVT::i8:
2678       Mask = 0xff;
2679       break;
2680     case MVT::i16:
2681       Mask = 0xffff;
2682       break;
2683     }
2684     // Issue an extract_subreg to get the lower 32-bits.
2685     unsigned Reg32 = FastEmitInst_extractsubreg(MVT::i32, SrcReg, SrcIsKill,
2686                                                 AArch64::sub_32);
2687     // Create the AND instruction which performs the actual truncation.
2688     unsigned ANDReg = emitAND_ri(MVT::i32, Reg32, /*IsKill=*/true, Mask);
2689     assert(ANDReg && "Unexpected AND instruction emission failure.");
2690     SrcReg = ANDReg;
2691   }
2692
2693   UpdateValueMap(I, SrcReg);
2694   return true;
2695 }
2696
2697 unsigned AArch64FastISel::Emiti1Ext(unsigned SrcReg, MVT DestVT, bool isZExt) {
2698   assert((DestVT == MVT::i8 || DestVT == MVT::i16 || DestVT == MVT::i32 ||
2699           DestVT == MVT::i64) &&
2700          "Unexpected value type.");
2701   // Handle i8 and i16 as i32.
2702   if (DestVT == MVT::i8 || DestVT == MVT::i16)
2703     DestVT = MVT::i32;
2704
2705   if (isZExt) {
2706     unsigned ResultReg = emitAND_ri(MVT::i32, SrcReg, /*TODO:IsKill=*/false, 1);
2707     assert(ResultReg && "Unexpected AND instruction emission failure.");
2708     if (DestVT == MVT::i64) {
2709       // We're ZExt i1 to i64.  The ANDWri Wd, Ws, #1 implicitly clears the
2710       // upper 32 bits.  Emit a SUBREG_TO_REG to extend from Wd to Xd.
2711       unsigned Reg64 = MRI.createVirtualRegister(&AArch64::GPR64RegClass);
2712       BuildMI(*FuncInfo.MBB, FuncInfo.InsertPt, DbgLoc,
2713               TII.get(AArch64::SUBREG_TO_REG), Reg64)
2714           .addImm(0)
2715           .addReg(ResultReg)
2716           .addImm(AArch64::sub_32);
2717       ResultReg = Reg64;
2718     }
2719     return ResultReg;
2720   } else {
2721     if (DestVT == MVT::i64) {
2722       // FIXME: We're SExt i1 to i64.
2723       return 0;
2724     }
2725     return FastEmitInst_rii(AArch64::SBFMWri, &AArch64::GPR32RegClass, SrcReg,
2726                             /*TODO:IsKill=*/false, 0, 0);
2727   }
2728 }
2729
2730 unsigned AArch64FastISel::Emit_MUL_rr(MVT RetVT, unsigned Op0, bool Op0IsKill,
2731                                       unsigned Op1, bool Op1IsKill) {
2732   unsigned Opc, ZReg;
2733   switch (RetVT.SimpleTy) {
2734   default: return 0;
2735   case MVT::i8:
2736   case MVT::i16:
2737   case MVT::i32:
2738     RetVT = MVT::i32;
2739     Opc = AArch64::MADDWrrr; ZReg = AArch64::WZR; break;
2740   case MVT::i64:
2741     Opc = AArch64::MADDXrrr; ZReg = AArch64::XZR; break;
2742   }
2743
2744   const TargetRegisterClass *RC =
2745       (RetVT == MVT::i64) ? &AArch64::GPR64RegClass : &AArch64::GPR32RegClass;
2746   return FastEmitInst_rrr(Opc, RC, Op0, Op0IsKill, Op1, Op1IsKill,
2747                           /*IsKill=*/ZReg, true);
2748 }
2749
2750 unsigned AArch64FastISel::Emit_SMULL_rr(MVT RetVT, unsigned Op0, bool Op0IsKill,
2751                                         unsigned Op1, bool Op1IsKill) {
2752   if (RetVT != MVT::i64)
2753     return 0;
2754
2755   return FastEmitInst_rrr(AArch64::SMADDLrrr, &AArch64::GPR64RegClass,
2756                           Op0, Op0IsKill, Op1, Op1IsKill,
2757                           AArch64::XZR, /*IsKill=*/true);
2758 }
2759
2760 unsigned AArch64FastISel::Emit_UMULL_rr(MVT RetVT, unsigned Op0, bool Op0IsKill,
2761                                         unsigned Op1, bool Op1IsKill) {
2762   if (RetVT != MVT::i64)
2763     return 0;
2764
2765   return FastEmitInst_rrr(AArch64::UMADDLrrr, &AArch64::GPR64RegClass,
2766                           Op0, Op0IsKill, Op1, Op1IsKill,
2767                           AArch64::XZR, /*IsKill=*/true);
2768 }
2769
2770 unsigned AArch64FastISel::emitLSL_rr(MVT RetVT, unsigned Op0Reg, bool Op0IsKill,
2771                                      unsigned Op1Reg, bool Op1IsKill) {
2772   unsigned Opc = 0;
2773   bool NeedTrunc = false;
2774   uint64_t Mask = 0;
2775   switch (RetVT.SimpleTy) {
2776   default: return 0;
2777   case MVT::i8:  Opc = AArch64::LSLVWr; NeedTrunc = true; Mask = 0xff;   break;
2778   case MVT::i16: Opc = AArch64::LSLVWr; NeedTrunc = true; Mask = 0xffff; break;
2779   case MVT::i32: Opc = AArch64::LSLVWr;                                  break;
2780   case MVT::i64: Opc = AArch64::LSLVXr;                                  break;
2781   }
2782
2783   const TargetRegisterClass *RC =
2784       (RetVT == MVT::i64) ? &AArch64::GPR64RegClass : &AArch64::GPR32RegClass;
2785   if (NeedTrunc) {
2786     Op1Reg = emitAND_ri(MVT::i32, Op1Reg, Op1IsKill, Mask);
2787     Op1IsKill = true;
2788   }
2789   unsigned ResultReg = FastEmitInst_rr(Opc, RC, Op0Reg, Op0IsKill, Op1Reg,
2790                                        Op1IsKill);
2791   if (NeedTrunc)
2792     ResultReg = emitAND_ri(MVT::i32, ResultReg, /*IsKill=*/true, Mask);
2793   return ResultReg;
2794 }
2795
2796 unsigned AArch64FastISel::emitLSL_ri(MVT RetVT, MVT SrcVT, unsigned Op0,
2797                                      bool Op0IsKill, uint64_t Shift,
2798                                      bool IsZext) {
2799   assert(RetVT.SimpleTy >= SrcVT.SimpleTy &&
2800          "Unexpected source/return type pair.");
2801   assert((SrcVT == MVT::i8 || SrcVT == MVT::i16 || SrcVT == MVT::i32 ||
2802           SrcVT == MVT::i64) && "Unexpected source value type.");
2803   assert((RetVT == MVT::i8 || RetVT == MVT::i16 || RetVT == MVT::i32 ||
2804           RetVT == MVT::i64) && "Unexpected return value type.");
2805
2806   bool Is64Bit = (RetVT == MVT::i64);
2807   unsigned RegSize = Is64Bit ? 64 : 32;
2808   unsigned DstBits = RetVT.getSizeInBits();
2809   unsigned SrcBits = SrcVT.getSizeInBits();
2810
2811   // Don't deal with undefined shifts.
2812   if (Shift >= DstBits)
2813     return 0;
2814
2815   // For immediate shifts we can fold the zero-/sign-extension into the shift.
2816   // {S|U}BFM Wd, Wn, #r, #s
2817   // Wd<32+s-r,32-r> = Wn<s:0> when r > s
2818
2819   // %1 = {s|z}ext i8 {0b1010_1010|0b0101_0101} to i16
2820   // %2 = shl i16 %1, 4
2821   // Wd<32+7-28,32-28> = Wn<7:0> <- clamp s to 7
2822   // 0b1111_1111_1111_1111__1111_1010_1010_0000 sext
2823   // 0b0000_0000_0000_0000__0000_0101_0101_0000 sext | zext
2824   // 0b0000_0000_0000_0000__0000_1010_1010_0000 zext
2825
2826   // %1 = {s|z}ext i8 {0b1010_1010|0b0101_0101} to i16
2827   // %2 = shl i16 %1, 8
2828   // Wd<32+7-24,32-24> = Wn<7:0>
2829   // 0b1111_1111_1111_1111__1010_1010_0000_0000 sext
2830   // 0b0000_0000_0000_0000__0101_0101_0000_0000 sext | zext
2831   // 0b0000_0000_0000_0000__1010_1010_0000_0000 zext
2832
2833   // %1 = {s|z}ext i8 {0b1010_1010|0b0101_0101} to i16
2834   // %2 = shl i16 %1, 12
2835   // Wd<32+3-20,32-20> = Wn<3:0>
2836   // 0b1111_1111_1111_1111__1010_0000_0000_0000 sext
2837   // 0b0000_0000_0000_0000__0101_0000_0000_0000 sext | zext
2838   // 0b0000_0000_0000_0000__1010_0000_0000_0000 zext
2839
2840   unsigned ImmR = RegSize - Shift;
2841   // Limit the width to the length of the source type.
2842   unsigned ImmS = std::min<unsigned>(SrcBits - 1, DstBits - 1 - Shift);
2843   static const unsigned OpcTable[2][2] = {
2844     {AArch64::SBFMWri, AArch64::SBFMXri},
2845     {AArch64::UBFMWri, AArch64::UBFMXri}
2846   };
2847   unsigned Opc = OpcTable[IsZext][Is64Bit];
2848   const TargetRegisterClass *RC =
2849       Is64Bit ? &AArch64::GPR64RegClass : &AArch64::GPR32RegClass;
2850   if (SrcVT.SimpleTy <= MVT::i32 && RetVT == MVT::i64) {
2851     unsigned TmpReg = MRI.createVirtualRegister(RC);
2852     BuildMI(*FuncInfo.MBB, FuncInfo.InsertPt, DbgLoc,
2853             TII.get(AArch64::SUBREG_TO_REG), TmpReg)
2854         .addImm(0)
2855         .addReg(Op0, getKillRegState(Op0IsKill))
2856         .addImm(AArch64::sub_32);
2857     Op0 = TmpReg;
2858     Op0IsKill = true;
2859   }
2860   return FastEmitInst_rii(Opc, RC, Op0, Op0IsKill, ImmR, ImmS);
2861 }
2862
2863 unsigned AArch64FastISel::emitLSR_rr(MVT RetVT, unsigned Op0Reg, bool Op0IsKill,
2864                                      unsigned Op1Reg, bool Op1IsKill) {
2865   unsigned Opc = 0;
2866   bool NeedTrunc = false;
2867   uint64_t Mask = 0;
2868   switch (RetVT.SimpleTy) {
2869   default: return 0;
2870   case MVT::i8:  Opc = AArch64::LSRVWr; NeedTrunc = true; Mask = 0xff;   break;
2871   case MVT::i16: Opc = AArch64::LSRVWr; NeedTrunc = true; Mask = 0xffff; break;
2872   case MVT::i32: Opc = AArch64::LSRVWr; break;
2873   case MVT::i64: Opc = AArch64::LSRVXr; break;
2874   }
2875
2876   const TargetRegisterClass *RC =
2877       (RetVT == MVT::i64) ? &AArch64::GPR64RegClass : &AArch64::GPR32RegClass;
2878   if (NeedTrunc) {
2879     Op0Reg = emitAND_ri(MVT::i32, Op0Reg, Op0IsKill, Mask);
2880     Op1Reg = emitAND_ri(MVT::i32, Op1Reg, Op1IsKill, Mask);
2881     Op0IsKill = Op1IsKill = true;
2882   }
2883   unsigned ResultReg = FastEmitInst_rr(Opc, RC, Op0Reg, Op0IsKill, Op1Reg,
2884                                        Op1IsKill);
2885   if (NeedTrunc)
2886     ResultReg = emitAND_ri(MVT::i32, ResultReg, /*IsKill=*/true, Mask);
2887   return ResultReg;
2888 }
2889
2890 unsigned AArch64FastISel::emitLSR_ri(MVT RetVT, MVT SrcVT, unsigned Op0,
2891                                      bool Op0IsKill, uint64_t Shift,
2892                                      bool IsZExt) {
2893   assert(RetVT.SimpleTy >= SrcVT.SimpleTy &&
2894          "Unexpected source/return type pair.");
2895   assert((SrcVT == MVT::i8 || SrcVT == MVT::i16 || SrcVT == MVT::i32 ||
2896           SrcVT == MVT::i64) && "Unexpected source value type.");
2897   assert((RetVT == MVT::i8 || RetVT == MVT::i16 || RetVT == MVT::i32 ||
2898           RetVT == MVT::i64) && "Unexpected return value type.");
2899
2900   bool Is64Bit = (RetVT == MVT::i64);
2901   unsigned RegSize = Is64Bit ? 64 : 32;
2902   unsigned DstBits = RetVT.getSizeInBits();
2903   unsigned SrcBits = SrcVT.getSizeInBits();
2904
2905   // Don't deal with undefined shifts.
2906   if (Shift >= DstBits)
2907     return 0;
2908
2909   // For immediate shifts we can fold the zero-/sign-extension into the shift.
2910   // {S|U}BFM Wd, Wn, #r, #s
2911   // Wd<s-r:0> = Wn<s:r> when r <= s
2912
2913   // %1 = {s|z}ext i8 {0b1010_1010|0b0101_0101} to i16
2914   // %2 = lshr i16 %1, 4
2915   // Wd<7-4:0> = Wn<7:4>
2916   // 0b0000_0000_0000_0000__0000_1111_1111_1010 sext
2917   // 0b0000_0000_0000_0000__0000_0000_0000_0101 sext | zext
2918   // 0b0000_0000_0000_0000__0000_0000_0000_1010 zext
2919
2920   // %1 = {s|z}ext i8 {0b1010_1010|0b0101_0101} to i16
2921   // %2 = lshr i16 %1, 8
2922   // Wd<7-7,0> = Wn<7:7>
2923   // 0b0000_0000_0000_0000__0000_0000_1111_1111 sext
2924   // 0b0000_0000_0000_0000__0000_0000_0000_0000 sext
2925   // 0b0000_0000_0000_0000__0000_0000_0000_0000 zext
2926
2927   // %1 = {s|z}ext i8 {0b1010_1010|0b0101_0101} to i16
2928   // %2 = lshr i16 %1, 12
2929   // Wd<7-7,0> = Wn<7:7> <- clamp r to 7
2930   // 0b0000_0000_0000_0000__0000_0000_0000_1111 sext
2931   // 0b0000_0000_0000_0000__0000_0000_0000_0000 sext
2932   // 0b0000_0000_0000_0000__0000_0000_0000_0000 zext
2933
2934   if (Shift >= SrcBits && IsZExt)
2935     return AArch64MaterializeInt(ConstantInt::get(*Context, APInt(RegSize, 0)),
2936                                  RetVT);
2937
2938   // It is not possible to fold a sign-extend into the LShr instruction. In this
2939   // case emit a sign-extend.
2940   if (!IsZExt) {
2941     Op0 = EmitIntExt(SrcVT, Op0, RetVT, IsZExt);
2942     if (!Op0)
2943       return 0;
2944     Op0IsKill = true;
2945     SrcVT = RetVT;
2946     SrcBits = SrcVT.getSizeInBits();
2947     IsZExt = true;
2948   }
2949
2950   unsigned ImmR = std::min<unsigned>(SrcBits - 1, Shift);
2951   unsigned ImmS = SrcBits - 1;
2952   static const unsigned OpcTable[2][2] = {
2953     {AArch64::SBFMWri, AArch64::SBFMXri},
2954     {AArch64::UBFMWri, AArch64::UBFMXri}
2955   };
2956   unsigned Opc = OpcTable[IsZExt][Is64Bit];
2957   const TargetRegisterClass *RC =
2958       Is64Bit ? &AArch64::GPR64RegClass : &AArch64::GPR32RegClass;
2959   if (SrcVT.SimpleTy <= MVT::i32 && RetVT == MVT::i64) {
2960     unsigned TmpReg = MRI.createVirtualRegister(RC);
2961     BuildMI(*FuncInfo.MBB, FuncInfo.InsertPt, DbgLoc,
2962             TII.get(AArch64::SUBREG_TO_REG), TmpReg)
2963         .addImm(0)
2964         .addReg(Op0, getKillRegState(Op0IsKill))
2965         .addImm(AArch64::sub_32);
2966     Op0 = TmpReg;
2967     Op0IsKill = true;
2968   }
2969   return FastEmitInst_rii(Opc, RC, Op0, Op0IsKill, ImmR, ImmS);
2970 }
2971
2972 unsigned AArch64FastISel::emitASR_rr(MVT RetVT, unsigned Op0Reg, bool Op0IsKill,
2973                                      unsigned Op1Reg, bool Op1IsKill) {
2974   unsigned Opc = 0;
2975   bool NeedTrunc = false;
2976   uint64_t Mask = 0;
2977   switch (RetVT.SimpleTy) {
2978   default: return 0;
2979   case MVT::i8:  Opc = AArch64::ASRVWr; NeedTrunc = true; Mask = 0xff;   break;
2980   case MVT::i16: Opc = AArch64::ASRVWr; NeedTrunc = true; Mask = 0xffff; break;
2981   case MVT::i32: Opc = AArch64::ASRVWr;                                  break;
2982   case MVT::i64: Opc = AArch64::ASRVXr;                                  break;
2983   }
2984
2985   const TargetRegisterClass *RC =
2986       (RetVT == MVT::i64) ? &AArch64::GPR64RegClass : &AArch64::GPR32RegClass;
2987   if (NeedTrunc) {
2988     Op0Reg = EmitIntExt(RetVT, Op0Reg, MVT::i32, /*IsZExt=*/false);
2989     Op1Reg = emitAND_ri(MVT::i32, Op1Reg, Op1IsKill, Mask);
2990     Op0IsKill = Op1IsKill = true;
2991   }
2992   unsigned ResultReg = FastEmitInst_rr(Opc, RC, Op0Reg, Op0IsKill, Op1Reg,
2993                                        Op1IsKill);
2994   if (NeedTrunc)
2995     ResultReg = emitAND_ri(MVT::i32, ResultReg, /*IsKill=*/true, Mask);
2996   return ResultReg;
2997 }
2998
2999 unsigned AArch64FastISel::emitASR_ri(MVT RetVT, MVT SrcVT, unsigned Op0,
3000                                      bool Op0IsKill, uint64_t Shift,
3001                                      bool IsZExt) {
3002   assert(RetVT.SimpleTy >= SrcVT.SimpleTy &&
3003          "Unexpected source/return type pair.");
3004   assert((SrcVT == MVT::i8 || SrcVT == MVT::i16 || SrcVT == MVT::i32 ||
3005           SrcVT == MVT::i64) && "Unexpected source value type.");
3006   assert((RetVT == MVT::i8 || RetVT == MVT::i16 || RetVT == MVT::i32 ||
3007           RetVT == MVT::i64) && "Unexpected return value type.");
3008
3009   bool Is64Bit = (RetVT == MVT::i64);
3010   unsigned RegSize = Is64Bit ? 64 : 32;
3011   unsigned DstBits = RetVT.getSizeInBits();
3012   unsigned SrcBits = SrcVT.getSizeInBits();
3013
3014   // Don't deal with undefined shifts.
3015   if (Shift >= DstBits)
3016     return 0;
3017
3018   // For immediate shifts we can fold the zero-/sign-extension into the shift.
3019   // {S|U}BFM Wd, Wn, #r, #s
3020   // Wd<s-r:0> = Wn<s:r> when r <= s
3021
3022   // %1 = {s|z}ext i8 {0b1010_1010|0b0101_0101} to i16
3023   // %2 = ashr i16 %1, 4
3024   // Wd<7-4:0> = Wn<7:4>
3025   // 0b1111_1111_1111_1111__1111_1111_1111_1010 sext
3026   // 0b0000_0000_0000_0000__0000_0000_0000_0101 sext | zext
3027   // 0b0000_0000_0000_0000__0000_0000_0000_1010 zext
3028
3029   // %1 = {s|z}ext i8 {0b1010_1010|0b0101_0101} to i16
3030   // %2 = ashr i16 %1, 8
3031   // Wd<7-7,0> = Wn<7:7>
3032   // 0b1111_1111_1111_1111__1111_1111_1111_1111 sext
3033   // 0b0000_0000_0000_0000__0000_0000_0000_0000 sext
3034   // 0b0000_0000_0000_0000__0000_0000_0000_0000 zext
3035
3036   // %1 = {s|z}ext i8 {0b1010_1010|0b0101_0101} to i16
3037   // %2 = ashr i16 %1, 12
3038   // Wd<7-7,0> = Wn<7:7> <- clamp r to 7
3039   // 0b1111_1111_1111_1111__1111_1111_1111_1111 sext
3040   // 0b0000_0000_0000_0000__0000_0000_0000_0000 sext
3041   // 0b0000_0000_0000_0000__0000_0000_0000_0000 zext
3042
3043   if (Shift >= SrcBits && IsZExt)
3044     return AArch64MaterializeInt(ConstantInt::get(*Context, APInt(RegSize, 0)),
3045                                  RetVT);
3046
3047   unsigned ImmR = std::min<unsigned>(SrcBits - 1, Shift);
3048   unsigned ImmS = SrcBits - 1;
3049   static const unsigned OpcTable[2][2] = {
3050     {AArch64::SBFMWri, AArch64::SBFMXri},
3051     {AArch64::UBFMWri, AArch64::UBFMXri}
3052   };
3053   unsigned Opc = OpcTable[IsZExt][Is64Bit];
3054   const TargetRegisterClass *RC =
3055       Is64Bit ? &AArch64::GPR64RegClass : &AArch64::GPR32RegClass;
3056   if (SrcVT.SimpleTy <= MVT::i32 && RetVT == MVT::i64) {
3057     unsigned TmpReg = MRI.createVirtualRegister(RC);
3058     BuildMI(*FuncInfo.MBB, FuncInfo.InsertPt, DbgLoc,
3059             TII.get(AArch64::SUBREG_TO_REG), TmpReg)
3060         .addImm(0)
3061         .addReg(Op0, getKillRegState(Op0IsKill))
3062         .addImm(AArch64::sub_32);
3063     Op0 = TmpReg;
3064     Op0IsKill = true;
3065   }
3066   return FastEmitInst_rii(Opc, RC, Op0, Op0IsKill, ImmR, ImmS);
3067 }
3068
3069 unsigned AArch64FastISel::EmitIntExt(MVT SrcVT, unsigned SrcReg, MVT DestVT,
3070                                      bool isZExt) {
3071   assert(DestVT != MVT::i1 && "ZeroExt/SignExt an i1?");
3072
3073   // FastISel does not have plumbing to deal with extensions where the SrcVT or
3074   // DestVT are odd things, so test to make sure that they are both types we can
3075   // handle (i1/i8/i16/i32 for SrcVT and i8/i16/i32/i64 for DestVT), otherwise
3076   // bail out to SelectionDAG.
3077   if (((DestVT != MVT::i8) && (DestVT != MVT::i16) &&
3078        (DestVT != MVT::i32) && (DestVT != MVT::i64)) ||
3079       ((SrcVT !=  MVT::i1) && (SrcVT !=  MVT::i8) &&
3080        (SrcVT !=  MVT::i16) && (SrcVT !=  MVT::i32)))
3081     return 0;
3082
3083   unsigned Opc;
3084   unsigned Imm = 0;
3085
3086   switch (SrcVT.SimpleTy) {
3087   default:
3088     return 0;
3089   case MVT::i1:
3090     return Emiti1Ext(SrcReg, DestVT, isZExt);
3091   case MVT::i8:
3092     if (DestVT == MVT::i64)
3093       Opc = isZExt ? AArch64::UBFMXri : AArch64::SBFMXri;
3094     else
3095       Opc = isZExt ? AArch64::UBFMWri : AArch64::SBFMWri;
3096     Imm = 7;
3097     break;
3098   case MVT::i16:
3099     if (DestVT == MVT::i64)
3100       Opc = isZExt ? AArch64::UBFMXri : AArch64::SBFMXri;
3101     else
3102       Opc = isZExt ? AArch64::UBFMWri : AArch64::SBFMWri;
3103     Imm = 15;
3104     break;
3105   case MVT::i32:
3106     assert(DestVT == MVT::i64 && "IntExt i32 to i32?!?");
3107     Opc = isZExt ? AArch64::UBFMXri : AArch64::SBFMXri;
3108     Imm = 31;
3109     break;
3110   }
3111
3112   // Handle i8 and i16 as i32.
3113   if (DestVT == MVT::i8 || DestVT == MVT::i16)
3114     DestVT = MVT::i32;
3115   else if (DestVT == MVT::i64) {
3116     unsigned Src64 = MRI.createVirtualRegister(&AArch64::GPR64RegClass);
3117     BuildMI(*FuncInfo.MBB, FuncInfo.InsertPt, DbgLoc,
3118             TII.get(AArch64::SUBREG_TO_REG), Src64)
3119         .addImm(0)
3120         .addReg(SrcReg)
3121         .addImm(AArch64::sub_32);
3122     SrcReg = Src64;
3123   }
3124
3125   const TargetRegisterClass *RC =
3126       (DestVT == MVT::i64) ? &AArch64::GPR64RegClass : &AArch64::GPR32RegClass;
3127   return FastEmitInst_rii(Opc, RC, SrcReg, /*TODO:IsKill=*/false, 0, Imm);
3128 }
3129
3130 bool AArch64FastISel::SelectIntExt(const Instruction *I) {
3131   // On ARM, in general, integer casts don't involve legal types; this code
3132   // handles promotable integers.  The high bits for a type smaller than
3133   // the register size are assumed to be undefined.
3134   Type *DestTy = I->getType();
3135   Value *Src = I->getOperand(0);
3136   Type *SrcTy = Src->getType();
3137
3138   bool isZExt = isa<ZExtInst>(I);
3139   unsigned SrcReg = getRegForValue(Src);
3140   if (!SrcReg)
3141     return false;
3142
3143   EVT SrcEVT = TLI.getValueType(SrcTy, true);
3144   EVT DestEVT = TLI.getValueType(DestTy, true);
3145   if (!SrcEVT.isSimple())
3146     return false;
3147   if (!DestEVT.isSimple())
3148     return false;
3149
3150   MVT SrcVT = SrcEVT.getSimpleVT();
3151   MVT DestVT = DestEVT.getSimpleVT();
3152   unsigned ResultReg = 0;
3153
3154   // Check if it is an argument and if it is already zero/sign-extended.
3155   if (const auto *Arg = dyn_cast<Argument>(Src)) {
3156     if ((isZExt && Arg->hasZExtAttr()) || (!isZExt && Arg->hasSExtAttr())) {
3157       if (DestVT == MVT::i64) {
3158         ResultReg = createResultReg(TLI.getRegClassFor(DestVT));
3159         BuildMI(*FuncInfo.MBB, FuncInfo.InsertPt, DbgLoc,
3160                 TII.get(AArch64::SUBREG_TO_REG), ResultReg)
3161           .addImm(0)
3162           .addReg(SrcReg)
3163           .addImm(AArch64::sub_32);
3164       } else
3165         ResultReg = SrcReg;
3166     }
3167   }
3168
3169   if (!ResultReg)
3170     ResultReg = EmitIntExt(SrcVT, SrcReg, DestVT, isZExt);
3171
3172   if (!ResultReg)
3173     return false;
3174
3175   UpdateValueMap(I, ResultReg);
3176   return true;
3177 }
3178
3179 bool AArch64FastISel::SelectRem(const Instruction *I, unsigned ISDOpcode) {
3180   EVT DestEVT = TLI.getValueType(I->getType(), true);
3181   if (!DestEVT.isSimple())
3182     return false;
3183
3184   MVT DestVT = DestEVT.getSimpleVT();
3185   if (DestVT != MVT::i64 && DestVT != MVT::i32)
3186     return false;
3187
3188   unsigned DivOpc;
3189   bool is64bit = (DestVT == MVT::i64);
3190   switch (ISDOpcode) {
3191   default:
3192     return false;
3193   case ISD::SREM:
3194     DivOpc = is64bit ? AArch64::SDIVXr : AArch64::SDIVWr;
3195     break;
3196   case ISD::UREM:
3197     DivOpc = is64bit ? AArch64::UDIVXr : AArch64::UDIVWr;
3198     break;
3199   }
3200   unsigned MSubOpc = is64bit ? AArch64::MSUBXrrr : AArch64::MSUBWrrr;
3201   unsigned Src0Reg = getRegForValue(I->getOperand(0));
3202   if (!Src0Reg)
3203     return false;
3204   bool Src0IsKill = hasTrivialKill(I->getOperand(0));
3205
3206   unsigned Src1Reg = getRegForValue(I->getOperand(1));
3207   if (!Src1Reg)
3208     return false;
3209   bool Src1IsKill = hasTrivialKill(I->getOperand(1));
3210
3211   const TargetRegisterClass *RC =
3212       (DestVT == MVT::i64) ? &AArch64::GPR64RegClass : &AArch64::GPR32RegClass;
3213   unsigned QuotReg = FastEmitInst_rr(DivOpc, RC, Src0Reg, /*IsKill=*/false,
3214                                      Src1Reg, /*IsKill=*/false);
3215   assert(QuotReg && "Unexpected DIV instruction emission failure.");
3216   // The remainder is computed as numerator - (quotient * denominator) using the
3217   // MSUB instruction.
3218   unsigned ResultReg = FastEmitInst_rrr(MSubOpc, RC, QuotReg, /*IsKill=*/true,
3219                                         Src1Reg, Src1IsKill, Src0Reg,
3220                                         Src0IsKill);
3221   UpdateValueMap(I, ResultReg);
3222   return true;
3223 }
3224
3225 bool AArch64FastISel::SelectMul(const Instruction *I) {
3226   EVT SrcEVT = TLI.getValueType(I->getOperand(0)->getType(), true);
3227   if (!SrcEVT.isSimple())
3228     return false;
3229   MVT SrcVT = SrcEVT.getSimpleVT();
3230
3231   // Must be simple value type.  Don't handle vectors.
3232   if (SrcVT != MVT::i64 && SrcVT != MVT::i32 && SrcVT != MVT::i16 &&
3233       SrcVT != MVT::i8)
3234     return false;
3235
3236   unsigned Src0Reg = getRegForValue(I->getOperand(0));
3237   if (!Src0Reg)
3238     return false;
3239   bool Src0IsKill = hasTrivialKill(I->getOperand(0));
3240
3241   unsigned Src1Reg = getRegForValue(I->getOperand(1));
3242   if (!Src1Reg)
3243     return false;
3244   bool Src1IsKill = hasTrivialKill(I->getOperand(1));
3245
3246   unsigned ResultReg =
3247     Emit_MUL_rr(SrcVT, Src0Reg, Src0IsKill, Src1Reg, Src1IsKill);
3248
3249   if (!ResultReg)
3250     return false;
3251
3252   UpdateValueMap(I, ResultReg);
3253   return true;
3254 }
3255
3256 bool AArch64FastISel::SelectShift(const Instruction *I) {
3257   MVT RetVT;
3258   if (!isLoadStoreTypeLegal(I->getType(), RetVT))
3259     return false;
3260
3261   if (const auto *C = dyn_cast<ConstantInt>(I->getOperand(1))) {
3262     unsigned ResultReg = 0;
3263     uint64_t ShiftVal = C->getZExtValue();
3264     MVT SrcVT = RetVT;
3265     bool IsZExt = (I->getOpcode() == Instruction::AShr) ? false : true;
3266     const Value * Op0 = I->getOperand(0);
3267     if (const auto *ZExt = dyn_cast<ZExtInst>(Op0)) {
3268       MVT TmpVT;
3269       if (isLoadStoreTypeLegal(ZExt->getSrcTy(), TmpVT)) {
3270         SrcVT = TmpVT;
3271         IsZExt = true;
3272         Op0 = ZExt->getOperand(0);
3273       }
3274     } else if (const auto *SExt = dyn_cast<SExtInst>(Op0)) {
3275       MVT TmpVT;
3276       if (isLoadStoreTypeLegal(SExt->getSrcTy(), TmpVT)) {
3277         SrcVT = TmpVT;
3278         IsZExt = false;
3279         Op0 = SExt->getOperand(0);
3280       }
3281     }
3282
3283     unsigned Op0Reg = getRegForValue(Op0);
3284     if (!Op0Reg)
3285       return false;
3286     bool Op0IsKill = hasTrivialKill(Op0);
3287
3288     switch (I->getOpcode()) {
3289     default: llvm_unreachable("Unexpected instruction.");
3290     case Instruction::Shl:
3291       ResultReg = emitLSL_ri(RetVT, SrcVT, Op0Reg, Op0IsKill, ShiftVal, IsZExt);
3292       break;
3293     case Instruction::AShr:
3294       ResultReg = emitASR_ri(RetVT, SrcVT, Op0Reg, Op0IsKill, ShiftVal, IsZExt);
3295       break;
3296     case Instruction::LShr:
3297       ResultReg = emitLSR_ri(RetVT, SrcVT, Op0Reg, Op0IsKill, ShiftVal, IsZExt);
3298       break;
3299     }
3300     if (!ResultReg)
3301       return false;
3302
3303     UpdateValueMap(I, ResultReg);
3304     return true;
3305   }
3306
3307   unsigned Op0Reg = getRegForValue(I->getOperand(0));
3308   if (!Op0Reg)
3309     return false;
3310   bool Op0IsKill = hasTrivialKill(I->getOperand(0));
3311
3312   unsigned Op1Reg = getRegForValue(I->getOperand(1));
3313   if (!Op1Reg)
3314     return false;
3315   bool Op1IsKill = hasTrivialKill(I->getOperand(1));
3316
3317   unsigned ResultReg = 0;
3318   switch (I->getOpcode()) {
3319   default: llvm_unreachable("Unexpected instruction.");
3320   case Instruction::Shl:
3321     ResultReg = emitLSL_rr(RetVT, Op0Reg, Op0IsKill, Op1Reg, Op1IsKill);
3322     break;
3323   case Instruction::AShr:
3324     ResultReg = emitASR_rr(RetVT, Op0Reg, Op0IsKill, Op1Reg, Op1IsKill);
3325     break;
3326   case Instruction::LShr:
3327     ResultReg = emitLSR_rr(RetVT, Op0Reg, Op0IsKill, Op1Reg, Op1IsKill);
3328     break;
3329   }
3330
3331   if (!ResultReg)
3332     return false;
3333
3334   UpdateValueMap(I, ResultReg);
3335   return true;
3336 }
3337
3338 bool AArch64FastISel::SelectBitCast(const Instruction *I) {
3339   MVT RetVT, SrcVT;
3340
3341   if (!isTypeLegal(I->getOperand(0)->getType(), SrcVT))
3342     return false;
3343   if (!isTypeLegal(I->getType(), RetVT))
3344     return false;
3345
3346   unsigned Opc;
3347   if (RetVT == MVT::f32 && SrcVT == MVT::i32)
3348     Opc = AArch64::FMOVWSr;
3349   else if (RetVT == MVT::f64 && SrcVT == MVT::i64)
3350     Opc = AArch64::FMOVXDr;
3351   else if (RetVT == MVT::i32 && SrcVT == MVT::f32)
3352     Opc = AArch64::FMOVSWr;
3353   else if (RetVT == MVT::i64 && SrcVT == MVT::f64)
3354     Opc = AArch64::FMOVDXr;
3355   else
3356     return false;
3357
3358   const TargetRegisterClass *RC = nullptr;
3359   switch (RetVT.SimpleTy) {
3360   default: llvm_unreachable("Unexpected value type.");
3361   case MVT::i32: RC = &AArch64::GPR32RegClass; break;
3362   case MVT::i64: RC = &AArch64::GPR64RegClass; break;
3363   case MVT::f32: RC = &AArch64::FPR32RegClass; break;
3364   case MVT::f64: RC = &AArch64::FPR64RegClass; break;
3365   }
3366   unsigned Op0Reg = getRegForValue(I->getOperand(0));
3367   if (!Op0Reg)
3368     return false;
3369   bool Op0IsKill = hasTrivialKill(I->getOperand(0));
3370   unsigned ResultReg = FastEmitInst_r(Opc, RC, Op0Reg, Op0IsKill);
3371
3372   if (!ResultReg)
3373     return false;
3374
3375   UpdateValueMap(I, ResultReg);
3376   return true;
3377 }
3378
3379 bool AArch64FastISel::TargetSelectInstruction(const Instruction *I) {
3380   switch (I->getOpcode()) {
3381   default:
3382     break;
3383   case Instruction::Load:
3384     return SelectLoad(I);
3385   case Instruction::Store:
3386     return SelectStore(I);
3387   case Instruction::Br:
3388     return SelectBranch(I);
3389   case Instruction::IndirectBr:
3390     return SelectIndirectBr(I);
3391   case Instruction::FCmp:
3392   case Instruction::ICmp:
3393     return SelectCmp(I);
3394   case Instruction::Select:
3395     return SelectSelect(I);
3396   case Instruction::FPExt:
3397     return SelectFPExt(I);
3398   case Instruction::FPTrunc:
3399     return SelectFPTrunc(I);
3400   case Instruction::FPToSI:
3401     return SelectFPToInt(I, /*Signed=*/true);
3402   case Instruction::FPToUI:
3403     return SelectFPToInt(I, /*Signed=*/false);
3404   case Instruction::SIToFP:
3405     return SelectIntToFP(I, /*Signed=*/true);
3406   case Instruction::UIToFP:
3407     return SelectIntToFP(I, /*Signed=*/false);
3408   case Instruction::SRem:
3409     return SelectRem(I, ISD::SREM);
3410   case Instruction::URem:
3411     return SelectRem(I, ISD::UREM);
3412   case Instruction::Ret:
3413     return SelectRet(I);
3414   case Instruction::Trunc:
3415     return SelectTrunc(I);
3416   case Instruction::ZExt:
3417   case Instruction::SExt:
3418     return SelectIntExt(I);
3419
3420   // FIXME: All of these should really be handled by the target-independent
3421   // selector -> improve FastISel tblgen.
3422   case Instruction::Mul:
3423     return SelectMul(I);
3424   case Instruction::Shl:  // fall-through
3425   case Instruction::LShr: // fall-through
3426   case Instruction::AShr:
3427     return SelectShift(I);
3428   case Instruction::BitCast:
3429     return SelectBitCast(I);
3430   }
3431   return false;
3432   // Silence warnings.
3433   (void)&CC_AArch64_DarwinPCS_VarArg;
3434 }
3435
3436 namespace llvm {
3437 llvm::FastISel *AArch64::createFastISel(FunctionLoweringInfo &funcInfo,
3438                                         const TargetLibraryInfo *libInfo) {
3439   return new AArch64FastISel(funcInfo, libInfo);
3440 }
3441 }