LCOV - code coverage report
Current view: top level - include/llvm/Analysis - TargetTransformInfoImpl.h (source / functions) Hit Total Coverage
Test: llvm-toolchain.info Lines: 120 133 90.2 %
Date: 2018-05-20 00:06:23 Functions: 60 105 57.1 %
Legend: Lines: hit not hit

          Line data    Source code
       1             : //===- TargetTransformInfoImpl.h --------------------------------*- C++ -*-===//
       2             : //
       3             : //                     The LLVM Compiler Infrastructure
       4             : //
       5             : // This file is distributed under the University of Illinois Open Source
       6             : // License. See LICENSE.TXT for details.
       7             : //
       8             : //===----------------------------------------------------------------------===//
       9             : /// \file
      10             : /// This file provides helpers for the implementation of
      11             : /// a TargetTransformInfo-conforming class.
      12             : ///
      13             : //===----------------------------------------------------------------------===//
      14             : 
      15             : #ifndef LLVM_ANALYSIS_TARGETTRANSFORMINFOIMPL_H
      16             : #define LLVM_ANALYSIS_TARGETTRANSFORMINFOIMPL_H
      17             : 
      18             : #include "llvm/Analysis/ScalarEvolutionExpressions.h"
      19             : #include "llvm/Analysis/TargetTransformInfo.h"
      20             : #include "llvm/Analysis/VectorUtils.h"
      21             : #include "llvm/IR/CallSite.h"
      22             : #include "llvm/IR/DataLayout.h"
      23             : #include "llvm/IR/Function.h"
      24             : #include "llvm/IR/GetElementPtrTypeIterator.h"
      25             : #include "llvm/IR/Operator.h"
      26             : #include "llvm/IR/Type.h"
      27             : 
      28             : namespace llvm {
      29             : 
      30             : /// Base class for use as a mix-in that aids implementing
      31             : /// a TargetTransformInfo-compatible class.
      32             : class TargetTransformInfoImplBase {
      33             : protected:
      34             :   typedef TargetTransformInfo TTI;
      35             : 
      36             :   const DataLayout &DL;
      37             : 
      38     2744099 :   explicit TargetTransformInfoImplBase(const DataLayout &DL) : DL(DL) {}
      39             : 
      40             : public:
      41             :   // Provide value semantics. MSVC requires that we spell all of these out.
      42             :   TargetTransformInfoImplBase(const TargetTransformInfoImplBase &Arg)
      43     2744099 :       : DL(Arg.DL) {}
      44     2760335 :   TargetTransformInfoImplBase(TargetTransformInfoImplBase &&Arg) : DL(Arg.DL) {}
      45             : 
      46        9151 :   const DataLayout &getDataLayout() const { return DL; }
      47             : 
      48     1397996 :   unsigned getOperationCost(unsigned Opcode, Type *Ty, Type *OpTy) {
      49     1397996 :     switch (Opcode) {
      50             :     default:
      51             :       // By default, just classify everything as 'basic'.
      52             :       return TTI::TCC_Basic;
      53             : 
      54           0 :     case Instruction::GetElementPtr:
      55           0 :       llvm_unreachable("Use getGEPCost for GEP operations!");
      56             : 
      57       28082 :     case Instruction::BitCast:
      58             :       assert(OpTy && "Cast instructions must provide the operand type");
      59       84148 :       if (Ty == OpTy || (Ty->isPointerTy() && OpTy->isPointerTy()))
      60             :         // Identity and pointer-to-pointer casts are free.
      61             :         return TTI::TCC_Free;
      62             : 
      63             :       // Otherwise, the default basic cost is used.
      64             :       return TTI::TCC_Basic;
      65             : 
      66        2053 :     case Instruction::FDiv:
      67             :     case Instruction::FRem:
      68             :     case Instruction::SDiv:
      69             :     case Instruction::SRem:
      70             :     case Instruction::UDiv:
      71             :     case Instruction::URem:
      72        2053 :       return TTI::TCC_Expensive;
      73             : 
      74        9954 :     case Instruction::IntToPtr: {
      75             :       // An inttoptr cast is free so long as the input is a legal integer type
      76             :       // which doesn't contain values outside the range of a pointer.
      77        9954 :       unsigned OpSize = OpTy->getScalarSizeInBits();
      78       29859 :       if (DL.isLegalInteger(OpSize) &&
      79        9951 :           OpSize <= DL.getPointerTypeSizeInBits(Ty))
      80             :         return TTI::TCC_Free;
      81             : 
      82             :       // Otherwise it's not a no-op.
      83             :       return TTI::TCC_Basic;
      84             :     }
      85       19019 :     case Instruction::PtrToInt: {
      86             :       // A ptrtoint cast is free so long as the result is large enough to store
      87             :       // the pointer, and a legal integer type.
      88       19019 :       unsigned DestSize = Ty->getScalarSizeInBits();
      89       57048 :       if (DL.isLegalInteger(DestSize) &&
      90       19010 :           DestSize >= DL.getPointerTypeSizeInBits(OpTy))
      91             :         return TTI::TCC_Free;
      92             : 
      93             :       // Otherwise it's not a no-op.
      94             :       return TTI::TCC_Basic;
      95             :     }
      96          42 :     case Instruction::Trunc:
      97             :       // trunc to a native type is free (assuming the target has compare and
      98             :       // shift-right of the same width).
      99          84 :       if (DL.isLegalInteger(DL.getTypeSizeInBits(Ty)))
     100             :         return TTI::TCC_Free;
     101             : 
     102          33 :       return TTI::TCC_Basic;
     103             :     }
     104             :   }
     105             : 
     106             :   int getGEPCost(Type *PointeeType, const Value *Ptr,
     107             :                  ArrayRef<const Value *> Operands) {
     108             :     // In the basic model, we just assume that all-constant GEPs will be folded
     109             :     // into their uses via addressing modes.
     110             :     for (unsigned Idx = 0, Size = Operands.size(); Idx != Size; ++Idx)
     111             :       if (!isa<Constant>(Operands[Idx]))
     112             :         return TTI::TCC_Basic;
     113             : 
     114             :     return TTI::TCC_Free;
     115             :   }
     116             : 
     117             :   unsigned getEstimatedNumberOfCaseClusters(const SwitchInst &SI,
     118             :                                             unsigned &JTSize) {
     119           2 :     JTSize = 0;
     120             :     return SI.getNumCases();
     121             :   }
     122             : 
     123             :   int getExtCost(const Instruction *I, const Value *Src) {
     124             :     return TTI::TCC_Basic;
     125             :   }
     126             : 
     127             :   unsigned getCallCost(FunctionType *FTy, int NumArgs) {
     128             :     assert(FTy && "FunctionType must be provided to this routine.");
     129             : 
     130             :     // The target-independent implementation just measures the size of the
     131             :     // function by approximating that each argument will take on average one
     132             :     // instruction to prepare.
     133             : 
     134      928981 :     if (NumArgs < 0)
     135             :       // Set the argument number to the number of explicit arguments in the
     136             :       // function.
     137           0 :       NumArgs = FTy->getNumParams();
     138             : 
     139      928981 :     return TTI::TCC_Basic * (NumArgs + 1);
     140             :   }
     141             : 
     142             :   unsigned getInliningThresholdMultiplier() { return 1; }
     143             : 
     144      397214 :   unsigned getIntrinsicCost(Intrinsic::ID IID, Type *RetTy,
     145             :                             ArrayRef<Type *> ParamTys) {
     146      397214 :     switch (IID) {
     147             :     default:
     148             :       // Intrinsics rarely (if ever) have normal argument setup constraints.
     149             :       // Model them as having a basic instruction cost.
     150             :       // FIXME: This is wrong for libc intrinsics.
     151             :       return TTI::TCC_Basic;
     152             : 
     153      394738 :     case Intrinsic::annotation:
     154             :     case Intrinsic::assume:
     155             :     case Intrinsic::sideeffect:
     156             :     case Intrinsic::dbg_declare:
     157             :     case Intrinsic::dbg_value:
     158             :     case Intrinsic::dbg_label:
     159             :     case Intrinsic::invariant_start:
     160             :     case Intrinsic::invariant_end:
     161             :     case Intrinsic::lifetime_start:
     162             :     case Intrinsic::lifetime_end:
     163             :     case Intrinsic::objectsize:
     164             :     case Intrinsic::ptr_annotation:
     165             :     case Intrinsic::var_annotation:
     166             :     case Intrinsic::experimental_gc_result:
     167             :     case Intrinsic::experimental_gc_relocate:
     168             :     case Intrinsic::coro_alloc:
     169             :     case Intrinsic::coro_begin:
     170             :     case Intrinsic::coro_free:
     171             :     case Intrinsic::coro_end:
     172             :     case Intrinsic::coro_frame:
     173             :     case Intrinsic::coro_size:
     174             :     case Intrinsic::coro_suspend:
     175             :     case Intrinsic::coro_param:
     176             :     case Intrinsic::coro_subfn_addr:
     177             :       // These intrinsics don't actually represent code after lowering.
     178             :       return TTI::TCC_Free;
     179             :     }
     180             :   }
     181             : 
     182             :   bool hasBranchDivergence() { return false; }
     183             : 
     184             :   bool isSourceOfDivergence(const Value *V) { return false; }
     185             : 
     186             :   bool isAlwaysUniform(const Value *V) { return false; }
     187             : 
     188             :   unsigned getFlatAddressSpace () {
     189             :     return -1;
     190             :   }
     191             : 
     192     1901459 :   bool isLoweredToCall(const Function *F) {
     193             :     assert(F && "A concrete function must be provided to this routine.");
     194             : 
     195             :     // FIXME: These should almost certainly not be handled here, and instead
     196             :     // handled with the help of TLI or the target itself. This was largely
     197             :     // ported from existing analysis heuristics here so that such refactorings
     198             :     // can take place in the future.
     199             : 
     200     1901459 :     if (F->isIntrinsic())
     201             :       return false;
     202             : 
     203     1285124 :     if (F->hasLocalLinkage() || !F->hasName())
     204             :       return true;
     205             : 
     206     1285124 :     StringRef Name = F->getName();
     207             : 
     208             :     // These will all likely lower to a single selection DAG node.
     209             :     if (Name == "copysign" || Name == "copysignf" || Name == "copysignl" ||
     210             :         Name == "fabs" || Name == "fabsf" || Name == "fabsl" || Name == "sin" ||
     211             :         Name == "fmin" || Name == "fminf" || Name == "fminl" ||
     212             :         Name == "fmax" || Name == "fmaxf" || Name == "fmaxl" ||
     213             :         Name == "sinf" || Name == "sinl" || Name == "cos" || Name == "cosf" ||
     214             :         Name == "cosl" || Name == "sqrt" || Name == "sqrtf" || Name == "sqrtl")
     215             :       return false;
     216             : 
     217             :     // These are all likely to be optimized into something smaller.
     218             :     if (Name == "pow" || Name == "powf" || Name == "powl" || Name == "exp2" ||
     219             :         Name == "exp2l" || Name == "exp2f" || Name == "floor" ||
     220             :         Name == "floorf" || Name == "ceil" || Name == "round" ||
     221             :         Name == "ffs" || Name == "ffsl" || Name == "abs" || Name == "labs" ||
     222             :         Name == "llabs")
     223             :       return false;
     224             : 
     225             :     return true;
     226             :   }
     227             : 
     228             :   void getUnrollingPreferences(Loop *, ScalarEvolution &,
     229             :                                TTI::UnrollingPreferences &) {}
     230             : 
     231             :   bool isLegalAddImmediate(int64_t Imm) { return false; }
     232             : 
     233             :   bool isLegalICmpImmediate(int64_t Imm) { return false; }
     234             : 
     235             :   bool isLegalAddressingMode(Type *Ty, GlobalValue *BaseGV, int64_t BaseOffset,
     236             :                              bool HasBaseReg, int64_t Scale,
     237             :                              unsigned AddrSpace, Instruction *I = nullptr) {
     238             :     // Guess that only reg and reg+reg addressing is allowed. This heuristic is
     239             :     // taken from the implementation of LSR.
     240       61113 :     return !BaseGV && BaseOffset == 0 && (Scale == 0 || Scale == 1);
     241             :   }
     242             : 
     243       35334 :   bool isLSRCostLess(TTI::LSRCost &C1, TTI::LSRCost &C2) {
     244       35334 :     return std::tie(C1.NumRegs, C1.AddRecCost, C1.NumIVMuls, C1.NumBaseAdds,
     245             :                     C1.ScaleCost, C1.ImmCost, C1.SetupCost) <
     246       35334 :            std::tie(C2.NumRegs, C2.AddRecCost, C2.NumIVMuls, C2.NumBaseAdds,
     247      106002 :                     C2.ScaleCost, C2.ImmCost, C2.SetupCost);
     248             :   }
     249             : 
     250             :   bool canMacroFuseCmp() { return false; }
     251             : 
     252             :   bool shouldFavorPostInc() const { return false; }
     253             : 
     254             :   bool isLegalMaskedStore(Type *DataType) { return false; }
     255             : 
     256             :   bool isLegalMaskedLoad(Type *DataType) { return false; }
     257             : 
     258             :   bool isLegalMaskedScatter(Type *DataType) { return false; }
     259             : 
     260             :   bool isLegalMaskedGather(Type *DataType) { return false; }
     261             : 
     262             :   bool hasDivRemOp(Type *DataType, bool IsSigned) { return false; }
     263             : 
     264             :   bool hasVolatileVariant(Instruction *I, unsigned AddrSpace) { return false; }
     265             : 
     266             :   bool prefersVectorizedAddressing() { return true; }
     267             : 
     268             :   int getScalingFactorCost(Type *Ty, GlobalValue *BaseGV, int64_t BaseOffset,
     269             :                            bool HasBaseReg, int64_t Scale, unsigned AddrSpace) {
     270             :     // Guess that all legal addressing mode are free.
     271             :     if (isLegalAddressingMode(Ty, BaseGV, BaseOffset, HasBaseReg,
     272             :                               Scale, AddrSpace))
     273             :       return 0;
     274             :     return -1;
     275             :   }
     276             : 
     277             :   bool LSRWithInstrQueries() { return false; }
     278             : 
     279             :   bool isTruncateFree(Type *Ty1, Type *Ty2) { return false; }
     280             : 
     281             :   bool isProfitableToHoist(Instruction *I) { return true; }
     282             : 
     283             :   bool useAA() { return false; }
     284             : 
     285             :   bool isTypeLegal(Type *Ty) { return false; }
     286             : 
     287             :   unsigned getJumpBufAlignment() { return 0; }
     288             : 
     289             :   unsigned getJumpBufSize() { return 0; }
     290             : 
     291             :   bool shouldBuildLookupTables() { return true; }
     292             :   bool shouldBuildLookupTablesForConstant(Constant *C) { return true; }
     293             : 
     294             :   bool useColdCCForColdCall(Function &F) { return false; }
     295             : 
     296             :   unsigned getScalarizationOverhead(Type *Ty, bool Insert, bool Extract) {
     297             :     return 0;
     298             :   }
     299             : 
     300             :   unsigned getOperandsScalarizationOverhead(ArrayRef<const Value *> Args,
     301             :                                             unsigned VF) { return 0; }
     302             : 
     303             :   bool supportsEfficientVectorElementLoadStore() { return false; }
     304             : 
     305             :   bool enableAggressiveInterleaving(bool LoopHasReductions) { return false; }
     306             : 
     307             :   const TTI::MemCmpExpansionOptions *enableMemCmpExpansion(
     308             :       bool IsZeroCmp) const {
     309             :     return nullptr;
     310             :   }
     311             : 
     312             :   bool enableInterleavedAccessVectorization() { return false; }
     313             : 
     314             :   bool isFPVectorizationPotentiallyUnsafe() { return false; }
     315             : 
     316             :   bool allowsMisalignedMemoryAccesses(LLVMContext &Context,
     317             :                                       unsigned BitWidth,
     318             :                                       unsigned AddressSpace,
     319             :                                       unsigned Alignment,
     320             :                                       bool *Fast) { return false; }
     321             : 
     322             :   TTI::PopcntSupportKind getPopcntSupport(unsigned IntTyWidthInBit) {
     323             :     return TTI::PSK_Software;
     324             :   }
     325             : 
     326             :   bool haveFastSqrt(Type *Ty) { return false; }
     327             : 
     328             :   bool isFCmpOrdCheaperThanFCmpZero(Type *Ty) { return true; }
     329             :   
     330             :   unsigned getFPOpCost(Type *Ty) { return TargetTransformInfo::TCC_Basic; }
     331             : 
     332             :   int getIntImmCodeSizeCost(unsigned Opcode, unsigned Idx, const APInt &Imm,
     333             :                             Type *Ty) {
     334             :     return 0;
     335             :   }
     336             : 
     337             :   unsigned getIntImmCost(const APInt &Imm, Type *Ty) { return TTI::TCC_Basic; }
     338             : 
     339             :   unsigned getIntImmCost(unsigned Opcode, unsigned Idx, const APInt &Imm,
     340             :                          Type *Ty) {
     341             :     return TTI::TCC_Free;
     342             :   }
     343             : 
     344             :   unsigned getIntImmCost(Intrinsic::ID IID, unsigned Idx, const APInt &Imm,
     345             :                          Type *Ty) {
     346             :     return TTI::TCC_Free;
     347             :   }
     348             : 
     349             :   unsigned getNumberOfRegisters(bool Vector) { return 8; }
     350             : 
     351             :   unsigned getRegisterBitWidth(bool Vector) const { return 32; }
     352             : 
     353             :   unsigned getMinVectorRegisterBitWidth() { return 128; }
     354             : 
     355             :   bool shouldMaximizeVectorBandwidth(bool OptSize) const { return false; }
     356             : 
     357             :   unsigned getMinimumVF(unsigned ElemWidth) const { return 0; }
     358             : 
     359             :   bool
     360             :   shouldConsiderAddressTypePromotion(const Instruction &I,
     361             :                                      bool &AllowPromotionWithoutCommonHeader) {
     362       29020 :     AllowPromotionWithoutCommonHeader = false;
     363             :     return false;
     364             :   }
     365             : 
     366             :   unsigned getCacheLineSize() { return 0; }
     367             : 
     368             :   llvm::Optional<unsigned> getCacheSize(TargetTransformInfo::CacheLevel Level) {
     369           4 :     switch (Level) {
     370             :     case TargetTransformInfo::CacheLevel::L1D:
     371             :       LLVM_FALLTHROUGH;
     372             :     case TargetTransformInfo::CacheLevel::L2D:
     373             :       return llvm::Optional<unsigned>();
     374             :     }
     375             : 
     376           0 :     llvm_unreachable("Unknown TargetTransformInfo::CacheLevel");
     377             :   }
     378             : 
     379             :   llvm::Optional<unsigned> getCacheAssociativity(
     380             :     TargetTransformInfo::CacheLevel Level) {
     381           2 :     switch (Level) {
     382             :     case TargetTransformInfo::CacheLevel::L1D:
     383             :       LLVM_FALLTHROUGH;
     384             :     case TargetTransformInfo::CacheLevel::L2D:
     385             :       return llvm::Optional<unsigned>();
     386             :     }
     387             : 
     388           0 :     llvm_unreachable("Unknown TargetTransformInfo::CacheLevel");
     389             :   }
     390             : 
     391             :   unsigned getPrefetchDistance() { return 0; }
     392             : 
     393             :   unsigned getMinPrefetchStride() { return 1; }
     394             : 
     395             :   unsigned getMaxPrefetchIterationsAhead() { return UINT_MAX; }
     396             : 
     397             :   unsigned getMaxInterleaveFactor(unsigned VF) { return 1; }
     398             : 
     399             :   unsigned getArithmeticInstrCost(unsigned Opcode, Type *Ty,
     400             :                                   TTI::OperandValueKind Opd1Info,
     401             :                                   TTI::OperandValueKind Opd2Info,
     402             :                                   TTI::OperandValueProperties Opd1PropInfo,
     403             :                                   TTI::OperandValueProperties Opd2PropInfo,
     404             :                                   ArrayRef<const Value *> Args) {
     405             :     return 1;
     406             :   }
     407             : 
     408             :   unsigned getShuffleCost(TTI::ShuffleKind Kind, Type *Ty, int Index,
     409             :                           Type *SubTp) {
     410             :     return 1;
     411             :   }
     412             : 
     413             :   unsigned getCastInstrCost(unsigned Opcode, Type *Dst, Type *Src,
     414             :                             const Instruction *I) { return 1; }
     415             : 
     416             :   unsigned getExtractWithExtendCost(unsigned Opcode, Type *Dst,
     417             :                                     VectorType *VecTy, unsigned Index) {
     418             :     return 1;
     419             :   }
     420             : 
     421             :   unsigned getCFInstrCost(unsigned Opcode) { return 1; }
     422             : 
     423             :   unsigned getCmpSelInstrCost(unsigned Opcode, Type *ValTy, Type *CondTy,
     424             :                               const Instruction *I) {
     425             :     return 1;
     426             :   }
     427             : 
     428             :   unsigned getVectorInstrCost(unsigned Opcode, Type *Val, unsigned Index) {
     429             :     return 1;
     430             :   }
     431             : 
     432             :   unsigned getMemoryOpCost(unsigned Opcode, Type *Src, unsigned Alignment,
     433             :                            unsigned AddressSpace, const Instruction *I) {
     434             :     return 1;
     435             :   }
     436             : 
     437             :   unsigned getMaskedMemoryOpCost(unsigned Opcode, Type *Src, unsigned Alignment,
     438             :                                  unsigned AddressSpace) {
     439             :     return 1;
     440             :   }
     441             : 
     442             :   unsigned getGatherScatterOpCost(unsigned Opcode, Type *DataTy, Value *Ptr,
     443             :                                   bool VariableMask,
     444             :                                   unsigned Alignment) {
     445             :     return 1;
     446             :   }
     447             : 
     448             :   unsigned getInterleavedMemoryOpCost(unsigned Opcode, Type *VecTy,
     449             :                                       unsigned Factor,
     450             :                                       ArrayRef<unsigned> Indices,
     451             :                                       unsigned Alignment,
     452             :                                       unsigned AddressSpace) {
     453             :     return 1;
     454             :   }
     455             : 
     456             :   unsigned getIntrinsicInstrCost(Intrinsic::ID ID, Type *RetTy,
     457             :                                  ArrayRef<Type *> Tys, FastMathFlags FMF,
     458             :                                  unsigned ScalarizationCostPassed) {
     459             :     return 1;
     460             :   }
     461             :   unsigned getIntrinsicInstrCost(Intrinsic::ID ID, Type *RetTy,
     462             :             ArrayRef<Value *> Args, FastMathFlags FMF, unsigned VF) {
     463             :     return 1;
     464             :   }
     465             : 
     466             :   unsigned getCallInstrCost(Function *F, Type *RetTy, ArrayRef<Type *> Tys) {
     467             :     return 1;
     468             :   }
     469             : 
     470             :   unsigned getNumberOfParts(Type *Tp) { return 0; }
     471             : 
     472             :   unsigned getAddressComputationCost(Type *Tp, ScalarEvolution *,
     473             :                                      const SCEV *) {
     474             :     return 0;
     475             :   }
     476             : 
     477             :   unsigned getArithmeticReductionCost(unsigned, Type *, bool) { return 1; }
     478             : 
     479             :   unsigned getMinMaxReductionCost(Type *, Type *, bool, bool) { return 1; }
     480             : 
     481             :   unsigned getCostOfKeepingLiveOverCall(ArrayRef<Type *> Tys) { return 0; }
     482             : 
     483             :   bool getTgtMemIntrinsic(IntrinsicInst *Inst, MemIntrinsicInfo &Info) {
     484             :     return false;
     485             :   }
     486             : 
     487             :   unsigned getAtomicMemIntrinsicMaxElementSize() const {
     488             :     // Note for overrides: You must ensure for all element unordered-atomic
     489             :     // memory intrinsics that all power-of-2 element sizes up to, and
     490             :     // including, the return value of this method have a corresponding
     491             :     // runtime lib call. These runtime lib call definitions can be found
     492             :     // in RuntimeLibcalls.h
     493             :     return 0;
     494             :   }
     495             : 
     496             :   Value *getOrCreateResultFromMemIntrinsic(IntrinsicInst *Inst,
     497             :                                            Type *ExpectedType) {
     498             :     return nullptr;
     499             :   }
     500             : 
     501             :   Type *getMemcpyLoopLoweringType(LLVMContext &Context, Value *Length,
     502             :                                   unsigned SrcAlign, unsigned DestAlign) const {
     503          15 :     return Type::getInt8Ty(Context);
     504             :   }
     505             : 
     506           0 :   void getMemcpyLoopResidualLoweringType(SmallVectorImpl<Type *> &OpsOut,
     507             :                                          LLVMContext &Context,
     508             :                                          unsigned RemainingBytes,
     509             :                                          unsigned SrcAlign,
     510             :                                          unsigned DestAlign) const {
     511           0 :     for (unsigned i = 0; i != RemainingBytes; ++i)
     512           0 :       OpsOut.push_back(Type::getInt8Ty(Context));
     513           0 :   }
     514             : 
     515        1012 :   bool areInlineCompatible(const Function *Caller,
     516             :                            const Function *Callee) const {
     517             :     return (Caller->getFnAttribute("target-cpu") ==
     518        2022 :             Callee->getFnAttribute("target-cpu")) &&
     519             :            (Caller->getFnAttribute("target-features") ==
     520        1012 :             Callee->getFnAttribute("target-features"));
     521             :   }
     522             : 
     523             :   bool isIndexedLoadLegal(TTI::MemIndexedMode Mode, Type *Ty,
     524             :                           const DataLayout &DL) const {
     525             :     return false;
     526             :   }
     527             : 
     528             :   bool isIndexedStoreLegal(TTI::MemIndexedMode Mode, Type *Ty,
     529             :                            const DataLayout &DL) const {
     530             :     return false;
     531             :   }
     532             : 
     533             :   unsigned getLoadStoreVecRegBitWidth(unsigned AddrSpace) const { return 128; }
     534             : 
     535             :   bool isLegalToVectorizeLoad(LoadInst *LI) const { return true; }
     536             : 
     537             :   bool isLegalToVectorizeStore(StoreInst *SI) const { return true; }
     538             : 
     539             :   bool isLegalToVectorizeLoadChain(unsigned ChainSizeInBytes,
     540             :                                    unsigned Alignment,
     541             :                                    unsigned AddrSpace) const {
     542             :     return true;
     543             :   }
     544             : 
     545             :   bool isLegalToVectorizeStoreChain(unsigned ChainSizeInBytes,
     546             :                                     unsigned Alignment,
     547             :                                     unsigned AddrSpace) const {
     548             :     return true;
     549             :   }
     550             : 
     551             :   unsigned getLoadVectorFactor(unsigned VF, unsigned LoadSize,
     552             :                                unsigned ChainSizeInBytes,
     553             :                                VectorType *VecTy) const {
     554             :     return VF;
     555             :   }
     556             : 
     557             :   unsigned getStoreVectorFactor(unsigned VF, unsigned StoreSize,
     558             :                                 unsigned ChainSizeInBytes,
     559             :                                 VectorType *VecTy) const {
     560             :     return VF;
     561             :   }
     562             : 
     563             :   bool useReductionIntrinsic(unsigned Opcode, Type *Ty,
     564             :                              TTI::ReductionFlags Flags) const {
     565             :     return false;
     566             :   }
     567             : 
     568             :   bool shouldExpandReduction(const IntrinsicInst *II) const {
     569             :     return true;
     570             :   }
     571             : 
     572             : protected:
     573             :   // Obtain the minimum required size to hold the value (without the sign)
     574             :   // In case of a vector it returns the min required size for one element.
     575          48 :   unsigned minRequiredElementSize(const Value* Val, bool &isSigned) {
     576          48 :     if (isa<ConstantDataVector>(Val) || isa<ConstantVector>(Val)) {
     577             :       const auto* VectorValue = cast<Constant>(Val);
     578             : 
     579             :       // In case of a vector need to pick the max between the min
     580             :       // required size for each element
     581          12 :       auto *VT = cast<VectorType>(Val->getType());
     582             : 
     583             :       // Assume unsigned elements
     584          12 :       isSigned = false;
     585             : 
     586             :       // The max required size is the total vector width divided by num
     587             :       // of elements in the vector
     588          12 :       unsigned MaxRequiredSize = VT->getBitWidth() / VT->getNumElements();
     589             : 
     590          12 :       unsigned MinRequiredSize = 0;
     591         108 :       for(unsigned i = 0, e = VT->getNumElements(); i < e; ++i) {
     592             :         if (auto* IntElement =
     593          48 :               dyn_cast<ConstantInt>(VectorValue->getAggregateElement(i))) {
     594          48 :           bool signedElement = IntElement->getValue().isNegative();
     595             :           // Get the element min required size.
     596             :           unsigned ElementMinRequiredSize =
     597          48 :             IntElement->getValue().getMinSignedBits() - 1;
     598             :           // In case one element is signed then all the vector is signed.
     599          48 :           isSigned |= signedElement;
     600             :           // Save the max required bit size between all the elements.
     601          48 :           MinRequiredSize = std::max(MinRequiredSize, ElementMinRequiredSize);
     602             :         }
     603             :         else {
     604             :           // not an int constant element
     605             :           return MaxRequiredSize;
     606             :         }
     607             :       }
     608          12 :       return MinRequiredSize;
     609             :     }
     610             : 
     611             :     if (const auto* CI = dyn_cast<ConstantInt>(Val)) {
     612           0 :       isSigned = CI->getValue().isNegative();
     613           0 :       return CI->getValue().getMinSignedBits() - 1;
     614             :     }
     615             : 
     616             :     if (const auto* Cast = dyn_cast<SExtInst>(Val)) {
     617           6 :       isSigned = true;
     618           6 :       return Cast->getSrcTy()->getScalarSizeInBits() - 1;
     619             :     }
     620             : 
     621             :     if (const auto* Cast = dyn_cast<ZExtInst>(Val)) {
     622           6 :       isSigned = false;
     623           6 :       return Cast->getSrcTy()->getScalarSizeInBits();
     624             :     }
     625             : 
     626          24 :     isSigned = false;
     627          24 :     return Val->getType()->getScalarSizeInBits();
     628             :   }
     629             : 
     630             :   bool isStridedAccess(const SCEV *Ptr) {
     631         657 :     return Ptr && isa<SCEVAddRecExpr>(Ptr);
     632             :   }
     633             : 
     634         170 :   const SCEVConstant *getConstantStrideStep(ScalarEvolution *SE,
     635             :                                             const SCEV *Ptr) {
     636             :     if (!isStridedAccess(Ptr))
     637             :       return nullptr;
     638             :     const SCEVAddRecExpr *AddRec = cast<SCEVAddRecExpr>(Ptr);
     639         153 :     return dyn_cast<SCEVConstant>(AddRec->getStepRecurrence(*SE));
     640             :   }
     641             : 
     642          36 :   bool isConstantStridedAccessLessThan(ScalarEvolution *SE, const SCEV *Ptr,
     643             :                                        int64_t MergeDistance) {
     644          36 :     const SCEVConstant *Step = getConstantStrideStep(SE, Ptr);
     645          36 :     if (!Step)
     646             :       return false;
     647             :     APInt StrideVal = Step->getAPInt();
     648          19 :     if (StrideVal.getBitWidth() > 64)
     649             :       return false;
     650             :     // FIXME: Need to take absolute value for negative stride case.
     651          19 :     return StrideVal.getSExtValue() < MergeDistance;
     652             :   }
     653             : };
     654             : 
     655             : /// CRTP base class for use as a mix-in that aids implementing
     656             : /// a TargetTransformInfo-compatible class.
     657             : template <typename T>
     658             : class TargetTransformInfoImplCRTPBase : public TargetTransformInfoImplBase {
     659             : private:
     660             :   typedef TargetTransformInfoImplBase BaseT;
     661             : 
     662             : protected:
     663             :   explicit TargetTransformInfoImplCRTPBase(const DataLayout &DL) : BaseT(DL) {}
     664             : 
     665             : public:
     666             :   using BaseT::getCallCost;
     667             : 
     668     1309710 :   unsigned getCallCost(const Function *F, int NumArgs) {
     669             :     assert(F && "A concrete function must be provided to this routine.");
     670             : 
     671     1309710 :     if (NumArgs < 0)
     672             :       // Set the argument number to the number of explicit arguments in the
     673             :       // function.
     674           0 :       NumArgs = F->arg_size();
     675             : 
     676     1309710 :     if (Intrinsic::ID IID = F->getIntrinsicID()) {
     677             :       FunctionType *FTy = F->getFunctionType();
     678      398454 :       SmallVector<Type *, 8> ParamTys(FTy->param_begin(), FTy->param_end());
     679             :       return static_cast<T *>(this)
     680      398454 :           ->getIntrinsicCost(IID, FTy->getReturnType(), ParamTys);
     681             :     }
     682             : 
     683      911256 :     if (!static_cast<T *>(this)->isLoweredToCall(F))
     684             :       return TTI::TCC_Basic; // Give a basic cost if it will be lowered
     685             :                              // directly.
     686             : 
     687      911227 :     return static_cast<T *>(this)->getCallCost(F->getFunctionType(), NumArgs);
     688             :   }
     689             : 
     690             :   unsigned getCallCost(const Function *F, ArrayRef<const Value *> Arguments) {
     691             :     // Simply delegate to generic handling of the call.
     692             :     // FIXME: We should use instsimplify or something else to catch calls which
     693             :     // will constant fold with these arguments.
     694     1309710 :     return static_cast<T *>(this)->getCallCost(F, Arguments.size());
     695             :   }
     696             : 
     697             :   using BaseT::getGEPCost;
     698             : 
     699      383500 :   int getGEPCost(Type *PointeeType, const Value *Ptr,
     700             :                  ArrayRef<const Value *> Operands) {
     701             :     const GlobalValue *BaseGV = nullptr;
     702      383500 :     if (Ptr != nullptr) {
     703             :       // TODO: will remove this when pointers have an opaque type.
     704             :       assert(Ptr->getType()->getScalarType()->getPointerElementType() ==
     705             :                  PointeeType &&
     706             :              "explicit pointee type doesn't match operand's pointee type");
     707      383500 :       BaseGV = dyn_cast<GlobalValue>(Ptr->stripPointerCasts());
     708             :     }
     709      383500 :     bool HasBaseReg = (BaseGV == nullptr);
     710             : 
     711      383500 :     auto PtrSizeBits = DL.getPointerTypeSizeInBits(Ptr->getType());
     712             :     APInt BaseOffset(PtrSizeBits, 0);
     713             :     int64_t Scale = 0;
     714             : 
     715             :     auto GTI = gep_type_begin(PointeeType, Operands);
     716             :     Type *TargetType = nullptr;
     717             : 
     718             :     // Handle the case where the GEP instruction has a single operand,
     719             :     // the basis, therefore TargetType is a nullptr.
     720      383500 :     if (Operands.empty())
     721           1 :       return !BaseGV ? TTI::TCC_Free : TTI::TCC_Basic;
     722             : 
     723     1880345 :     for (auto I = Operands.begin(); I != Operands.end(); ++I, ++GTI) {
     724      753676 :       TargetType = GTI.getIndexedType();
     725             :       // We assume that the cost of Scalar GEP with constant index and the
     726             :       // cost of Vector GEP with splat constant index are the same.
     727      753676 :       const ConstantInt *ConstIdx = dyn_cast<ConstantInt>(*I);
     728             :       if (!ConstIdx)
     729      332112 :         if (auto Splat = getSplatValue(*I))
     730             :           ConstIdx = dyn_cast<ConstantInt>(Splat);
     731       92406 :       if (StructType *STy = GTI.getStructTypeOrNull()) {
     732             :         // For structures the index is always splat or scalar constant
     733             :         assert(ConstIdx && "Unexpected GEP index");
     734             :         uint64_t Field = ConstIdx->getZExtValue();
     735      184812 :         BaseOffset += DL.getStructLayout(STy)->getElementOffset(Field);
     736             :       } else {
     737      661270 :         int64_t ElementSize = DL.getTypeAllocSize(GTI.getIndexedType());
     738      661270 :         if (ConstIdx) {
     739     1324644 :           BaseOffset +=
     740             :               ConstIdx->getValue().sextOrTrunc(PtrSizeBits) * ElementSize;
     741             :         } else {
     742             :           // Needs scale register.
     743      330109 :           if (Scale != 0)
     744             :             // No addressing mode takes two scale registers.
     745             :             return TTI::TCC_Basic;
     746             :           Scale = ElementSize;
     747             :         }
     748             :       }
     749             :     }
     750             : 
     751             :     // Assumes the address space is 0 when Ptr is nullptr.
     752             :     unsigned AS =
     753      368712 :         (Ptr == nullptr ? 0 : Ptr->getType()->getPointerAddressSpace());
     754             : 
     755      756492 :     if (static_cast<T *>(this)->isLegalAddressingMode(
     756             :             TargetType, const_cast<GlobalValue *>(BaseGV),
     757             :             BaseOffset.sextOrTrunc(64).getSExtValue(), HasBaseReg, Scale, AS))
     758             :       return TTI::TCC_Free;
     759      171772 :     return TTI::TCC_Basic;
     760             :   }
     761             : 
     762             :   using BaseT::getIntrinsicCost;
     763             : 
     764           6 :   unsigned getIntrinsicCost(Intrinsic::ID IID, Type *RetTy,
     765             :                             ArrayRef<const Value *> Arguments) {
     766             :     // Delegate to the generic intrinsic handling code. This mostly provides an
     767             :     // opportunity for targets to (for example) special case the cost of
     768             :     // certain intrinsics based on constants used as arguments.
     769             :     SmallVector<Type *, 8> ParamTys;
     770           6 :     ParamTys.reserve(Arguments.size());
     771          18 :     for (unsigned Idx = 0, Size = Arguments.size(); Idx != Size; ++Idx)
     772          24 :       ParamTys.push_back(Arguments[Idx]->getType());
     773          12 :     return static_cast<T *>(this)->getIntrinsicCost(IID, RetTy, ParamTys);
     774             :   }
     775             : 
     776     3167869 :   unsigned getUserCost(const User *U, ArrayRef<const Value *> Operands) {
     777             :     if (isa<PHINode>(U))
     778             :       return TTI::TCC_Free; // Model all PHI nodes as free.
     779             : 
     780             :     // Static alloca doesn't generate target instructions.
     781             :     if (auto *A = dyn_cast<AllocaInst>(U))
     782         430 :       if (A->isStaticAlloca())
     783             :         return TTI::TCC_Free;
     784             : 
     785             :     if (const GEPOperator *GEP = dyn_cast<GEPOperator>(U)) {
     786             :       return static_cast<T *>(this)->getGEPCost(GEP->getSourceElementType(),
     787             :                                                 GEP->getPointerOperand(),
     788      697492 :                                                 Operands.drop_front());
     789             :     }
     790             : 
     791     2756374 :     if (auto CS = ImmutableCallSite(U)) {
     792             :       const Function *F = CS.getCalledFunction();
     793             :       if (!F) {
     794             :         // Just use the called value type.
     795       17754 :         Type *FTy = CS.getCalledValue()->getType()->getPointerElementType();
     796             :         return static_cast<T *>(this)
     797       35508 :             ->getCallCost(cast<FunctionType>(FTy), CS.arg_size());
     798             :       }
     799             : 
     800     1309710 :       SmallVector<const Value *, 8> Arguments(CS.arg_begin(), CS.arg_end());
     801             :       return static_cast<T *>(this)->getCallCost(F, Arguments);
     802             :     }
     803             : 
     804             :     if (const CastInst *CI = dyn_cast<CastInst>(U)) {
     805             :       // Result of a cmp instruction is often extended (to be used by other
     806             :       // cmp instructions, logical or return instructions). These are usually
     807             :       // nop on most sane targets.
     808             :       if (isa<CmpInst>(CI->getOperand(0)))
     809             :         return TTI::TCC_Free;
     810       85852 :       if (isa<SExtInst>(CI) || isa<ZExtInst>(CI) || isa<FPExtInst>(CI))
     811       36632 :         return static_cast<T *>(this)->getExtCost(CI, Operands.back());
     812             :     }
     813             : 
     814             :     return static_cast<T *>(this)->getOperationCost(
     815             :         Operator::getOpcode(U), U->getType(),
     816     4803782 :         U->getNumOperands() == 1 ? U->getOperand(0)->getType() : nullptr);
     817             :   }
     818             : 
     819          10 :   int getInstructionLatency(const Instruction *I) {
     820          10 :     SmallVector<const Value *, 4> Operands(I->value_op_begin(),
     821             :                                            I->value_op_end());
     822          10 :     if (getUserCost(I, Operands) == TTI::TCC_Free)
     823             :       return 0;
     824             : 
     825           5 :     if (isa<LoadInst>(I))
     826             :       return 4;
     827             : 
     828           5 :     Type *DstTy = I->getType();
     829             : 
     830             :     // Usually an intrinsic is a simple instruction.
     831             :     // A real function call is much slower.
     832             :     if (auto *CI = dyn_cast<CallInst>(I)) {
     833             :       const Function *F = CI->getCalledFunction();
     834           1 :       if (!F || static_cast<T *>(this)->isLoweredToCall(F))
     835             :         return 40;
     836             :       // Some intrinsics return a value and a flag, we use the value type
     837             :       // to decide its latency.
     838             :       if (StructType* StructTy = dyn_cast<StructType>(DstTy))
     839           1 :         DstTy = StructTy->getElementType(0);
     840             :       // Fall through to simple instructions.
     841             :     }
     842             : 
     843             :     if (VectorType *VectorTy = dyn_cast<VectorType>(DstTy))
     844           0 :       DstTy = VectorTy->getElementType();
     845             :     if (DstTy->isFloatingPointTy())
     846             :       return 3;
     847             : 
     848             :     return 1;
     849             :   }
     850             : };
     851             : }
     852             : 
     853             : #endif

Generated by: LCOV version 1.13