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 arithmetic negation
  91   NEG,
  92
  93   // Vector shuffles
  94   ZIP1,
  95   ZIP2,
  96   UZP1,
  97   UZP2,
  98   TRN1,
  99   TRN2,
 100   REV16,
 101   REV32,
 102   REV64,
 103   EXT,
 104
 105   // Vector shift by scalar
 106   VSHL,
 107   VLSHR,
 108   VASHR,
 109
 110   // Vector shift by scalar (again)
 111   SQSHL_I,
 112   UQSHL_I,
 113   SQSHLU_I,
 114   SRSHR_I,
 115   URSHR_I,
 116
 117   // Vector comparisons
 118   CMEQ,
 119   CMGE,
 120   CMGT,
 121   CMHI,
 122   CMHS,
 123   FCMEQ,
 124   FCMGE,
 125   FCMGT,
 126
 127   // Vector zero comparisons
 128   CMEQz,
 129   CMGEz,
 130   CMGTz,
 131   CMLEz,
 132   CMLTz,
 133   FCMEQz,
 134   FCMGEz,
 135   FCMGTz,
 136   FCMLEz,
 137   FCMLTz,
 138
 139   // Vector bitwise negation
 140   NOT,
 141
 142   // Vector bitwise selection
 143   BIT,
 144
 145   // Compare-and-branch
 146   CBZ,
 147   CBNZ,
 148   TBZ,
 149   TBNZ,
 150
 151   // Tail calls
 152   TC_RETURN,
 153
 154   // Custom prefetch handling
 155   PREFETCH,
 156
 157   // {s|u}int to FP within a FP register.
 158   SITOF,
 159   UITOF
 160 };
 161
 162 } // end namespace ARM64ISD
 163
 164 class ARM64Subtarget;
 165 class ARM64TargetMachine;
 166
 167 class ARM64TargetLowering : public TargetLowering {
 168   bool RequireStrictAlign;
 169
 170 public:
 171   explicit ARM64TargetLowering(ARM64TargetMachine &TM);
 172
 173   /// Selects the correct CCAssignFn for a the given CallingConvention
 174   /// value.
 175   CCAssignFn *CCAssignFnForCall(CallingConv::ID CC, bool IsVarArg) const;
 176
 177   /// computeMaskedBitsForTargetNode - Determine which of the bits specified in
 178   /// Mask are known to be either zero or one and return them in the
 179   /// KnownZero/KnownOne bitsets.
 180   void computeMaskedBitsForTargetNode(const SDValue Op, APInt &KnownZero,
 181                                       APInt &KnownOne, const SelectionDAG &DAG,
 182                                       unsigned Depth = 0) const;
 183
 184   MVT getScalarShiftAmountTy(EVT LHSTy) const override;
 185
 186   /// allowsUnalignedMemoryAccesses - Returns true if the target allows
 187   /// unaligned memory accesses. of the specified type.
 188   bool allowsUnalignedMemoryAccesses(EVT VT, unsigned AddrSpace = 0,
 189                                      bool *Fast = 0) const override {
 190     if (RequireStrictAlign)
 191       return false;
 192     // FIXME: True for Cyclone, but not necessary others.
 193     if (Fast)
 194       *Fast = true;
 195     return true;
 196   }
 197
 198   /// LowerOperation - Provide custom lowering hooks for some operations.
 199   SDValue LowerOperation(SDValue Op, SelectionDAG &DAG) const override;
 200
 201   const char *getTargetNodeName(unsigned Opcode) const override;
 202
 203   SDValue PerformDAGCombine(SDNode *N, DAGCombinerInfo &DCI) const override;
 204
 205   /// getFunctionAlignment - Return the Log2 alignment of this function.
 206   unsigned getFunctionAlignment(const Function *F) const;
 207
 208   /// getMaximalGlobalOffset - Returns the maximal possible offset which can
 209   /// be used for loads / stores from the global.
 210   unsigned getMaximalGlobalOffset() const override;
 211
 212   /// Returns true if a cast between SrcAS and DestAS is a noop.
 213   bool isNoopAddrSpaceCast(unsigned SrcAS, unsigned DestAS) const override {
 214     // Addrspacecasts are always noops.
 215     return true;
 216   }
 217
 218   /// createFastISel - This method returns a target specific FastISel object,
 219   /// or null if the target does not support "fast" ISel.
 220   FastISel *createFastISel(FunctionLoweringInfo &funcInfo,
 221                            const TargetLibraryInfo *libInfo) const override;
 222
 223   bool isOffsetFoldingLegal(const GlobalAddressSDNode *GA) const override;
 224
 225   bool isFPImmLegal(const APFloat &Imm, EVT VT) const override;
 226
 227   /// isShuffleMaskLegal - Return true if the given shuffle mask can be
 228   /// codegen'd directly, or if it should be stack expanded.
 229   bool isShuffleMaskLegal(const SmallVectorImpl<int> &M, EVT VT) const override;
 230
 231   /// getSetCCResultType - Return the ISD::SETCC ValueType
 232   EVT getSetCCResultType(LLVMContext &Context, EVT VT) const override;
 233
 234   SDValue ReconstructShuffle(SDValue Op, SelectionDAG &DAG) const;
 235
 236   MachineBasicBlock *EmitAtomicBinary(MachineInstr *MI, MachineBasicBlock *BB,
 237                                       unsigned Size, unsigned BinOpcode) const;
 238   MachineBasicBlock *EmitAtomicCmpSwap(MachineInstr *MI, MachineBasicBlock *BB,
 239                                        unsigned Size) const;
 240   MachineBasicBlock *EmitAtomicBinary128(MachineInstr *MI,
 241                                          MachineBasicBlock *BB,
 242                                          unsigned BinOpcodeLo,
 243                                          unsigned BinOpcodeHi) const;
 244   MachineBasicBlock *EmitAtomicCmpSwap128(MachineInstr *MI,
 245                                           MachineBasicBlock *BB) const;
 246   MachineBasicBlock *EmitAtomicMinMax128(MachineInstr *MI,
 247                                          MachineBasicBlock *BB,
 248                                          unsigned CondCode) const;
 249   MachineBasicBlock *EmitF128CSEL(MachineInstr *MI,
 250                                   MachineBasicBlock *BB) const;
 251
 252   MachineBasicBlock *
 253   EmitInstrWithCustomInserter(MachineInstr *MI,
 254                               MachineBasicBlock *MBB) const override;
 255
 256   bool getTgtMemIntrinsic(IntrinsicInfo &Info, const CallInst &I,
 257                           unsigned Intrinsic) const override;
 258
 259   bool isTruncateFree(Type *Ty1, Type *Ty2) const override;
 260   bool isTruncateFree(EVT VT1, EVT VT2) const override;
 261
 262   bool isZExtFree(Type *Ty1, Type *Ty2) const override;
 263   bool isZExtFree(EVT VT1, EVT VT2) const override;
 264   bool isZExtFree(SDValue Val, EVT VT2) const override;
 265
 266   bool hasPairedLoad(Type *LoadedType,
 267                      unsigned &RequiredAligment) const override;
 268   bool hasPairedLoad(EVT LoadedType, unsigned &RequiredAligment) const override;
 269
 270   bool isLegalAddImmediate(int64_t) const override;
 271   bool isLegalICmpImmediate(int64_t) const override;
 272
 273   EVT getOptimalMemOpType(uint64_t Size, unsigned DstAlign, unsigned SrcAlign,
 274                           bool IsMemset, bool ZeroMemset, bool MemcpyStrSrc,
 275                           MachineFunction &MF) const override;
 276
 277   /// isLegalAddressingMode - Return true if the addressing mode represented
 278   /// by AM is legal for this target, for a load/store of the specified type.
 279   bool isLegalAddressingMode(const AddrMode &AM, Type *Ty) const override;
 280
 281   /// \brief Return the cost of the scaling factor used in the addressing
 282   /// mode represented by AM for this target, for a load/store
 283   /// of the specified type.
 284   /// If the AM is supported, the return value must be >= 0.
 285   /// If the AM is not supported, it returns a negative value.
 286   int getScalingFactorCost(const AddrMode &AM, Type *Ty) const override;
 287
 288   /// isFMAFasterThanFMulAndFAdd - Return true if an FMA operation is faster
 289   /// than a pair of fmul and fadd instructions. fmuladd intrinsics will be
 290   /// expanded to FMAs when this method returns true, otherwise fmuladd is
 291   /// expanded to fmul + fadd.
 292   bool isFMAFasterThanFMulAndFAdd(EVT VT) const override;
 293
 294   const MCPhysReg *getScratchRegisters(CallingConv::ID CC) const override;
 295
 296   bool shouldConvertConstantLoadToIntImm(const APInt &Imm,
 297                                          Type *Ty) const override;
 298
 299 private:
 300   /// Subtarget - Keep a pointer to the ARM64Subtarget around so that we can
 301   /// make the right decision when generating code for different targets.
 302   const ARM64Subtarget *Subtarget;
 303
 304   void addTypeForNEON(EVT VT, EVT PromotedBitwiseVT);
 305   void addDRTypeForNEON(MVT VT);
 306   void addQRTypeForNEON(MVT VT);
 307
 308   SDValue
 309   LowerFormalArguments(SDValue Chain, CallingConv::ID CallConv, bool isVarArg,
 310                        const SmallVectorImpl<ISD::InputArg> &Ins, SDLoc DL,
 311                        SelectionDAG &DAG,
 312                        SmallVectorImpl<SDValue> &InVals) const override;
 313
 314   SDValue LowerCall(CallLoweringInfo & /*CLI*/,
 315                     SmallVectorImpl<SDValue> &InVals) const override;
 316
 317   SDValue LowerCallResult(SDValue Chain, SDValue InFlag,
 318                           CallingConv::ID CallConv, bool isVarArg,
 319                           const SmallVectorImpl<ISD::InputArg> &Ins, SDLoc DL,
 320                           SelectionDAG &DAG, SmallVectorImpl<SDValue> &InVals,
 321                           bool isThisReturn, SDValue ThisVal) const;
 322
 323   bool isEligibleForTailCallOptimization(
 324       SDValue Callee, CallingConv::ID CalleeCC, bool isVarArg,
 325       bool isCalleeStructRet, bool isCallerStructRet,
 326       const SmallVectorImpl<ISD::OutputArg> &Outs,
 327       const SmallVectorImpl<SDValue> &OutVals,
 328       const SmallVectorImpl<ISD::InputArg> &Ins, SelectionDAG &DAG) const;
 329
 330   void saveVarArgRegisters(CCState &CCInfo, SelectionDAG &DAG, SDLoc DL,
 331                            SDValue &Chain) const;
 332
 333   bool CanLowerReturn(CallingConv::ID CallConv, MachineFunction &MF,
 334                       bool isVarArg,
 335                       const SmallVectorImpl<ISD::OutputArg> &Outs,
 336                       LLVMContext &Context) const override;
 337
 338   SDValue LowerReturn(SDValue Chain, CallingConv::ID CallConv, bool isVarArg,
 339                       const SmallVectorImpl<ISD::OutputArg> &Outs,
 340                       const SmallVectorImpl<SDValue> &OutVals, SDLoc DL,
 341                       SelectionDAG &DAG) const override;
 342
 343   SDValue LowerGlobalAddress(SDValue Op, SelectionDAG &DAG) const;
 344   SDValue LowerGlobalTLSAddress(SDValue Op, SelectionDAG &DAG) const;
 345   SDValue LowerDarwinGlobalTLSAddress(SDValue Op, SelectionDAG &DAG) const;
 346   SDValue LowerELFGlobalTLSAddress(SDValue Op, SelectionDAG &DAG) const;
 347   SDValue LowerELFTLSDescCall(SDValue SymAddr, SDValue DescAddr, SDLoc DL,
 348                               SelectionDAG &DAG) const;
 349   SDValue LowerSETCC(SDValue Op, SelectionDAG &DAG) const;
 350   SDValue LowerBR_CC(SDValue Op, SelectionDAG &DAG) const;
 351   SDValue LowerSELECT(SDValue Op, SelectionDAG &DAG) const;
 352   SDValue LowerSELECT_CC(SDValue Op, SelectionDAG &DAG) const;
 353   SDValue LowerJumpTable(SDValue Op, SelectionDAG &DAG) const;
 354   SDValue LowerConstantPool(SDValue Op, SelectionDAG &DAG) const;
 355   SDValue LowerBlockAddress(SDValue Op, SelectionDAG &DAG) const;
 356   SDValue LowerAAPCS_VASTART(SDValue Op, SelectionDAG &DAG) const;
 357   SDValue LowerDarwin_VASTART(SDValue Op, SelectionDAG &DAG) const;
 358   SDValue LowerVASTART(SDValue Op, SelectionDAG &DAG) const;
 359   SDValue LowerVACOPY(SDValue Op, SelectionDAG &DAG) const;
 360   SDValue LowerVAARG(SDValue Op, SelectionDAG &DAG) const;
 361   SDValue LowerFRAMEADDR(SDValue Op, SelectionDAG &DAG) const;
 362   SDValue LowerRETURNADDR(SDValue Op, SelectionDAG &DAG) const;
 363   SDValue LowerINSERT_VECTOR_ELT(SDValue Op, SelectionDAG &DAG) const;
 364   SDValue LowerEXTRACT_VECTOR_ELT(SDValue Op, SelectionDAG &DAG) const;
 365   SDValue LowerSCALAR_TO_VECTOR(SDValue Op, SelectionDAG &DAG) const;
 366   SDValue LowerBUILD_VECTOR(SDValue Op, SelectionDAG &DAG) const;
 367   SDValue LowerVECTOR_SHUFFLE(SDValue Op, SelectionDAG &DAG) const;
 368   SDValue LowerEXTRACT_SUBVECTOR(SDValue Op, SelectionDAG &DAG) const;
 369   SDValue LowerVectorSRA_SRL_SHL(SDValue Op, SelectionDAG &DAG) const;
 370   SDValue LowerShiftLeftParts(SDValue Op, SelectionDAG &DAG) const;
 371   SDValue LowerShiftRightParts(SDValue Op, SelectionDAG &DAG) const;
 372   SDValue LowerVSETCC(SDValue Op, SelectionDAG &DAG) const;
 373   SDValue LowerCTPOP(SDValue Op, SelectionDAG &DAG) const;
 374   SDValue LowerF128Call(SDValue Op, SelectionDAG &DAG,
 375                         RTLIB::Libcall Call) const;
 376   SDValue LowerFCOPYSIGN(SDValue Op, SelectionDAG &DAG) const;
 377   SDValue LowerFP_EXTEND(SDValue Op, SelectionDAG &DAG) const;
 378   SDValue LowerFP_ROUND(SDValue Op, SelectionDAG &DAG) const;
 379   SDValue LowerFP_TO_INT(SDValue Op, SelectionDAG &DAG) const;
 380   SDValue LowerINT_TO_FP(SDValue Op, SelectionDAG &DAG) const;
 381   SDValue LowerVectorAND(SDValue Op, SelectionDAG &DAG) const;
 382   SDValue LowerVectorOR(SDValue Op, SelectionDAG &DAG) const;
 383   SDValue LowerCONCAT_VECTORS(SDValue Op, SelectionDAG &DAG) const;
 384   SDValue LowerFSINCOS(SDValue Op, SelectionDAG &DAG) const;
 385
 386   ConstraintType getConstraintType(const std::string &Constraint) const;
 387
 388   /// Examine constraint string and operand type and determine a weight value.
 389   /// The operand object must already have been set up with the operand type.
 390   ConstraintWeight getSingleConstraintMatchWeight(AsmOperandInfo &info,
 391                                                   const char *constraint) const;
 392
 393   std::pair<unsigned, const TargetRegisterClass *>
 394   getRegForInlineAsmConstraint(const std::string &Constraint, MVT VT) const;
 395   void LowerAsmOperandForConstraint(SDValue Op, std::string &Constraint,
 396                                     std::vector<SDValue> &Ops,
 397                                     SelectionDAG &DAG) const;
 398
 399   bool isUsedByReturnOnly(SDNode *N, SDValue &Chain) const;
 400   bool mayBeEmittedAsTailCall(CallInst *CI) const;
 401   bool getIndexedAddressParts(SDNode *Op, SDValue &Base, SDValue &Offset,
 402                               ISD::MemIndexedMode &AM, bool &IsInc,
 403                               SelectionDAG &DAG) const;
 404   bool getPreIndexedAddressParts(SDNode *N, SDValue &Base, SDValue &Offset,
 405                                  ISD::MemIndexedMode &AM,
 406                                  SelectionDAG &DAG) const;
 407   bool getPostIndexedAddressParts(SDNode *N, SDNode *Op, SDValue &Base,
 408                                   SDValue &Offset, ISD::MemIndexedMode &AM,
 409                                   SelectionDAG &DAG) const;
 410
 411   void ReplaceNodeResults(SDNode *N, SmallVectorImpl<SDValue> &Results,
 412                           SelectionDAG &DAG) const;
 413 };
 414
 415 namespace ARM64 {
 416 FastISel *createFastISel(FunctionLoweringInfo &funcInfo,
 417                          const TargetLibraryInfo *libInfo);
 418 } // end namespace ARM64
 419
 420 } // end namespace llvm
 421
 422 #endif // LLVM_TARGET_ARM64_ISELLOWERING_H