contrib/llvm/lib/Target/AArch64/AArch64ISelLowering.h

   1 //==-- AArch64ISelLowering.h - AArch64 DAG Lowering Interface ----*- C++ -*-==//
   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 interfaces that AArch64 uses to lower LLVM code into a
  11 // selection DAG.
  12 //
  13 //===----------------------------------------------------------------------===//
  14
  15 #ifndef LLVM_LIB_TARGET_AARCH64_AARCH64ISELLOWERING_H
  16 #define LLVM_LIB_TARGET_AARCH64_AARCH64ISELLOWERING_H
  17
  18 #include "AArch64.h"
  19 #include "llvm/CodeGen/CallingConvLower.h"
  20 #include "llvm/CodeGen/SelectionDAG.h"
  21 #include "llvm/IR/CallingConv.h"
  22 #include "llvm/IR/Instruction.h"
  23 #include "llvm/Target/TargetLowering.h"
  24
  25 namespace llvm {
  26
  27 namespace AArch64ISD {
  28
  29 enum NodeType : unsigned {
  30   FIRST_NUMBER = ISD::BUILTIN_OP_END,
  31   WrapperLarge, // 4-instruction MOVZ/MOVK sequence for 64-bit addresses.
  32   CALL,         // Function call.
  33
  34   // Produces the full sequence of instructions for getting the thread pointer
  35   // offset of a variable into X0, using the TLSDesc model.
  36   TLSDESC_CALLSEQ,
  37   ADRP,     // Page address of a TargetGlobalAddress operand.
  38   ADDlow,   // Add the low 12 bits of a TargetGlobalAddress operand.
  39   LOADgot,  // Load from automatically generated descriptor (e.g. Global
  40             // Offset Table, TLS record).
  41   RET_FLAG, // Return with a flag operand. Operand 0 is the chain operand.
  42   BRCOND,   // Conditional branch instruction; "b.cond".
  43   CSEL,
  44   FCSEL, // Conditional move instruction.
  45   CSINV, // Conditional select invert.
  46   CSNEG, // Conditional select negate.
  47   CSINC, // Conditional select increment.
  48
  49   // Pointer to the thread's local storage area. Materialised from TPIDR_EL0 on
  50   // ELF.
  51   THREAD_POINTER,
  52   ADC,
  53   SBC, // adc, sbc instructions
  54
  55   // Arithmetic instructions which write flags.
  56   ADDS,
  57   SUBS,
  58   ADCS,
  59   SBCS,
  60   ANDS,
  61
  62   // Conditional compares. Operands: left,right,falsecc,cc,flags
  63   CCMP,
  64   CCMN,
  65   FCCMP,
  66
  67   // Floating point comparison
  68   FCMP,
  69
  70   // Scalar extract
  71   EXTR,
  72
  73   // Scalar-to-vector duplication
  74   DUP,
  75   DUPLANE8,
  76   DUPLANE16,
  77   DUPLANE32,
  78   DUPLANE64,
  79
  80   // Vector immedate moves
  81   MOVI,
  82   MOVIshift,
  83   MOVIedit,
  84   MOVImsl,
  85   FMOV,
  86   MVNIshift,
  87   MVNImsl,
  88
  89   // Vector immediate ops
  90   BICi,
  91   ORRi,
  92
  93   // Vector bit select: similar to ISD::VSELECT but not all bits within an
  94   // element must be identical.
  95   BSL,
  96
  97   // Vector arithmetic negation
  98   NEG,
  99
 100   // Vector shuffles
 101   ZIP1,
 102   ZIP2,
 103   UZP1,
 104   UZP2,
 105   TRN1,
 106   TRN2,
 107   REV16,
 108   REV32,
 109   REV64,
 110   EXT,
 111
 112   // Vector shift by scalar
 113   VSHL,
 114   VLSHR,
 115   VASHR,
 116
 117   // Vector shift by scalar (again)
 118   SQSHL_I,
 119   UQSHL_I,
 120   SQSHLU_I,
 121   SRSHR_I,
 122   URSHR_I,
 123
 124   // Vector comparisons
 125   CMEQ,
 126   CMGE,
 127   CMGT,
 128   CMHI,
 129   CMHS,
 130   FCMEQ,
 131   FCMGE,
 132   FCMGT,
 133
 134   // Vector zero comparisons
 135   CMEQz,
 136   CMGEz,
 137   CMGTz,
 138   CMLEz,
 139   CMLTz,
 140   FCMEQz,
 141   FCMGEz,
 142   FCMGTz,
 143   FCMLEz,
 144   FCMLTz,
 145
 146   // Vector across-lanes addition
 147   // Only the lower result lane is defined.
 148   SADDV,
 149   UADDV,
 150
 151   // Vector across-lanes min/max
 152   // Only the lower result lane is defined.
 153   SMINV,
 154   UMINV,
 155   SMAXV,
 156   UMAXV,
 157
 158   // Vector bitwise negation
 159   NOT,
 160
 161   // Vector bitwise selection
 162   BIT,
 163
 164   // Compare-and-branch
 165   CBZ,
 166   CBNZ,
 167   TBZ,
 168   TBNZ,
 169
 170   // Tail calls
 171   TC_RETURN,
 172
 173   // Custom prefetch handling
 174   PREFETCH,
 175
 176   // {s|u}int to FP within a FP register.
 177   SITOF,
 178   UITOF,
 179
 180   /// Natural vector cast. ISD::BITCAST is not natural in the big-endian
 181   /// world w.r.t vectors; which causes additional REV instructions to be
 182   /// generated to compensate for the byte-swapping. But sometimes we do
 183   /// need to re-interpret the data in SIMD vector registers in big-endian
 184   /// mode without emitting such REV instructions.
 185   NVCAST,
 186
 187   SMULL,
 188   UMULL,
 189
 190   // Reciprocal estimates and steps.
 191   FRECPE, FRECPS,
 192   FRSQRTE, FRSQRTS,
 193
 194   // NEON Load/Store with post-increment base updates
 195   LD2post = ISD::FIRST_TARGET_MEMORY_OPCODE,
 196   LD3post,
 197   LD4post,
 198   ST2post,
 199   ST3post,
 200   ST4post,
 201   LD1x2post,
 202   LD1x3post,
 203   LD1x4post,
 204   ST1x2post,
 205   ST1x3post,
 206   ST1x4post,
 207   LD1DUPpost,
 208   LD2DUPpost,
 209   LD3DUPpost,
 210   LD4DUPpost,
 211   LD1LANEpost,
 212   LD2LANEpost,
 213   LD3LANEpost,
 214   LD4LANEpost,
 215   ST2LANEpost,
 216   ST3LANEpost,
 217   ST4LANEpost
 218 };
 219
 220 } // end namespace AArch64ISD
 221
 222 namespace {
 223
 224 // Any instruction that defines a 32-bit result zeros out the high half of the
 225 // register. Truncate can be lowered to EXTRACT_SUBREG. CopyFromReg may
 226 // be copying from a truncate. But any other 32-bit operation will zero-extend
 227 // up to 64 bits.
 228 // FIXME: X86 also checks for CMOV here. Do we need something similar?
 229 static inline bool isDef32(const SDNode &N) {
 230   unsigned Opc = N.getOpcode();
 231   return Opc != ISD::TRUNCATE && Opc != TargetOpcode::EXTRACT_SUBREG &&
 232          Opc != ISD::CopyFromReg;
 233 }
 234
 235 } // end anonymous namespace
 236
 237 class AArch64Subtarget;
 238 class AArch64TargetMachine;
 239
 240 class AArch64TargetLowering : public TargetLowering {
 241 public:
 242   explicit AArch64TargetLowering(const TargetMachine &TM,
 243                                  const AArch64Subtarget &STI);
 244
 245   /// Selects the correct CCAssignFn for a given CallingConvention value.
 246   CCAssignFn *CCAssignFnForCall(CallingConv::ID CC, bool IsVarArg) const;
 247
 248   /// Selects the correct CCAssignFn for a given CallingConvention value.
 249   CCAssignFn *CCAssignFnForReturn(CallingConv::ID CC) const;
 250
 251   /// Determine which of the bits specified in Mask are known to be either zero
 252   /// or one and return them in the KnownZero/KnownOne bitsets.
 253   void computeKnownBitsForTargetNode(const SDValue Op, APInt &KnownZero,
 254                                      APInt &KnownOne, const APInt &DemandedElts,
 255                                      const SelectionDAG &DAG,
 256                                      unsigned Depth = 0) const override;
 257
 258   MVT getScalarShiftAmountTy(const DataLayout &DL, EVT) const override;
 259
 260   /// Returns true if the target allows unaligned memory accesses of the
 261   /// specified type.
 262   bool allowsMisalignedMemoryAccesses(EVT VT, unsigned AddrSpace = 0,
 263                                       unsigned Align = 1,
 264                                       bool *Fast = nullptr) const override;
 265
 266   /// Provide custom lowering hooks for some operations.
 267   SDValue LowerOperation(SDValue Op, SelectionDAG &DAG) const override;
 268
 269   const char *getTargetNodeName(unsigned Opcode) const override;
 270
 271   SDValue PerformDAGCombine(SDNode *N, DAGCombinerInfo &DCI) const override;
 272
 273   /// Returns true if a cast between SrcAS and DestAS is a noop.
 274   bool isNoopAddrSpaceCast(unsigned SrcAS, unsigned DestAS) const override {
 275     // Addrspacecasts are always noops.
 276     return true;
 277   }
 278
 279   /// This method returns a target specific FastISel object, or null if the
 280   /// target does not support "fast" ISel.
 281   FastISel *createFastISel(FunctionLoweringInfo &funcInfo,
 282                            const TargetLibraryInfo *libInfo) const override;
 283
 284   bool isOffsetFoldingLegal(const GlobalAddressSDNode *GA) const override;
 285
 286   bool isFPImmLegal(const APFloat &Imm, EVT VT) const override;
 287
 288   /// Return true if the given shuffle mask can be codegen'd directly, or if it
 289   /// should be stack expanded.
 290   bool isShuffleMaskLegal(const SmallVectorImpl<int> &M, EVT VT) const override;
 291
 292   /// Return the ISD::SETCC ValueType.
 293   EVT getSetCCResultType(const DataLayout &DL, LLVMContext &Context,
 294                          EVT VT) const override;
 295
 296   SDValue ReconstructShuffle(SDValue Op, SelectionDAG &DAG) const;
 297
 298   MachineBasicBlock *EmitF128CSEL(MachineInstr &MI,
 299                                   MachineBasicBlock *BB) const;
 300
 301   MachineBasicBlock *
 302   EmitInstrWithCustomInserter(MachineInstr &MI,
 303                               MachineBasicBlock *MBB) const override;
 304
 305   bool getTgtMemIntrinsic(IntrinsicInfo &Info, const CallInst &I,
 306                           unsigned Intrinsic) const override;
 307
 308   bool isTruncateFree(Type *Ty1, Type *Ty2) const override;
 309   bool isTruncateFree(EVT VT1, EVT VT2) const override;
 310
 311   bool isProfitableToHoist(Instruction *I) const override;
 312
 313   bool isZExtFree(Type *Ty1, Type *Ty2) const override;
 314   bool isZExtFree(EVT VT1, EVT VT2) const override;
 315   bool isZExtFree(SDValue Val, EVT VT2) const override;
 316
 317   bool hasPairedLoad(EVT LoadedType, unsigned &RequiredAligment) const override;
 318
 319   unsigned getMaxSupportedInterleaveFactor() const override { return 4; }
 320
 321   bool lowerInterleavedLoad(LoadInst *LI,
 322                             ArrayRef<ShuffleVectorInst *> Shuffles,
 323                             ArrayRef<unsigned> Indices,
 324                             unsigned Factor) const override;
 325   bool lowerInterleavedStore(StoreInst *SI, ShuffleVectorInst *SVI,
 326                              unsigned Factor) const override;
 327
 328   bool isLegalAddImmediate(int64_t) const override;
 329   bool isLegalICmpImmediate(int64_t) const override;
 330
 331   EVT getOptimalMemOpType(uint64_t Size, unsigned DstAlign, unsigned SrcAlign,
 332                           bool IsMemset, bool ZeroMemset, bool MemcpyStrSrc,
 333                           MachineFunction &MF) const override;
 334
 335   /// Return true if the addressing mode represented by AM is legal for this
 336   /// target, for a load/store of the specified type.
 337   bool isLegalAddressingMode(const DataLayout &DL, const AddrMode &AM, Type *Ty,
 338                              unsigned AS) const override;
 339
 340   /// \brief Return the cost of the scaling factor used in the addressing
 341   /// mode represented by AM for this target, for a load/store
 342   /// of the specified type.
 343   /// If the AM is supported, the return value must be >= 0.
 344   /// If the AM is not supported, it returns a negative value.
 345   int getScalingFactorCost(const DataLayout &DL, const AddrMode &AM, Type *Ty,
 346                            unsigned AS) const override;
 347
 348   /// Return true if an FMA operation is faster than a pair of fmul and fadd
 349   /// instructions. fmuladd intrinsics will be expanded to FMAs when this method
 350   /// returns true, otherwise fmuladd is expanded to fmul + fadd.
 351   bool isFMAFasterThanFMulAndFAdd(EVT VT) const override;
 352
 353   const MCPhysReg *getScratchRegisters(CallingConv::ID CC) const override;
 354
 355   /// \brief Returns false if N is a bit extraction pattern of (X >> C) & Mask.
 356   bool isDesirableToCommuteWithShift(const SDNode *N) const override;
 357
 358   /// \brief Returns true if it is beneficial to convert a load of a constant
 359   /// to just the constant itself.
 360   bool shouldConvertConstantLoadToIntImm(const APInt &Imm,
 361                                          Type *Ty) const override;
 362
 363   Value *emitLoadLinked(IRBuilder<> &Builder, Value *Addr,
 364                         AtomicOrdering Ord) const override;
 365   Value *emitStoreConditional(IRBuilder<> &Builder, Value *Val,
 366                               Value *Addr, AtomicOrdering Ord) const override;
 367
 368   void emitAtomicCmpXchgNoStoreLLBalance(IRBuilder<> &Builder) const override;
 369
 370   TargetLoweringBase::AtomicExpansionKind
 371   shouldExpandAtomicLoadInIR(LoadInst *LI) const override;
 372   bool shouldExpandAtomicStoreInIR(StoreInst *SI) const override;
 373   TargetLoweringBase::AtomicExpansionKind
 374   shouldExpandAtomicRMWInIR(AtomicRMWInst *AI) const override;
 375
 376   bool shouldExpandAtomicCmpXchgInIR(AtomicCmpXchgInst *AI) const override;
 377
 378   bool useLoadStackGuardNode() const override;
 379   TargetLoweringBase::LegalizeTypeAction
 380   getPreferredVectorAction(EVT VT) const override;
 381
 382   /// If the target has a standard location for the stack protector cookie,
 383   /// returns the address of that location. Otherwise, returns nullptr.
 384   Value *getIRStackGuard(IRBuilder<> &IRB) const override;
 385
 386   /// If the target has a standard location for the unsafe stack pointer,
 387   /// returns the address of that location. Otherwise, returns nullptr.
 388   Value *getSafeStackPointerLocation(IRBuilder<> &IRB) const override;
 389
 390   /// If a physical register, this returns the register that receives the
 391   /// exception address on entry to an EH pad.
 392   unsigned
 393   getExceptionPointerRegister(const Constant *PersonalityFn) const override {
 394     // FIXME: This is a guess. Has this been defined yet?
 395     return AArch64::X0;
 396   }
 397
 398   /// If a physical register, this returns the register that receives the
 399   /// exception typeid on entry to a landing pad.
 400   unsigned
 401   getExceptionSelectorRegister(const Constant *PersonalityFn) const override {
 402     // FIXME: This is a guess. Has this been defined yet?
 403     return AArch64::X1;
 404   }
 405
 406   bool isIntDivCheap(EVT VT, AttributeList Attr) const override;
 407
 408   bool isCheapToSpeculateCttz() const override {
 409     return true;
 410   }
 411
 412   bool isCheapToSpeculateCtlz() const override {
 413     return true;
 414   }
 415
 416   bool isMaskAndCmp0FoldingBeneficial(const Instruction &AndI) const override;
 417
 418   bool hasAndNotCompare(SDValue) const override {
 419     // 'bics'
 420     return true;
 421   }
 422
 423   bool hasBitPreservingFPLogic(EVT VT) const override {
 424     // FIXME: Is this always true? It should be true for vectors at least.
 425     return VT == MVT::f32 || VT == MVT::f64;
 426   }
 427
 428   bool supportSplitCSR(MachineFunction *MF) const override {
 429     return MF->getFunction()->getCallingConv() == CallingConv::CXX_FAST_TLS &&
 430            MF->getFunction()->hasFnAttribute(Attribute::NoUnwind);
 431   }
 432   void initializeSplitCSR(MachineBasicBlock *Entry) const override;
 433   void insertCopiesSplitCSR(
 434       MachineBasicBlock *Entry,
 435       const SmallVectorImpl<MachineBasicBlock *> &Exits) const override;
 436
 437   bool supportSwiftError() const override {
 438     return true;
 439   }
 440
 441   /// Returns the size of the platform's va_list object.
 442   unsigned getVaListSizeInBits(const DataLayout &DL) const override;
 443
 444   /// Returns true if \p VecTy is a legal interleaved access type. This
 445   /// function checks the vector element type and the overall width of the
 446   /// vector.
 447   bool isLegalInterleavedAccessType(VectorType *VecTy,
 448                                     const DataLayout &DL) const;
 449
 450   /// Returns the number of interleaved accesses that will be generated when
 451   /// lowering accesses of the given type.
 452   unsigned getNumInterleavedAccesses(VectorType *VecTy,
 453                                      const DataLayout &DL) const;
 454
 455 private:
 456   bool isExtFreeImpl(const Instruction *Ext) const override;
 457
 458   /// Keep a pointer to the AArch64Subtarget around so that we can
 459   /// make the right decision when generating code for different targets.
 460   const AArch64Subtarget *Subtarget;
 461
 462   void addTypeForNEON(MVT VT, MVT PromotedBitwiseVT);
 463   void addDRTypeForNEON(MVT VT);
 464   void addQRTypeForNEON(MVT VT);
 465
 466   SDValue LowerFormalArguments(SDValue Chain, CallingConv::ID CallConv,
 467                                bool isVarArg,
 468                                const SmallVectorImpl<ISD::InputArg> &Ins,
 469                                const SDLoc &DL, SelectionDAG &DAG,
 470                                SmallVectorImpl<SDValue> &InVals) const override;
 471
 472   SDValue LowerCall(CallLoweringInfo & /*CLI*/,
 473                     SmallVectorImpl<SDValue> &InVals) const override;
 474
 475   SDValue LowerCallResult(SDValue Chain, SDValue InFlag,
 476                           CallingConv::ID CallConv, bool isVarArg,
 477                           const SmallVectorImpl<ISD::InputArg> &Ins,
 478                           const SDLoc &DL, SelectionDAG &DAG,
 479                           SmallVectorImpl<SDValue> &InVals, bool isThisReturn,
 480                           SDValue ThisVal) const;
 481
 482   SDValue LowerINTRINSIC_WO_CHAIN(SDValue Op, SelectionDAG &DAG) const;
 483
 484   bool isEligibleForTailCallOptimization(
 485       SDValue Callee, CallingConv::ID CalleeCC, bool isVarArg,
 486       const SmallVectorImpl<ISD::OutputArg> &Outs,
 487       const SmallVectorImpl<SDValue> &OutVals,
 488       const SmallVectorImpl<ISD::InputArg> &Ins, SelectionDAG &DAG) const;
 489
 490   /// Finds the incoming stack arguments which overlap the given fixed stack
 491   /// object and incorporates their load into the current chain. This prevents
 492   /// an upcoming store from clobbering the stack argument before it's used.
 493   SDValue addTokenForArgument(SDValue Chain, SelectionDAG &DAG,
 494                               MachineFrameInfo &MFI, int ClobberedFI) const;
 495
 496   bool DoesCalleeRestoreStack(CallingConv::ID CallCC, bool TailCallOpt) const;
 497
 498   void saveVarArgRegisters(CCState &CCInfo, SelectionDAG &DAG, const SDLoc &DL,
 499                            SDValue &Chain) const;
 500
 501   bool CanLowerReturn(CallingConv::ID CallConv, MachineFunction &MF,
 502                       bool isVarArg,
 503                       const SmallVectorImpl<ISD::OutputArg> &Outs,
 504                       LLVMContext &Context) const override;
 505
 506   SDValue LowerReturn(SDValue Chain, CallingConv::ID CallConv, bool isVarArg,
 507                       const SmallVectorImpl<ISD::OutputArg> &Outs,
 508                       const SmallVectorImpl<SDValue> &OutVals, const SDLoc &DL,
 509                       SelectionDAG &DAG) const override;
 510
 511   SDValue LowerGlobalAddress(SDValue Op, SelectionDAG &DAG) const;
 512   SDValue LowerGlobalTLSAddress(SDValue Op, SelectionDAG &DAG) const;
 513   SDValue LowerDarwinGlobalTLSAddress(SDValue Op, SelectionDAG &DAG) const;
 514   SDValue LowerELFGlobalTLSAddress(SDValue Op, SelectionDAG &DAG) const;
 515   SDValue LowerELFTLSDescCallSeq(SDValue SymAddr, const SDLoc &DL,
 516                                  SelectionDAG &DAG) const;
 517   SDValue LowerSETCC(SDValue Op, SelectionDAG &DAG) const;
 518   SDValue LowerBR_CC(SDValue Op, SelectionDAG &DAG) const;
 519   SDValue LowerSELECT(SDValue Op, SelectionDAG &DAG) const;
 520   SDValue LowerSELECT_CC(SDValue Op, SelectionDAG &DAG) const;
 521   SDValue LowerSELECT_CC(ISD::CondCode CC, SDValue LHS, SDValue RHS,
 522                          SDValue TVal, SDValue FVal, const SDLoc &dl,
 523                          SelectionDAG &DAG) const;
 524   SDValue LowerJumpTable(SDValue Op, SelectionDAG &DAG) const;
 525   SDValue LowerConstantPool(SDValue Op, SelectionDAG &DAG) const;
 526   SDValue LowerBlockAddress(SDValue Op, SelectionDAG &DAG) const;
 527   SDValue LowerAAPCS_VASTART(SDValue Op, SelectionDAG &DAG) const;
 528   SDValue LowerDarwin_VASTART(SDValue Op, SelectionDAG &DAG) const;
 529   SDValue LowerVASTART(SDValue Op, SelectionDAG &DAG) const;
 530   SDValue LowerVACOPY(SDValue Op, SelectionDAG &DAG) const;
 531   SDValue LowerVAARG(SDValue Op, SelectionDAG &DAG) const;
 532   SDValue LowerFRAMEADDR(SDValue Op, SelectionDAG &DAG) const;
 533   SDValue LowerRETURNADDR(SDValue Op, SelectionDAG &DAG) const;
 534   SDValue LowerINSERT_VECTOR_ELT(SDValue Op, SelectionDAG &DAG) const;
 535   SDValue LowerEXTRACT_VECTOR_ELT(SDValue Op, SelectionDAG &DAG) const;
 536   SDValue LowerSCALAR_TO_VECTOR(SDValue Op, SelectionDAG &DAG) const;
 537   SDValue LowerBUILD_VECTOR(SDValue Op, SelectionDAG &DAG) const;
 538   SDValue LowerVECTOR_SHUFFLE(SDValue Op, SelectionDAG &DAG) const;
 539   SDValue LowerEXTRACT_SUBVECTOR(SDValue Op, SelectionDAG &DAG) const;
 540   SDValue LowerVectorSRA_SRL_SHL(SDValue Op, SelectionDAG &DAG) const;
 541   SDValue LowerShiftLeftParts(SDValue Op, SelectionDAG &DAG) const;
 542   SDValue LowerShiftRightParts(SDValue Op, SelectionDAG &DAG) const;
 543   SDValue LowerVSETCC(SDValue Op, SelectionDAG &DAG) const;
 544   SDValue LowerCTPOP(SDValue Op, SelectionDAG &DAG) const;
 545   SDValue LowerF128Call(SDValue Op, SelectionDAG &DAG,
 546                         RTLIB::Libcall Call) const;
 547   SDValue LowerFCOPYSIGN(SDValue Op, SelectionDAG &DAG) const;
 548   SDValue LowerFP_EXTEND(SDValue Op, SelectionDAG &DAG) const;
 549   SDValue LowerFP_ROUND(SDValue Op, SelectionDAG &DAG) const;
 550   SDValue LowerFP_TO_INT(SDValue Op, SelectionDAG &DAG) const;
 551   SDValue LowerINT_TO_FP(SDValue Op, SelectionDAG &DAG) const;
 552   SDValue LowerVectorAND(SDValue Op, SelectionDAG &DAG) const;
 553   SDValue LowerVectorOR(SDValue Op, SelectionDAG &DAG) const;
 554   SDValue LowerCONCAT_VECTORS(SDValue Op, SelectionDAG &DAG) const;
 555   SDValue LowerFSINCOS(SDValue Op, SelectionDAG &DAG) const;
 556
 557   SDValue BuildSDIVPow2(SDNode *N, const APInt &Divisor, SelectionDAG &DAG,
 558                         std::vector<SDNode *> *Created) const override;
 559   SDValue getSqrtEstimate(SDValue Operand, SelectionDAG &DAG, int Enabled,
 560                           int &ExtraSteps, bool &UseOneConst,
 561                           bool Reciprocal) const override;
 562   SDValue getRecipEstimate(SDValue Operand, SelectionDAG &DAG, int Enabled,
 563                            int &ExtraSteps) const override;
 564   unsigned combineRepeatedFPDivisors() const override;
 565
 566   ConstraintType getConstraintType(StringRef Constraint) const override;
 567   unsigned getRegisterByName(const char* RegName, EVT VT,
 568                              SelectionDAG &DAG) const override;
 569
 570   /// Examine constraint string and operand type and determine a weight value.
 571   /// The operand object must already have been set up with the operand type.
 572   ConstraintWeight
 573   getSingleConstraintMatchWeight(AsmOperandInfo &info,
 574                                  const char *constraint) const override;
 575
 576   std::pair<unsigned, const TargetRegisterClass *>
 577   getRegForInlineAsmConstraint(const TargetRegisterInfo *TRI,
 578                                StringRef Constraint, MVT VT) const override;
 579
 580   const char *LowerXConstraint(EVT ConstraintVT) const override;
 581
 582   void LowerAsmOperandForConstraint(SDValue Op, std::string &Constraint,
 583                                     std::vector<SDValue> &Ops,
 584                                     SelectionDAG &DAG) const override;
 585
 586   unsigned getInlineAsmMemConstraint(StringRef ConstraintCode) const override {
 587     if (ConstraintCode == "Q")
 588       return InlineAsm::Constraint_Q;
 589     // FIXME: clang has code for 'Ump', 'Utf', 'Usa', and 'Ush' but these are
 590     //        followed by llvm_unreachable so we'll leave them unimplemented in
 591     //        the backend for now.
 592     return TargetLowering::getInlineAsmMemConstraint(ConstraintCode);
 593   }
 594
 595   bool isUsedByReturnOnly(SDNode *N, SDValue &Chain) const override;
 596   bool mayBeEmittedAsTailCall(const CallInst *CI) const override;
 597   bool getIndexedAddressParts(SDNode *Op, SDValue &Base, SDValue &Offset,
 598                               ISD::MemIndexedMode &AM, bool &IsInc,
 599                               SelectionDAG &DAG) const;
 600   bool getPreIndexedAddressParts(SDNode *N, SDValue &Base, SDValue &Offset,
 601                                  ISD::MemIndexedMode &AM,
 602                                  SelectionDAG &DAG) const override;
 603   bool getPostIndexedAddressParts(SDNode *N, SDNode *Op, SDValue &Base,
 604                                   SDValue &Offset, ISD::MemIndexedMode &AM,
 605                                   SelectionDAG &DAG) const override;
 606
 607   void ReplaceNodeResults(SDNode *N, SmallVectorImpl<SDValue> &Results,
 608                           SelectionDAG &DAG) const override;
 609
 610   bool functionArgumentNeedsConsecutiveRegisters(Type *Ty,
 611                                                  CallingConv::ID CallConv,
 612                                                  bool isVarArg) const override;
 613
 614   bool shouldNormalizeToSelectSequence(LLVMContext &, EVT) const override;
 615 };
 616
 617 namespace AArch64 {
 618 FastISel *createFastISel(FunctionLoweringInfo &funcInfo,
 619                          const TargetLibraryInfo *libInfo);
 620 } // end namespace AArch64
 621
 622 } // end namespace llvm
 623
 624 #endif