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   // NEON Load/Store with post-increment base updates
 191   LD2post = ISD::FIRST_TARGET_MEMORY_OPCODE,
 192   LD3post,
 193   LD4post,
 194   ST2post,
 195   ST3post,
 196   ST4post,
 197   LD1x2post,
 198   LD1x3post,
 199   LD1x4post,
 200   ST1x2post,
 201   ST1x3post,
 202   ST1x4post,
 203   LD1DUPpost,
 204   LD2DUPpost,
 205   LD3DUPpost,
 206   LD4DUPpost,
 207   LD1LANEpost,
 208   LD2LANEpost,
 209   LD3LANEpost,
 210   LD4LANEpost,
 211   ST2LANEpost,
 212   ST3LANEpost,
 213   ST4LANEpost
 214 };
 215
 216 } // end namespace AArch64ISD
 217
 218 class AArch64Subtarget;
 219 class AArch64TargetMachine;
 220
 221 class AArch64TargetLowering : public TargetLowering {
 222 public:
 223   explicit AArch64TargetLowering(const TargetMachine &TM,
 224                                  const AArch64Subtarget &STI);
 225
 226   /// Selects the correct CCAssignFn for a given CallingConvention value.
 227   CCAssignFn *CCAssignFnForCall(CallingConv::ID CC, bool IsVarArg) const;
 228
 229   /// Determine which of the bits specified in Mask are known to be either zero
 230   /// or one and return them in the KnownZero/KnownOne bitsets.
 231   void computeKnownBitsForTargetNode(const SDValue Op, APInt &KnownZero,
 232                                      APInt &KnownOne, const SelectionDAG &DAG,
 233                                      unsigned Depth = 0) const override;
 234
 235   MVT getScalarShiftAmountTy(const DataLayout &DL, EVT) const override;
 236
 237   /// Returns true if the target allows unaligned memory accesses of the
 238   /// specified type.
 239   bool allowsMisalignedMemoryAccesses(EVT VT, unsigned AddrSpace = 0,
 240                                       unsigned Align = 1,
 241                                       bool *Fast = nullptr) const override;
 242
 243   /// Provide custom lowering hooks for some operations.
 244   SDValue LowerOperation(SDValue Op, SelectionDAG &DAG) const override;
 245
 246   const char *getTargetNodeName(unsigned Opcode) const override;
 247
 248   SDValue PerformDAGCombine(SDNode *N, DAGCombinerInfo &DCI) const override;
 249
 250   /// Return the Log2 alignment of this function.
 251   unsigned getFunctionAlignment(const Function *F) const;
 252
 253   /// Returns true if a cast between SrcAS and DestAS is a noop.
 254   bool isNoopAddrSpaceCast(unsigned SrcAS, unsigned DestAS) const override {
 255     // Addrspacecasts are always noops.
 256     return true;
 257   }
 258
 259   /// This method returns a target specific FastISel object, or null if the
 260   /// target does not support "fast" ISel.
 261   FastISel *createFastISel(FunctionLoweringInfo &funcInfo,
 262                            const TargetLibraryInfo *libInfo) const override;
 263
 264   bool isOffsetFoldingLegal(const GlobalAddressSDNode *GA) const override;
 265
 266   bool isFPImmLegal(const APFloat &Imm, EVT VT) const override;
 267
 268   /// Return true if the given shuffle mask can be codegen'd directly, or if it
 269   /// should be stack expanded.
 270   bool isShuffleMaskLegal(const SmallVectorImpl<int> &M, EVT VT) const override;
 271
 272   /// Return the ISD::SETCC ValueType.
 273   EVT getSetCCResultType(const DataLayout &DL, LLVMContext &Context,
 274                          EVT VT) const override;
 275
 276   SDValue ReconstructShuffle(SDValue Op, SelectionDAG &DAG) const;
 277
 278   MachineBasicBlock *EmitF128CSEL(MachineInstr *MI,
 279                                   MachineBasicBlock *BB) const;
 280
 281   MachineBasicBlock *
 282   EmitInstrWithCustomInserter(MachineInstr *MI,
 283                               MachineBasicBlock *MBB) const override;
 284
 285   bool getTgtMemIntrinsic(IntrinsicInfo &Info, const CallInst &I,
 286                           unsigned Intrinsic) const override;
 287
 288   bool isTruncateFree(Type *Ty1, Type *Ty2) const override;
 289   bool isTruncateFree(EVT VT1, EVT VT2) const override;
 290
 291   bool isProfitableToHoist(Instruction *I) const override;
 292
 293   bool isZExtFree(Type *Ty1, Type *Ty2) const override;
 294   bool isZExtFree(EVT VT1, EVT VT2) const override;
 295   bool isZExtFree(SDValue Val, EVT VT2) const override;
 296
 297   bool hasPairedLoad(Type *LoadedType,
 298                      unsigned &RequiredAligment) const override;
 299   bool hasPairedLoad(EVT LoadedType, unsigned &RequiredAligment) const override;
 300
 301   unsigned getMaxSupportedInterleaveFactor() const override { return 4; }
 302
 303   bool lowerInterleavedLoad(LoadInst *LI,
 304                             ArrayRef<ShuffleVectorInst *> Shuffles,
 305                             ArrayRef<unsigned> Indices,
 306                             unsigned Factor) const override;
 307   bool lowerInterleavedStore(StoreInst *SI, ShuffleVectorInst *SVI,
 308                              unsigned Factor) const override;
 309
 310   bool isLegalAddImmediate(int64_t) const override;
 311   bool isLegalICmpImmediate(int64_t) const override;
 312
 313   EVT getOptimalMemOpType(uint64_t Size, unsigned DstAlign, unsigned SrcAlign,
 314                           bool IsMemset, bool ZeroMemset, bool MemcpyStrSrc,
 315                           MachineFunction &MF) const override;
 316
 317   /// Return true if the addressing mode represented by AM is legal for this
 318   /// target, for a load/store of the specified type.
 319   bool isLegalAddressingMode(const DataLayout &DL, const AddrMode &AM, Type *Ty,
 320                              unsigned AS) const override;
 321
 322   /// \brief Return the cost of the scaling factor used in the addressing
 323   /// mode represented by AM for this target, for a load/store
 324   /// of the specified type.
 325   /// If the AM is supported, the return value must be >= 0.
 326   /// If the AM is not supported, it returns a negative value.
 327   int getScalingFactorCost(const DataLayout &DL, const AddrMode &AM, Type *Ty,
 328                            unsigned AS) const override;
 329
 330   /// Return true if an FMA operation is faster than a pair of fmul and fadd
 331   /// instructions. fmuladd intrinsics will be expanded to FMAs when this method
 332   /// returns true, otherwise fmuladd is expanded to fmul + fadd.
 333   bool isFMAFasterThanFMulAndFAdd(EVT VT) const override;
 334
 335   const MCPhysReg *getScratchRegisters(CallingConv::ID CC) const override;
 336
 337   /// \brief Returns false if N is a bit extraction pattern of (X >> C) & Mask.
 338   bool isDesirableToCommuteWithShift(const SDNode *N) const override;
 339
 340   /// \brief Returns true if it is beneficial to convert a load of a constant
 341   /// to just the constant itself.
 342   bool shouldConvertConstantLoadToIntImm(const APInt &Imm,
 343                                          Type *Ty) const override;
 344
 345   Value *emitLoadLinked(IRBuilder<> &Builder, Value *Addr,
 346                         AtomicOrdering Ord) const override;
 347   Value *emitStoreConditional(IRBuilder<> &Builder, Value *Val,
 348                               Value *Addr, AtomicOrdering Ord) const override;
 349
 350   void emitAtomicCmpXchgNoStoreLLBalance(IRBuilder<> &Builder) const override;
 351
 352   TargetLoweringBase::AtomicExpansionKind
 353   shouldExpandAtomicLoadInIR(LoadInst *LI) const override;
 354   bool shouldExpandAtomicStoreInIR(StoreInst *SI) const override;
 355   TargetLoweringBase::AtomicExpansionKind
 356   shouldExpandAtomicRMWInIR(AtomicRMWInst *AI) const override;
 357
 358   bool shouldExpandAtomicCmpXchgInIR(AtomicCmpXchgInst *AI) const override;
 359
 360   bool useLoadStackGuardNode() const override;
 361   TargetLoweringBase::LegalizeTypeAction
 362   getPreferredVectorAction(EVT VT) const override;
 363
 364   /// If the target has a standard location for the unsafe stack pointer,
 365   /// returns the address of that location. Otherwise, returns nullptr.
 366   Value *getSafeStackPointerLocation(IRBuilder<> &IRB) const override;
 367
 368   /// If a physical register, this returns the register that receives the
 369   /// exception address on entry to an EH pad.
 370   unsigned
 371   getExceptionPointerRegister(const Constant *PersonalityFn) const override {
 372     // FIXME: This is a guess. Has this been defined yet?
 373     return AArch64::X0;
 374   }
 375
 376   /// If a physical register, this returns the register that receives the
 377   /// exception typeid on entry to a landing pad.
 378   unsigned
 379   getExceptionSelectorRegister(const Constant *PersonalityFn) const override {
 380     // FIXME: This is a guess. Has this been defined yet?
 381     return AArch64::X1;
 382   }
 383
 384 private:
 385   bool isExtFreeImpl(const Instruction *Ext) const override;
 386
 387   /// Keep a pointer to the AArch64Subtarget around so that we can
 388   /// make the right decision when generating code for different targets.
 389   const AArch64Subtarget *Subtarget;
 390
 391   void addTypeForNEON(EVT VT, EVT PromotedBitwiseVT);
 392   void addDRTypeForNEON(MVT VT);
 393   void addQRTypeForNEON(MVT VT);
 394
 395   SDValue
 396   LowerFormalArguments(SDValue Chain, CallingConv::ID CallConv, bool isVarArg,
 397                        const SmallVectorImpl<ISD::InputArg> &Ins, SDLoc DL,
 398                        SelectionDAG &DAG,
 399                        SmallVectorImpl<SDValue> &InVals) const override;
 400
 401   SDValue LowerCall(CallLoweringInfo & /*CLI*/,
 402                     SmallVectorImpl<SDValue> &InVals) const override;
 403
 404   SDValue LowerCallResult(SDValue Chain, SDValue InFlag,
 405                           CallingConv::ID CallConv, bool isVarArg,
 406                           const SmallVectorImpl<ISD::InputArg> &Ins, SDLoc DL,
 407                           SelectionDAG &DAG, SmallVectorImpl<SDValue> &InVals,
 408                           bool isThisReturn, SDValue ThisVal) const;
 409
 410   SDValue LowerINTRINSIC_WO_CHAIN(SDValue Op, SelectionDAG &DAG) const;
 411
 412   bool isEligibleForTailCallOptimization(
 413       SDValue Callee, CallingConv::ID CalleeCC, bool isVarArg,
 414       bool isCalleeStructRet, bool isCallerStructRet,
 415       const SmallVectorImpl<ISD::OutputArg> &Outs,
 416       const SmallVectorImpl<SDValue> &OutVals,
 417       const SmallVectorImpl<ISD::InputArg> &Ins, SelectionDAG &DAG) const;
 418
 419   /// Finds the incoming stack arguments which overlap the given fixed stack
 420   /// object and incorporates their load into the current chain. This prevents
 421   /// an upcoming store from clobbering the stack argument before it's used.
 422   SDValue addTokenForArgument(SDValue Chain, SelectionDAG &DAG,
 423                               MachineFrameInfo *MFI, int ClobberedFI) const;
 424
 425   bool DoesCalleeRestoreStack(CallingConv::ID CallCC, bool TailCallOpt) const;
 426
 427   bool IsTailCallConvention(CallingConv::ID CallCC) const;
 428
 429   void saveVarArgRegisters(CCState &CCInfo, SelectionDAG &DAG, SDLoc DL,
 430                            SDValue &Chain) const;
 431
 432   bool CanLowerReturn(CallingConv::ID CallConv, MachineFunction &MF,
 433                       bool isVarArg,
 434                       const SmallVectorImpl<ISD::OutputArg> &Outs,
 435                       LLVMContext &Context) const override;
 436
 437   SDValue LowerReturn(SDValue Chain, CallingConv::ID CallConv, bool isVarArg,
 438                       const SmallVectorImpl<ISD::OutputArg> &Outs,
 439                       const SmallVectorImpl<SDValue> &OutVals, SDLoc DL,
 440                       SelectionDAG &DAG) const override;
 441
 442   SDValue LowerGlobalAddress(SDValue Op, SelectionDAG &DAG) const;
 443   SDValue LowerGlobalTLSAddress(SDValue Op, SelectionDAG &DAG) const;
 444   SDValue LowerDarwinGlobalTLSAddress(SDValue Op, SelectionDAG &DAG) const;
 445   SDValue LowerELFGlobalTLSAddress(SDValue Op, SelectionDAG &DAG) const;
 446   SDValue LowerELFTLSDescCallSeq(SDValue SymAddr, SDLoc DL,
 447                                  SelectionDAG &DAG) const;
 448   SDValue LowerSETCC(SDValue Op, SelectionDAG &DAG) const;
 449   SDValue LowerBR_CC(SDValue Op, SelectionDAG &DAG) const;
 450   SDValue LowerSELECT(SDValue Op, SelectionDAG &DAG) const;
 451   SDValue LowerSELECT_CC(SDValue Op, SelectionDAG &DAG) const;
 452   SDValue LowerSELECT_CC(ISD::CondCode CC, SDValue LHS, SDValue RHS,
 453                          SDValue TVal, SDValue FVal, SDLoc dl,
 454                          SelectionDAG &DAG) const;
 455   SDValue LowerJumpTable(SDValue Op, SelectionDAG &DAG) const;
 456   SDValue LowerConstantPool(SDValue Op, SelectionDAG &DAG) const;
 457   SDValue LowerBlockAddress(SDValue Op, SelectionDAG &DAG) const;
 458   SDValue LowerAAPCS_VASTART(SDValue Op, SelectionDAG &DAG) const;
 459   SDValue LowerDarwin_VASTART(SDValue Op, SelectionDAG &DAG) const;
 460   SDValue LowerVASTART(SDValue Op, SelectionDAG &DAG) const;
 461   SDValue LowerVACOPY(SDValue Op, SelectionDAG &DAG) const;
 462   SDValue LowerVAARG(SDValue Op, SelectionDAG &DAG) const;
 463   SDValue LowerFRAMEADDR(SDValue Op, SelectionDAG &DAG) const;
 464   SDValue LowerRETURNADDR(SDValue Op, SelectionDAG &DAG) const;
 465   SDValue LowerINSERT_VECTOR_ELT(SDValue Op, SelectionDAG &DAG) const;
 466   SDValue LowerEXTRACT_VECTOR_ELT(SDValue Op, SelectionDAG &DAG) const;
 467   SDValue LowerSCALAR_TO_VECTOR(SDValue Op, SelectionDAG &DAG) const;
 468   SDValue LowerBUILD_VECTOR(SDValue Op, SelectionDAG &DAG) const;
 469   SDValue LowerVECTOR_SHUFFLE(SDValue Op, SelectionDAG &DAG) const;
 470   SDValue LowerEXTRACT_SUBVECTOR(SDValue Op, SelectionDAG &DAG) const;
 471   SDValue LowerVectorSRA_SRL_SHL(SDValue Op, SelectionDAG &DAG) const;
 472   SDValue LowerShiftLeftParts(SDValue Op, SelectionDAG &DAG) const;
 473   SDValue LowerShiftRightParts(SDValue Op, SelectionDAG &DAG) const;
 474   SDValue LowerVSETCC(SDValue Op, SelectionDAG &DAG) const;
 475   SDValue LowerCTPOP(SDValue Op, SelectionDAG &DAG) const;
 476   SDValue LowerF128Call(SDValue Op, SelectionDAG &DAG,
 477                         RTLIB::Libcall Call) const;
 478   SDValue LowerFCOPYSIGN(SDValue Op, SelectionDAG &DAG) const;
 479   SDValue LowerFP_EXTEND(SDValue Op, SelectionDAG &DAG) const;
 480   SDValue LowerFP_ROUND(SDValue Op, SelectionDAG &DAG) const;
 481   SDValue LowerFP_TO_INT(SDValue Op, SelectionDAG &DAG) const;
 482   SDValue LowerINT_TO_FP(SDValue Op, SelectionDAG &DAG) const;
 483   SDValue LowerVectorAND(SDValue Op, SelectionDAG &DAG) const;
 484   SDValue LowerVectorOR(SDValue Op, SelectionDAG &DAG) const;
 485   SDValue LowerCONCAT_VECTORS(SDValue Op, SelectionDAG &DAG) const;
 486   SDValue LowerFSINCOS(SDValue Op, SelectionDAG &DAG) const;
 487
 488   SDValue BuildSDIVPow2(SDNode *N, const APInt &Divisor, SelectionDAG &DAG,
 489                         std::vector<SDNode *> *Created) const override;
 490   unsigned combineRepeatedFPDivisors() const override;
 491
 492   ConstraintType getConstraintType(StringRef Constraint) const override;
 493   unsigned getRegisterByName(const char* RegName, EVT VT,
 494                              SelectionDAG &DAG) const override;
 495
 496   /// Examine constraint string and operand type and determine a weight value.
 497   /// The operand object must already have been set up with the operand type.
 498   ConstraintWeight
 499   getSingleConstraintMatchWeight(AsmOperandInfo &info,
 500                                  const char *constraint) const override;
 501
 502   std::pair<unsigned, const TargetRegisterClass *>
 503   getRegForInlineAsmConstraint(const TargetRegisterInfo *TRI,
 504                                StringRef Constraint, MVT VT) const override;
 505   void LowerAsmOperandForConstraint(SDValue Op, std::string &Constraint,
 506                                     std::vector<SDValue> &Ops,
 507                                     SelectionDAG &DAG) const override;
 508
 509   unsigned getInlineAsmMemConstraint(StringRef ConstraintCode) const override {
 510     if (ConstraintCode == "Q")
 511       return InlineAsm::Constraint_Q;
 512     // FIXME: clang has code for 'Ump', 'Utf', 'Usa', and 'Ush' but these are
 513     //        followed by llvm_unreachable so we'll leave them unimplemented in
 514     //        the backend for now.
 515     return TargetLowering::getInlineAsmMemConstraint(ConstraintCode);
 516   }
 517
 518   bool isUsedByReturnOnly(SDNode *N, SDValue &Chain) const override;
 519   bool mayBeEmittedAsTailCall(CallInst *CI) const override;
 520   bool getIndexedAddressParts(SDNode *Op, SDValue &Base, SDValue &Offset,
 521                               ISD::MemIndexedMode &AM, bool &IsInc,
 522                               SelectionDAG &DAG) const;
 523   bool getPreIndexedAddressParts(SDNode *N, SDValue &Base, SDValue &Offset,
 524                                  ISD::MemIndexedMode &AM,
 525                                  SelectionDAG &DAG) const override;
 526   bool getPostIndexedAddressParts(SDNode *N, SDNode *Op, SDValue &Base,
 527                                   SDValue &Offset, ISD::MemIndexedMode &AM,
 528                                   SelectionDAG &DAG) const override;
 529
 530   void ReplaceNodeResults(SDNode *N, SmallVectorImpl<SDValue> &Results,
 531                           SelectionDAG &DAG) const override;
 532
 533   bool functionArgumentNeedsConsecutiveRegisters(Type *Ty,
 534                                                  CallingConv::ID CallConv,
 535                                                  bool isVarArg) const override;
 536
 537   bool shouldNormalizeToSelectSequence(LLVMContext &, EVT) const override;
 538 };
 539
 540 namespace AArch64 {
 541 FastISel *createFastISel(FunctionLoweringInfo &funcInfo,
 542                          const TargetLibraryInfo *libInfo);
 543 } // end namespace AArch64
 544
 545 } // end namespace llvm
 546
 547 #endif