contrib/llvm/lib/Target/SystemZ/SystemZTargetTransformInfo.h

   1 //===-- SystemZTargetTransformInfo.h - SystemZ-specific TTI ---------------===//
   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 #ifndef LLVM_LIB_TARGET_SYSTEMZ_SYSTEMZTARGETTRANSFORMINFO_H
  11 #define LLVM_LIB_TARGET_SYSTEMZ_SYSTEMZTARGETTRANSFORMINFO_H
  12
  13 #include "SystemZTargetMachine.h"
  14 #include "llvm/Analysis/TargetTransformInfo.h"
  15 #include "llvm/CodeGen/BasicTTIImpl.h"
  16
  17 namespace llvm {
  18
  19 class SystemZTTIImpl : public BasicTTIImplBase<SystemZTTIImpl> {
  20   typedef BasicTTIImplBase<SystemZTTIImpl> BaseT;
  21   typedef TargetTransformInfo TTI;
  22   friend BaseT;
  23
  24   const SystemZSubtarget *ST;
  25   const SystemZTargetLowering *TLI;
  26
  27   const SystemZSubtarget *getST() const { return ST; }
  28   const SystemZTargetLowering *getTLI() const { return TLI; }
  29
  30   unsigned const LIBCALL_COST = 30;
  31
  32 public:
  33   explicit SystemZTTIImpl(const SystemZTargetMachine *TM, const Function &F)
  34       : BaseT(TM, F.getParent()->getDataLayout()), ST(TM->getSubtargetImpl(F)),
  35         TLI(ST->getTargetLowering()) {}
  36
  37   /// \name Scalar TTI Implementations
  38   /// @{
  39
  40   int getIntImmCost(const APInt &Imm, Type *Ty);
  41
  42   int getIntImmCost(unsigned Opcode, unsigned Idx, const APInt &Imm, Type *Ty);
  43   int getIntImmCost(Intrinsic::ID IID, unsigned Idx, const APInt &Imm,
  44                     Type *Ty);
  45
  46   TTI::PopcntSupportKind getPopcntSupport(unsigned TyWidth);
  47
  48   void getUnrollingPreferences(Loop *L, TTI::UnrollingPreferences &UP);
  49
  50   /// @}
  51
  52   /// \name Vector TTI Implementations
  53   /// @{
  54
  55   unsigned getNumberOfRegisters(bool Vector);
  56   unsigned getRegisterBitWidth(bool Vector) const;
  57
  58   bool prefersVectorizedAddressing() { return false; }
  59   bool supportsEfficientVectorElementLoadStore() { return true; }
  60   bool enableInterleavedAccessVectorization() { return true; }
  61
  62   int getArithmeticInstrCost(
  63       unsigned Opcode, Type *Ty,
  64       TTI::OperandValueKind Opd1Info = TTI::OK_AnyValue,
  65       TTI::OperandValueKind Opd2Info = TTI::OK_AnyValue,
  66       TTI::OperandValueProperties Opd1PropInfo = TTI::OP_None,
  67       TTI::OperandValueProperties Opd2PropInfo = TTI::OP_None,
  68       ArrayRef<const Value *> Args = ArrayRef<const Value *>());
  69   int getShuffleCost(TTI::ShuffleKind Kind, Type *Tp, int Index, Type *SubTp);
  70   unsigned getVectorTruncCost(Type *SrcTy, Type *DstTy);
  71   unsigned getVectorBitmaskConversionCost(Type *SrcTy, Type *DstTy);
  72   int getCastInstrCost(unsigned Opcode, Type *Dst, Type *Src,
  73                        const Instruction *I = nullptr);
  74   int getCmpSelInstrCost(unsigned Opcode, Type *ValTy, Type *CondTy,
  75                          const Instruction *I = nullptr);
  76   int getVectorInstrCost(unsigned Opcode, Type *Val, unsigned Index);
  77   int getMemoryOpCost(unsigned Opcode, Type *Src, unsigned Alignment,
  78                       unsigned AddressSpace, const Instruction *I = nullptr);
  79
  80   int getInterleavedMemoryOpCost(unsigned Opcode, Type *VecTy,
  81                                  unsigned Factor,
  82                                  ArrayRef<unsigned> Indices,
  83                                  unsigned Alignment,
  84                                  unsigned AddressSpace);
  85   /// @}
  86 };
  87
  88 } // end namespace llvm
  89
  90 #endif