lib/Target/ARM64/ARM64ISelLowering.h

   1 //==-- ARM64ISelLowering.h - ARM64 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 ARM64 uses to lower LLVM code into a
  11 // selection DAG.
  12 //
  13 //===----------------------------------------------------------------------===//
  14
  15 #ifndef LLVM_TARGET_ARM64_ISELLOWERING_H
  16 #define LLVM_TARGET_ARM64_ISELLOWERING_H
  17
  18 #include "llvm/CodeGen/CallingConvLower.h"
  19 #include "llvm/CodeGen/SelectionDAG.h"
  20 #include "llvm/IR/CallingConv.h"
  21 #include "llvm/Target/TargetLowering.h"
  22
  23 namespace llvm {
  24
  25 namespace ARM64ISD {
  26
  27 enum {
  28   FIRST_NUMBER = ISD::BUILTIN_OP_END,
  29   WrapperLarge, // 4-instruction MOVZ/MOVK sequence for 64-bit addresses.
  30   CALL,         // Function call.
  31
  32   // Almost the same as a normal call node, except that a TLSDesc relocation is
  33   // needed so the linker can relax it correctly if possible.
  34   TLSDESC_CALL,
  35   ADRP,     // Page address of a TargetGlobalAddress operand.
  36   ADDlow,   // Add the low 12 bits of a TargetGlobalAddress operand.
  37   LOADgot,  // Load from automatically generated descriptor (e.g. Global
  38             // Offset Table, TLS record).
  39   RET_FLAG, // Return with a flag operand. Operand 0 is the chain operand.
  40   BRCOND,   // Conditional branch instruction; "b.cond".
  41   CSEL,
  42   FCSEL, // Conditional move instruction.
  43   CSINV, // Conditional select invert.
  44   CSNEG, // Conditional select negate.
  45   CSINC, // Conditional select increment.
  46
  47   // Pointer to the thread's local storage area. Materialised from TPIDR_EL0 on
  48   // ELF.
  49   THREAD_POINTER,
  50   ADC,
  51   SBC, // adc, sbc instructions
  52
  53   // Arithmetic instructions which write flags.
  54   ADDS,
  55   SUBS,
  56   ADCS,
  57   SBCS,
  58   ANDS,
  59
  60   // Floating point comparison
  61   FCMP,
  62
  63   // Floating point max and min instructions.
  64   FMAX,
  65   FMIN,
  66
  67   // Scalar extract
  68   EXTR,
  69
  70   // Scalar-to-vector duplication
  71   DUP,
  72   DUPLANE8,
  73   DUPLANE16,
  74   DUPLANE32,
  75   DUPLANE64,
  76
  77   // Vector immedate moves
  78   MOVI,
  79   MOVIshift,
  80   MOVIedit,
  81   MOVImsl,
  82   FMOV,
  83   MVNIshift,
  84   MVNImsl,
  85
  86   // Vector immediate ops
  87   BICi,
  88   ORRi,
  89
  90   // Vector bit select: similar to ISD::VSELECT but not all bits within an
  91   // element must be identical.
  92   BSL,
  93
  94   // Vector arithmetic negation
  95   NEG,
  96
  97   // Vector shuffles
  98   ZIP1,
  99   ZIP2,
 100   UZP1,
 101   UZP2,
 102   TRN1,
 103   TRN2,
 104   REV16,
 105   REV32,
 106   REV64,
 107   EXT,
 108
 109   // Vector shift by scalar
 110   VSHL,
 111   VLSHR,
 112   VASHR,
 113
 114   // Vector shift by scalar (again)
 115   SQSHL_I,
 116   UQSHL_I,
 117   SQSHLU_I,
 118   SRSHR_I,
 119   URSHR_I,
 120
 121   // Vector comparisons
 122   CMEQ,
 123   CMGE,
 124   CMGT,
 125   CMHI,
 126   CMHS,
 127   FCMEQ,
 128   FCMGE,
 129   FCMGT,
 130
 131   // Vector zero comparisons
 132   CMEQz,
 133   CMGEz,
 134   CMGTz,
 135   CMLEz,
 136   CMLTz,
 137   FCMEQz,
 138   FCMGEz,
 139   FCMGTz,
 140   FCMLEz,
 141   FCMLTz,
 142
 143   // Vector bitwise negation
 144   NOT,
 145
 146   // Vector bitwise selection
 147   BIT,
 148
 149   // Compare-and-branch
 150   CBZ,
 151   CBNZ,
 152   TBZ,
 153   TBNZ,
 154
 155   // Tail calls
 156   TC_RETURN,
 157
 158   // Custom prefetch handling
 159   PREFETCH,
 160
 161   // {s|u}int to FP within a FP register.
 162   SITOF,
 163   UITOF,
 164
 165   // NEON Load/Store with post-increment base updates
 166   LD2post = ISD::FIRST_TARGET_MEMORY_OPCODE,
 167   LD3post,
 168   LD4post,
 169   ST2post,
 170   ST3post,
 171   ST4post,
 172   LD1x2post,
 173   LD1x3post,
 174   LD1x4post,
 175   ST1x2post,
 176   ST1x3post,
 177   ST1x4post,
 178   LD2DUPpost,
 179   LD3DUPpost,
 180   LD4DUPpost,
 181   LD2LANEpost,
 182   LD3LANEpost,
 183   LD4LANEpost,
 184   ST2LANEpost,
 185   ST3LANEpost,
 186   ST4LANEpost
 187 };
 188
 189 } // end namespace ARM64ISD
 190
 191 class ARM64Subtarget;
 192 class ARM64TargetMachine;
 193
 194 class ARM64TargetLowering : public TargetLowering {
 195   bool RequireStrictAlign;
 196
 197 public:
 198   explicit ARM64TargetLowering(ARM64TargetMachine &TM);
 199
 200   /// Selects the correct CCAssignFn for a the given CallingConvention
 201   /// value.
 202   CCAssignFn *CCAssignFnForCall(CallingConv::ID CC, bool IsVarArg) const;
 203
 204   /// computeMaskedBitsForTargetNode - Determine which of the bits specified in
 205   /// Mask are known to be either zero or one and return them in the
 206   /// KnownZero/KnownOne bitsets.
 207   void computeMaskedBitsForTargetNode(const SDValue Op, APInt &KnownZero,
 208                                       APInt &KnownOne, const SelectionDAG &DAG,
 209                                       unsigned Depth = 0) const override;
 210
 211   MVT getScalarShiftAmountTy(EVT LHSTy) const override;
 212
 213   /// allowsUnalignedMemoryAccesses - Returns true if the target allows
 214   /// unaligned memory accesses. of the specified type.
 215   bool allowsUnalignedMemoryAccesses(EVT VT, unsigned AddrSpace = 0,
 216                                      bool *Fast = nullptr) const override {
 217     if (RequireStrictAlign)
 218       return false;
 219     // FIXME: True for Cyclone, but not necessary others.
 220     if (Fast)
 221       *Fast = true;
 222     return true;
 223   }
 224
 225   /// LowerOperation - Provide custom lowering hooks for some operations.
 226   SDValue LowerOperation(SDValue Op, SelectionDAG &DAG) const override;
 227
 228   const char *getTargetNodeName(unsigned Opcode) const override;
 229
 230   SDValue PerformDAGCombine(SDNode *N, DAGCombinerInfo &DCI) const override;
 231
 232   /// getFunctionAlignment - Return the Log2 alignment of this function.
 233   unsigned getFunctionAlignment(const Function *F) const;
 234
 235   /// getMaximalGlobalOffset - Returns the maximal possible offset which can
 236   /// be used for loads / stores from the global.
 237   unsigned getMaximalGlobalOffset() const override;
 238
 239   /// Returns true if a cast between SrcAS and DestAS is a noop.
 240   bool isNoopAddrSpaceCast(unsigned SrcAS, unsigned DestAS) const override {
 241     // Addrspacecasts are always noops.
 242     return true;
 243   }
 244
 245   /// createFastISel - This method returns a target specific FastISel object,
 246   /// or null if the target does not support "fast" ISel.
 247   FastISel *createFastISel(FunctionLoweringInfo &funcInfo,
 248                            const TargetLibraryInfo *libInfo) const override;
 249
 250   bool isOffsetFoldingLegal(const GlobalAddressSDNode *GA) const override;
 251
 252   bool isFPImmLegal(const APFloat &Imm, EVT VT) const override;
 253
 254   /// isShuffleMaskLegal - Return true if the given shuffle mask can be
 255   /// codegen'd directly, or if it should be stack expanded.
 256   bool isShuffleMaskLegal(const SmallVectorImpl<int> &M, EVT VT) const override;
 257
 258   /// getSetCCResultType - Return the ISD::SETCC ValueType
 259   EVT getSetCCResultType(LLVMContext &Context, EVT VT) const override;
 260
 261   SDValue ReconstructShuffle(SDValue Op, SelectionDAG &DAG) const;
 262
 263   MachineBasicBlock *EmitF128CSEL(MachineInstr *MI,
 264                                   MachineBasicBlock *BB) const;
 265
 266   MachineBasicBlock *
 267   EmitInstrWithCustomInserter(MachineInstr *MI,
 268                               MachineBasicBlock *MBB) const override;
 269
 270   bool getTgtMemIntrinsic(IntrinsicInfo &Info, const CallInst &I,
 271                           unsigned Intrinsic) const override;
 272
 273   bool isTruncateFree(Type *Ty1, Type *Ty2) const override;
 274   bool isTruncateFree(EVT VT1, EVT VT2) const override;
 275
 276   bool isZExtFree(Type *Ty1, Type *Ty2) const override;
 277   bool isZExtFree(EVT VT1, EVT VT2) const override;
 278   bool isZExtFree(SDValue Val, EVT VT2) const override;
 279
 280   bool hasPairedLoad(Type *LoadedType,
 281                      unsigned &RequiredAligment) const override;
 282   bool hasPairedLoad(EVT LoadedType, unsigned &RequiredAligment) const override;
 283
 284   bool isLegalAddImmediate(int64_t) const override;
 285   bool isLegalICmpImmediate(int64_t) const override;
 286
 287   EVT getOptimalMemOpType(uint64_t Size, unsigned DstAlign, unsigned SrcAlign,
 288                           bool IsMemset, bool ZeroMemset, bool MemcpyStrSrc,
 289                           MachineFunction &MF) const override;
 290
 291   /// isLegalAddressingMode - Return true if the addressing mode represented
 292   /// by AM is legal for this target, for a load/store of the specified type.
 293   bool isLegalAddressingMode(const AddrMode &AM, Type *Ty) const override;
 294
 295   /// \brief Return the cost of the scaling factor used in the addressing
 296   /// mode represented by AM for this target, for a load/store
 297   /// of the specified type.
 298   /// If the AM is supported, the return value must be >= 0.
 299   /// If the AM is not supported, it returns a negative value.
 300   int getScalingFactorCost(const AddrMode &AM, Type *Ty) const override;
 301
 302   /// isFMAFasterThanFMulAndFAdd - Return true if an FMA operation is faster
 303   /// than a pair of fmul and fadd instructions. fmuladd intrinsics will be
 304   /// expanded to FMAs when this method returns true, otherwise fmuladd is
 305   /// expanded to fmul + fadd.
 306   bool isFMAFasterThanFMulAndFAdd(EVT VT) const override;
 307
 308   const MCPhysReg *getScratchRegisters(CallingConv::ID CC) const override;
 309
 310   /// \brief Returns false if N is a bit extraction pattern of (X >> C) & Mask.
 311   bool isDesirableToCommuteWithShift(const SDNode *N) const override;
 312
 313   /// \brief Returns true if it is beneficial to convert a load of a constant
 314   /// to just the constant itself.
 315   bool shouldConvertConstantLoadToIntImm(const APInt &Imm,
 316                                          Type *Ty) const override;
 317
 318   Value *emitLoadLinked(IRBuilder<> &Builder, Value *Addr,
 319                         AtomicOrdering Ord) const override;
 320   Value *emitStoreConditional(IRBuilder<> &Builder, Value *Val,
 321                               Value *Addr, AtomicOrdering Ord) const override;
 322
 323   bool shouldExpandAtomicInIR(Instruction *Inst) const override;
 324
 325 private:
 326   /// Subtarget - Keep a pointer to the ARM64Subtarget around so that we can
 327   /// make the right decision when generating code for different targets.
 328   const ARM64Subtarget *Subtarget;
 329
 330   void addTypeForNEON(EVT VT, EVT PromotedBitwiseVT);
 331   void addDRTypeForNEON(MVT VT);
 332   void addQRTypeForNEON(MVT VT);
 333
 334   SDValue
 335   LowerFormalArguments(SDValue Chain, CallingConv::ID CallConv, bool isVarArg,
 336                        const SmallVectorImpl<ISD::InputArg> &Ins, SDLoc DL,
 337                        SelectionDAG &DAG,
 338                        SmallVectorImpl<SDValue> &InVals) const override;
 339
 340   SDValue LowerCall(CallLoweringInfo & /*CLI*/,
 341                     SmallVectorImpl<SDValue> &InVals) const override;
 342
 343   SDValue LowerCallResult(SDValue Chain, SDValue InFlag,
 344                           CallingConv::ID CallConv, bool isVarArg,
 345                           const SmallVectorImpl<ISD::InputArg> &Ins, SDLoc DL,
 346                           SelectionDAG &DAG, SmallVectorImpl<SDValue> &InVals,
 347                           bool isThisReturn, SDValue ThisVal) const;
 348
 349   bool isEligibleForTailCallOptimization(
 350       SDValue Callee, CallingConv::ID CalleeCC, bool isVarArg,
 351       bool isCalleeStructRet, bool isCallerStructRet,
 352       const SmallVectorImpl<ISD::OutputArg> &Outs,
 353       const SmallVectorImpl<SDValue> &OutVals,
 354       const SmallVectorImpl<ISD::InputArg> &Ins, SelectionDAG &DAG) const;
 355
 356   void saveVarArgRegisters(CCState &CCInfo, SelectionDAG &DAG, SDLoc DL,
 357                            SDValue &Chain) const;
 358
 359   bool CanLowerReturn(CallingConv::ID CallConv, MachineFunction &MF,
 360                       bool isVarArg,
 361                       const SmallVectorImpl<ISD::OutputArg> &Outs,
 362                       LLVMContext &Context) const override;
 363
 364   SDValue LowerReturn(SDValue Chain, CallingConv::ID CallConv, bool isVarArg,
 365                       const SmallVectorImpl<ISD::OutputArg> &Outs,
 366                       const SmallVectorImpl<SDValue> &OutVals, SDLoc DL,
 367                       SelectionDAG &DAG) const override;
 368
 369   SDValue LowerGlobalAddress(SDValue Op, SelectionDAG &DAG) const;
 370   SDValue LowerGlobalTLSAddress(SDValue Op, SelectionDAG &DAG) const;
 371   SDValue LowerDarwinGlobalTLSAddress(SDValue Op, SelectionDAG &DAG) const;
 372   SDValue LowerELFGlobalTLSAddress(SDValue Op, SelectionDAG &DAG) const;
 373   SDValue LowerELFTLSDescCall(SDValue SymAddr, SDValue DescAddr, SDLoc DL,
 374                               SelectionDAG &DAG) const;
 375   SDValue LowerSETCC(SDValue Op, SelectionDAG &DAG) const;
 376   SDValue LowerBR_CC(SDValue Op, SelectionDAG &DAG) const;
 377   SDValue LowerSELECT(SDValue Op, SelectionDAG &DAG) const;
 378   SDValue LowerSELECT_CC(SDValue Op, SelectionDAG &DAG) const;
 379   SDValue LowerJumpTable(SDValue Op, SelectionDAG &DAG) const;
 380   SDValue LowerConstantPool(SDValue Op, SelectionDAG &DAG) const;
 381   SDValue LowerBlockAddress(SDValue Op, SelectionDAG &DAG) const;
 382   SDValue LowerAAPCS_VASTART(SDValue Op, SelectionDAG &DAG) const;
 383   SDValue LowerDarwin_VASTART(SDValue Op, SelectionDAG &DAG) const;
 384   SDValue LowerVASTART(SDValue Op, SelectionDAG &DAG) const;
 385   SDValue LowerVACOPY(SDValue Op, SelectionDAG &DAG) const;
 386   SDValue LowerVAARG(SDValue Op, SelectionDAG &DAG) const;
 387   SDValue LowerFRAMEADDR(SDValue Op, SelectionDAG &DAG) const;
 388   SDValue LowerRETURNADDR(SDValue Op, SelectionDAG &DAG) const;
 389   SDValue LowerINSERT_VECTOR_ELT(SDValue Op, SelectionDAG &DAG) const;
 390   SDValue LowerEXTRACT_VECTOR_ELT(SDValue Op, SelectionDAG &DAG) const;
 391   SDValue LowerSCALAR_TO_VECTOR(SDValue Op, SelectionDAG &DAG) const;
 392   SDValue LowerBUILD_VECTOR(SDValue Op, SelectionDAG &DAG) const;
 393   SDValue LowerVECTOR_SHUFFLE(SDValue Op, SelectionDAG &DAG) const;
 394   SDValue LowerEXTRACT_SUBVECTOR(SDValue Op, SelectionDAG &DAG) const;
 395   SDValue LowerVectorSRA_SRL_SHL(SDValue Op, SelectionDAG &DAG) const;
 396   SDValue LowerShiftLeftParts(SDValue Op, SelectionDAG &DAG) const;
 397   SDValue LowerShiftRightParts(SDValue Op, SelectionDAG &DAG) const;
 398   SDValue LowerVSETCC(SDValue Op, SelectionDAG &DAG) const;
 399   SDValue LowerCTPOP(SDValue Op, SelectionDAG &DAG) const;
 400   SDValue LowerF128Call(SDValue Op, SelectionDAG &DAG,
 401                         RTLIB::Libcall Call) const;
 402   SDValue LowerFCOPYSIGN(SDValue Op, SelectionDAG &DAG) const;
 403   SDValue LowerFP_EXTEND(SDValue Op, SelectionDAG &DAG) const;
 404   SDValue LowerFP_ROUND(SDValue Op, SelectionDAG &DAG) const;
 405   SDValue LowerFP_TO_INT(SDValue Op, SelectionDAG &DAG) const;
 406   SDValue LowerINT_TO_FP(SDValue Op, SelectionDAG &DAG) const;
 407   SDValue LowerVectorAND(SDValue Op, SelectionDAG &DAG) const;
 408   SDValue LowerVectorOR(SDValue Op, SelectionDAG &DAG) const;
 409   SDValue LowerCONCAT_VECTORS(SDValue Op, SelectionDAG &DAG) const;
 410   SDValue LowerFSINCOS(SDValue Op, SelectionDAG &DAG) const;
 411
 412   ConstraintType
 413   getConstraintType(const std::string &Constraint) const override;
 414   unsigned getRegisterByName(const char* RegName) const;
 415
 416   /// Examine constraint string and operand type and determine a weight value.
 417   /// The operand object must already have been set up with the operand type.
 418   ConstraintWeight
 419   getSingleConstraintMatchWeight(AsmOperandInfo &info,
 420                                  const char *constraint) const override;
 421
 422   std::pair<unsigned, const TargetRegisterClass *>
 423   getRegForInlineAsmConstraint(const std::string &Constraint,
 424                                MVT VT) const override;
 425   void LowerAsmOperandForConstraint(SDValue Op, std::string &Constraint,
 426                                     std::vector<SDValue> &Ops,
 427                                     SelectionDAG &DAG) const override;
 428
 429   bool isUsedByReturnOnly(SDNode *N, SDValue &Chain) const override;
 430   bool mayBeEmittedAsTailCall(CallInst *CI) const override;
 431   bool getIndexedAddressParts(SDNode *Op, SDValue &Base, SDValue &Offset,
 432                               ISD::MemIndexedMode &AM, bool &IsInc,
 433                               SelectionDAG &DAG) const;
 434   bool getPreIndexedAddressParts(SDNode *N, SDValue &Base, SDValue &Offset,
 435                                  ISD::MemIndexedMode &AM,
 436                                  SelectionDAG &DAG) const override;
 437   bool getPostIndexedAddressParts(SDNode *N, SDNode *Op, SDValue &Base,
 438                                   SDValue &Offset, ISD::MemIndexedMode &AM,
 439                                   SelectionDAG &DAG) const override;
 440
 441   void ReplaceNodeResults(SDNode *N, SmallVectorImpl<SDValue> &Results,
 442                           SelectionDAG &DAG) const override;
 443 };
 444
 445 namespace ARM64 {
 446 FastISel *createFastISel(FunctionLoweringInfo &funcInfo,
 447                          const TargetLibraryInfo *libInfo);
 448 } // end namespace ARM64
 449
 450 } // end namespace llvm
 451
 452 #endif // LLVM_TARGET_ARM64_ISELLOWERING_H