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 26namespace llvm { 27 28class PPCTTIImpl : public BasicTTIImplBase<PPCTTIImpl> { 29 typedef BasicTTIImplBase<PPCTTIImpl> BaseT; 30 typedef TargetTransformInfo TTI; 31 friend BaseT; 32 33 const PPCSubtarget *ST; 34 const PPCTargetLowering *TLI; 35 36 const PPCSubtarget *getST() const { return ST; } 37 const PPCTargetLowering *getTLI() const { return TLI; } 38 39public: 40 explicit PPCTTIImpl(const PPCTargetMachine *TM, Function &F) 41 : BaseT(TM), ST(TM->getSubtargetImpl(F)), TLI(ST->getTargetLowering()) {} 42 43 // Provide value semantics. MSVC requires that we spell all of these out. 44 PPCTTIImpl(const PPCTTIImpl &Arg) 45 : BaseT(static_cast<const BaseT &>(Arg)), ST(Arg.ST), TLI(Arg.TLI) {} 46 PPCTTIImpl(PPCTTIImpl &&Arg) 47 : BaseT(std::move(static_cast<BaseT &>(Arg))), ST(std::move(Arg.ST)), 48 TLI(std::move(Arg.TLI)) {} 49 PPCTTIImpl &operator=(const PPCTTIImpl &RHS) { 50 BaseT::operator=(static_cast<const BaseT &>(RHS)); 51 ST = RHS.ST; 52 TLI = RHS.TLI; 53 return *this; 54 } 55 PPCTTIImpl &operator=(PPCTTIImpl &&RHS) { 56 BaseT::operator=(std::move(static_cast<BaseT &>(RHS))); 57 ST = std::move(RHS.ST); 58 TLI = std::move(RHS.TLI); 59 return *this; 60 } 61 62 /// \name Scalar TTI Implementations 63 /// @{ 64 65 using BaseT::getIntImmCost; 66 unsigned getIntImmCost(const APInt &Imm, Type *Ty); 67 68 unsigned getIntImmCost(unsigned Opcode, unsigned Idx, const APInt &Imm, 69 Type *Ty); 70 unsigned getIntImmCost(Intrinsic::ID IID, unsigned Idx, const APInt &Imm, 71 Type *Ty); 72 73 TTI::PopcntSupportKind getPopcntSupport(unsigned TyWidth); 74 void getUnrollingPreferences(Loop *L, TTI::UnrollingPreferences &UP); 75 76 /// @} 77 78 /// \name Vector TTI Implementations 79 /// @{ 80 81 bool enableAggressiveInterleaving(bool LoopHasReductions); 82 unsigned getNumberOfRegisters(bool Vector); 83 unsigned getRegisterBitWidth(bool Vector); 84 unsigned getMaxInterleaveFactor(); 85 unsigned getArithmeticInstrCost( 86 unsigned Opcode, Type *Ty, 87 TTI::OperandValueKind Opd1Info = TTI::OK_AnyValue, 88 TTI::OperandValueKind Opd2Info = TTI::OK_AnyValue, 89 TTI::OperandValueProperties Opd1PropInfo = TTI::OP_None, 90 TTI::OperandValueProperties Opd2PropInfo = TTI::OP_None); 91 unsigned getShuffleCost(TTI::ShuffleKind Kind, Type *Tp, int Index, 92 Type *SubTp); 93 unsigned getCastInstrCost(unsigned Opcode, Type *Dst, Type *Src); 94 unsigned getCmpSelInstrCost(unsigned Opcode, Type *ValTy, Type *CondTy); 95 unsigned getVectorInstrCost(unsigned Opcode, Type *Val, unsigned Index); 96 unsigned getMemoryOpCost(unsigned Opcode, Type *Src, unsigned Alignment, 97 unsigned AddressSpace); 98 99 /// @} 100}; 101 102} // end namespace llvm 103 104#endif 105