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

Generated by: LCOV version 1.13