lib/Target/PowerPC/PPCTargetTransformInfo.h

   1 //===-- PPCTargetTransformInfo.h - PPC specific TTI -------------*- 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 /// \file
  10 /// This file a TargetTransformInfo::Concept conforming object specific to the
  11 /// PPC target machine. It uses the target's detailed information to
  12 /// provide more precise answers to certain TTI queries, while letting the
  13 /// target independent and default TTI implementations handle the rest.
  14 ///
  15 //===----------------------------------------------------------------------===//
  16
  17 #ifndef LLVM_LIB_TARGET_POWERPC_PPCTARGETTRANSFORMINFO_H
  18 #define LLVM_LIB_TARGET_POWERPC_PPCTARGETTRANSFORMINFO_H
  19
  20 #include "PPC.h"
  21 #include "PPCTargetMachine.h"
  22 #include "llvm/Analysis/TargetTransformInfo.h"
  23 #include "llvm/CodeGen/BasicTTIImpl.h"
  24 #include "llvm/Target/TargetLowering.h"
  25
  26 namespace llvm {
  27
  28 class PPCTTIImpl : public BasicTTIImplBase<PPCTTIImpl> {
  29   typedef BasicTTIImplBase<PPCTTIImpl> BaseT;
  30   typedef TargetTransformInfo TTI;
  31   friend BaseT;
  32
  33   const PPCTargetMachine *TM;
  34   const PPCSubtarget *ST;
  35   const PPCTargetLowering *TLI;
  36
  37   const PPCTargetMachine *getTM() const { return TM; }
  38   const PPCTargetLowering *getTLI() const { return TLI; }
  39
  40 public:
  41   explicit PPCTTIImpl(const PPCTargetMachine *TM, Function &F)
  42       : BaseT(TM), TM(TM), ST(TM->getSubtargetImpl(F)),
  43         TLI(ST->getTargetLowering()) {}
  44
  45   // Provide value semantics. MSVC requires that we spell all of these out.
  46   PPCTTIImpl(const PPCTTIImpl &Arg)
  47       : BaseT(static_cast<const BaseT &>(Arg)), TM(Arg.TM), ST(Arg.ST),
  48         TLI(Arg.TLI) {}
  49   PPCTTIImpl(PPCTTIImpl &&Arg)
  50       : BaseT(std::move(static_cast<BaseT &>(Arg))), TM(std::move(Arg.TM)),
  51         ST(std::move(Arg.ST)), TLI(std::move(Arg.TLI)) {}
  52   PPCTTIImpl &operator=(const PPCTTIImpl &RHS) {
  53     BaseT::operator=(static_cast<const BaseT &>(RHS));
  54     TM = RHS.TM;
  55     ST = RHS.ST;
  56     TLI = RHS.TLI;
  57     return *this;
  58   }
  59   PPCTTIImpl &operator=(PPCTTIImpl &&RHS) {
  60     BaseT::operator=(std::move(static_cast<BaseT &>(RHS)));
  61     TM = std::move(RHS.TM);
  62     ST = std::move(RHS.ST);
  63     TLI = std::move(RHS.TLI);
  64     return *this;
  65   }
  66
  67   /// \name Scalar TTI Implementations
  68   /// @{
  69
  70   using BaseT::getIntImmCost;
  71   unsigned getIntImmCost(const APInt &Imm, Type *Ty);
  72
  73   unsigned getIntImmCost(unsigned Opcode, unsigned Idx, const APInt &Imm,
  74                          Type *Ty);
  75   unsigned getIntImmCost(Intrinsic::ID IID, unsigned Idx, const APInt &Imm,
  76                          Type *Ty);
  77
  78   TTI::PopcntSupportKind getPopcntSupport(unsigned TyWidth);
  79   void getUnrollingPreferences(const Function *F, Loop *L,
  80                                TTI::UnrollingPreferences &UP);
  81
  82   /// @}
  83
  84   /// \name Vector TTI Implementations
  85   /// @{
  86
  87   unsigned getNumberOfRegisters(bool Vector);
  88   unsigned getRegisterBitWidth(bool Vector);
  89   unsigned getMaxInterleaveFactor();
  90   unsigned getArithmeticInstrCost(
  91       unsigned Opcode, Type *Ty,
  92       TTI::OperandValueKind Opd1Info = TTI::OK_AnyValue,
  93       TTI::OperandValueKind Opd2Info = TTI::OK_AnyValue,
  94       TTI::OperandValueProperties Opd1PropInfo = TTI::OP_None,
  95       TTI::OperandValueProperties Opd2PropInfo = TTI::OP_None);
  96   unsigned getShuffleCost(TTI::ShuffleKind Kind, Type *Tp, int Index,
  97                           Type *SubTp);
  98   unsigned getCastInstrCost(unsigned Opcode, Type *Dst, Type *Src);
  99   unsigned getCmpSelInstrCost(unsigned Opcode, Type *ValTy, Type *CondTy);
 100   unsigned getVectorInstrCost(unsigned Opcode, Type *Val, unsigned Index);
 101   unsigned getMemoryOpCost(unsigned Opcode, Type *Src, unsigned Alignment,
 102                            unsigned AddressSpace);
 103
 104   /// @}
 105 };
 106
 107 } // end namespace llvm
 108
 109 #endif