LCOV - code coverage report
Current view: top level - lib/Analysis - TargetTransformInfo.cpp (source / functions) Hit Total Coverage
Test: llvm-toolchain.info Lines: 403 449 89.8 %
Date: 2018-09-23 13:06:45 Functions: 119 130 91.5 %
Legend: Lines: hit not hit

          Line data    Source code
       1             : //===- llvm/Analysis/TargetTransformInfo.cpp ------------------------------===//
       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             : #include "llvm/Analysis/TargetTransformInfo.h"
      11             : #include "llvm/Analysis/TargetTransformInfoImpl.h"
      12             : #include "llvm/IR/CallSite.h"
      13             : #include "llvm/IR/DataLayout.h"
      14             : #include "llvm/IR/Instruction.h"
      15             : #include "llvm/IR/Instructions.h"
      16             : #include "llvm/IR/IntrinsicInst.h"
      17             : #include "llvm/IR/Module.h"
      18             : #include "llvm/IR/Operator.h"
      19             : #include "llvm/IR/PatternMatch.h"
      20             : #include "llvm/Support/CommandLine.h"
      21             : #include "llvm/Support/ErrorHandling.h"
      22             : #include <utility>
      23             : 
      24             : using namespace llvm;
      25             : using namespace PatternMatch;
      26             : 
      27             : #define DEBUG_TYPE "tti"
      28             : 
      29             : static cl::opt<bool> EnableReduxCost("costmodel-reduxcost", cl::init(false),
      30             :                                      cl::Hidden,
      31             :                                      cl::desc("Recognize reduction patterns."));
      32             : 
      33             : namespace {
      34             : /// No-op implementation of the TTI interface using the utility base
      35             : /// classes.
      36             : ///
      37             : /// This is used when no target specific information is available.
      38             : struct NoTTIImpl : TargetTransformInfoImplCRTPBase<NoTTIImpl> {
      39             :   explicit NoTTIImpl(const DataLayout &DL)
      40             :       : TargetTransformInfoImplCRTPBase<NoTTIImpl>(DL) {}
      41             : };
      42             : }
      43             : 
      44       17799 : TargetTransformInfo::TargetTransformInfo(const DataLayout &DL)
      45       17799 :     : TTIImpl(new Model<NoTTIImpl>(NoTTIImpl(DL))) {}
      46             : 
      47     4417240 : TargetTransformInfo::~TargetTransformInfo() {}
      48             : 
      49       36047 : TargetTransformInfo::TargetTransformInfo(TargetTransformInfo &&Arg)
      50       36047 :     : TTIImpl(std::move(Arg.TTIImpl)) {}
      51             : 
      52     4346967 : TargetTransformInfo &TargetTransformInfo::operator=(TargetTransformInfo &&RHS) {
      53             :   TTIImpl = std::move(RHS.TTIImpl);
      54     4346967 :   return *this;
      55             : }
      56             : 
      57           0 : int TargetTransformInfo::getOperationCost(unsigned Opcode, Type *Ty,
      58             :                                           Type *OpTy) const {
      59           0 :   int Cost = TTIImpl->getOperationCost(Opcode, Ty, OpTy);
      60             :   assert(Cost >= 0 && "TTI should not produce negative costs!");
      61           0 :   return Cost;
      62             : }
      63             : 
      64           0 : int TargetTransformInfo::getCallCost(FunctionType *FTy, int NumArgs) const {
      65           0 :   int Cost = TTIImpl->getCallCost(FTy, NumArgs);
      66             :   assert(Cost >= 0 && "TTI should not produce negative costs!");
      67           0 :   return Cost;
      68             : }
      69             : 
      70           0 : int TargetTransformInfo::getCallCost(const Function *F,
      71             :                                      ArrayRef<const Value *> Arguments) const {
      72           0 :   int Cost = TTIImpl->getCallCost(F, Arguments);
      73             :   assert(Cost >= 0 && "TTI should not produce negative costs!");
      74           0 :   return Cost;
      75             : }
      76             : 
      77      285466 : unsigned TargetTransformInfo::getInliningThresholdMultiplier() const {
      78      285466 :   return TTIImpl->getInliningThresholdMultiplier();
      79             : }
      80             : 
      81       34368 : int TargetTransformInfo::getGEPCost(Type *PointeeType, const Value *Ptr,
      82             :                                     ArrayRef<const Value *> Operands) const {
      83       34368 :   return TTIImpl->getGEPCost(PointeeType, Ptr, Operands);
      84             : }
      85             : 
      86           0 : int TargetTransformInfo::getExtCost(const Instruction *I,
      87             :                                     const Value *Src) const {
      88           0 :   return TTIImpl->getExtCost(I, Src);
      89             : }
      90             : 
      91           4 : int TargetTransformInfo::getIntrinsicCost(
      92             :     Intrinsic::ID IID, Type *RetTy, ArrayRef<const Value *> Arguments) const {
      93           4 :   int Cost = TTIImpl->getIntrinsicCost(IID, RetTy, Arguments);
      94             :   assert(Cost >= 0 && "TTI should not produce negative costs!");
      95           4 :   return Cost;
      96             : }
      97             : 
      98             : unsigned
      99        7196 : TargetTransformInfo::getEstimatedNumberOfCaseClusters(const SwitchInst &SI,
     100             :                                                       unsigned &JTSize) const {
     101        7196 :   return TTIImpl->getEstimatedNumberOfCaseClusters(SI, JTSize);
     102             : }
     103             : 
     104     4046745 : int TargetTransformInfo::getUserCost(const User *U,
     105             :     ArrayRef<const Value *> Operands) const {
     106     4046745 :   int Cost = TTIImpl->getUserCost(U, Operands);
     107             :   assert(Cost >= 0 && "TTI should not produce negative costs!");
     108     4046745 :   return Cost;
     109             : }
     110             : 
     111     5510853 : bool TargetTransformInfo::hasBranchDivergence() const {
     112     5510853 :   return TTIImpl->hasBranchDivergence();
     113             : }
     114             : 
     115     1404136 : bool TargetTransformInfo::isSourceOfDivergence(const Value *V) const {
     116     1404136 :   return TTIImpl->isSourceOfDivergence(V);
     117             : }
     118             : 
     119      245287 : bool llvm::TargetTransformInfo::isAlwaysUniform(const Value *V) const {
     120      245287 :   return TTIImpl->isAlwaysUniform(V);
     121             : }
     122             : 
     123       22983 : unsigned TargetTransformInfo::getFlatAddressSpace() const {
     124       22983 :   return TTIImpl->getFlatAddressSpace();
     125             : }
     126             : 
     127      991617 : bool TargetTransformInfo::isLoweredToCall(const Function *F) const {
     128      991617 :   return TTIImpl->isLoweredToCall(F);
     129             : }
     130             : 
     131        8833 : void TargetTransformInfo::getUnrollingPreferences(
     132             :     Loop *L, ScalarEvolution &SE, UnrollingPreferences &UP) const {
     133        8833 :   return TTIImpl->getUnrollingPreferences(L, SE, UP);
     134             : }
     135             : 
     136       25983 : bool TargetTransformInfo::isLegalAddImmediate(int64_t Imm) const {
     137       25983 :   return TTIImpl->isLegalAddImmediate(Imm);
     138             : }
     139             : 
     140       28692 : bool TargetTransformInfo::isLegalICmpImmediate(int64_t Imm) const {
     141       28692 :   return TTIImpl->isLegalICmpImmediate(Imm);
     142             : }
     143             : 
     144      579433 : bool TargetTransformInfo::isLegalAddressingMode(Type *Ty, GlobalValue *BaseGV,
     145             :                                                 int64_t BaseOffset,
     146             :                                                 bool HasBaseReg,
     147             :                                                 int64_t Scale,
     148             :                                                 unsigned AddrSpace,
     149             :                                                 Instruction *I) const {
     150      579433 :   return TTIImpl->isLegalAddressingMode(Ty, BaseGV, BaseOffset, HasBaseReg,
     151      579433 :                                         Scale, AddrSpace, I);
     152             : }
     153             : 
     154      121266 : bool TargetTransformInfo::isLSRCostLess(LSRCost &C1, LSRCost &C2) const {
     155      121266 :   return TTIImpl->isLSRCostLess(C1, C2);
     156             : }
     157             : 
     158       33918 : bool TargetTransformInfo::canMacroFuseCmp() const {
     159       33918 :   return TTIImpl->canMacroFuseCmp();
     160             : }
     161             : 
     162      256965 : bool TargetTransformInfo::shouldFavorPostInc() const {
     163      256965 :   return TTIImpl->shouldFavorPostInc();
     164             : }
     165             : 
     166         507 : bool TargetTransformInfo::isLegalMaskedStore(Type *DataType) const {
     167         507 :   return TTIImpl->isLegalMaskedStore(DataType);
     168             : }
     169             : 
     170         486 : bool TargetTransformInfo::isLegalMaskedLoad(Type *DataType) const {
     171         486 :   return TTIImpl->isLegalMaskedLoad(DataType);
     172             : }
     173             : 
     174         786 : bool TargetTransformInfo::isLegalMaskedGather(Type *DataType) const {
     175         786 :   return TTIImpl->isLegalMaskedGather(DataType);
     176             : }
     177             : 
     178         600 : bool TargetTransformInfo::isLegalMaskedScatter(Type *DataType) const {
     179         600 :   return TTIImpl->isLegalMaskedScatter(DataType);
     180             : }
     181             : 
     182          65 : bool TargetTransformInfo::hasDivRemOp(Type *DataType, bool IsSigned) const {
     183          65 :   return TTIImpl->hasDivRemOp(DataType, IsSigned);
     184             : }
     185             : 
     186         599 : bool TargetTransformInfo::hasVolatileVariant(Instruction *I,
     187             :                                              unsigned AddrSpace) const {
     188         599 :   return TTIImpl->hasVolatileVariant(I, AddrSpace);
     189             : }
     190             : 
     191        1351 : bool TargetTransformInfo::prefersVectorizedAddressing() const {
     192        1351 :   return TTIImpl->prefersVectorizedAddressing();
     193             : }
     194             : 
     195      126088 : int TargetTransformInfo::getScalingFactorCost(Type *Ty, GlobalValue *BaseGV,
     196             :                                               int64_t BaseOffset,
     197             :                                               bool HasBaseReg,
     198             :                                               int64_t Scale,
     199             :                                               unsigned AddrSpace) const {
     200      126088 :   int Cost = TTIImpl->getScalingFactorCost(Ty, BaseGV, BaseOffset, HasBaseReg,
     201      126088 :                                            Scale, AddrSpace);
     202             :   assert(Cost >= 0 && "TTI should not produce negative costs!");
     203      126088 :   return Cost;
     204             : }
     205             : 
     206       71554 : bool TargetTransformInfo::LSRWithInstrQueries() const {
     207       71554 :   return TTIImpl->LSRWithInstrQueries();
     208             : }
     209             : 
     210       21321 : bool TargetTransformInfo::isTruncateFree(Type *Ty1, Type *Ty2) const {
     211       21321 :   return TTIImpl->isTruncateFree(Ty1, Ty2);
     212             : }
     213             : 
     214        5523 : bool TargetTransformInfo::isProfitableToHoist(Instruction *I) const {
     215        5523 :   return TTIImpl->isProfitableToHoist(I);
     216             : }
     217             : 
     218        1104 : bool TargetTransformInfo::useAA() const { return TTIImpl->useAA(); }
     219             : 
     220         756 : bool TargetTransformInfo::isTypeLegal(Type *Ty) const {
     221         756 :   return TTIImpl->isTypeLegal(Ty);
     222             : }
     223             : 
     224           0 : unsigned TargetTransformInfo::getJumpBufAlignment() const {
     225           0 :   return TTIImpl->getJumpBufAlignment();
     226             : }
     227             : 
     228           0 : unsigned TargetTransformInfo::getJumpBufSize() const {
     229           0 :   return TTIImpl->getJumpBufSize();
     230             : }
     231             : 
     232        1295 : bool TargetTransformInfo::shouldBuildLookupTables() const {
     233        1295 :   return TTIImpl->shouldBuildLookupTables();
     234             : }
     235        3592 : bool TargetTransformInfo::shouldBuildLookupTablesForConstant(Constant *C) const {
     236        3592 :   return TTIImpl->shouldBuildLookupTablesForConstant(C);
     237             : }
     238             : 
     239           4 : bool TargetTransformInfo::useColdCCForColdCall(Function &F) const {
     240           4 :   return TTIImpl->useColdCCForColdCall(F);
     241             : }
     242             : 
     243         808 : unsigned TargetTransformInfo::
     244             : getScalarizationOverhead(Type *Ty, bool Insert, bool Extract) const {
     245         808 :   return TTIImpl->getScalarizationOverhead(Ty, Insert, Extract);
     246             : }
     247             : 
     248         851 : unsigned TargetTransformInfo::
     249             : getOperandsScalarizationOverhead(ArrayRef<const Value *> Args,
     250             :                                  unsigned VF) const {
     251         851 :   return TTIImpl->getOperandsScalarizationOverhead(Args, VF);
     252             : }
     253             : 
     254         458 : bool TargetTransformInfo::supportsEfficientVectorElementLoadStore() const {
     255         458 :   return TTIImpl->supportsEfficientVectorElementLoadStore();
     256             : }
     257             : 
     258          78 : bool TargetTransformInfo::enableAggressiveInterleaving(bool LoopHasReductions) const {
     259          78 :   return TTIImpl->enableAggressiveInterleaving(LoopHasReductions);
     260             : }
     261             : 
     262             : const TargetTransformInfo::MemCmpExpansionOptions *
     263      195891 : TargetTransformInfo::enableMemCmpExpansion(bool IsZeroCmp) const {
     264      195891 :   return TTIImpl->enableMemCmpExpansion(IsZeroCmp);
     265             : }
     266             : 
     267         948 : bool TargetTransformInfo::enableInterleavedAccessVectorization() const {
     268         948 :   return TTIImpl->enableInterleavedAccessVectorization();
     269             : }
     270             : 
     271         156 : bool TargetTransformInfo::isFPVectorizationPotentiallyUnsafe() const {
     272         156 :   return TTIImpl->isFPVectorizationPotentiallyUnsafe();
     273             : }
     274             : 
     275        8232 : bool TargetTransformInfo::allowsMisalignedMemoryAccesses(LLVMContext &Context,
     276             :                                                          unsigned BitWidth,
     277             :                                                          unsigned AddressSpace,
     278             :                                                          unsigned Alignment,
     279             :                                                          bool *Fast) const {
     280        8232 :   return TTIImpl->allowsMisalignedMemoryAccesses(Context, BitWidth, AddressSpace,
     281        8232 :                                                  Alignment, Fast);
     282             : }
     283             : 
     284             : TargetTransformInfo::PopcntSupportKind
     285        3582 : TargetTransformInfo::getPopcntSupport(unsigned IntTyWidthInBit) const {
     286        3582 :   return TTIImpl->getPopcntSupport(IntTyWidthInBit);
     287             : }
     288             : 
     289          58 : bool TargetTransformInfo::haveFastSqrt(Type *Ty) const {
     290          58 :   return TTIImpl->haveFastSqrt(Ty);
     291             : }
     292             : 
     293          27 : bool TargetTransformInfo::isFCmpOrdCheaperThanFCmpZero(Type *Ty) const {
     294          27 :   return TTIImpl->isFCmpOrdCheaperThanFCmpZero(Ty);
     295             : }
     296             : 
     297         547 : int TargetTransformInfo::getFPOpCost(Type *Ty) const {
     298         547 :   int Cost = TTIImpl->getFPOpCost(Ty);
     299             :   assert(Cost >= 0 && "TTI should not produce negative costs!");
     300         547 :   return Cost;
     301             : }
     302             : 
     303         182 : int TargetTransformInfo::getIntImmCodeSizeCost(unsigned Opcode, unsigned Idx,
     304             :                                                const APInt &Imm,
     305             :                                                Type *Ty) const {
     306         182 :   int Cost = TTIImpl->getIntImmCodeSizeCost(Opcode, Idx, Imm, Ty);
     307             :   assert(Cost >= 0 && "TTI should not produce negative costs!");
     308         182 :   return Cost;
     309             : }
     310             : 
     311          84 : int TargetTransformInfo::getIntImmCost(const APInt &Imm, Type *Ty) const {
     312          84 :   int Cost = TTIImpl->getIntImmCost(Imm, Ty);
     313             :   assert(Cost >= 0 && "TTI should not produce negative costs!");
     314          84 :   return Cost;
     315             : }
     316             : 
     317      543514 : int TargetTransformInfo::getIntImmCost(unsigned Opcode, unsigned Idx,
     318             :                                        const APInt &Imm, Type *Ty) const {
     319      543514 :   int Cost = TTIImpl->getIntImmCost(Opcode, Idx, Imm, Ty);
     320             :   assert(Cost >= 0 && "TTI should not produce negative costs!");
     321      543514 :   return Cost;
     322             : }
     323             : 
     324      170267 : int TargetTransformInfo::getIntImmCost(Intrinsic::ID IID, unsigned Idx,
     325             :                                        const APInt &Imm, Type *Ty) const {
     326      170267 :   int Cost = TTIImpl->getIntImmCost(IID, Idx, Imm, Ty);
     327             :   assert(Cost >= 0 && "TTI should not produce negative costs!");
     328      170267 :   return Cost;
     329             : }
     330             : 
     331      243538 : unsigned TargetTransformInfo::getNumberOfRegisters(bool Vector) const {
     332      243538 :   return TTIImpl->getNumberOfRegisters(Vector);
     333             : }
     334             : 
     335       13656 : unsigned TargetTransformInfo::getRegisterBitWidth(bool Vector) const {
     336       13656 :   return TTIImpl->getRegisterBitWidth(Vector);
     337             : }
     338             : 
     339       11877 : unsigned TargetTransformInfo::getMinVectorRegisterBitWidth() const {
     340       11877 :   return TTIImpl->getMinVectorRegisterBitWidth();
     341             : }
     342             : 
     343         874 : bool TargetTransformInfo::shouldMaximizeVectorBandwidth(bool OptSize) const {
     344         874 :   return TTIImpl->shouldMaximizeVectorBandwidth(OptSize);
     345             : }
     346             : 
     347           2 : unsigned TargetTransformInfo::getMinimumVF(unsigned ElemWidth) const {
     348           2 :   return TTIImpl->getMinimumVF(ElemWidth);
     349             : }
     350             : 
     351       41270 : bool TargetTransformInfo::shouldConsiderAddressTypePromotion(
     352             :     const Instruction &I, bool &AllowPromotionWithoutCommonHeader) const {
     353       41270 :   return TTIImpl->shouldConsiderAddressTypePromotion(
     354       41270 :       I, AllowPromotionWithoutCommonHeader);
     355             : }
     356             : 
     357          51 : unsigned TargetTransformInfo::getCacheLineSize() const {
     358          51 :   return TTIImpl->getCacheLineSize();
     359             : }
     360             : 
     361           8 : llvm::Optional<unsigned> TargetTransformInfo::getCacheSize(CacheLevel Level)
     362             :   const {
     363           8 :   return TTIImpl->getCacheSize(Level);
     364             : }
     365             : 
     366          10 : llvm::Optional<unsigned> TargetTransformInfo::getCacheAssociativity(
     367             :   CacheLevel Level) const {
     368          10 :   return TTIImpl->getCacheAssociativity(Level);
     369             : }
     370             : 
     371       21225 : unsigned TargetTransformInfo::getPrefetchDistance() const {
     372       21225 :   return TTIImpl->getPrefetchDistance();
     373             : }
     374             : 
     375          78 : unsigned TargetTransformInfo::getMinPrefetchStride() const {
     376          78 :   return TTIImpl->getMinPrefetchStride();
     377             : }
     378             : 
     379         229 : unsigned TargetTransformInfo::getMaxPrefetchIterationsAhead() const {
     380         229 :   return TTIImpl->getMaxPrefetchIterationsAhead();
     381             : }
     382             : 
     383        1986 : unsigned TargetTransformInfo::getMaxInterleaveFactor(unsigned VF) const {
     384        1986 :   return TTIImpl->getMaxInterleaveFactor(VF);
     385             : }
     386             : 
     387      212223 : int TargetTransformInfo::getArithmeticInstrCost(
     388             :     unsigned Opcode, Type *Ty, OperandValueKind Opd1Info,
     389             :     OperandValueKind Opd2Info, OperandValueProperties Opd1PropInfo,
     390             :     OperandValueProperties Opd2PropInfo,
     391             :     ArrayRef<const Value *> Args) const {
     392      212223 :   int Cost = TTIImpl->getArithmeticInstrCost(Opcode, Ty, Opd1Info, Opd2Info,
     393      212223 :                                              Opd1PropInfo, Opd2PropInfo, Args);
     394             :   assert(Cost >= 0 && "TTI should not produce negative costs!");
     395      212223 :   return Cost;
     396             : }
     397             : 
     398        2953 : int TargetTransformInfo::getShuffleCost(ShuffleKind Kind, Type *Ty, int Index,
     399             :                                         Type *SubTp) const {
     400        2953 :   int Cost = TTIImpl->getShuffleCost(Kind, Ty, Index, SubTp);
     401             :   assert(Cost >= 0 && "TTI should not produce negative costs!");
     402        2953 :   return Cost;
     403             : }
     404             : 
     405        6923 : int TargetTransformInfo::getCastInstrCost(unsigned Opcode, Type *Dst,
     406             :                                  Type *Src, const Instruction *I) const {
     407             :   assert ((I == nullptr || I->getOpcode() == Opcode) &&
     408             :           "Opcode should reflect passed instruction.");
     409        6923 :   int Cost = TTIImpl->getCastInstrCost(Opcode, Dst, Src, I);
     410             :   assert(Cost >= 0 && "TTI should not produce negative costs!");
     411        6923 :   return Cost;
     412             : }
     413             : 
     414          32 : int TargetTransformInfo::getExtractWithExtendCost(unsigned Opcode, Type *Dst,
     415             :                                                   VectorType *VecTy,
     416             :                                                   unsigned Index) const {
     417          32 :   int Cost = TTIImpl->getExtractWithExtendCost(Opcode, Dst, VecTy, Index);
     418             :   assert(Cost >= 0 && "TTI should not produce negative costs!");
     419          32 :   return Cost;
     420             : }
     421             : 
     422       11418 : int TargetTransformInfo::getCFInstrCost(unsigned Opcode) const {
     423       11418 :   int Cost = TTIImpl->getCFInstrCost(Opcode);
     424             :   assert(Cost >= 0 && "TTI should not produce negative costs!");
     425       11418 :   return Cost;
     426             : }
     427             : 
     428        5476 : int TargetTransformInfo::getCmpSelInstrCost(unsigned Opcode, Type *ValTy,
     429             :                                  Type *CondTy, const Instruction *I) const {
     430             :   assert ((I == nullptr || I->getOpcode() == Opcode) &&
     431             :           "Opcode should reflect passed instruction.");
     432        5476 :   int Cost = TTIImpl->getCmpSelInstrCost(Opcode, ValTy, CondTy, I);
     433             :   assert(Cost >= 0 && "TTI should not produce negative costs!");
     434        5476 :   return Cost;
     435             : }
     436             : 
     437       88023 : int TargetTransformInfo::getVectorInstrCost(unsigned Opcode, Type *Val,
     438             :                                             unsigned Index) const {
     439       88023 :   int Cost = TTIImpl->getVectorInstrCost(Opcode, Val, Index);
     440             :   assert(Cost >= 0 && "TTI should not produce negative costs!");
     441       88023 :   return Cost;
     442             : }
     443             : 
     444      399520 : int TargetTransformInfo::getMemoryOpCost(unsigned Opcode, Type *Src,
     445             :                                          unsigned Alignment,
     446             :                                          unsigned AddressSpace,
     447             :                                          const Instruction *I) const {
     448             :   assert ((I == nullptr || I->getOpcode() == Opcode) &&
     449             :           "Opcode should reflect passed instruction.");
     450      399520 :   int Cost = TTIImpl->getMemoryOpCost(Opcode, Src, Alignment, AddressSpace, I);
     451             :   assert(Cost >= 0 && "TTI should not produce negative costs!");
     452      399520 :   return Cost;
     453             : }
     454             : 
     455         128 : int TargetTransformInfo::getMaskedMemoryOpCost(unsigned Opcode, Type *Src,
     456             :                                                unsigned Alignment,
     457             :                                                unsigned AddressSpace) const {
     458             :   int Cost =
     459         128 :       TTIImpl->getMaskedMemoryOpCost(Opcode, Src, Alignment, AddressSpace);
     460             :   assert(Cost >= 0 && "TTI should not produce negative costs!");
     461         128 :   return Cost;
     462             : }
     463             : 
     464         124 : int TargetTransformInfo::getGatherScatterOpCost(unsigned Opcode, Type *DataTy,
     465             :                                                 Value *Ptr, bool VariableMask,
     466             :                                                 unsigned Alignment) const {
     467         124 :   int Cost = TTIImpl->getGatherScatterOpCost(Opcode, DataTy, Ptr, VariableMask,
     468         124 :                                              Alignment);
     469             :   assert(Cost >= 0 && "TTI should not produce negative costs!");
     470         124 :   return Cost;
     471             : }
     472             : 
     473          93 : int TargetTransformInfo::getInterleavedMemoryOpCost(
     474             :     unsigned Opcode, Type *VecTy, unsigned Factor, ArrayRef<unsigned> Indices,
     475             :     unsigned Alignment, unsigned AddressSpace) const {
     476          93 :   int Cost = TTIImpl->getInterleavedMemoryOpCost(Opcode, VecTy, Factor, Indices,
     477          93 :                                                  Alignment, AddressSpace);
     478             :   assert(Cost >= 0 && "TTI should not produce negative costs!");
     479          93 :   return Cost;
     480             : }
     481             : 
     482         957 : int TargetTransformInfo::getIntrinsicInstrCost(Intrinsic::ID ID, Type *RetTy,
     483             :                                     ArrayRef<Type *> Tys, FastMathFlags FMF,
     484             :                                     unsigned ScalarizationCostPassed) const {
     485         957 :   int Cost = TTIImpl->getIntrinsicInstrCost(ID, RetTy, Tys, FMF,
     486         957 :                                             ScalarizationCostPassed);
     487             :   assert(Cost >= 0 && "TTI should not produce negative costs!");
     488         957 :   return Cost;
     489             : }
     490             : 
     491        2857 : int TargetTransformInfo::getIntrinsicInstrCost(Intrinsic::ID ID, Type *RetTy,
     492             :            ArrayRef<Value *> Args, FastMathFlags FMF, unsigned VF) const {
     493        2857 :   int Cost = TTIImpl->getIntrinsicInstrCost(ID, RetTy, Args, FMF, VF);
     494             :   assert(Cost >= 0 && "TTI should not produce negative costs!");
     495        2857 :   return Cost;
     496             : }
     497             : 
     498         554 : int TargetTransformInfo::getCallInstrCost(Function *F, Type *RetTy,
     499             :                                           ArrayRef<Type *> Tys) const {
     500         554 :   int Cost = TTIImpl->getCallInstrCost(F, RetTy, Tys);
     501             :   assert(Cost >= 0 && "TTI should not produce negative costs!");
     502         554 :   return Cost;
     503             : }
     504             : 
     505       22282 : unsigned TargetTransformInfo::getNumberOfParts(Type *Tp) const {
     506       22282 :   return TTIImpl->getNumberOfParts(Tp);
     507             : }
     508             : 
     509        1515 : int TargetTransformInfo::getAddressComputationCost(Type *Tp,
     510             :                                                    ScalarEvolution *SE,
     511             :                                                    const SCEV *Ptr) const {
     512        1515 :   int Cost = TTIImpl->getAddressComputationCost(Tp, SE, Ptr);
     513             :   assert(Cost >= 0 && "TTI should not produce negative costs!");
     514        1515 :   return Cost;
     515             : }
     516             : 
     517         285 : int TargetTransformInfo::getArithmeticReductionCost(unsigned Opcode, Type *Ty,
     518             :                                                     bool IsPairwiseForm) const {
     519         285 :   int Cost = TTIImpl->getArithmeticReductionCost(Opcode, Ty, IsPairwiseForm);
     520             :   assert(Cost >= 0 && "TTI should not produce negative costs!");
     521         285 :   return Cost;
     522             : }
     523             : 
     524         936 : int TargetTransformInfo::getMinMaxReductionCost(Type *Ty, Type *CondTy,
     525             :                                                 bool IsPairwiseForm,
     526             :                                                 bool IsUnsigned) const {
     527             :   int Cost =
     528         936 :       TTIImpl->getMinMaxReductionCost(Ty, CondTy, IsPairwiseForm, IsUnsigned);
     529             :   assert(Cost >= 0 && "TTI should not produce negative costs!");
     530         936 :   return Cost;
     531             : }
     532             : 
     533             : unsigned
     534       13821 : TargetTransformInfo::getCostOfKeepingLiveOverCall(ArrayRef<Type *> Tys) const {
     535       13821 :   return TTIImpl->getCostOfKeepingLiveOverCall(Tys);
     536             : }
     537             : 
     538      392367 : bool TargetTransformInfo::getTgtMemIntrinsic(IntrinsicInst *Inst,
     539             :                                              MemIntrinsicInfo &Info) const {
     540      392367 :   return TTIImpl->getTgtMemIntrinsic(Inst, Info);
     541             : }
     542             : 
     543           9 : unsigned TargetTransformInfo::getAtomicMemIntrinsicMaxElementSize() const {
     544           9 :   return TTIImpl->getAtomicMemIntrinsicMaxElementSize();
     545             : }
     546             : 
     547          29 : Value *TargetTransformInfo::getOrCreateResultFromMemIntrinsic(
     548             :     IntrinsicInst *Inst, Type *ExpectedType) const {
     549          29 :   return TTIImpl->getOrCreateResultFromMemIntrinsic(Inst, ExpectedType);
     550             : }
     551             : 
     552          15 : Type *TargetTransformInfo::getMemcpyLoopLoweringType(LLVMContext &Context,
     553             :                                                      Value *Length,
     554             :                                                      unsigned SrcAlign,
     555             :                                                      unsigned DestAlign) const {
     556          15 :   return TTIImpl->getMemcpyLoopLoweringType(Context, Length, SrcAlign,
     557          15 :                                             DestAlign);
     558             : }
     559             : 
     560           0 : void TargetTransformInfo::getMemcpyLoopResidualLoweringType(
     561             :     SmallVectorImpl<Type *> &OpsOut, LLVMContext &Context,
     562             :     unsigned RemainingBytes, unsigned SrcAlign, unsigned DestAlign) const {
     563           0 :   TTIImpl->getMemcpyLoopResidualLoweringType(OpsOut, Context, RemainingBytes,
     564           0 :                                              SrcAlign, DestAlign);
     565           0 : }
     566             : 
     567      332627 : bool TargetTransformInfo::areInlineCompatible(const Function *Caller,
     568             :                                               const Function *Callee) const {
     569      332627 :   return TTIImpl->areInlineCompatible(Caller, Callee);
     570             : }
     571             : 
     572        7719 : bool TargetTransformInfo::isIndexedLoadLegal(MemIndexedMode Mode,
     573             :                                              Type *Ty) const {
     574        7719 :   return TTIImpl->isIndexedLoadLegal(Mode, Ty);
     575             : }
     576             : 
     577           0 : bool TargetTransformInfo::isIndexedStoreLegal(MemIndexedMode Mode,
     578             :                                               Type *Ty) const {
     579           0 :   return TTIImpl->isIndexedStoreLegal(Mode, Ty);
     580             : }
     581             : 
     582       68382 : unsigned TargetTransformInfo::getLoadStoreVecRegBitWidth(unsigned AS) const {
     583       68382 :   return TTIImpl->getLoadStoreVecRegBitWidth(AS);
     584             : }
     585             : 
     586       42562 : bool TargetTransformInfo::isLegalToVectorizeLoad(LoadInst *LI) const {
     587       42562 :   return TTIImpl->isLegalToVectorizeLoad(LI);
     588             : }
     589             : 
     590       17086 : bool TargetTransformInfo::isLegalToVectorizeStore(StoreInst *SI) const {
     591       17086 :   return TTIImpl->isLegalToVectorizeStore(SI);
     592             : }
     593             : 
     594        8574 : bool TargetTransformInfo::isLegalToVectorizeLoadChain(
     595             :     unsigned ChainSizeInBytes, unsigned Alignment, unsigned AddrSpace) const {
     596        8574 :   return TTIImpl->isLegalToVectorizeLoadChain(ChainSizeInBytes, Alignment,
     597        8574 :                                               AddrSpace);
     598             : }
     599             : 
     600         360 : bool TargetTransformInfo::isLegalToVectorizeStoreChain(
     601             :     unsigned ChainSizeInBytes, unsigned Alignment, unsigned AddrSpace) const {
     602         360 :   return TTIImpl->isLegalToVectorizeStoreChain(ChainSizeInBytes, Alignment,
     603         360 :                                                AddrSpace);
     604             : }
     605             : 
     606       13790 : unsigned TargetTransformInfo::getLoadVectorFactor(unsigned VF,
     607             :                                                   unsigned LoadSize,
     608             :                                                   unsigned ChainSizeInBytes,
     609             :                                                   VectorType *VecTy) const {
     610       13790 :   return TTIImpl->getLoadVectorFactor(VF, LoadSize, ChainSizeInBytes, VecTy);
     611             : }
     612             : 
     613        4032 : unsigned TargetTransformInfo::getStoreVectorFactor(unsigned VF,
     614             :                                                    unsigned StoreSize,
     615             :                                                    unsigned ChainSizeInBytes,
     616             :                                                    VectorType *VecTy) const {
     617        4032 :   return TTIImpl->getStoreVectorFactor(VF, StoreSize, ChainSizeInBytes, VecTy);
     618             : }
     619             : 
     620         309 : bool TargetTransformInfo::useReductionIntrinsic(unsigned Opcode,
     621             :                                                 Type *Ty, ReductionFlags Flags) const {
     622         309 :   return TTIImpl->useReductionIntrinsic(Opcode, Ty, Flags);
     623             : }
     624             : 
     625        1741 : bool TargetTransformInfo::shouldExpandReduction(const IntrinsicInst *II) const {
     626        1741 :   return TTIImpl->shouldExpandReduction(II);
     627             : }
     628             : 
     629          11 : int TargetTransformInfo::getInstructionLatency(const Instruction *I) const {
     630          11 :   return TTIImpl->getInstructionLatency(I);
     631             : }
     632             : 
     633             : static TargetTransformInfo::OperandValueKind
     634       22312 : getOperandInfo(Value *V, TargetTransformInfo::OperandValueProperties &OpProps) {
     635             :   TargetTransformInfo::OperandValueKind OpInfo =
     636             :       TargetTransformInfo::OK_AnyValue;
     637       22312 :   OpProps = TargetTransformInfo::OP_None;
     638             : 
     639             :   if (auto *CI = dyn_cast<ConstantInt>(V)) {
     640        2188 :     if (CI->getValue().isPowerOf2())
     641        1037 :       OpProps = TargetTransformInfo::OP_PowerOf2;
     642        2188 :     return TargetTransformInfo::OK_UniformConstantValue;
     643             :   }
     644             : 
     645       20124 :   const Value *Splat = getSplatValue(V);
     646             : 
     647             :   // Check for a splat of a constant or for a non uniform vector of constants
     648             :   // and check if the constant(s) are all powers of two.
     649       20124 :   if (isa<ConstantVector>(V) || isa<ConstantDataVector>(V)) {
     650             :     OpInfo = TargetTransformInfo::OK_NonUniformConstantValue;
     651        3380 :     if (Splat) {
     652             :       OpInfo = TargetTransformInfo::OK_UniformConstantValue;
     653             :       if (auto *CI = dyn_cast<ConstantInt>(Splat))
     654        1657 :         if (CI->getValue().isPowerOf2())
     655         489 :           OpProps = TargetTransformInfo::OP_PowerOf2;
     656             :     } else if (auto *CDS = dyn_cast<ConstantDataSequential>(V)) {
     657        1696 :       OpProps = TargetTransformInfo::OP_PowerOf2;
     658       11155 :       for (unsigned I = 0, E = CDS->getNumElements(); I != E; ++I) {
     659       10675 :         if (auto *CI = dyn_cast<ConstantInt>(CDS->getElementAsConstant(I)))
     660       10675 :           if (CI->getValue().isPowerOf2())
     661             :             continue;
     662        1216 :         OpProps = TargetTransformInfo::OP_None;
     663        1216 :         break;
     664             :       }
     665             :     }
     666             :   }
     667             : 
     668             :   // Check for a splat of a uniform value. This is not loop aware, so return
     669             :   // true only for the obviously uniform cases (argument, globalvalue)
     670       20124 :   if (Splat && (isa<Argument>(Splat) || isa<GlobalValue>(Splat)))
     671             :     OpInfo = TargetTransformInfo::OK_UniformValue;
     672             : 
     673             :   return OpInfo;
     674             : }
     675             : 
     676         255 : static bool matchPairwiseShuffleMask(ShuffleVectorInst *SI, bool IsLeft,
     677             :                                      unsigned Level) {
     678             :   // We don't need a shuffle if we just want to have element 0 in position 0 of
     679             :   // the vector.
     680         255 :   if (!SI && Level == 0 && IsLeft)
     681             :     return true;
     682         250 :   else if (!SI)
     683             :     return false;
     684             : 
     685         250 :   SmallVector<int, 32> Mask(SI->getType()->getVectorNumElements(), -1);
     686             : 
     687             :   // Build a mask of 0, 2, ... (left) or 1, 3, ... (right) depending on whether
     688             :   // we look at the left or right side.
     689         695 :   for (unsigned i = 0, e = (1 << Level), val = !IsLeft; i != e; ++i, val += 2)
     690         890 :     Mask[i] = val;
     691             : 
     692             :   SmallVector<int, 16> ActualMask = SI->getShuffleMask();
     693         250 :   return Mask == ActualMask;
     694             : }
     695             : 
     696             : namespace {
     697             : /// Kind of the reduction data.
     698             : enum ReductionKind {
     699             :   RK_None,           /// Not a reduction.
     700             :   RK_Arithmetic,     /// Binary reduction data.
     701             :   RK_MinMax,         /// Min/max reduction data.
     702             :   RK_UnsignedMinMax, /// Unsigned min/max reduction data.
     703             : };
     704             : /// Contains opcode + LHS/RHS parts of the reduction operations.
     705             : struct ReductionData {
     706             :   ReductionData() = delete;
     707             :   ReductionData(ReductionKind Kind, unsigned Opcode, Value *LHS, Value *RHS)
     708         550 :       : Opcode(Opcode), LHS(LHS), RHS(RHS), Kind(Kind) {
     709             :     assert(Kind != RK_None && "expected binary or min/max reduction only.");
     710             :   }
     711             :   unsigned Opcode = 0;
     712             :   Value *LHS = nullptr;
     713             :   Value *RHS = nullptr;
     714             :   ReductionKind Kind = RK_None;
     715           0 :   bool hasSameData(ReductionData &RD) const {
     716         250 :     return Kind == RD.Kind && Opcode == RD.Opcode;
     717             :   }
     718             : };
     719             : } // namespace
     720             : 
     721         550 : static Optional<ReductionData> getReductionData(Instruction *I) {
     722             :   Value *L, *R;
     723             :   if (m_BinOp(m_Value(L), m_Value(R)).match(I))
     724         550 :     return ReductionData(RK_Arithmetic, I->getOpcode(), L, R);
     725             :   if (auto *SI = dyn_cast<SelectInst>(I)) {
     726           0 :     if (m_SMin(m_Value(L), m_Value(R)).match(SI) ||
     727           0 :         m_SMax(m_Value(L), m_Value(R)).match(SI) ||
     728           0 :         m_OrdFMin(m_Value(L), m_Value(R)).match(SI) ||
     729           0 :         m_OrdFMax(m_Value(L), m_Value(R)).match(SI) ||
     730           0 :         m_UnordFMin(m_Value(L), m_Value(R)).match(SI) ||
     731           0 :         m_UnordFMax(m_Value(L), m_Value(R)).match(SI)) {
     732             :       auto *CI = cast<CmpInst>(SI->getCondition());
     733           0 :       return ReductionData(RK_MinMax, CI->getOpcode(), L, R);
     734             :     }
     735           0 :     if (m_UMin(m_Value(L), m_Value(R)).match(SI) ||
     736           0 :         m_UMax(m_Value(L), m_Value(R)).match(SI)) {
     737             :       auto *CI = cast<CmpInst>(SI->getCondition());
     738           0 :       return ReductionData(RK_UnsignedMinMax, CI->getOpcode(), L, R);
     739             :     }
     740             :   }
     741             :   return llvm::None;
     742             : }
     743             : 
     744          60 : static ReductionKind matchPairwiseReductionAtLevel(Instruction *I,
     745             :                                                    unsigned Level,
     746             :                                                    unsigned NumLevels) {
     747             :   // Match one level of pairwise operations.
     748             :   // %rdx.shuf.0.0 = shufflevector <4 x float> %rdx, <4 x float> undef,
     749             :   //       <4 x i32> <i32 0, i32 2 , i32 undef, i32 undef>
     750             :   // %rdx.shuf.0.1 = shufflevector <4 x float> %rdx, <4 x float> undef,
     751             :   //       <4 x i32> <i32 1, i32 3, i32 undef, i32 undef>
     752             :   // %bin.rdx.0 = fadd <4 x float> %rdx.shuf.0.0, %rdx.shuf.0.1
     753         125 :   if (!I)
     754             :     return RK_None;
     755             : 
     756             :   assert(I->getType()->isVectorTy() && "Expecting a vector type");
     757             : 
     758         125 :   Optional<ReductionData> RD = getReductionData(I);
     759         125 :   if (!RD)
     760             :     return RK_None;
     761             : 
     762             :   ShuffleVectorInst *LS = dyn_cast<ShuffleVectorInst>(RD->LHS);
     763         125 :   if (!LS && Level)
     764             :     return RK_None;
     765             :   ShuffleVectorInst *RS = dyn_cast<ShuffleVectorInst>(RD->RHS);
     766         125 :   if (!RS && Level)
     767             :     return RK_None;
     768             : 
     769             :   // On level 0 we can omit one shufflevector instruction.
     770         125 :   if (!Level && !RS && !LS)
     771             :     return RK_None;
     772             : 
     773             :   // Shuffle inputs must match.
     774         125 :   Value *NextLevelOpL = LS ? LS->getOperand(0) : nullptr;
     775         125 :   Value *NextLevelOpR = RS ? RS->getOperand(0) : nullptr;
     776             :   Value *NextLevelOp = nullptr;
     777         125 :   if (NextLevelOpR && NextLevelOpL) {
     778             :     // If we have two shuffles their operands must match.
     779         120 :     if (NextLevelOpL != NextLevelOpR)
     780             :       return RK_None;
     781             : 
     782             :     NextLevelOp = NextLevelOpL;
     783           5 :   } else if (Level == 0 && (NextLevelOpR || NextLevelOpL)) {
     784             :     // On the first level we can omit the shufflevector <0, undef,...>. So the
     785             :     // input to the other shufflevector <1, undef> must match with one of the
     786             :     // inputs to the current binary operation.
     787             :     // Example:
     788             :     //  %NextLevelOpL = shufflevector %R, <1, undef ...>
     789             :     //  %BinOp        = fadd          %NextLevelOpL, %R
     790           5 :     if (NextLevelOpL && NextLevelOpL != RD->RHS)
     791             :       return RK_None;
     792           5 :     else if (NextLevelOpR && NextLevelOpR != RD->LHS)
     793             :       return RK_None;
     794             : 
     795           5 :     NextLevelOp = NextLevelOpL ? RD->RHS : RD->LHS;
     796             :   } else
     797             :     return RK_None;
     798             : 
     799             :   // Check that the next levels binary operation exists and matches with the
     800             :   // current one.
     801         125 :   if (Level + 1 != NumLevels) {
     802             :     Optional<ReductionData> NextLevelRD =
     803          65 :         getReductionData(cast<Instruction>(NextLevelOp));
     804          65 :     if (!NextLevelRD || !RD->hasSameData(*NextLevelRD))
     805           0 :       return RK_None;
     806             :   }
     807             : 
     808             :   // Shuffle mask for pairwise operation must match.
     809         125 :   if (matchPairwiseShuffleMask(LS, /*IsLeft=*/true, Level)) {
     810         120 :     if (!matchPairwiseShuffleMask(RS, /*IsLeft=*/false, Level))
     811             :       return RK_None;
     812           5 :   } else if (matchPairwiseShuffleMask(RS, /*IsLeft=*/true, Level)) {
     813           5 :     if (!matchPairwiseShuffleMask(LS, /*IsLeft=*/false, Level))
     814             :       return RK_None;
     815             :   } else {
     816             :     return RK_None;
     817             :   }
     818             : 
     819         125 :   if (++Level == NumLevels)
     820             :     return RD->Kind;
     821             : 
     822             :   // Match next level.
     823             :   return matchPairwiseReductionAtLevel(cast<Instruction>(NextLevelOp), Level,
     824             :                                        NumLevels);
     825             : }
     826             : 
     827         980 : static ReductionKind matchPairwiseReduction(const ExtractElementInst *ReduxRoot,
     828             :                                             unsigned &Opcode, Type *&Ty) {
     829         980 :   if (!EnableReduxCost)
     830             :     return RK_None;
     831             : 
     832             :   // Need to extract the first element.
     833             :   ConstantInt *CI = dyn_cast<ConstantInt>(ReduxRoot->getOperand(1));
     834             :   unsigned Idx = ~0u;
     835             :   if (CI)
     836          60 :     Idx = CI->getZExtValue();
     837          60 :   if (Idx != 0)
     838             :     return RK_None;
     839             : 
     840             :   auto *RdxStart = dyn_cast<Instruction>(ReduxRoot->getOperand(0));
     841             :   if (!RdxStart)
     842             :     return RK_None;
     843          60 :   Optional<ReductionData> RD = getReductionData(RdxStart);
     844          60 :   if (!RD)
     845             :     return RK_None;
     846             : 
     847          60 :   Type *VecTy = RdxStart->getType();
     848             :   unsigned NumVecElems = VecTy->getVectorNumElements();
     849             :   if (!isPowerOf2_32(NumVecElems))
     850             :     return RK_None;
     851             : 
     852             :   // We look for a sequence of shuffle,shuffle,add triples like the following
     853             :   // that builds a pairwise reduction tree.
     854             :   //
     855             :   //  (X0, X1, X2, X3)
     856             :   //   (X0 + X1, X2 + X3, undef, undef)
     857             :   //    ((X0 + X1) + (X2 + X3), undef, undef, undef)
     858             :   //
     859             :   // %rdx.shuf.0.0 = shufflevector <4 x float> %rdx, <4 x float> undef,
     860             :   //       <4 x i32> <i32 0, i32 2 , i32 undef, i32 undef>
     861             :   // %rdx.shuf.0.1 = shufflevector <4 x float> %rdx, <4 x float> undef,
     862             :   //       <4 x i32> <i32 1, i32 3, i32 undef, i32 undef>
     863             :   // %bin.rdx.0 = fadd <4 x float> %rdx.shuf.0.0, %rdx.shuf.0.1
     864             :   // %rdx.shuf.1.0 = shufflevector <4 x float> %bin.rdx.0, <4 x float> undef,
     865             :   //       <4 x i32> <i32 0, i32 undef, i32 undef, i32 undef>
     866             :   // %rdx.shuf.1.1 = shufflevector <4 x float> %bin.rdx.0, <4 x float> undef,
     867             :   //       <4 x i32> <i32 1, i32 undef, i32 undef, i32 undef>
     868             :   // %bin.rdx8 = fadd <4 x float> %rdx.shuf.1.0, %rdx.shuf.1.1
     869             :   // %r = extractelement <4 x float> %bin.rdx8, i32 0
     870          60 :   if (matchPairwiseReductionAtLevel(RdxStart, 0, Log2_32(NumVecElems)) ==
     871             :       RK_None)
     872             :     return RK_None;
     873             : 
     874          60 :   Opcode = RD->Opcode;
     875          60 :   Ty = VecTy;
     876             : 
     877          60 :   return RD->Kind;
     878             : }
     879             : 
     880             : static std::pair<Value *, ShuffleVectorInst *>
     881             : getShuffleAndOtherOprd(Value *L, Value *R) {
     882             :   ShuffleVectorInst *S = nullptr;
     883             : 
     884             :   if ((S = dyn_cast<ShuffleVectorInst>(L)))
     885             :     return std::make_pair(R, S);
     886             : 
     887             :   S = dyn_cast<ShuffleVectorInst>(R);
     888             :   return std::make_pair(L, S);
     889             : }
     890             : 
     891             : static ReductionKind
     892        1035 : matchVectorSplittingReduction(const ExtractElementInst *ReduxRoot,
     893             :                               unsigned &Opcode, Type *&Ty) {
     894        1035 :   if (!EnableReduxCost)
     895             :     return RK_None;
     896             : 
     897             :   // Need to extract the first element.
     898             :   ConstantInt *CI = dyn_cast<ConstantInt>(ReduxRoot->getOperand(1));
     899             :   unsigned Idx = ~0u;
     900             :   if (CI)
     901         115 :     Idx = CI->getZExtValue();
     902         115 :   if (Idx != 0)
     903             :     return RK_None;
     904             : 
     905             :   auto *RdxStart = dyn_cast<Instruction>(ReduxRoot->getOperand(0));
     906             :   if (!RdxStart)
     907             :     return RK_None;
     908         115 :   Optional<ReductionData> RD = getReductionData(RdxStart);
     909         115 :   if (!RD)
     910             :     return RK_None;
     911             : 
     912         115 :   Type *VecTy = ReduxRoot->getOperand(0)->getType();
     913             :   unsigned NumVecElems = VecTy->getVectorNumElements();
     914             :   if (!isPowerOf2_32(NumVecElems))
     915             :     return RK_None;
     916             : 
     917             :   // We look for a sequence of shuffles and adds like the following matching one
     918             :   // fadd, shuffle vector pair at a time.
     919             :   //
     920             :   // %rdx.shuf = shufflevector <4 x float> %rdx, <4 x float> undef,
     921             :   //                           <4 x i32> <i32 2, i32 3, i32 undef, i32 undef>
     922             :   // %bin.rdx = fadd <4 x float> %rdx, %rdx.shuf
     923             :   // %rdx.shuf7 = shufflevector <4 x float> %bin.rdx, <4 x float> undef,
     924             :   //                          <4 x i32> <i32 1, i32 undef, i32 undef, i32 undef>
     925             :   // %bin.rdx8 = fadd <4 x float> %bin.rdx, %rdx.shuf7
     926             :   // %r = extractelement <4 x float> %bin.rdx8, i32 0
     927             : 
     928             :   unsigned MaskStart = 1;
     929             :   Instruction *RdxOp = RdxStart;
     930         115 :   SmallVector<int, 32> ShuffleMask(NumVecElems, 0);
     931             :   unsigned NumVecElemsRemain = NumVecElems;
     932         240 :   while (NumVecElemsRemain - 1) {
     933             :     // Check for the right reduction operation.
     934         185 :     if (!RdxOp)
     935          60 :       return RK_None;
     936         185 :     Optional<ReductionData> RDLevel = getReductionData(RdxOp);
     937         185 :     if (!RDLevel || !RDLevel->hasSameData(*RD))
     938             :       return RK_None;
     939             : 
     940             :     Value *NextRdxOp;
     941             :     ShuffleVectorInst *Shuffle;
     942             :     std::tie(NextRdxOp, Shuffle) =
     943         185 :         getShuffleAndOtherOprd(RDLevel->LHS, RDLevel->RHS);
     944             : 
     945             :     // Check the current reduction operation and the shuffle use the same value.
     946         185 :     if (Shuffle == nullptr)
     947             :       return RK_None;
     948         185 :     if (Shuffle->getOperand(0) != NextRdxOp)
     949             :       return RK_None;
     950             : 
     951             :     // Check that shuffle masks matches.
     952         355 :     for (unsigned j = 0; j != MaskStart; ++j)
     953         460 :       ShuffleMask[j] = MaskStart + j;
     954             :     // Fill the rest of the mask with -1 for undef.
     955         125 :     std::fill(&ShuffleMask[MaskStart], ShuffleMask.end(), -1);
     956             : 
     957             :     SmallVector<int, 16> Mask = Shuffle->getShuffleMask();
     958         125 :     if (ShuffleMask != Mask)
     959             :       return RK_None;
     960             : 
     961             :     RdxOp = dyn_cast<Instruction>(NextRdxOp);
     962         125 :     NumVecElemsRemain /= 2;
     963         125 :     MaskStart *= 2;
     964             :   }
     965             : 
     966          55 :   Opcode = RD->Opcode;
     967          55 :   Ty = VecTy;
     968          55 :   return RD->Kind;
     969             : }
     970             : 
     971       30635 : int TargetTransformInfo::getInstructionThroughput(const Instruction *I) const {
     972       30635 :   switch (I->getOpcode()) {
     973         132 :   case Instruction::GetElementPtr:
     974         132 :     return getUserCost(I);
     975             : 
     976             :   case Instruction::Ret:
     977             :   case Instruction::PHI:
     978             :   case Instruction::Br: {
     979        6803 :     return getCFInstrCost(I->getOpcode());
     980             :   }
     981       11156 :   case Instruction::Add:
     982             :   case Instruction::FAdd:
     983             :   case Instruction::Sub:
     984             :   case Instruction::FSub:
     985             :   case Instruction::Mul:
     986             :   case Instruction::FMul:
     987             :   case Instruction::UDiv:
     988             :   case Instruction::SDiv:
     989             :   case Instruction::FDiv:
     990             :   case Instruction::URem:
     991             :   case Instruction::SRem:
     992             :   case Instruction::FRem:
     993             :   case Instruction::Shl:
     994             :   case Instruction::LShr:
     995             :   case Instruction::AShr:
     996             :   case Instruction::And:
     997             :   case Instruction::Or:
     998             :   case Instruction::Xor: {
     999             :     TargetTransformInfo::OperandValueKind Op1VK, Op2VK;
    1000             :     TargetTransformInfo::OperandValueProperties Op1VP, Op2VP;
    1001       22312 :     Op1VK = getOperandInfo(I->getOperand(0), Op1VP);
    1002       11156 :     Op2VK = getOperandInfo(I->getOperand(1), Op2VP);
    1003             :     SmallVector<const Value *, 2> Operands(I->operand_values());
    1004       22312 :     return getArithmeticInstrCost(I->getOpcode(), I->getType(), Op1VK, Op2VK,
    1005             :                                   Op1VP, Op2VP, Operands);
    1006             :   }
    1007             :   case Instruction::Select: {
    1008             :     const SelectInst *SI = cast<SelectInst>(I);
    1009         487 :     Type *CondTy = SI->getCondition()->getType();
    1010         487 :     return getCmpSelInstrCost(I->getOpcode(), I->getType(), CondTy, I);
    1011             :   }
    1012        1244 :   case Instruction::ICmp:
    1013             :   case Instruction::FCmp: {
    1014        1244 :     Type *ValTy = I->getOperand(0)->getType();
    1015        1244 :     return getCmpSelInstrCost(I->getOpcode(), ValTy, I->getType(), I);
    1016             :   }
    1017             :   case Instruction::Store: {
    1018             :     const StoreInst *SI = cast<StoreInst>(I);
    1019         474 :     Type *ValTy = SI->getValueOperand()->getType();
    1020         474 :     return getMemoryOpCost(I->getOpcode(), ValTy,
    1021             :                                 SI->getAlignment(),
    1022         474 :                                 SI->getPointerAddressSpace(), I);
    1023             :   }
    1024             :   case Instruction::Load: {
    1025             :     const LoadInst *LI = cast<LoadInst>(I);
    1026         587 :     return getMemoryOpCost(I->getOpcode(), I->getType(),
    1027             :                                 LI->getAlignment(),
    1028         587 :                                 LI->getPointerAddressSpace(), I);
    1029             :   }
    1030        3181 :   case Instruction::ZExt:
    1031             :   case Instruction::SExt:
    1032             :   case Instruction::FPToUI:
    1033             :   case Instruction::FPToSI:
    1034             :   case Instruction::FPExt:
    1035             :   case Instruction::PtrToInt:
    1036             :   case Instruction::IntToPtr:
    1037             :   case Instruction::SIToFP:
    1038             :   case Instruction::UIToFP:
    1039             :   case Instruction::Trunc:
    1040             :   case Instruction::FPTrunc:
    1041             :   case Instruction::BitCast:
    1042             :   case Instruction::AddrSpaceCast: {
    1043        3181 :     Type *SrcTy = I->getOperand(0)->getType();
    1044        3181 :     return getCastInstrCost(I->getOpcode(), I->getType(), SrcTy, I);
    1045             :   }
    1046             :   case Instruction::ExtractElement: {
    1047             :     const ExtractElementInst * EEI = cast<ExtractElementInst>(I);
    1048        1035 :     ConstantInt *CI = dyn_cast<ConstantInt>(I->getOperand(1));
    1049             :     unsigned Idx = -1;
    1050             :     if (CI)
    1051        1028 :       Idx = CI->getZExtValue();
    1052             : 
    1053             :     // Try to match a reduction sequence (series of shufflevector and vector
    1054             :     // adds followed by a extractelement).
    1055             :     unsigned ReduxOpCode;
    1056             :     Type *ReduxType;
    1057             : 
    1058        1035 :     switch (matchVectorSplittingReduction(EEI, ReduxOpCode, ReduxType)) {
    1059          55 :     case RK_Arithmetic:
    1060          55 :       return getArithmeticReductionCost(ReduxOpCode, ReduxType,
    1061          55 :                                              /*IsPairwiseForm=*/false);
    1062           0 :     case RK_MinMax:
    1063           0 :       return getMinMaxReductionCost(
    1064             :           ReduxType, CmpInst::makeCmpResultType(ReduxType),
    1065           0 :           /*IsPairwiseForm=*/false, /*IsUnsigned=*/false);
    1066           0 :     case RK_UnsignedMinMax:
    1067           0 :       return getMinMaxReductionCost(
    1068             :           ReduxType, CmpInst::makeCmpResultType(ReduxType),
    1069           0 :           /*IsPairwiseForm=*/false, /*IsUnsigned=*/true);
    1070             :     case RK_None:
    1071             :       break;
    1072             :     }
    1073             : 
    1074         980 :     switch (matchPairwiseReduction(EEI, ReduxOpCode, ReduxType)) {
    1075          60 :     case RK_Arithmetic:
    1076          60 :       return getArithmeticReductionCost(ReduxOpCode, ReduxType,
    1077          60 :                                              /*IsPairwiseForm=*/true);
    1078           0 :     case RK_MinMax:
    1079           0 :       return getMinMaxReductionCost(
    1080             :           ReduxType, CmpInst::makeCmpResultType(ReduxType),
    1081           0 :           /*IsPairwiseForm=*/true, /*IsUnsigned=*/false);
    1082           0 :     case RK_UnsignedMinMax:
    1083           0 :       return getMinMaxReductionCost(
    1084             :           ReduxType, CmpInst::makeCmpResultType(ReduxType),
    1085           0 :           /*IsPairwiseForm=*/true, /*IsUnsigned=*/true);
    1086             :     case RK_None:
    1087             :       break;
    1088             :     }
    1089             : 
    1090        1840 :     return getVectorInstrCost(I->getOpcode(),
    1091         920 :                                    EEI->getOperand(0)->getType(), Idx);
    1092             :   }
    1093             :   case Instruction::InsertElement: {
    1094             :     const InsertElementInst * IE = cast<InsertElementInst>(I);
    1095             :     ConstantInt *CI = dyn_cast<ConstantInt>(IE->getOperand(2));
    1096             :     unsigned Idx = -1;
    1097             :     if (CI)
    1098        1439 :       Idx = CI->getZExtValue();
    1099        1439 :     return getVectorInstrCost(I->getOpcode(),
    1100        1439 :                                    IE->getType(), Idx);
    1101             :   }
    1102             :   case Instruction::ShuffleVector: {
    1103             :     const ShuffleVectorInst *Shuffle = cast<ShuffleVectorInst>(I);
    1104             :     // TODO: Identify and add costs for insert/extract subvector, etc.
    1105        2480 :     if (Shuffle->changesLength())
    1106             :       return -1;
    1107             : 
    1108        2480 :     if (Shuffle->isIdentity())
    1109             :       return 0;
    1110             : 
    1111             :     Type *Ty = Shuffle->getType();
    1112        2387 :     if (Shuffle->isReverse())
    1113         307 :       return TTIImpl->getShuffleCost(SK_Reverse, Ty, 0, nullptr);
    1114             : 
    1115        2080 :     if (Shuffle->isSelect())
    1116         401 :       return TTIImpl->getShuffleCost(SK_Select, Ty, 0, nullptr);
    1117             : 
    1118        1679 :     if (Shuffle->isTranspose())
    1119          22 :       return TTIImpl->getShuffleCost(SK_Transpose, Ty, 0, nullptr);
    1120             : 
    1121        1657 :     if (Shuffle->isZeroEltSplat())
    1122         828 :       return TTIImpl->getShuffleCost(SK_Broadcast, Ty, 0, nullptr);
    1123             : 
    1124         829 :     if (Shuffle->isSingleSource())
    1125         546 :       return TTIImpl->getShuffleCost(SK_PermuteSingleSrc, Ty, 0, nullptr);
    1126             : 
    1127         283 :     return TTIImpl->getShuffleCost(SK_PermuteTwoSrc, Ty, 0, nullptr);
    1128             :   }
    1129             :   case Instruction::Call:
    1130             :     if (const IntrinsicInst *II = dyn_cast<IntrinsicInst>(I)) {
    1131        1616 :       SmallVector<Value *, 4> Args(II->arg_operands());
    1132             : 
    1133        1616 :       FastMathFlags FMF;
    1134             :       if (auto *FPMO = dyn_cast<FPMathOperator>(II))
    1135         745 :         FMF = FPMO->getFastMathFlags();
    1136             : 
    1137        3232 :       return getIntrinsicInstrCost(II->getIntrinsicID(), II->getType(),
    1138             :                                         Args, FMF);
    1139             :     }
    1140             :     return -1;
    1141             :   default:
    1142             :     // We don't have any information on this instruction.
    1143             :     return -1;
    1144             :   }
    1145             : }
    1146             : 
    1147     4381191 : TargetTransformInfo::Concept::~Concept() {}
    1148             : 
    1149       15206 : TargetIRAnalysis::TargetIRAnalysis() : TTICallback(&getDefaultTTI) {}
    1150             : 
    1151       80253 : TargetIRAnalysis::TargetIRAnalysis(
    1152             :     std::function<Result(const Function &)> TTICallback)
    1153       80253 :     : TTICallback(std::move(TTICallback)) {}
    1154             : 
    1155     4381287 : TargetIRAnalysis::Result TargetIRAnalysis::run(const Function &F,
    1156             :                                                FunctionAnalysisManager &) {
    1157     4381286 :   return TTICallback(F);
    1158             : }
    1159             : 
    1160             : AnalysisKey TargetIRAnalysis::Key;
    1161             : 
    1162       13968 : TargetIRAnalysis::Result TargetIRAnalysis::getDefaultTTI(const Function &F) {
    1163       13968 :   return Result(F.getParent()->getDataLayout());
    1164             : }
    1165             : 
    1166             : // Register the basic pass.
    1167     1311143 : INITIALIZE_PASS(TargetTransformInfoWrapperPass, "tti",
    1168             :                 "Target Transform Information", false, true)
    1169             : char TargetTransformInfoWrapperPass::ID = 0;
    1170             : 
    1171           0 : void TargetTransformInfoWrapperPass::anchor() {}
    1172             : 
    1173         275 : TargetTransformInfoWrapperPass::TargetTransformInfoWrapperPass()
    1174         275 :     : ImmutablePass(ID) {
    1175         275 :   initializeTargetTransformInfoWrapperPassPass(
    1176         275 :       *PassRegistry::getPassRegistry());
    1177         275 : }
    1178             : 
    1179       86578 : TargetTransformInfoWrapperPass::TargetTransformInfoWrapperPass(
    1180       86578 :     TargetIRAnalysis TIRA)
    1181       86578 :     : ImmutablePass(ID), TIRA(std::move(TIRA)) {
    1182       86578 :   initializeTargetTransformInfoWrapperPassPass(
    1183       86578 :       *PassRegistry::getPassRegistry());
    1184       86578 : }
    1185             : 
    1186     4379558 : TargetTransformInfo &TargetTransformInfoWrapperPass::getTTI(const Function &F) {
    1187     8759115 :   FunctionAnalysisManager DummyFAM;
    1188     8759114 :   TTI = TIRA.run(F, DummyFAM);
    1189     4379557 :   return *TTI;
    1190             : }
    1191             : 
    1192             : ImmutablePass *
    1193       86578 : llvm::createTargetTransformInfoWrapperPass(TargetIRAnalysis TIRA) {
    1194       86578 :   return new TargetTransformInfoWrapperPass(std::move(TIRA));
    1195             : }

Generated by: LCOV version 1.13