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 "llvm/CodeGen/CallingConvLower.h"
  19 #include "llvm/CodeGen/SelectionDAG.h"
  20 #include "llvm/IR/CallingConv.h"
  21 #include "llvm/IR/Instruction.h"
  22 #include "llvm/Target/TargetLowering.h"
  23
  24 namespace llvm {
  25
  26 namespace AArch64ISD {
  27
  28 enum NodeType : unsigned {
  29   FIRST_NUMBER = ISD::BUILTIN_OP_END,
  30   WrapperLarge, // 4-instruction MOVZ/MOVK sequence for 64-bit addresses.
  31   CALL,         // Function call.
  32
  33   // Produces the full sequence of instructions for getting the thread pointer
  34   // offset of a variable into X0, using the TLSDesc model.
  35   TLSDESC_CALLSEQ,
  36   ADRP,     // Page address of a TargetGlobalAddress operand.
  37   ADDlow,   // Add the low 12 bits of a TargetGlobalAddress operand.
  38   LOADgot,  // Load from automatically generated descriptor (e.g. Global
  39             // Offset Table, TLS record).
  40   RET_FLAG, // Return with a flag operand. Operand 0 is the chain operand.
  41   BRCOND,   // Conditional branch instruction; "b.cond".
  42   CSEL,
  43   FCSEL, // Conditional move instruction.
  44   CSINV, // Conditional select invert.
  45   CSNEG, // Conditional select negate.
  46   CSINC, // Conditional select increment.
  47
  48   // Pointer to the thread's local storage area. Materialised from TPIDR_EL0 on
  49   // ELF.
  50   THREAD_POINTER,
  51   ADC,
  52   SBC, // adc, sbc instructions
  53
  54   // Arithmetic instructions which write flags.
  55   ADDS,
  56   SUBS,
  57   ADCS,
  58   SBCS,
  59   ANDS,
  60
  61   // Conditional compares. Operands: left,right,falsecc,cc,flags
  62   CCMP,
  63   CCMN,
  64   FCCMP,
  65
  66   // Floating point comparison
  67   FCMP,
  68
  69   // Scalar extract
  70   EXTR,
  71
  72   // Scalar-to-vector duplication
  73   DUP,
  74   DUPLANE8,
  75   DUPLANE16,
  76   DUPLANE32,
  77   DUPLANE64,
  78
  79   // Vector immedate moves
  80   MOVI,
  81   MOVIshift,
  82   MOVIedit,
  83   MOVImsl,
  84   FMOV,
  85   MVNIshift,
  86   MVNImsl,
  87
  88   // Vector immediate ops
  89   BICi,
  90   ORRi,
  91
  92   // Vector bit select: similar to ISD::VSELECT but not all bits within an
  93   // element must be identical.
  94   BSL,
  95
  96   // Vector arithmetic negation
  97   NEG,
  98
  99   // Vector shuffles
 100   ZIP1,
 101   ZIP2,
 102   UZP1,
 103   UZP2,
 104   TRN1,
 105   TRN2,
 106   REV16,
 107   REV32,
 108   REV64,
 109   EXT,
 110
 111   // Vector shift by scalar
 112   VSHL,
 113   VLSHR,
 114   VASHR,
 115
 116   // Vector shift by scalar (again)
 117   SQSHL_I,
 118   UQSHL_I,
 119   SQSHLU_I,
 120   SRSHR_I,
 121   URSHR_I,
 122
 123   // Vector comparisons
 124   CMEQ,
 125   CMGE,
 126   CMGT,
 127   CMHI,
 128   CMHS,
 129   FCMEQ,
 130   FCMGE,
 131   FCMGT,
 132
 133   // Vector zero comparisons
 134   CMEQz,
 135   CMGEz,
 136   CMGTz,
 137   CMLEz,
 138   CMLTz,
 139   FCMEQz,
 140   FCMGEz,
 141   FCMGTz,
 142   FCMLEz,
 143   FCMLTz,
 144
 145   // Vector across-lanes addition
 146   // Only the lower result lane is defined.
 147   SADDV,
 148   UADDV,
 149
 150   // Vector across-lanes min/max
 151   // Only the lower result lane is defined.
 152   SMINV,
 153   UMINV,
 154   SMAXV,
 155   UMAXV,
 156
 157   // Vector bitwise negation
 158   NOT,
 159
 160   // Vector bitwise selection
 161   BIT,
 162
 163   // Compare-and-branch
 164   CBZ,
 165   CBNZ,
 166   TBZ,
 167   TBNZ,
 168
 169   // Tail calls
 170   TC_RETURN,
 171
 172   // Custom prefetch handling
 173   PREFETCH,
 174
 175   // {s|u}int to FP within a FP register.
 176   SITOF,
 177   UITOF,
 178
 179   /// Natural vector cast. ISD::BITCAST is not natural in the big-endian
 180   /// world w.r.t vectors; which causes additional REV instructions to be
 181   /// generated to compensate for the byte-swapping. But sometimes we do
 182   /// need to re-interpret the data in SIMD vector registers in big-endian
 183   /// mode without emitting such REV instructions.
 184   NVCAST,
 185
 186   SMULL,
 187   UMULL,
 188
 189   // NEON Load/Store with post-increment base updates
 190   LD2post = ISD::FIRST_TARGET_MEMORY_OPCODE,
 191   LD3post,
 192   LD4post,
 193   ST2post,
 194   ST3post,
 195   ST4post,
 196   LD1x2post,
 197   LD1x3post,
 198   LD1x4post,
 199   ST1x2post,
 200   ST1x3post,
 201   ST1x4post,
 202   LD1DUPpost,
 203   LD2DUPpost,
 204   LD3DUPpost,
 205   LD4DUPpost,
 206   LD1LANEpost,
 207   LD2LANEpost,
 208   LD3LANEpost,
 209   LD4LANEpost,
 210   ST2LANEpost,
 211   ST3LANEpost,
 212   ST4LANEpost
 213 };
 214
 215 } // end namespace AArch64ISD
 216
 217 class AArch64Subtarget;
 218 class AArch64TargetMachine;
 219
 220 class AArch64TargetLowering : public TargetLowering {
 221 public:
 222   explicit AArch64TargetLowering(const TargetMachine &TM,
 223                                  const AArch64Subtarget &STI);
 224
 225   /// Selects the correct CCAssignFn for a given CallingConvention value.
 226   CCAssignFn *CCAssignFnForCall(CallingConv::ID CC, bool IsVarArg) const;
 227
 228   /// computeKnownBitsForTargetNode - Determine which of the bits specified in
 229   /// Mask are known to be either zero or one and return them in the
 230   /// 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   /// allowsMisalignedMemoryAccesses - Returns true if the target allows
 238   /// unaligned memory accesses of the specified type.
 239   bool allowsMisalignedMemoryAccesses(EVT VT, unsigned AddrSpace = 0,
 240                                       unsigned Align = 1,
 241                                       bool *Fast = nullptr) const override;
 242
 243   /// LowerOperation - 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   /// getFunctionAlignment - 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   /// createFastISel - This method returns a target specific FastISel object,
 260   /// or null if the 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   /// isShuffleMaskLegal - Return true if the given shuffle mask can be
 269   /// codegen'd directly, or if it should be stack expanded.
 270   bool isShuffleMaskLegal(const SmallVectorImpl<int> &M, EVT VT) const override;
 271
 272   /// getSetCCResultType - 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   /// isLegalAddressingMode - Return true if the addressing mode represented
 318   /// by AM is legal for this 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   /// isFMAFasterThanFMulAndFAdd - Return true if an FMA operation is faster
 331   /// than a pair of fmul and fadd instructions. fmuladd intrinsics will be
 332   /// expanded to FMAs when this method returns true, otherwise fmuladd is
 333   /// expanded to fmul + fadd.
 334   bool isFMAFasterThanFMulAndFAdd(EVT VT) const override;
 335
 336   const MCPhysReg *getScratchRegisters(CallingConv::ID CC) const override;
 337
 338   /// \brief Returns false if N is a bit extraction pattern of (X >> C) & Mask.
 339   bool isDesirableToCommuteWithShift(const SDNode *N) const override;
 340
 341   /// \brief Returns true if it is beneficial to convert a load of a constant
 342   /// to just the constant itself.
 343   bool shouldConvertConstantLoadToIntImm(const APInt &Imm,
 344                                          Type *Ty) const override;
 345
 346   Value *emitLoadLinked(IRBuilder<> &Builder, Value *Addr,
 347                         AtomicOrdering Ord) const override;
 348   Value *emitStoreConditional(IRBuilder<> &Builder, Value *Val,
 349                               Value *Addr, AtomicOrdering Ord) const override;
 350
 351   void emitAtomicCmpXchgNoStoreLLBalance(IRBuilder<> &Builder) const override;
 352
 353   TargetLoweringBase::AtomicExpansionKind
 354   shouldExpandAtomicLoadInIR(LoadInst *LI) const override;
 355   bool shouldExpandAtomicStoreInIR(StoreInst *SI) const override;
 356   TargetLoweringBase::AtomicExpansionKind
 357   shouldExpandAtomicRMWInIR(AtomicRMWInst *AI) const override;
 358
 359   bool shouldExpandAtomicCmpXchgInIR(AtomicCmpXchgInst *AI) const override;
 360
 361   bool useLoadStackGuardNode() const override;
 362   TargetLoweringBase::LegalizeTypeAction
 363   getPreferredVectorAction(EVT VT) const override;
 364
 365   /// If the target has a standard location for the unsafe stack pointer,
 366   /// returns the address of that location. Otherwise, returns nullptr.
 367   Value *getSafeStackPointerLocation(IRBuilder<> &IRB) const override;
 368
 369 private:
 370   bool isExtFreeImpl(const Instruction *Ext) const override;
 371
 372   /// Subtarget - Keep a pointer to the AArch64Subtarget around so that we can
 373   /// make the right decision when generating code for different targets.
 374   const AArch64Subtarget *Subtarget;
 375
 376   void addTypeForNEON(EVT VT, EVT PromotedBitwiseVT);
 377   void addDRTypeForNEON(MVT VT);
 378   void addQRTypeForNEON(MVT VT);
 379
 380   SDValue
 381   LowerFormalArguments(SDValue Chain, CallingConv::ID CallConv, bool isVarArg,
 382                        const SmallVectorImpl<ISD::InputArg> &Ins, SDLoc DL,
 383                        SelectionDAG &DAG,
 384                        SmallVectorImpl<SDValue> &InVals) const override;
 385
 386   SDValue LowerCall(CallLoweringInfo & /*CLI*/,
 387                     SmallVectorImpl<SDValue> &InVals) const override;
 388
 389   SDValue LowerCallResult(SDValue Chain, SDValue InFlag,
 390                           CallingConv::ID CallConv, bool isVarArg,
 391                           const SmallVectorImpl<ISD::InputArg> &Ins, SDLoc DL,
 392                           SelectionDAG &DAG, SmallVectorImpl<SDValue> &InVals,
 393                           bool isThisReturn, SDValue ThisVal) const;
 394
 395   SDValue LowerINTRINSIC_WO_CHAIN(SDValue Op, SelectionDAG &DAG) const;
 396
 397   bool isEligibleForTailCallOptimization(
 398       SDValue Callee, CallingConv::ID CalleeCC, bool isVarArg,
 399       bool isCalleeStructRet, bool isCallerStructRet,
 400       const SmallVectorImpl<ISD::OutputArg> &Outs,
 401       const SmallVectorImpl<SDValue> &OutVals,
 402       const SmallVectorImpl<ISD::InputArg> &Ins, SelectionDAG &DAG) const;
 403
 404   /// Finds the incoming stack arguments which overlap the given fixed stack
 405   /// object and incorporates their load into the current chain. This prevents
 406   /// an upcoming store from clobbering the stack argument before it's used.
 407   SDValue addTokenForArgument(SDValue Chain, SelectionDAG &DAG,
 408                               MachineFrameInfo *MFI, int ClobberedFI) const;
 409
 410   bool DoesCalleeRestoreStack(CallingConv::ID CallCC, bool TailCallOpt) const;
 411
 412   bool IsTailCallConvention(CallingConv::ID CallCC) const;
 413
 414   void saveVarArgRegisters(CCState &CCInfo, SelectionDAG &DAG, SDLoc DL,
 415                            SDValue &Chain) const;
 416
 417   bool CanLowerReturn(CallingConv::ID CallConv, MachineFunction &MF,
 418                       bool isVarArg,
 419                       const SmallVectorImpl<ISD::OutputArg> &Outs,
 420                       LLVMContext &Context) const override;
 421
 422   SDValue LowerReturn(SDValue Chain, CallingConv::ID CallConv, bool isVarArg,
 423                       const SmallVectorImpl<ISD::OutputArg> &Outs,
 424                       const SmallVectorImpl<SDValue> &OutVals, SDLoc DL,
 425                       SelectionDAG &DAG) const override;
 426
 427   SDValue LowerGlobalAddress(SDValue Op, SelectionDAG &DAG) const;
 428   SDValue LowerGlobalTLSAddress(SDValue Op, SelectionDAG &DAG) const;
 429   SDValue LowerDarwinGlobalTLSAddress(SDValue Op, SelectionDAG &DAG) const;
 430   SDValue LowerELFGlobalTLSAddress(SDValue Op, SelectionDAG &DAG) const;
 431   SDValue LowerELFTLSDescCallSeq(SDValue SymAddr, SDLoc DL,
 432                                  SelectionDAG &DAG) const;
 433   SDValue LowerSETCC(SDValue Op, SelectionDAG &DAG) const;
 434   SDValue LowerBR_CC(SDValue Op, SelectionDAG &DAG) const;
 435   SDValue LowerSELECT(SDValue Op, SelectionDAG &DAG) const;
 436   SDValue LowerSELECT_CC(SDValue Op, SelectionDAG &DAG) const;
 437   SDValue LowerSELECT_CC(ISD::CondCode CC, SDValue LHS, SDValue RHS,
 438                          SDValue TVal, SDValue FVal, SDLoc dl,
 439                          SelectionDAG &DAG) const;
 440   SDValue LowerJumpTable(SDValue Op, SelectionDAG &DAG) const;
 441   SDValue LowerConstantPool(SDValue Op, SelectionDAG &DAG) const;
 442   SDValue LowerBlockAddress(SDValue Op, SelectionDAG &DAG) const;
 443   SDValue LowerAAPCS_VASTART(SDValue Op, SelectionDAG &DAG) const;
 444   SDValue LowerDarwin_VASTART(SDValue Op, SelectionDAG &DAG) const;
 445   SDValue LowerVASTART(SDValue Op, SelectionDAG &DAG) const;
 446   SDValue LowerVACOPY(SDValue Op, SelectionDAG &DAG) const;
 447   SDValue LowerVAARG(SDValue Op, SelectionDAG &DAG) const;
 448   SDValue LowerFRAMEADDR(SDValue Op, SelectionDAG &DAG) const;
 449   SDValue LowerRETURNADDR(SDValue Op, SelectionDAG &DAG) const;
 450   SDValue LowerINSERT_VECTOR_ELT(SDValue Op, SelectionDAG &DAG) const;
 451   SDValue LowerEXTRACT_VECTOR_ELT(SDValue Op, SelectionDAG &DAG) const;
 452   SDValue LowerSCALAR_TO_VECTOR(SDValue Op, SelectionDAG &DAG) const;
 453   SDValue LowerBUILD_VECTOR(SDValue Op, SelectionDAG &DAG) const;
 454   SDValue LowerVECTOR_SHUFFLE(SDValue Op, SelectionDAG &DAG) const;
 455   SDValue LowerEXTRACT_SUBVECTOR(SDValue Op, SelectionDAG &DAG) const;
 456   SDValue LowerVectorSRA_SRL_SHL(SDValue Op, SelectionDAG &DAG) const;
 457   SDValue LowerShiftLeftParts(SDValue Op, SelectionDAG &DAG) const;
 458   SDValue LowerShiftRightParts(SDValue Op, SelectionDAG &DAG) const;
 459   SDValue LowerVSETCC(SDValue Op, SelectionDAG &DAG) const;
 460   SDValue LowerCTPOP(SDValue Op, SelectionDAG &DAG) const;
 461   SDValue LowerF128Call(SDValue Op, SelectionDAG &DAG,
 462                         RTLIB::Libcall Call) const;
 463   SDValue LowerFCOPYSIGN(SDValue Op, SelectionDAG &DAG) const;
 464   SDValue LowerFP_EXTEND(SDValue Op, SelectionDAG &DAG) const;
 465   SDValue LowerFP_ROUND(SDValue Op, SelectionDAG &DAG) const;
 466   SDValue LowerFP_TO_INT(SDValue Op, SelectionDAG &DAG) const;
 467   SDValue LowerINT_TO_FP(SDValue Op, SelectionDAG &DAG) const;
 468   SDValue LowerVectorAND(SDValue Op, SelectionDAG &DAG) const;
 469   SDValue LowerVectorOR(SDValue Op, SelectionDAG &DAG) const;
 470   SDValue LowerCONCAT_VECTORS(SDValue Op, SelectionDAG &DAG) const;
 471   SDValue LowerFSINCOS(SDValue Op, SelectionDAG &DAG) const;
 472
 473   SDValue BuildSDIVPow2(SDNode *N, const APInt &Divisor, SelectionDAG &DAG,
 474                         std::vector<SDNode *> *Created) const override;
 475   unsigned combineRepeatedFPDivisors() const override;
 476
 477   ConstraintType getConstraintType(StringRef Constraint) const override;
 478   unsigned getRegisterByName(const char* RegName, EVT VT,
 479                              SelectionDAG &DAG) const override;
 480
 481   /// Examine constraint string and operand type and determine a weight value.
 482   /// The operand object must already have been set up with the operand type.
 483   ConstraintWeight
 484   getSingleConstraintMatchWeight(AsmOperandInfo &info,
 485                                  const char *constraint) const override;
 486
 487   std::pair<unsigned, const TargetRegisterClass *>
 488   getRegForInlineAsmConstraint(const TargetRegisterInfo *TRI,
 489                                StringRef Constraint, MVT VT) const override;
 490   void LowerAsmOperandForConstraint(SDValue Op, std::string &Constraint,
 491                                     std::vector<SDValue> &Ops,
 492                                     SelectionDAG &DAG) const override;
 493
 494   unsigned getInlineAsmMemConstraint(StringRef ConstraintCode) const override {
 495     if (ConstraintCode == "Q")
 496       return InlineAsm::Constraint_Q;
 497     // FIXME: clang has code for 'Ump', 'Utf', 'Usa', and 'Ush' but these are
 498     //        followed by llvm_unreachable so we'll leave them unimplemented in
 499     //        the backend for now.
 500     return TargetLowering::getInlineAsmMemConstraint(ConstraintCode);
 501   }
 502
 503   bool isUsedByReturnOnly(SDNode *N, SDValue &Chain) const override;
 504   bool mayBeEmittedAsTailCall(CallInst *CI) const override;
 505   bool getIndexedAddressParts(SDNode *Op, SDValue &Base, SDValue &Offset,
 506                               ISD::MemIndexedMode &AM, bool &IsInc,
 507                               SelectionDAG &DAG) const;
 508   bool getPreIndexedAddressParts(SDNode *N, SDValue &Base, SDValue &Offset,
 509                                  ISD::MemIndexedMode &AM,
 510                                  SelectionDAG &DAG) const override;
 511   bool getPostIndexedAddressParts(SDNode *N, SDNode *Op, SDValue &Base,
 512                                   SDValue &Offset, ISD::MemIndexedMode &AM,
 513                                   SelectionDAG &DAG) const override;
 514
 515   void ReplaceNodeResults(SDNode *N, SmallVectorImpl<SDValue> &Results,
 516                           SelectionDAG &DAG) const override;
 517
 518   bool functionArgumentNeedsConsecutiveRegisters(Type *Ty,
 519                                                  CallingConv::ID CallConv,
 520                                                  bool isVarArg) const override;
 521
 522   bool shouldNormalizeToSelectSequence(LLVMContext &, EVT) const override;
 523 };
 524
 525 namespace AArch64 {
 526 FastISel *createFastISel(FunctionLoweringInfo &funcInfo,
 527                          const TargetLibraryInfo *libInfo);
 528 } // end namespace AArch64
 529
 530 } // end namespace llvm
 531
 532 #endif