LLVM 19.0.0git
BPFTargetTransformInfo.h
Go to the documentation of this file.
1//===------ BPFTargetTransformInfo.h - BPF specific TTI ---------*- C++ -*-===//
2//
3// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
4// See https://llvm.org/LICENSE.txt for license information.
5// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
6//
7//===----------------------------------------------------------------------===//
8//
9// This file uses the target's specific information to
10// provide more precise answers to certain TTI queries, while letting the
11// target independent and default TTI implementations handle the rest.
12//
13//===----------------------------------------------------------------------===//
14
15#ifndef LLVM_LIB_TARGET_BPF_BPFTARGETTRANSFORMINFO_H
16#define LLVM_LIB_TARGET_BPF_BPFTARGETTRANSFORMINFO_H
17
18#include "BPFTargetMachine.h"
22
23namespace llvm {
24class BPFTTIImpl : public BasicTTIImplBase<BPFTTIImpl> {
27 friend BaseT;
28
29 const BPFSubtarget *ST;
30 const BPFTargetLowering *TLI;
31
32 const BPFSubtarget *getST() const { return ST; }
33 const BPFTargetLowering *getTLI() const { return TLI; }
34
35public:
36 explicit BPFTTIImpl(const BPFTargetMachine *TM, const Function &F)
37 : BaseT(TM, F.getParent()->getDataLayout()), ST(TM->getSubtargetImpl(F)),
38 TLI(ST->getTargetLowering()) {}
39
41 if (Imm.getBitWidth() <= 64 && isInt<32>(Imm.getSExtValue()))
42 return TTI::TCC_Free;
43
44 return TTI::TCC_Basic;
45 }
46
47 InstructionCost getCmpSelInstrCost(unsigned Opcode, Type *ValTy, Type *CondTy,
48 CmpInst::Predicate VecPred,
50 const llvm::Instruction *I = nullptr) {
51 if (Opcode == Instruction::Select)
52 return SCEVCheapExpansionBudget.getValue();
53
54 return BaseT::getCmpSelInstrCost(Opcode, ValTy, CondTy, VecPred, CostKind,
55 I);
56 }
57
59 unsigned Opcode, Type *Ty, TTI::TargetCostKind CostKind,
62 ArrayRef<const Value *> Args = ArrayRef<const Value *>(),
63 const Instruction *CxtI = nullptr) {
64 int ISD = TLI->InstructionOpcodeToISD(Opcode);
66 return SCEVCheapExpansionBudget.getValue() + 1;
67
68 return BaseT::getArithmeticInstrCost(Opcode, Ty, CostKind, Op1Info,
69 Op2Info);
70 }
71
73 bool IsZeroCmp) const {
75 Options.LoadSizes = {8, 4, 2, 1};
76 Options.MaxNumLoads = TLI->getMaxExpandSizeMemcmp(OptSize);
77 return Options;
78 }
79
80 unsigned getMaxNumArgs() const {
81 return 5;
82 }
83
84};
85
86} // end namespace llvm
87
88#endif // LLVM_LIB_TARGET_BPF_BPFTARGETTRANSFORMINFO_H
static const Function * getParent(const Value *V)
This file provides a helper that implements much of the TTI interface in terms of the target-independ...
static cl::opt< TargetTransformInfo::TargetCostKind > CostKind("cost-kind", cl::desc("Target cost kind"), cl::init(TargetTransformInfo::TCK_RecipThroughput), cl::values(clEnumValN(TargetTransformInfo::TCK_RecipThroughput, "throughput", "Reciprocal throughput"), clEnumValN(TargetTransformInfo::TCK_Latency, "latency", "Instruction latency"), clEnumValN(TargetTransformInfo::TCK_CodeSize, "code-size", "Code size"), clEnumValN(TargetTransformInfo::TCK_SizeAndLatency, "size-latency", "Code size and latency")))
static LVOptions Options
Definition: LVOptions.cpp:25
#define F(x, y, z)
Definition: MD5.cpp:55
#define I(x, y, z)
Definition: MD5.cpp:58
const char LLVMTargetMachineRef TM
This pass exposes codegen information to IR-level passes.
Class for arbitrary precision integers.
Definition: APInt.h:76
int getIntImmCost(const APInt &Imm, Type *Ty, TTI::TargetCostKind CostKind)
unsigned getMaxNumArgs() const
BPFTTIImpl(const BPFTargetMachine *TM, const Function &F)
InstructionCost getCmpSelInstrCost(unsigned Opcode, Type *ValTy, Type *CondTy, CmpInst::Predicate VecPred, TTI::TargetCostKind CostKind, const llvm::Instruction *I=nullptr)
TTI::MemCmpExpansionOptions enableMemCmpExpansion(bool OptSize, bool IsZeroCmp) const
InstructionCost getArithmeticInstrCost(unsigned Opcode, Type *Ty, TTI::TargetCostKind CostKind, TTI::OperandValueInfo Op1Info={TTI::OK_AnyValue, TTI::OP_None}, TTI::OperandValueInfo Op2Info={TTI::OK_AnyValue, TTI::OP_None}, ArrayRef< const Value * > Args=ArrayRef< const Value * >(), const Instruction *CxtI=nullptr)
Base class which can be used to help build a TTI implementation.
Definition: BasicTTIImpl.h:80
InstructionCost getCmpSelInstrCost(unsigned Opcode, Type *ValTy, Type *CondTy, CmpInst::Predicate VecPred, TTI::TargetCostKind CostKind, const Instruction *I=nullptr)
InstructionCost getArithmeticInstrCost(unsigned Opcode, Type *Ty, TTI::TargetCostKind CostKind, TTI::OperandValueInfo Opd1Info={TTI::OK_AnyValue, TTI::OP_None}, TTI::OperandValueInfo Opd2Info={TTI::OK_AnyValue, TTI::OP_None}, ArrayRef< const Value * > Args=ArrayRef< const Value * >(), const Instruction *CxtI=nullptr)
Definition: BasicTTIImpl.h:885
Predicate
This enumeration lists the possible predicates for CmpInst subclasses.
Definition: InstrTypes.h:967
int InstructionOpcodeToISD(unsigned Opcode) const
Get the ISD node that corresponds to the Instruction class opcode.
unsigned getMaxExpandSizeMemcmp(bool OptSize) const
Get maximum # of load operations permitted for memcmp.
const DataLayout & getDataLayout() const
This pass provides access to the codegen interfaces that are needed for IR-level transformations.
TargetCostKind
The kind of cost model.
@ TCK_RecipThroughput
Reciprocal throughput.
@ TCC_Free
Expected to fold away in lowering.
@ TCC_Basic
The cost of a typical 'add' instruction.
The instances of the Type class are immutable: once they are created, they are never changed.
Definition: Type.h:45
@ ADD
Simple integer binary arithmetic operators.
Definition: ISDOpcodes.h:239
This is an optimization pass for GlobalISel generic memory operations.
Definition: AddressRanges.h:18
cl::opt< unsigned > SCEVCheapExpansionBudget
Returns options for expansion of memcmp. IsZeroCmp is.