1aeef83c6afa1e18d1cf9d359cc678ca0ad556175Chandler Carruth//===- BasicTargetTransformInfo.cpp - Basic target-independent TTI impl ---===// 2aeef83c6afa1e18d1cf9d359cc678ca0ad556175Chandler Carruth// 3aeef83c6afa1e18d1cf9d359cc678ca0ad556175Chandler Carruth// The LLVM Compiler Infrastructure 4aeef83c6afa1e18d1cf9d359cc678ca0ad556175Chandler Carruth// 5aeef83c6afa1e18d1cf9d359cc678ca0ad556175Chandler Carruth// This file is distributed under the University of Illinois Open Source 6aeef83c6afa1e18d1cf9d359cc678ca0ad556175Chandler Carruth// License. See LICENSE.TXT for details. 7aeef83c6afa1e18d1cf9d359cc678ca0ad556175Chandler Carruth// 8aeef83c6afa1e18d1cf9d359cc678ca0ad556175Chandler Carruth//===----------------------------------------------------------------------===// 9aeef83c6afa1e18d1cf9d359cc678ca0ad556175Chandler Carruth/// \file 10aeef83c6afa1e18d1cf9d359cc678ca0ad556175Chandler Carruth/// This file provides the implementation of a basic TargetTransformInfo pass 11aeef83c6afa1e18d1cf9d359cc678ca0ad556175Chandler Carruth/// predicated on the target abstractions present in the target independent 12aeef83c6afa1e18d1cf9d359cc678ca0ad556175Chandler Carruth/// code generator. It uses these (primarily TargetLowering) to model as much 13aeef83c6afa1e18d1cf9d359cc678ca0ad556175Chandler Carruth/// of the TTI query interface as possible. It is included by most targets so 14aeef83c6afa1e18d1cf9d359cc678ca0ad556175Chandler Carruth/// that they can specialize only a small subset of the query space. 15aeef83c6afa1e18d1cf9d359cc678ca0ad556175Chandler Carruth/// 16aeef83c6afa1e18d1cf9d359cc678ca0ad556175Chandler Carruth//===----------------------------------------------------------------------===// 17aeef83c6afa1e18d1cf9d359cc678ca0ad556175Chandler Carruth 18aeef83c6afa1e18d1cf9d359cc678ca0ad556175Chandler Carruth#include "llvm/CodeGen/Passes.h" 19dce4a407a24b04eebc6a376f8e62b41aaa7b071fStephen Hines#include "llvm/Analysis/LoopInfo.h" 20be04929f7fd76a921540e9901f24563e51dc1219Chandler Carruth#include "llvm/Analysis/TargetTransformInfo.h" 21dce4a407a24b04eebc6a376f8e62b41aaa7b071fStephen Hines#include "llvm/Support/CommandLine.h" 22aeef83c6afa1e18d1cf9d359cc678ca0ad556175Chandler Carruth#include "llvm/Target/TargetLowering.h" 23dce4a407a24b04eebc6a376f8e62b41aaa7b071fStephen Hines#include "llvm/Target/TargetSubtargetInfo.h" 24aeef83c6afa1e18d1cf9d359cc678ca0ad556175Chandler Carruth#include <utility> 25aeef83c6afa1e18d1cf9d359cc678ca0ad556175Chandler Carruthusing namespace llvm; 26aeef83c6afa1e18d1cf9d359cc678ca0ad556175Chandler Carruth 27dce4a407a24b04eebc6a376f8e62b41aaa7b071fStephen Hinesstatic cl::opt<unsigned> 28dce4a407a24b04eebc6a376f8e62b41aaa7b071fStephen HinesPartialUnrollingThreshold("partial-unrolling-threshold", cl::init(0), 29dce4a407a24b04eebc6a376f8e62b41aaa7b071fStephen Hines cl::desc("Threshold for partial unrolling"), cl::Hidden); 30dce4a407a24b04eebc6a376f8e62b41aaa7b071fStephen Hines 31dce4a407a24b04eebc6a376f8e62b41aaa7b071fStephen Hines#define DEBUG_TYPE "basictti" 32dce4a407a24b04eebc6a376f8e62b41aaa7b071fStephen Hines 33aeef83c6afa1e18d1cf9d359cc678ca0ad556175Chandler Carruthnamespace { 34aeef83c6afa1e18d1cf9d359cc678ca0ad556175Chandler Carruth 3536b56886974eae4f9c5ebc96befd3e7bfe5de338Stephen Hinesclass BasicTTI final : public ImmutablePass, public TargetTransformInfo { 36ea44281d5da5096de50ce1cb358ff0c6f20e1a2aBill Wendling const TargetMachine *TM; 37aeef83c6afa1e18d1cf9d359cc678ca0ad556175Chandler Carruth 38aeef83c6afa1e18d1cf9d359cc678ca0ad556175Chandler Carruth /// Estimate the overhead of scalarizing an instruction. Insert and Extract 39aeef83c6afa1e18d1cf9d359cc678ca0ad556175Chandler Carruth /// are set if the result needs to be inserted and/or extracted from vectors. 40aeef83c6afa1e18d1cf9d359cc678ca0ad556175Chandler Carruth unsigned getScalarizationOverhead(Type *Ty, bool Insert, bool Extract) const; 41aeef83c6afa1e18d1cf9d359cc678ca0ad556175Chandler Carruth 42cd81d94322a39503e4a3e87b6ee03d4fcb3465fbStephen Hines /// Estimate the cost overhead of SK_Alternate shuffle. 43cd81d94322a39503e4a3e87b6ee03d4fcb3465fbStephen Hines unsigned getAltShuffleOverhead(Type *Ty) const; 44cd81d94322a39503e4a3e87b6ee03d4fcb3465fbStephen Hines 45ea44281d5da5096de50ce1cb358ff0c6f20e1a2aBill Wendling const TargetLoweringBase *getTLI() const { return TM->getTargetLowering(); } 46ea44281d5da5096de50ce1cb358ff0c6f20e1a2aBill Wendling 47aeef83c6afa1e18d1cf9d359cc678ca0ad556175Chandler Carruthpublic: 48dce4a407a24b04eebc6a376f8e62b41aaa7b071fStephen Hines BasicTTI() : ImmutablePass(ID), TM(nullptr) { 49aeef83c6afa1e18d1cf9d359cc678ca0ad556175Chandler Carruth llvm_unreachable("This pass cannot be directly constructed"); 50aeef83c6afa1e18d1cf9d359cc678ca0ad556175Chandler Carruth } 51aeef83c6afa1e18d1cf9d359cc678ca0ad556175Chandler Carruth 52ea44281d5da5096de50ce1cb358ff0c6f20e1a2aBill Wendling BasicTTI(const TargetMachine *TM) : ImmutablePass(ID), TM(TM) { 53aeef83c6afa1e18d1cf9d359cc678ca0ad556175Chandler Carruth initializeBasicTTIPass(*PassRegistry::getPassRegistry()); 54aeef83c6afa1e18d1cf9d359cc678ca0ad556175Chandler Carruth } 55aeef83c6afa1e18d1cf9d359cc678ca0ad556175Chandler Carruth 5636b56886974eae4f9c5ebc96befd3e7bfe5de338Stephen Hines void initializePass() override { 57aeef83c6afa1e18d1cf9d359cc678ca0ad556175Chandler Carruth pushTTIStack(this); 58aeef83c6afa1e18d1cf9d359cc678ca0ad556175Chandler Carruth } 59aeef83c6afa1e18d1cf9d359cc678ca0ad556175Chandler Carruth 6036b56886974eae4f9c5ebc96befd3e7bfe5de338Stephen Hines void getAnalysisUsage(AnalysisUsage &AU) const override { 61aeef83c6afa1e18d1cf9d359cc678ca0ad556175Chandler Carruth TargetTransformInfo::getAnalysisUsage(AU); 62aeef83c6afa1e18d1cf9d359cc678ca0ad556175Chandler Carruth } 63aeef83c6afa1e18d1cf9d359cc678ca0ad556175Chandler Carruth 64aeef83c6afa1e18d1cf9d359cc678ca0ad556175Chandler Carruth /// Pass identification. 65aeef83c6afa1e18d1cf9d359cc678ca0ad556175Chandler Carruth static char ID; 66aeef83c6afa1e18d1cf9d359cc678ca0ad556175Chandler Carruth 67aeef83c6afa1e18d1cf9d359cc678ca0ad556175Chandler Carruth /// Provide necessary pointer adjustments for the two base classes. 6836b56886974eae4f9c5ebc96befd3e7bfe5de338Stephen Hines void *getAdjustedAnalysisPointer(const void *ID) override { 69aeef83c6afa1e18d1cf9d359cc678ca0ad556175Chandler Carruth if (ID == &TargetTransformInfo::ID) 70aeef83c6afa1e18d1cf9d359cc678ca0ad556175Chandler Carruth return (TargetTransformInfo*)this; 71aeef83c6afa1e18d1cf9d359cc678ca0ad556175Chandler Carruth return this; 72aeef83c6afa1e18d1cf9d359cc678ca0ad556175Chandler Carruth } 73aeef83c6afa1e18d1cf9d359cc678ca0ad556175Chandler Carruth 7436b56886974eae4f9c5ebc96befd3e7bfe5de338Stephen Hines bool hasBranchDivergence() const override; 7557e6b2d1f3de0bf459e96f7038e692d624f7e580Tom Stellard 76aeef83c6afa1e18d1cf9d359cc678ca0ad556175Chandler Carruth /// \name Scalar TTI Implementations 77aeef83c6afa1e18d1cf9d359cc678ca0ad556175Chandler Carruth /// @{ 78aeef83c6afa1e18d1cf9d359cc678ca0ad556175Chandler Carruth 7936b56886974eae4f9c5ebc96befd3e7bfe5de338Stephen Hines bool isLegalAddImmediate(int64_t imm) const override; 8036b56886974eae4f9c5ebc96befd3e7bfe5de338Stephen Hines bool isLegalICmpImmediate(int64_t imm) const override; 8136b56886974eae4f9c5ebc96befd3e7bfe5de338Stephen Hines bool isLegalAddressingMode(Type *Ty, GlobalValue *BaseGV, 8236b56886974eae4f9c5ebc96befd3e7bfe5de338Stephen Hines int64_t BaseOffset, bool HasBaseReg, 8336b56886974eae4f9c5ebc96befd3e7bfe5de338Stephen Hines int64_t Scale) const override; 8436b56886974eae4f9c5ebc96befd3e7bfe5de338Stephen Hines int getScalingFactorCost(Type *Ty, GlobalValue *BaseGV, 8536b56886974eae4f9c5ebc96befd3e7bfe5de338Stephen Hines int64_t BaseOffset, bool HasBaseReg, 8636b56886974eae4f9c5ebc96befd3e7bfe5de338Stephen Hines int64_t Scale) const override; 8736b56886974eae4f9c5ebc96befd3e7bfe5de338Stephen Hines bool isTruncateFree(Type *Ty1, Type *Ty2) const override; 8836b56886974eae4f9c5ebc96befd3e7bfe5de338Stephen Hines bool isTypeLegal(Type *Ty) const override; 8936b56886974eae4f9c5ebc96befd3e7bfe5de338Stephen Hines unsigned getJumpBufAlignment() const override; 9036b56886974eae4f9c5ebc96befd3e7bfe5de338Stephen Hines unsigned getJumpBufSize() const override; 9136b56886974eae4f9c5ebc96befd3e7bfe5de338Stephen Hines bool shouldBuildLookupTables() const override; 9236b56886974eae4f9c5ebc96befd3e7bfe5de338Stephen Hines bool haveFastSqrt(Type *Ty) const override; 9336b56886974eae4f9c5ebc96befd3e7bfe5de338Stephen Hines void getUnrollingPreferences(Loop *L, 9436b56886974eae4f9c5ebc96befd3e7bfe5de338Stephen Hines UnrollingPreferences &UP) const override; 95aeef83c6afa1e18d1cf9d359cc678ca0ad556175Chandler Carruth 96aeef83c6afa1e18d1cf9d359cc678ca0ad556175Chandler Carruth /// @} 97aeef83c6afa1e18d1cf9d359cc678ca0ad556175Chandler Carruth 98aeef83c6afa1e18d1cf9d359cc678ca0ad556175Chandler Carruth /// \name Vector TTI Implementations 99aeef83c6afa1e18d1cf9d359cc678ca0ad556175Chandler Carruth /// @{ 100aeef83c6afa1e18d1cf9d359cc678ca0ad556175Chandler Carruth 10136b56886974eae4f9c5ebc96befd3e7bfe5de338Stephen Hines unsigned getNumberOfRegisters(bool Vector) const override; 10236b56886974eae4f9c5ebc96befd3e7bfe5de338Stephen Hines unsigned getMaximumUnrollFactor() const override; 10336b56886974eae4f9c5ebc96befd3e7bfe5de338Stephen Hines unsigned getRegisterBitWidth(bool Vector) const override; 10436b56886974eae4f9c5ebc96befd3e7bfe5de338Stephen Hines unsigned getArithmeticInstrCost(unsigned Opcode, Type *Ty, OperandValueKind, 10536b56886974eae4f9c5ebc96befd3e7bfe5de338Stephen Hines OperandValueKind) const override; 10636b56886974eae4f9c5ebc96befd3e7bfe5de338Stephen Hines unsigned getShuffleCost(ShuffleKind Kind, Type *Tp, 10736b56886974eae4f9c5ebc96befd3e7bfe5de338Stephen Hines int Index, Type *SubTp) const override; 10836b56886974eae4f9c5ebc96befd3e7bfe5de338Stephen Hines unsigned getCastInstrCost(unsigned Opcode, Type *Dst, 10936b56886974eae4f9c5ebc96befd3e7bfe5de338Stephen Hines Type *Src) const override; 11036b56886974eae4f9c5ebc96befd3e7bfe5de338Stephen Hines unsigned getCFInstrCost(unsigned Opcode) const override; 11136b56886974eae4f9c5ebc96befd3e7bfe5de338Stephen Hines unsigned getCmpSelInstrCost(unsigned Opcode, Type *ValTy, 11236b56886974eae4f9c5ebc96befd3e7bfe5de338Stephen Hines Type *CondTy) const override; 11336b56886974eae4f9c5ebc96befd3e7bfe5de338Stephen Hines unsigned getVectorInstrCost(unsigned Opcode, Type *Val, 11436b56886974eae4f9c5ebc96befd3e7bfe5de338Stephen Hines unsigned Index) const override; 11536b56886974eae4f9c5ebc96befd3e7bfe5de338Stephen Hines unsigned getMemoryOpCost(unsigned Opcode, Type *Src, unsigned Alignment, 11636b56886974eae4f9c5ebc96befd3e7bfe5de338Stephen Hines unsigned AddressSpace) const override; 11736b56886974eae4f9c5ebc96befd3e7bfe5de338Stephen Hines unsigned getIntrinsicInstrCost(Intrinsic::ID, Type *RetTy, 11836b56886974eae4f9c5ebc96befd3e7bfe5de338Stephen Hines ArrayRef<Type*> Tys) const override; 11936b56886974eae4f9c5ebc96befd3e7bfe5de338Stephen Hines unsigned getNumberOfParts(Type *Tp) const override; 12036b56886974eae4f9c5ebc96befd3e7bfe5de338Stephen Hines unsigned getAddressComputationCost( Type *Ty, bool IsComplex) const override; 12136b56886974eae4f9c5ebc96befd3e7bfe5de338Stephen Hines unsigned getReductionCost(unsigned Opcode, Type *Ty, 12236b56886974eae4f9c5ebc96befd3e7bfe5de338Stephen Hines bool IsPairwise) const override; 123aeef83c6afa1e18d1cf9d359cc678ca0ad556175Chandler Carruth 124aeef83c6afa1e18d1cf9d359cc678ca0ad556175Chandler Carruth /// @} 125aeef83c6afa1e18d1cf9d359cc678ca0ad556175Chandler Carruth}; 126aeef83c6afa1e18d1cf9d359cc678ca0ad556175Chandler Carruth 127aeef83c6afa1e18d1cf9d359cc678ca0ad556175Chandler Carruth} 128aeef83c6afa1e18d1cf9d359cc678ca0ad556175Chandler Carruth 129aeef83c6afa1e18d1cf9d359cc678ca0ad556175Chandler CarruthINITIALIZE_AG_PASS(BasicTTI, TargetTransformInfo, "basictti", 130aeef83c6afa1e18d1cf9d359cc678ca0ad556175Chandler Carruth "Target independent code generator's TTI", true, true, false) 131aeef83c6afa1e18d1cf9d359cc678ca0ad556175Chandler Carruthchar BasicTTI::ID = 0; 132aeef83c6afa1e18d1cf9d359cc678ca0ad556175Chandler Carruth 133aeef83c6afa1e18d1cf9d359cc678ca0ad556175Chandler CarruthImmutablePass * 134ea44281d5da5096de50ce1cb358ff0c6f20e1a2aBill Wendlingllvm::createBasicTargetTransformInfoPass(const TargetMachine *TM) { 135ea44281d5da5096de50ce1cb358ff0c6f20e1a2aBill Wendling return new BasicTTI(TM); 136aeef83c6afa1e18d1cf9d359cc678ca0ad556175Chandler Carruth} 137aeef83c6afa1e18d1cf9d359cc678ca0ad556175Chandler Carruth 13857e6b2d1f3de0bf459e96f7038e692d624f7e580Tom Stellardbool BasicTTI::hasBranchDivergence() const { return false; } 139aeef83c6afa1e18d1cf9d359cc678ca0ad556175Chandler Carruth 140aeef83c6afa1e18d1cf9d359cc678ca0ad556175Chandler Carruthbool BasicTTI::isLegalAddImmediate(int64_t imm) const { 141ea44281d5da5096de50ce1cb358ff0c6f20e1a2aBill Wendling return getTLI()->isLegalAddImmediate(imm); 142aeef83c6afa1e18d1cf9d359cc678ca0ad556175Chandler Carruth} 143aeef83c6afa1e18d1cf9d359cc678ca0ad556175Chandler Carruth 144aeef83c6afa1e18d1cf9d359cc678ca0ad556175Chandler Carruthbool BasicTTI::isLegalICmpImmediate(int64_t imm) const { 145ea44281d5da5096de50ce1cb358ff0c6f20e1a2aBill Wendling return getTLI()->isLegalICmpImmediate(imm); 146aeef83c6afa1e18d1cf9d359cc678ca0ad556175Chandler Carruth} 147aeef83c6afa1e18d1cf9d359cc678ca0ad556175Chandler Carruth 148aeef83c6afa1e18d1cf9d359cc678ca0ad556175Chandler Carruthbool BasicTTI::isLegalAddressingMode(Type *Ty, GlobalValue *BaseGV, 149aeef83c6afa1e18d1cf9d359cc678ca0ad556175Chandler Carruth int64_t BaseOffset, bool HasBaseReg, 150aeef83c6afa1e18d1cf9d359cc678ca0ad556175Chandler Carruth int64_t Scale) const { 15169e42dbd006c0afb732067ece7327988b1e24c01Benjamin Kramer TargetLoweringBase::AddrMode AM; 152aeef83c6afa1e18d1cf9d359cc678ca0ad556175Chandler Carruth AM.BaseGV = BaseGV; 153aeef83c6afa1e18d1cf9d359cc678ca0ad556175Chandler Carruth AM.BaseOffs = BaseOffset; 154aeef83c6afa1e18d1cf9d359cc678ca0ad556175Chandler Carruth AM.HasBaseReg = HasBaseReg; 155aeef83c6afa1e18d1cf9d359cc678ca0ad556175Chandler Carruth AM.Scale = Scale; 156ea44281d5da5096de50ce1cb358ff0c6f20e1a2aBill Wendling return getTLI()->isLegalAddressingMode(AM, Ty); 157aeef83c6afa1e18d1cf9d359cc678ca0ad556175Chandler Carruth} 158aeef83c6afa1e18d1cf9d359cc678ca0ad556175Chandler Carruth 15906f5ebc5a1604b01689cf2d482dd05f956538af6Quentin Colombetint BasicTTI::getScalingFactorCost(Type *Ty, GlobalValue *BaseGV, 16006f5ebc5a1604b01689cf2d482dd05f956538af6Quentin Colombet int64_t BaseOffset, bool HasBaseReg, 16106f5ebc5a1604b01689cf2d482dd05f956538af6Quentin Colombet int64_t Scale) const { 16206f5ebc5a1604b01689cf2d482dd05f956538af6Quentin Colombet TargetLoweringBase::AddrMode AM; 16306f5ebc5a1604b01689cf2d482dd05f956538af6Quentin Colombet AM.BaseGV = BaseGV; 16406f5ebc5a1604b01689cf2d482dd05f956538af6Quentin Colombet AM.BaseOffs = BaseOffset; 16506f5ebc5a1604b01689cf2d482dd05f956538af6Quentin Colombet AM.HasBaseReg = HasBaseReg; 16606f5ebc5a1604b01689cf2d482dd05f956538af6Quentin Colombet AM.Scale = Scale; 167ea44281d5da5096de50ce1cb358ff0c6f20e1a2aBill Wendling return getTLI()->getScalingFactorCost(AM, Ty); 16806f5ebc5a1604b01689cf2d482dd05f956538af6Quentin Colombet} 16906f5ebc5a1604b01689cf2d482dd05f956538af6Quentin Colombet 170aeef83c6afa1e18d1cf9d359cc678ca0ad556175Chandler Carruthbool BasicTTI::isTruncateFree(Type *Ty1, Type *Ty2) const { 171ea44281d5da5096de50ce1cb358ff0c6f20e1a2aBill Wendling return getTLI()->isTruncateFree(Ty1, Ty2); 172aeef83c6afa1e18d1cf9d359cc678ca0ad556175Chandler Carruth} 173aeef83c6afa1e18d1cf9d359cc678ca0ad556175Chandler Carruth 174aeef83c6afa1e18d1cf9d359cc678ca0ad556175Chandler Carruthbool BasicTTI::isTypeLegal(Type *Ty) const { 175ea44281d5da5096de50ce1cb358ff0c6f20e1a2aBill Wendling EVT T = getTLI()->getValueType(Ty); 176ea44281d5da5096de50ce1cb358ff0c6f20e1a2aBill Wendling return getTLI()->isTypeLegal(T); 177aeef83c6afa1e18d1cf9d359cc678ca0ad556175Chandler Carruth} 178aeef83c6afa1e18d1cf9d359cc678ca0ad556175Chandler Carruth 179aeef83c6afa1e18d1cf9d359cc678ca0ad556175Chandler Carruthunsigned BasicTTI::getJumpBufAlignment() const { 180ea44281d5da5096de50ce1cb358ff0c6f20e1a2aBill Wendling return getTLI()->getJumpBufAlignment(); 181aeef83c6afa1e18d1cf9d359cc678ca0ad556175Chandler Carruth} 182aeef83c6afa1e18d1cf9d359cc678ca0ad556175Chandler Carruth 183aeef83c6afa1e18d1cf9d359cc678ca0ad556175Chandler Carruthunsigned BasicTTI::getJumpBufSize() const { 184ea44281d5da5096de50ce1cb358ff0c6f20e1a2aBill Wendling return getTLI()->getJumpBufSize(); 185aeef83c6afa1e18d1cf9d359cc678ca0ad556175Chandler Carruth} 186aeef83c6afa1e18d1cf9d359cc678ca0ad556175Chandler Carruth 187aeef83c6afa1e18d1cf9d359cc678ca0ad556175Chandler Carruthbool BasicTTI::shouldBuildLookupTables() const { 188ea44281d5da5096de50ce1cb358ff0c6f20e1a2aBill Wendling const TargetLoweringBase *TLI = getTLI(); 189aeef83c6afa1e18d1cf9d359cc678ca0ad556175Chandler Carruth return TLI->supportJumpTables() && 190aeef83c6afa1e18d1cf9d359cc678ca0ad556175Chandler Carruth (TLI->isOperationLegalOrCustom(ISD::BR_JT, MVT::Other) || 191aeef83c6afa1e18d1cf9d359cc678ca0ad556175Chandler Carruth TLI->isOperationLegalOrCustom(ISD::BRIND, MVT::Other)); 192aeef83c6afa1e18d1cf9d359cc678ca0ad556175Chandler Carruth} 193aeef83c6afa1e18d1cf9d359cc678ca0ad556175Chandler Carruth 194a8a7099c1849fcbb4a68642a292fd0250aa46505Richard Sandifordbool BasicTTI::haveFastSqrt(Type *Ty) const { 195a8a7099c1849fcbb4a68642a292fd0250aa46505Richard Sandiford const TargetLoweringBase *TLI = getTLI(); 196a8a7099c1849fcbb4a68642a292fd0250aa46505Richard Sandiford EVT VT = TLI->getValueType(Ty); 197a8a7099c1849fcbb4a68642a292fd0250aa46505Richard Sandiford return TLI->isTypeLegal(VT) && TLI->isOperationLegalOrCustom(ISD::FSQRT, VT); 198a8a7099c1849fcbb4a68642a292fd0250aa46505Richard Sandiford} 199a8a7099c1849fcbb4a68642a292fd0250aa46505Richard Sandiford 200dce4a407a24b04eebc6a376f8e62b41aaa7b071fStephen Hinesvoid BasicTTI::getUnrollingPreferences(Loop *L, 201dce4a407a24b04eebc6a376f8e62b41aaa7b071fStephen Hines UnrollingPreferences &UP) const { 202dce4a407a24b04eebc6a376f8e62b41aaa7b071fStephen Hines // This unrolling functionality is target independent, but to provide some 203dce4a407a24b04eebc6a376f8e62b41aaa7b071fStephen Hines // motivation for its intended use, for x86: 204dce4a407a24b04eebc6a376f8e62b41aaa7b071fStephen Hines 205dce4a407a24b04eebc6a376f8e62b41aaa7b071fStephen Hines // According to the Intel 64 and IA-32 Architectures Optimization Reference 206dce4a407a24b04eebc6a376f8e62b41aaa7b071fStephen Hines // Manual, Intel Core models and later have a loop stream detector 207dce4a407a24b04eebc6a376f8e62b41aaa7b071fStephen Hines // (and associated uop queue) that can benefit from partial unrolling. 208dce4a407a24b04eebc6a376f8e62b41aaa7b071fStephen Hines // The relevant requirements are: 209dce4a407a24b04eebc6a376f8e62b41aaa7b071fStephen Hines // - The loop must have no more than 4 (8 for Nehalem and later) branches 210dce4a407a24b04eebc6a376f8e62b41aaa7b071fStephen Hines // taken, and none of them may be calls. 211dce4a407a24b04eebc6a376f8e62b41aaa7b071fStephen Hines // - The loop can have no more than 18 (28 for Nehalem and later) uops. 212dce4a407a24b04eebc6a376f8e62b41aaa7b071fStephen Hines 213dce4a407a24b04eebc6a376f8e62b41aaa7b071fStephen Hines // According to the Software Optimization Guide for AMD Family 15h Processors, 214dce4a407a24b04eebc6a376f8e62b41aaa7b071fStephen Hines // models 30h-4fh (Steamroller and later) have a loop predictor and loop 215dce4a407a24b04eebc6a376f8e62b41aaa7b071fStephen Hines // buffer which can benefit from partial unrolling. 216dce4a407a24b04eebc6a376f8e62b41aaa7b071fStephen Hines // The relevant requirements are: 217dce4a407a24b04eebc6a376f8e62b41aaa7b071fStephen Hines // - The loop must have fewer than 16 branches 218dce4a407a24b04eebc6a376f8e62b41aaa7b071fStephen Hines // - The loop must have less than 40 uops in all executed loop branches 219dce4a407a24b04eebc6a376f8e62b41aaa7b071fStephen Hines 220dce4a407a24b04eebc6a376f8e62b41aaa7b071fStephen Hines // The number of taken branches in a loop is hard to estimate here, and 221dce4a407a24b04eebc6a376f8e62b41aaa7b071fStephen Hines // benchmarking has revealed that it is better not to be conservative when 222dce4a407a24b04eebc6a376f8e62b41aaa7b071fStephen Hines // estimating the branch count. As a result, we'll ignore the branch limits 223dce4a407a24b04eebc6a376f8e62b41aaa7b071fStephen Hines // until someone finds a case where it matters in practice. 224dce4a407a24b04eebc6a376f8e62b41aaa7b071fStephen Hines 225dce4a407a24b04eebc6a376f8e62b41aaa7b071fStephen Hines unsigned MaxOps; 226dce4a407a24b04eebc6a376f8e62b41aaa7b071fStephen Hines const TargetSubtargetInfo *ST = &TM->getSubtarget<TargetSubtargetInfo>(); 227dce4a407a24b04eebc6a376f8e62b41aaa7b071fStephen Hines if (PartialUnrollingThreshold.getNumOccurrences() > 0) 228dce4a407a24b04eebc6a376f8e62b41aaa7b071fStephen Hines MaxOps = PartialUnrollingThreshold; 229dce4a407a24b04eebc6a376f8e62b41aaa7b071fStephen Hines else if (ST->getSchedModel()->LoopMicroOpBufferSize > 0) 230dce4a407a24b04eebc6a376f8e62b41aaa7b071fStephen Hines MaxOps = ST->getSchedModel()->LoopMicroOpBufferSize; 231dce4a407a24b04eebc6a376f8e62b41aaa7b071fStephen Hines else 232dce4a407a24b04eebc6a376f8e62b41aaa7b071fStephen Hines return; 233dce4a407a24b04eebc6a376f8e62b41aaa7b071fStephen Hines 234dce4a407a24b04eebc6a376f8e62b41aaa7b071fStephen Hines // Scan the loop: don't unroll loops with calls. 235dce4a407a24b04eebc6a376f8e62b41aaa7b071fStephen Hines for (Loop::block_iterator I = L->block_begin(), E = L->block_end(); 236dce4a407a24b04eebc6a376f8e62b41aaa7b071fStephen Hines I != E; ++I) { 237dce4a407a24b04eebc6a376f8e62b41aaa7b071fStephen Hines BasicBlock *BB = *I; 238dce4a407a24b04eebc6a376f8e62b41aaa7b071fStephen Hines 239dce4a407a24b04eebc6a376f8e62b41aaa7b071fStephen Hines for (BasicBlock::iterator J = BB->begin(), JE = BB->end(); J != JE; ++J) 240dce4a407a24b04eebc6a376f8e62b41aaa7b071fStephen Hines if (isa<CallInst>(J) || isa<InvokeInst>(J)) { 241dce4a407a24b04eebc6a376f8e62b41aaa7b071fStephen Hines ImmutableCallSite CS(J); 242dce4a407a24b04eebc6a376f8e62b41aaa7b071fStephen Hines if (const Function *F = CS.getCalledFunction()) { 243dce4a407a24b04eebc6a376f8e62b41aaa7b071fStephen Hines if (!TopTTI->isLoweredToCall(F)) 244dce4a407a24b04eebc6a376f8e62b41aaa7b071fStephen Hines continue; 245dce4a407a24b04eebc6a376f8e62b41aaa7b071fStephen Hines } 246dce4a407a24b04eebc6a376f8e62b41aaa7b071fStephen Hines 247dce4a407a24b04eebc6a376f8e62b41aaa7b071fStephen Hines return; 248dce4a407a24b04eebc6a376f8e62b41aaa7b071fStephen Hines } 249dce4a407a24b04eebc6a376f8e62b41aaa7b071fStephen Hines } 250dce4a407a24b04eebc6a376f8e62b41aaa7b071fStephen Hines 251dce4a407a24b04eebc6a376f8e62b41aaa7b071fStephen Hines // Enable runtime and partial unrolling up to the specified size. 252dce4a407a24b04eebc6a376f8e62b41aaa7b071fStephen Hines UP.Partial = UP.Runtime = true; 253dce4a407a24b04eebc6a376f8e62b41aaa7b071fStephen Hines UP.PartialThreshold = UP.PartialOptSizeThreshold = MaxOps; 254dce4a407a24b04eebc6a376f8e62b41aaa7b071fStephen Hines} 2554f7e2c38e864d7eaeb407ac501478e9579624d1bHal Finkel 256aeef83c6afa1e18d1cf9d359cc678ca0ad556175Chandler Carruth//===----------------------------------------------------------------------===// 257aeef83c6afa1e18d1cf9d359cc678ca0ad556175Chandler Carruth// 258aeef83c6afa1e18d1cf9d359cc678ca0ad556175Chandler Carruth// Calls used by the vectorizers. 259aeef83c6afa1e18d1cf9d359cc678ca0ad556175Chandler Carruth// 260aeef83c6afa1e18d1cf9d359cc678ca0ad556175Chandler Carruth//===----------------------------------------------------------------------===// 261aeef83c6afa1e18d1cf9d359cc678ca0ad556175Chandler Carruth 262aeef83c6afa1e18d1cf9d359cc678ca0ad556175Chandler Carruthunsigned BasicTTI::getScalarizationOverhead(Type *Ty, bool Insert, 263aeef83c6afa1e18d1cf9d359cc678ca0ad556175Chandler Carruth bool Extract) const { 264aeef83c6afa1e18d1cf9d359cc678ca0ad556175Chandler Carruth assert (Ty->isVectorTy() && "Can only scalarize vectors"); 265aeef83c6afa1e18d1cf9d359cc678ca0ad556175Chandler Carruth unsigned Cost = 0; 266aeef83c6afa1e18d1cf9d359cc678ca0ad556175Chandler Carruth 267aeef83c6afa1e18d1cf9d359cc678ca0ad556175Chandler Carruth for (int i = 0, e = Ty->getVectorNumElements(); i < e; ++i) { 268aeef83c6afa1e18d1cf9d359cc678ca0ad556175Chandler Carruth if (Insert) 269aeef83c6afa1e18d1cf9d359cc678ca0ad556175Chandler Carruth Cost += TopTTI->getVectorInstrCost(Instruction::InsertElement, Ty, i); 270aeef83c6afa1e18d1cf9d359cc678ca0ad556175Chandler Carruth if (Extract) 271aeef83c6afa1e18d1cf9d359cc678ca0ad556175Chandler Carruth Cost += TopTTI->getVectorInstrCost(Instruction::ExtractElement, Ty, i); 272aeef83c6afa1e18d1cf9d359cc678ca0ad556175Chandler Carruth } 273aeef83c6afa1e18d1cf9d359cc678ca0ad556175Chandler Carruth 274aeef83c6afa1e18d1cf9d359cc678ca0ad556175Chandler Carruth return Cost; 275aeef83c6afa1e18d1cf9d359cc678ca0ad556175Chandler Carruth} 276aeef83c6afa1e18d1cf9d359cc678ca0ad556175Chandler Carruth 277aeef83c6afa1e18d1cf9d359cc678ca0ad556175Chandler Carruthunsigned BasicTTI::getNumberOfRegisters(bool Vector) const { 278aeef83c6afa1e18d1cf9d359cc678ca0ad556175Chandler Carruth return 1; 279aeef83c6afa1e18d1cf9d359cc678ca0ad556175Chandler Carruth} 280aeef83c6afa1e18d1cf9d359cc678ca0ad556175Chandler Carruth 28114925e6b885f8bd8cf448627386d412831f4bf1bNadav Rotemunsigned BasicTTI::getRegisterBitWidth(bool Vector) const { 28214925e6b885f8bd8cf448627386d412831f4bf1bNadav Rotem return 32; 28314925e6b885f8bd8cf448627386d412831f4bf1bNadav Rotem} 28414925e6b885f8bd8cf448627386d412831f4bf1bNadav Rotem 28583be7b0dd3ae9a3cb22d36ae4c1775972553b94bNadav Rotemunsigned BasicTTI::getMaximumUnrollFactor() const { 28683be7b0dd3ae9a3cb22d36ae4c1775972553b94bNadav Rotem return 1; 28783be7b0dd3ae9a3cb22d36ae4c1775972553b94bNadav Rotem} 28883be7b0dd3ae9a3cb22d36ae4c1775972553b94bNadav Rotem 2896bf4f676413b8f7d97aaff289997aab344180957Arnold Schwaighoferunsigned BasicTTI::getArithmeticInstrCost(unsigned Opcode, Type *Ty, 2906bf4f676413b8f7d97aaff289997aab344180957Arnold Schwaighofer OperandValueKind, 2916bf4f676413b8f7d97aaff289997aab344180957Arnold Schwaighofer OperandValueKind) const { 292aeef83c6afa1e18d1cf9d359cc678ca0ad556175Chandler Carruth // Check if any of the operands are vector operands. 293ea44281d5da5096de50ce1cb358ff0c6f20e1a2aBill Wendling const TargetLoweringBase *TLI = getTLI(); 294aeef83c6afa1e18d1cf9d359cc678ca0ad556175Chandler Carruth int ISD = TLI->InstructionOpcodeToISD(Opcode); 295aeef83c6afa1e18d1cf9d359cc678ca0ad556175Chandler Carruth assert(ISD && "Invalid opcode"); 296aeef83c6afa1e18d1cf9d359cc678ca0ad556175Chandler Carruth 297aeef83c6afa1e18d1cf9d359cc678ca0ad556175Chandler Carruth std::pair<unsigned, MVT> LT = TLI->getTypeLegalizationCost(Ty); 298aeef83c6afa1e18d1cf9d359cc678ca0ad556175Chandler Carruth 2999eb366acba65b5779d2129db3a6fb6a0414572d4Nadav Rotem bool IsFloat = Ty->getScalarType()->isFloatingPointTy(); 300420820056d42c93ea64cd86a95848bf4e0040670Nadav Rotem // Assume that floating point arithmetic operations cost twice as much as 301420820056d42c93ea64cd86a95848bf4e0040670Nadav Rotem // integer operations. 3029eb366acba65b5779d2129db3a6fb6a0414572d4Nadav Rotem unsigned OpCost = (IsFloat ? 2 : 1); 3039eb366acba65b5779d2129db3a6fb6a0414572d4Nadav Rotem 304aeef83c6afa1e18d1cf9d359cc678ca0ad556175Chandler Carruth if (TLI->isOperationLegalOrPromote(ISD, LT.second)) { 305aeef83c6afa1e18d1cf9d359cc678ca0ad556175Chandler Carruth // The operation is legal. Assume it costs 1. 306420820056d42c93ea64cd86a95848bf4e0040670Nadav Rotem // If the type is split to multiple registers, assume that there is some 307aeef83c6afa1e18d1cf9d359cc678ca0ad556175Chandler Carruth // overhead to this. 308aeef83c6afa1e18d1cf9d359cc678ca0ad556175Chandler Carruth // TODO: Once we have extract/insert subvector cost we need to use them. 309aeef83c6afa1e18d1cf9d359cc678ca0ad556175Chandler Carruth if (LT.first > 1) 3109eb366acba65b5779d2129db3a6fb6a0414572d4Nadav Rotem return LT.first * 2 * OpCost; 3119eb366acba65b5779d2129db3a6fb6a0414572d4Nadav Rotem return LT.first * 1 * OpCost; 312aeef83c6afa1e18d1cf9d359cc678ca0ad556175Chandler Carruth } 313aeef83c6afa1e18d1cf9d359cc678ca0ad556175Chandler Carruth 314aeef83c6afa1e18d1cf9d359cc678ca0ad556175Chandler Carruth if (!TLI->isOperationExpand(ISD, LT.second)) { 315aeef83c6afa1e18d1cf9d359cc678ca0ad556175Chandler Carruth // If the operation is custom lowered then assume 316aeef83c6afa1e18d1cf9d359cc678ca0ad556175Chandler Carruth // thare the code is twice as expensive. 3179eb366acba65b5779d2129db3a6fb6a0414572d4Nadav Rotem return LT.first * 2 * OpCost; 318aeef83c6afa1e18d1cf9d359cc678ca0ad556175Chandler Carruth } 319aeef83c6afa1e18d1cf9d359cc678ca0ad556175Chandler Carruth 320aeef83c6afa1e18d1cf9d359cc678ca0ad556175Chandler Carruth // Else, assume that we need to scalarize this op. 321aeef83c6afa1e18d1cf9d359cc678ca0ad556175Chandler Carruth if (Ty->isVectorTy()) { 322aeef83c6afa1e18d1cf9d359cc678ca0ad556175Chandler Carruth unsigned Num = Ty->getVectorNumElements(); 323aeef83c6afa1e18d1cf9d359cc678ca0ad556175Chandler Carruth unsigned Cost = TopTTI->getArithmeticInstrCost(Opcode, Ty->getScalarType()); 324aeef83c6afa1e18d1cf9d359cc678ca0ad556175Chandler Carruth // return the cost of multiple scalar invocation plus the cost of inserting 325aeef83c6afa1e18d1cf9d359cc678ca0ad556175Chandler Carruth // and extracting the values. 326aeef83c6afa1e18d1cf9d359cc678ca0ad556175Chandler Carruth return getScalarizationOverhead(Ty, true, true) + Num * Cost; 327aeef83c6afa1e18d1cf9d359cc678ca0ad556175Chandler Carruth } 328aeef83c6afa1e18d1cf9d359cc678ca0ad556175Chandler Carruth 329aeef83c6afa1e18d1cf9d359cc678ca0ad556175Chandler Carruth // We don't know anything about this scalar instruction. 3309eb366acba65b5779d2129db3a6fb6a0414572d4Nadav Rotem return OpCost; 331aeef83c6afa1e18d1cf9d359cc678ca0ad556175Chandler Carruth} 332aeef83c6afa1e18d1cf9d359cc678ca0ad556175Chandler Carruth 333cd81d94322a39503e4a3e87b6ee03d4fcb3465fbStephen Hinesunsigned BasicTTI::getAltShuffleOverhead(Type *Ty) const { 334cd81d94322a39503e4a3e87b6ee03d4fcb3465fbStephen Hines assert(Ty->isVectorTy() && "Can only shuffle vectors"); 335cd81d94322a39503e4a3e87b6ee03d4fcb3465fbStephen Hines unsigned Cost = 0; 336cd81d94322a39503e4a3e87b6ee03d4fcb3465fbStephen Hines // Shuffle cost is equal to the cost of extracting element from its argument 337cd81d94322a39503e4a3e87b6ee03d4fcb3465fbStephen Hines // plus the cost of inserting them onto the result vector. 338cd81d94322a39503e4a3e87b6ee03d4fcb3465fbStephen Hines 339cd81d94322a39503e4a3e87b6ee03d4fcb3465fbStephen Hines // e.g. <4 x float> has a mask of <0,5,2,7> i.e we need to extract from index 340cd81d94322a39503e4a3e87b6ee03d4fcb3465fbStephen Hines // 0 of first vector, index 1 of second vector,index 2 of first vector and 341cd81d94322a39503e4a3e87b6ee03d4fcb3465fbStephen Hines // finally index 3 of second vector and insert them at index <0,1,2,3> of 342cd81d94322a39503e4a3e87b6ee03d4fcb3465fbStephen Hines // result vector. 343cd81d94322a39503e4a3e87b6ee03d4fcb3465fbStephen Hines for (int i = 0, e = Ty->getVectorNumElements(); i < e; ++i) { 344cd81d94322a39503e4a3e87b6ee03d4fcb3465fbStephen Hines Cost += TopTTI->getVectorInstrCost(Instruction::InsertElement, Ty, i); 345cd81d94322a39503e4a3e87b6ee03d4fcb3465fbStephen Hines Cost += TopTTI->getVectorInstrCost(Instruction::ExtractElement, Ty, i); 346cd81d94322a39503e4a3e87b6ee03d4fcb3465fbStephen Hines } 347cd81d94322a39503e4a3e87b6ee03d4fcb3465fbStephen Hines return Cost; 348cd81d94322a39503e4a3e87b6ee03d4fcb3465fbStephen Hines} 349cd81d94322a39503e4a3e87b6ee03d4fcb3465fbStephen Hines 350aeef83c6afa1e18d1cf9d359cc678ca0ad556175Chandler Carruthunsigned BasicTTI::getShuffleCost(ShuffleKind Kind, Type *Tp, int Index, 351aeef83c6afa1e18d1cf9d359cc678ca0ad556175Chandler Carruth Type *SubTp) const { 352cd81d94322a39503e4a3e87b6ee03d4fcb3465fbStephen Hines if (Kind == SK_Alternate) { 353cd81d94322a39503e4a3e87b6ee03d4fcb3465fbStephen Hines return getAltShuffleOverhead(Tp); 354cd81d94322a39503e4a3e87b6ee03d4fcb3465fbStephen Hines } 355aeef83c6afa1e18d1cf9d359cc678ca0ad556175Chandler Carruth return 1; 356aeef83c6afa1e18d1cf9d359cc678ca0ad556175Chandler Carruth} 357aeef83c6afa1e18d1cf9d359cc678ca0ad556175Chandler Carruth 358aeef83c6afa1e18d1cf9d359cc678ca0ad556175Chandler Carruthunsigned BasicTTI::getCastInstrCost(unsigned Opcode, Type *Dst, 359aeef83c6afa1e18d1cf9d359cc678ca0ad556175Chandler Carruth Type *Src) const { 360ea44281d5da5096de50ce1cb358ff0c6f20e1a2aBill Wendling const TargetLoweringBase *TLI = getTLI(); 361aeef83c6afa1e18d1cf9d359cc678ca0ad556175Chandler Carruth int ISD = TLI->InstructionOpcodeToISD(Opcode); 362aeef83c6afa1e18d1cf9d359cc678ca0ad556175Chandler Carruth assert(ISD && "Invalid opcode"); 363aeef83c6afa1e18d1cf9d359cc678ca0ad556175Chandler Carruth 364aeef83c6afa1e18d1cf9d359cc678ca0ad556175Chandler Carruth std::pair<unsigned, MVT> SrcLT = TLI->getTypeLegalizationCost(Src); 365aeef83c6afa1e18d1cf9d359cc678ca0ad556175Chandler Carruth std::pair<unsigned, MVT> DstLT = TLI->getTypeLegalizationCost(Dst); 366aeef83c6afa1e18d1cf9d359cc678ca0ad556175Chandler Carruth 3673e40d927a775994d8f4c2d30695be69c248fa16cNadav Rotem // Check for NOOP conversions. 3683e40d927a775994d8f4c2d30695be69c248fa16cNadav Rotem if (SrcLT.first == DstLT.first && 3693e40d927a775994d8f4c2d30695be69c248fa16cNadav Rotem SrcLT.second.getSizeInBits() == DstLT.second.getSizeInBits()) { 3703e40d927a775994d8f4c2d30695be69c248fa16cNadav Rotem 3713e40d927a775994d8f4c2d30695be69c248fa16cNadav Rotem // Bitcast between types that are legalized to the same type are free. 3723e40d927a775994d8f4c2d30695be69c248fa16cNadav Rotem if (Opcode == Instruction::BitCast || Opcode == Instruction::Trunc) 3733e40d927a775994d8f4c2d30695be69c248fa16cNadav Rotem return 0; 3743e40d927a775994d8f4c2d30695be69c248fa16cNadav Rotem } 3753e40d927a775994d8f4c2d30695be69c248fa16cNadav Rotem 3763e40d927a775994d8f4c2d30695be69c248fa16cNadav Rotem if (Opcode == Instruction::Trunc && 3773e40d927a775994d8f4c2d30695be69c248fa16cNadav Rotem TLI->isTruncateFree(SrcLT.second, DstLT.second)) 3783e40d927a775994d8f4c2d30695be69c248fa16cNadav Rotem return 0; 3793e40d927a775994d8f4c2d30695be69c248fa16cNadav Rotem 3803e40d927a775994d8f4c2d30695be69c248fa16cNadav Rotem if (Opcode == Instruction::ZExt && 3813e40d927a775994d8f4c2d30695be69c248fa16cNadav Rotem TLI->isZExtFree(SrcLT.second, DstLT.second)) 3823e40d927a775994d8f4c2d30695be69c248fa16cNadav Rotem return 0; 3833e40d927a775994d8f4c2d30695be69c248fa16cNadav Rotem 3843e40d927a775994d8f4c2d30695be69c248fa16cNadav Rotem // If the cast is marked as legal (or promote) then assume low cost. 38536b56886974eae4f9c5ebc96befd3e7bfe5de338Stephen Hines if (SrcLT.first == DstLT.first && 38636b56886974eae4f9c5ebc96befd3e7bfe5de338Stephen Hines TLI->isOperationLegalOrPromote(ISD, DstLT.second)) 3873e40d927a775994d8f4c2d30695be69c248fa16cNadav Rotem return 1; 3883e40d927a775994d8f4c2d30695be69c248fa16cNadav Rotem 389aeef83c6afa1e18d1cf9d359cc678ca0ad556175Chandler Carruth // Handle scalar conversions. 390aeef83c6afa1e18d1cf9d359cc678ca0ad556175Chandler Carruth if (!Src->isVectorTy() && !Dst->isVectorTy()) { 391aeef83c6afa1e18d1cf9d359cc678ca0ad556175Chandler Carruth 392aeef83c6afa1e18d1cf9d359cc678ca0ad556175Chandler Carruth // Scalar bitcasts are usually free. 393aeef83c6afa1e18d1cf9d359cc678ca0ad556175Chandler Carruth if (Opcode == Instruction::BitCast) 394aeef83c6afa1e18d1cf9d359cc678ca0ad556175Chandler Carruth return 0; 395aeef83c6afa1e18d1cf9d359cc678ca0ad556175Chandler Carruth 396aeef83c6afa1e18d1cf9d359cc678ca0ad556175Chandler Carruth // Just check the op cost. If the operation is legal then assume it costs 1. 397aeef83c6afa1e18d1cf9d359cc678ca0ad556175Chandler Carruth if (!TLI->isOperationExpand(ISD, DstLT.second)) 398aeef83c6afa1e18d1cf9d359cc678ca0ad556175Chandler Carruth return 1; 399aeef83c6afa1e18d1cf9d359cc678ca0ad556175Chandler Carruth 400aeef83c6afa1e18d1cf9d359cc678ca0ad556175Chandler Carruth // Assume that illegal scalar instruction are expensive. 401aeef83c6afa1e18d1cf9d359cc678ca0ad556175Chandler Carruth return 4; 402aeef83c6afa1e18d1cf9d359cc678ca0ad556175Chandler Carruth } 403aeef83c6afa1e18d1cf9d359cc678ca0ad556175Chandler Carruth 404aeef83c6afa1e18d1cf9d359cc678ca0ad556175Chandler Carruth // Check vector-to-vector casts. 405aeef83c6afa1e18d1cf9d359cc678ca0ad556175Chandler Carruth if (Dst->isVectorTy() && Src->isVectorTy()) { 406aeef83c6afa1e18d1cf9d359cc678ca0ad556175Chandler Carruth 407aeef83c6afa1e18d1cf9d359cc678ca0ad556175Chandler Carruth // If the cast is between same-sized registers, then the check is simple. 408aeef83c6afa1e18d1cf9d359cc678ca0ad556175Chandler Carruth if (SrcLT.first == DstLT.first && 409aeef83c6afa1e18d1cf9d359cc678ca0ad556175Chandler Carruth SrcLT.second.getSizeInBits() == DstLT.second.getSizeInBits()) { 410aeef83c6afa1e18d1cf9d359cc678ca0ad556175Chandler Carruth 411aeef83c6afa1e18d1cf9d359cc678ca0ad556175Chandler Carruth // Assume that Zext is done using AND. 412aeef83c6afa1e18d1cf9d359cc678ca0ad556175Chandler Carruth if (Opcode == Instruction::ZExt) 413aeef83c6afa1e18d1cf9d359cc678ca0ad556175Chandler Carruth return 1; 414aeef83c6afa1e18d1cf9d359cc678ca0ad556175Chandler Carruth 415aeef83c6afa1e18d1cf9d359cc678ca0ad556175Chandler Carruth // Assume that sext is done using SHL and SRA. 416aeef83c6afa1e18d1cf9d359cc678ca0ad556175Chandler Carruth if (Opcode == Instruction::SExt) 417aeef83c6afa1e18d1cf9d359cc678ca0ad556175Chandler Carruth return 2; 418aeef83c6afa1e18d1cf9d359cc678ca0ad556175Chandler Carruth 419aeef83c6afa1e18d1cf9d359cc678ca0ad556175Chandler Carruth // Just check the op cost. If the operation is legal then assume it costs 420aeef83c6afa1e18d1cf9d359cc678ca0ad556175Chandler Carruth // 1 and multiply by the type-legalization overhead. 421aeef83c6afa1e18d1cf9d359cc678ca0ad556175Chandler Carruth if (!TLI->isOperationExpand(ISD, DstLT.second)) 422aeef83c6afa1e18d1cf9d359cc678ca0ad556175Chandler Carruth return SrcLT.first * 1; 423aeef83c6afa1e18d1cf9d359cc678ca0ad556175Chandler Carruth } 424aeef83c6afa1e18d1cf9d359cc678ca0ad556175Chandler Carruth 425aeef83c6afa1e18d1cf9d359cc678ca0ad556175Chandler Carruth // If we are converting vectors and the operation is illegal, or 426aeef83c6afa1e18d1cf9d359cc678ca0ad556175Chandler Carruth // if the vectors are legalized to different types, estimate the 427aeef83c6afa1e18d1cf9d359cc678ca0ad556175Chandler Carruth // scalarization costs. 428aeef83c6afa1e18d1cf9d359cc678ca0ad556175Chandler Carruth unsigned Num = Dst->getVectorNumElements(); 429aeef83c6afa1e18d1cf9d359cc678ca0ad556175Chandler Carruth unsigned Cost = TopTTI->getCastInstrCost(Opcode, Dst->getScalarType(), 430aeef83c6afa1e18d1cf9d359cc678ca0ad556175Chandler Carruth Src->getScalarType()); 431aeef83c6afa1e18d1cf9d359cc678ca0ad556175Chandler Carruth 432aeef83c6afa1e18d1cf9d359cc678ca0ad556175Chandler Carruth // Return the cost of multiple scalar invocation plus the cost of 433aeef83c6afa1e18d1cf9d359cc678ca0ad556175Chandler Carruth // inserting and extracting the values. 434aeef83c6afa1e18d1cf9d359cc678ca0ad556175Chandler Carruth return getScalarizationOverhead(Dst, true, true) + Num * Cost; 435aeef83c6afa1e18d1cf9d359cc678ca0ad556175Chandler Carruth } 436aeef83c6afa1e18d1cf9d359cc678ca0ad556175Chandler Carruth 437aeef83c6afa1e18d1cf9d359cc678ca0ad556175Chandler Carruth // We already handled vector-to-vector and scalar-to-scalar conversions. This 438aeef83c6afa1e18d1cf9d359cc678ca0ad556175Chandler Carruth // is where we handle bitcast between vectors and scalars. We need to assume 439aeef83c6afa1e18d1cf9d359cc678ca0ad556175Chandler Carruth // that the conversion is scalarized in one way or another. 440aeef83c6afa1e18d1cf9d359cc678ca0ad556175Chandler Carruth if (Opcode == Instruction::BitCast) 441aeef83c6afa1e18d1cf9d359cc678ca0ad556175Chandler Carruth // Illegal bitcasts are done by storing and loading from a stack slot. 442aeef83c6afa1e18d1cf9d359cc678ca0ad556175Chandler Carruth return (Src->isVectorTy()? getScalarizationOverhead(Src, false, true):0) + 443aeef83c6afa1e18d1cf9d359cc678ca0ad556175Chandler Carruth (Dst->isVectorTy()? getScalarizationOverhead(Dst, true, false):0); 444aeef83c6afa1e18d1cf9d359cc678ca0ad556175Chandler Carruth 445aeef83c6afa1e18d1cf9d359cc678ca0ad556175Chandler Carruth llvm_unreachable("Unhandled cast"); 446aeef83c6afa1e18d1cf9d359cc678ca0ad556175Chandler Carruth } 447aeef83c6afa1e18d1cf9d359cc678ca0ad556175Chandler Carruth 448aeef83c6afa1e18d1cf9d359cc678ca0ad556175Chandler Carruthunsigned BasicTTI::getCFInstrCost(unsigned Opcode) const { 449aeef83c6afa1e18d1cf9d359cc678ca0ad556175Chandler Carruth // Branches are assumed to be predicted. 450aeef83c6afa1e18d1cf9d359cc678ca0ad556175Chandler Carruth return 0; 451aeef83c6afa1e18d1cf9d359cc678ca0ad556175Chandler Carruth} 452aeef83c6afa1e18d1cf9d359cc678ca0ad556175Chandler Carruth 453aeef83c6afa1e18d1cf9d359cc678ca0ad556175Chandler Carruthunsigned BasicTTI::getCmpSelInstrCost(unsigned Opcode, Type *ValTy, 454aeef83c6afa1e18d1cf9d359cc678ca0ad556175Chandler Carruth Type *CondTy) const { 455ea44281d5da5096de50ce1cb358ff0c6f20e1a2aBill Wendling const TargetLoweringBase *TLI = getTLI(); 456aeef83c6afa1e18d1cf9d359cc678ca0ad556175Chandler Carruth int ISD = TLI->InstructionOpcodeToISD(Opcode); 457aeef83c6afa1e18d1cf9d359cc678ca0ad556175Chandler Carruth assert(ISD && "Invalid opcode"); 458aeef83c6afa1e18d1cf9d359cc678ca0ad556175Chandler Carruth 459aeef83c6afa1e18d1cf9d359cc678ca0ad556175Chandler Carruth // Selects on vectors are actually vector selects. 460aeef83c6afa1e18d1cf9d359cc678ca0ad556175Chandler Carruth if (ISD == ISD::SELECT) { 461aeef83c6afa1e18d1cf9d359cc678ca0ad556175Chandler Carruth assert(CondTy && "CondTy must exist"); 462aeef83c6afa1e18d1cf9d359cc678ca0ad556175Chandler Carruth if (CondTy->isVectorTy()) 463aeef83c6afa1e18d1cf9d359cc678ca0ad556175Chandler Carruth ISD = ISD::VSELECT; 464aeef83c6afa1e18d1cf9d359cc678ca0ad556175Chandler Carruth } 465aeef83c6afa1e18d1cf9d359cc678ca0ad556175Chandler Carruth 466aeef83c6afa1e18d1cf9d359cc678ca0ad556175Chandler Carruth std::pair<unsigned, MVT> LT = TLI->getTypeLegalizationCost(ValTy); 467aeef83c6afa1e18d1cf9d359cc678ca0ad556175Chandler Carruth 468aeef83c6afa1e18d1cf9d359cc678ca0ad556175Chandler Carruth if (!TLI->isOperationExpand(ISD, LT.second)) { 469aeef83c6afa1e18d1cf9d359cc678ca0ad556175Chandler Carruth // The operation is legal. Assume it costs 1. Multiply 470aeef83c6afa1e18d1cf9d359cc678ca0ad556175Chandler Carruth // by the type-legalization overhead. 471aeef83c6afa1e18d1cf9d359cc678ca0ad556175Chandler Carruth return LT.first * 1; 472aeef83c6afa1e18d1cf9d359cc678ca0ad556175Chandler Carruth } 473aeef83c6afa1e18d1cf9d359cc678ca0ad556175Chandler Carruth 474aeef83c6afa1e18d1cf9d359cc678ca0ad556175Chandler Carruth // Otherwise, assume that the cast is scalarized. 475aeef83c6afa1e18d1cf9d359cc678ca0ad556175Chandler Carruth if (ValTy->isVectorTy()) { 476aeef83c6afa1e18d1cf9d359cc678ca0ad556175Chandler Carruth unsigned Num = ValTy->getVectorNumElements(); 477aeef83c6afa1e18d1cf9d359cc678ca0ad556175Chandler Carruth if (CondTy) 478aeef83c6afa1e18d1cf9d359cc678ca0ad556175Chandler Carruth CondTy = CondTy->getScalarType(); 479aeef83c6afa1e18d1cf9d359cc678ca0ad556175Chandler Carruth unsigned Cost = TopTTI->getCmpSelInstrCost(Opcode, ValTy->getScalarType(), 480aeef83c6afa1e18d1cf9d359cc678ca0ad556175Chandler Carruth CondTy); 481aeef83c6afa1e18d1cf9d359cc678ca0ad556175Chandler Carruth 482aeef83c6afa1e18d1cf9d359cc678ca0ad556175Chandler Carruth // Return the cost of multiple scalar invocation plus the cost of inserting 483aeef83c6afa1e18d1cf9d359cc678ca0ad556175Chandler Carruth // and extracting the values. 484aeef83c6afa1e18d1cf9d359cc678ca0ad556175Chandler Carruth return getScalarizationOverhead(ValTy, true, false) + Num * Cost; 485aeef83c6afa1e18d1cf9d359cc678ca0ad556175Chandler Carruth } 486aeef83c6afa1e18d1cf9d359cc678ca0ad556175Chandler Carruth 487aeef83c6afa1e18d1cf9d359cc678ca0ad556175Chandler Carruth // Unknown scalar opcode. 488aeef83c6afa1e18d1cf9d359cc678ca0ad556175Chandler Carruth return 1; 489aeef83c6afa1e18d1cf9d359cc678ca0ad556175Chandler Carruth} 490aeef83c6afa1e18d1cf9d359cc678ca0ad556175Chandler Carruth 491aeef83c6afa1e18d1cf9d359cc678ca0ad556175Chandler Carruthunsigned BasicTTI::getVectorInstrCost(unsigned Opcode, Type *Val, 492aeef83c6afa1e18d1cf9d359cc678ca0ad556175Chandler Carruth unsigned Index) const { 49336b56886974eae4f9c5ebc96befd3e7bfe5de338Stephen Hines std::pair<unsigned, MVT> LT = getTLI()->getTypeLegalizationCost(Val->getScalarType()); 49436b56886974eae4f9c5ebc96befd3e7bfe5de338Stephen Hines 49536b56886974eae4f9c5ebc96befd3e7bfe5de338Stephen Hines return LT.first; 496aeef83c6afa1e18d1cf9d359cc678ca0ad556175Chandler Carruth} 497aeef83c6afa1e18d1cf9d359cc678ca0ad556175Chandler Carruth 498aeef83c6afa1e18d1cf9d359cc678ca0ad556175Chandler Carruthunsigned BasicTTI::getMemoryOpCost(unsigned Opcode, Type *Src, 499aeef83c6afa1e18d1cf9d359cc678ca0ad556175Chandler Carruth unsigned Alignment, 500aeef83c6afa1e18d1cf9d359cc678ca0ad556175Chandler Carruth unsigned AddressSpace) const { 501aeef83c6afa1e18d1cf9d359cc678ca0ad556175Chandler Carruth assert(!Src->isVoidTy() && "Invalid type"); 502ea44281d5da5096de50ce1cb358ff0c6f20e1a2aBill Wendling std::pair<unsigned, MVT> LT = getTLI()->getTypeLegalizationCost(Src); 503aeef83c6afa1e18d1cf9d359cc678ca0ad556175Chandler Carruth 50436b56886974eae4f9c5ebc96befd3e7bfe5de338Stephen Hines // Assuming that all loads of legal types cost 1. 50536b56886974eae4f9c5ebc96befd3e7bfe5de338Stephen Hines unsigned Cost = LT.first; 50636b56886974eae4f9c5ebc96befd3e7bfe5de338Stephen Hines 50736b56886974eae4f9c5ebc96befd3e7bfe5de338Stephen Hines if (Src->isVectorTy() && 50836b56886974eae4f9c5ebc96befd3e7bfe5de338Stephen Hines Src->getPrimitiveSizeInBits() < LT.second.getSizeInBits()) { 50936b56886974eae4f9c5ebc96befd3e7bfe5de338Stephen Hines // This is a vector load that legalizes to a larger type than the vector 51036b56886974eae4f9c5ebc96befd3e7bfe5de338Stephen Hines // itself. Unless the corresponding extending load or truncating store is 51136b56886974eae4f9c5ebc96befd3e7bfe5de338Stephen Hines // legal, then this will scalarize. 512dce4a407a24b04eebc6a376f8e62b41aaa7b071fStephen Hines TargetLowering::LegalizeAction LA = TargetLowering::Expand; 513dce4a407a24b04eebc6a376f8e62b41aaa7b071fStephen Hines EVT MemVT = getTLI()->getValueType(Src, true); 514dce4a407a24b04eebc6a376f8e62b41aaa7b071fStephen Hines if (MemVT.isSimple() && MemVT != MVT::Other) { 515dce4a407a24b04eebc6a376f8e62b41aaa7b071fStephen Hines if (Opcode == Instruction::Store) 516dce4a407a24b04eebc6a376f8e62b41aaa7b071fStephen Hines LA = getTLI()->getTruncStoreAction(LT.second, MemVT.getSimpleVT()); 517dce4a407a24b04eebc6a376f8e62b41aaa7b071fStephen Hines else 518dce4a407a24b04eebc6a376f8e62b41aaa7b071fStephen Hines LA = getTLI()->getLoadExtAction(ISD::EXTLOAD, MemVT.getSimpleVT()); 519dce4a407a24b04eebc6a376f8e62b41aaa7b071fStephen Hines } 52036b56886974eae4f9c5ebc96befd3e7bfe5de338Stephen Hines 52136b56886974eae4f9c5ebc96befd3e7bfe5de338Stephen Hines if (LA != TargetLowering::Legal && LA != TargetLowering::Custom) { 52236b56886974eae4f9c5ebc96befd3e7bfe5de338Stephen Hines // This is a vector load/store for some illegal type that is scalarized. 52336b56886974eae4f9c5ebc96befd3e7bfe5de338Stephen Hines // We must account for the cost of building or decomposing the vector. 52436b56886974eae4f9c5ebc96befd3e7bfe5de338Stephen Hines Cost += getScalarizationOverhead(Src, Opcode != Instruction::Store, 52536b56886974eae4f9c5ebc96befd3e7bfe5de338Stephen Hines Opcode == Instruction::Store); 52636b56886974eae4f9c5ebc96befd3e7bfe5de338Stephen Hines } 52736b56886974eae4f9c5ebc96befd3e7bfe5de338Stephen Hines } 52836b56886974eae4f9c5ebc96befd3e7bfe5de338Stephen Hines 52936b56886974eae4f9c5ebc96befd3e7bfe5de338Stephen Hines return Cost; 530aeef83c6afa1e18d1cf9d359cc678ca0ad556175Chandler Carruth} 531aeef83c6afa1e18d1cf9d359cc678ca0ad556175Chandler Carruth 5328611d4449a77ca05e808823bc966573a85da00cbBenjamin Kramerunsigned BasicTTI::getIntrinsicInstrCost(Intrinsic::ID IID, Type *RetTy, 533aeef83c6afa1e18d1cf9d359cc678ca0ad556175Chandler Carruth ArrayRef<Type *> Tys) const { 5348611d4449a77ca05e808823bc966573a85da00cbBenjamin Kramer unsigned ISD = 0; 5358611d4449a77ca05e808823bc966573a85da00cbBenjamin Kramer switch (IID) { 5368611d4449a77ca05e808823bc966573a85da00cbBenjamin Kramer default: { 5378611d4449a77ca05e808823bc966573a85da00cbBenjamin Kramer // Assume that we need to scalarize this intrinsic. 5388611d4449a77ca05e808823bc966573a85da00cbBenjamin Kramer unsigned ScalarizationCost = 0; 5398611d4449a77ca05e808823bc966573a85da00cbBenjamin Kramer unsigned ScalarCalls = 1; 5408611d4449a77ca05e808823bc966573a85da00cbBenjamin Kramer if (RetTy->isVectorTy()) { 5418611d4449a77ca05e808823bc966573a85da00cbBenjamin Kramer ScalarizationCost = getScalarizationOverhead(RetTy, true, false); 542aeef83c6afa1e18d1cf9d359cc678ca0ad556175Chandler Carruth ScalarCalls = std::max(ScalarCalls, RetTy->getVectorNumElements()); 543aeef83c6afa1e18d1cf9d359cc678ca0ad556175Chandler Carruth } 5448611d4449a77ca05e808823bc966573a85da00cbBenjamin Kramer for (unsigned i = 0, ie = Tys.size(); i != ie; ++i) { 5458611d4449a77ca05e808823bc966573a85da00cbBenjamin Kramer if (Tys[i]->isVectorTy()) { 5468611d4449a77ca05e808823bc966573a85da00cbBenjamin Kramer ScalarizationCost += getScalarizationOverhead(Tys[i], false, true); 5478611d4449a77ca05e808823bc966573a85da00cbBenjamin Kramer ScalarCalls = std::max(ScalarCalls, RetTy->getVectorNumElements()); 5488611d4449a77ca05e808823bc966573a85da00cbBenjamin Kramer } 5498611d4449a77ca05e808823bc966573a85da00cbBenjamin Kramer } 5508611d4449a77ca05e808823bc966573a85da00cbBenjamin Kramer 5518611d4449a77ca05e808823bc966573a85da00cbBenjamin Kramer return ScalarCalls + ScalarizationCost; 5528611d4449a77ca05e808823bc966573a85da00cbBenjamin Kramer } 5538611d4449a77ca05e808823bc966573a85da00cbBenjamin Kramer // Look for intrinsics that can be lowered directly or turned into a scalar 5548611d4449a77ca05e808823bc966573a85da00cbBenjamin Kramer // intrinsic call. 5558611d4449a77ca05e808823bc966573a85da00cbBenjamin Kramer case Intrinsic::sqrt: ISD = ISD::FSQRT; break; 5568611d4449a77ca05e808823bc966573a85da00cbBenjamin Kramer case Intrinsic::sin: ISD = ISD::FSIN; break; 5578611d4449a77ca05e808823bc966573a85da00cbBenjamin Kramer case Intrinsic::cos: ISD = ISD::FCOS; break; 5588611d4449a77ca05e808823bc966573a85da00cbBenjamin Kramer case Intrinsic::exp: ISD = ISD::FEXP; break; 5598611d4449a77ca05e808823bc966573a85da00cbBenjamin Kramer case Intrinsic::exp2: ISD = ISD::FEXP2; break; 5608611d4449a77ca05e808823bc966573a85da00cbBenjamin Kramer case Intrinsic::log: ISD = ISD::FLOG; break; 5618611d4449a77ca05e808823bc966573a85da00cbBenjamin Kramer case Intrinsic::log10: ISD = ISD::FLOG10; break; 5628611d4449a77ca05e808823bc966573a85da00cbBenjamin Kramer case Intrinsic::log2: ISD = ISD::FLOG2; break; 5638611d4449a77ca05e808823bc966573a85da00cbBenjamin Kramer case Intrinsic::fabs: ISD = ISD::FABS; break; 56466d1fa6f4b443ac9f8bcea5d1f71a73ada733a42Hal Finkel case Intrinsic::copysign: ISD = ISD::FCOPYSIGN; break; 5658611d4449a77ca05e808823bc966573a85da00cbBenjamin Kramer case Intrinsic::floor: ISD = ISD::FFLOOR; break; 5668611d4449a77ca05e808823bc966573a85da00cbBenjamin Kramer case Intrinsic::ceil: ISD = ISD::FCEIL; break; 5678611d4449a77ca05e808823bc966573a85da00cbBenjamin Kramer case Intrinsic::trunc: ISD = ISD::FTRUNC; break; 56804b84c2f92b8c9cf863853eca33f47f9fbd80fd1Hal Finkel case Intrinsic::nearbyint: 56904b84c2f92b8c9cf863853eca33f47f9fbd80fd1Hal Finkel ISD = ISD::FNEARBYINT; break; 5708611d4449a77ca05e808823bc966573a85da00cbBenjamin Kramer case Intrinsic::rint: ISD = ISD::FRINT; break; 57141418d17cced656f91038b2482bc9d173b4974b0Hal Finkel case Intrinsic::round: ISD = ISD::FROUND; break; 5728611d4449a77ca05e808823bc966573a85da00cbBenjamin Kramer case Intrinsic::pow: ISD = ISD::FPOW; break; 5738611d4449a77ca05e808823bc966573a85da00cbBenjamin Kramer case Intrinsic::fma: ISD = ISD::FMA; break; 574dce4a407a24b04eebc6a376f8e62b41aaa7b071fStephen Hines case Intrinsic::fmuladd: ISD = ISD::FMA; break; 5752d66d4cf42022239bfc9cd260a7b924400139cb5Arnold Schwaighofer case Intrinsic::lifetime_start: 5762d66d4cf42022239bfc9cd260a7b924400139cb5Arnold Schwaighofer case Intrinsic::lifetime_end: 5772d66d4cf42022239bfc9cd260a7b924400139cb5Arnold Schwaighofer return 0; 5788611d4449a77ca05e808823bc966573a85da00cbBenjamin Kramer } 5798611d4449a77ca05e808823bc966573a85da00cbBenjamin Kramer 580ea44281d5da5096de50ce1cb358ff0c6f20e1a2aBill Wendling const TargetLoweringBase *TLI = getTLI(); 5818611d4449a77ca05e808823bc966573a85da00cbBenjamin Kramer std::pair<unsigned, MVT> LT = TLI->getTypeLegalizationCost(RetTy); 5828611d4449a77ca05e808823bc966573a85da00cbBenjamin Kramer 5838611d4449a77ca05e808823bc966573a85da00cbBenjamin Kramer if (TLI->isOperationLegalOrPromote(ISD, LT.second)) { 5848611d4449a77ca05e808823bc966573a85da00cbBenjamin Kramer // The operation is legal. Assume it costs 1. 5858611d4449a77ca05e808823bc966573a85da00cbBenjamin Kramer // If the type is split to multiple registers, assume that thre is some 5868611d4449a77ca05e808823bc966573a85da00cbBenjamin Kramer // overhead to this. 5878611d4449a77ca05e808823bc966573a85da00cbBenjamin Kramer // TODO: Once we have extract/insert subvector cost we need to use them. 5888611d4449a77ca05e808823bc966573a85da00cbBenjamin Kramer if (LT.first > 1) 5898611d4449a77ca05e808823bc966573a85da00cbBenjamin Kramer return LT.first * 2; 5908611d4449a77ca05e808823bc966573a85da00cbBenjamin Kramer return LT.first * 1; 591aeef83c6afa1e18d1cf9d359cc678ca0ad556175Chandler Carruth } 5928611d4449a77ca05e808823bc966573a85da00cbBenjamin Kramer 5938611d4449a77ca05e808823bc966573a85da00cbBenjamin Kramer if (!TLI->isOperationExpand(ISD, LT.second)) { 5948611d4449a77ca05e808823bc966573a85da00cbBenjamin Kramer // If the operation is custom lowered then assume 5958611d4449a77ca05e808823bc966573a85da00cbBenjamin Kramer // thare the code is twice as expensive. 5968611d4449a77ca05e808823bc966573a85da00cbBenjamin Kramer return LT.first * 2; 5978611d4449a77ca05e808823bc966573a85da00cbBenjamin Kramer } 5988611d4449a77ca05e808823bc966573a85da00cbBenjamin Kramer 599dce4a407a24b04eebc6a376f8e62b41aaa7b071fStephen Hines // If we can't lower fmuladd into an FMA estimate the cost as a floating 600dce4a407a24b04eebc6a376f8e62b41aaa7b071fStephen Hines // point mul followed by an add. 601dce4a407a24b04eebc6a376f8e62b41aaa7b071fStephen Hines if (IID == Intrinsic::fmuladd) 602dce4a407a24b04eebc6a376f8e62b41aaa7b071fStephen Hines return TopTTI->getArithmeticInstrCost(BinaryOperator::FMul, RetTy) + 603dce4a407a24b04eebc6a376f8e62b41aaa7b071fStephen Hines TopTTI->getArithmeticInstrCost(BinaryOperator::FAdd, RetTy); 604dce4a407a24b04eebc6a376f8e62b41aaa7b071fStephen Hines 6058611d4449a77ca05e808823bc966573a85da00cbBenjamin Kramer // Else, assume that we need to scalarize this intrinsic. For math builtins 6068611d4449a77ca05e808823bc966573a85da00cbBenjamin Kramer // this will emit a costly libcall, adding call overhead and spills. Make it 6078611d4449a77ca05e808823bc966573a85da00cbBenjamin Kramer // very expensive. 6088611d4449a77ca05e808823bc966573a85da00cbBenjamin Kramer if (RetTy->isVectorTy()) { 6098611d4449a77ca05e808823bc966573a85da00cbBenjamin Kramer unsigned Num = RetTy->getVectorNumElements(); 6108611d4449a77ca05e808823bc966573a85da00cbBenjamin Kramer unsigned Cost = TopTTI->getIntrinsicInstrCost(IID, RetTy->getScalarType(), 6118611d4449a77ca05e808823bc966573a85da00cbBenjamin Kramer Tys); 6128611d4449a77ca05e808823bc966573a85da00cbBenjamin Kramer return 10 * Cost * Num; 6138611d4449a77ca05e808823bc966573a85da00cbBenjamin Kramer } 6148611d4449a77ca05e808823bc966573a85da00cbBenjamin Kramer 6158611d4449a77ca05e808823bc966573a85da00cbBenjamin Kramer // This is going to be turned into a library call, make it expensive. 6168611d4449a77ca05e808823bc966573a85da00cbBenjamin Kramer return 10; 617aeef83c6afa1e18d1cf9d359cc678ca0ad556175Chandler Carruth} 618aeef83c6afa1e18d1cf9d359cc678ca0ad556175Chandler Carruth 619aeef83c6afa1e18d1cf9d359cc678ca0ad556175Chandler Carruthunsigned BasicTTI::getNumberOfParts(Type *Tp) const { 620ea44281d5da5096de50ce1cb358ff0c6f20e1a2aBill Wendling std::pair<unsigned, MVT> LT = getTLI()->getTypeLegalizationCost(Tp); 621aeef83c6afa1e18d1cf9d359cc678ca0ad556175Chandler Carruth return LT.first; 622aeef83c6afa1e18d1cf9d359cc678ca0ad556175Chandler Carruth} 623fb55a8fd7c38aa09d9c243d48a8a72d890f36a3dArnold Schwaighofer 624c0a11edba6ea46c782672ab3fb4e4ab3dc267a22Arnold Schwaighoferunsigned BasicTTI::getAddressComputationCost(Type *Ty, bool IsComplex) const { 625fb55a8fd7c38aa09d9c243d48a8a72d890f36a3dArnold Schwaighofer return 0; 626fb55a8fd7c38aa09d9c243d48a8a72d890f36a3dArnold Schwaighofer} 62765457b679ae240c1a37da82c5484dac478c47b6dArnold Schwaighofer 62865457b679ae240c1a37da82c5484dac478c47b6dArnold Schwaighoferunsigned BasicTTI::getReductionCost(unsigned Opcode, Type *Ty, 62965457b679ae240c1a37da82c5484dac478c47b6dArnold Schwaighofer bool IsPairwise) const { 63065457b679ae240c1a37da82c5484dac478c47b6dArnold Schwaighofer assert(Ty->isVectorTy() && "Expect a vector type"); 63165457b679ae240c1a37da82c5484dac478c47b6dArnold Schwaighofer unsigned NumVecElts = Ty->getVectorNumElements(); 63265457b679ae240c1a37da82c5484dac478c47b6dArnold Schwaighofer unsigned NumReduxLevels = Log2_32(NumVecElts); 63365457b679ae240c1a37da82c5484dac478c47b6dArnold Schwaighofer unsigned ArithCost = NumReduxLevels * 63465457b679ae240c1a37da82c5484dac478c47b6dArnold Schwaighofer TopTTI->getArithmeticInstrCost(Opcode, Ty); 63565457b679ae240c1a37da82c5484dac478c47b6dArnold Schwaighofer // Assume the pairwise shuffles add a cost. 63665457b679ae240c1a37da82c5484dac478c47b6dArnold Schwaighofer unsigned ShuffleCost = 63765457b679ae240c1a37da82c5484dac478c47b6dArnold Schwaighofer NumReduxLevels * (IsPairwise + 1) * 63865457b679ae240c1a37da82c5484dac478c47b6dArnold Schwaighofer TopTTI->getShuffleCost(SK_ExtractSubvector, Ty, NumVecElts / 2, Ty); 63965457b679ae240c1a37da82c5484dac478c47b6dArnold Schwaighofer return ShuffleCost + ArithCost + getScalarizationOverhead(Ty, false, true); 64065457b679ae240c1a37da82c5484dac478c47b6dArnold Schwaighofer} 641