LLVM 20.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.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
48 unsigned Opcode, Type *ValTy, Type *CondTy, CmpInst::Predicate VecPred,
52 const llvm::Instruction *I = nullptr) {
53 if (Opcode == Instruction::Select)
54 return SCEVCheapExpansionBudget.getValue();
55
56 return BaseT::getCmpSelInstrCost(Opcode, ValTy, CondTy, VecPred, CostKind,
57 Op1Info, Op2Info, I);
58 }
59
61 unsigned Opcode, Type *Ty, TTI::TargetCostKind CostKind,
64 ArrayRef<const Value *> Args = {}, const Instruction *CxtI = nullptr) {
65 int ISD = TLI->InstructionOpcodeToISD(Opcode);
67 return SCEVCheapExpansionBudget.getValue() + 1;
68
69 return BaseT::getArithmeticInstrCost(Opcode, Ty, CostKind, Op1Info,
70 Op2Info);
71 }
72
74 bool IsZeroCmp) const {
76 Options.LoadSizes = {8, 4, 2, 1};
77 Options.MaxNumLoads = TLI->getMaxExpandSizeMemcmp(OptSize);
78 return Options;
79 }
80
81 unsigned getMaxNumArgs() const {
82 return 5;
83 }
84
85};
86
87} // end namespace llvm
88
89#endif // LLVM_LIB_TARGET_BPF_BPFTARGETTRANSFORMINFO_H
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
This pass exposes codegen information to IR-level passes.
Class for arbitrary precision integers.
Definition: APInt.h:78
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={}, const Instruction *CxtI=nullptr)
int getIntImmCost(const APInt &Imm, Type *Ty, TTI::TargetCostKind CostKind)
unsigned getMaxNumArgs() const
InstructionCost getCmpSelInstrCost(unsigned Opcode, Type *ValTy, Type *CondTy, CmpInst::Predicate VecPred, TTI::TargetCostKind CostKind, TTI::OperandValueInfo Op1Info={TTI::OK_AnyValue, TTI::OP_None}, TTI::OperandValueInfo Op2Info={TTI::OK_AnyValue, TTI::OP_None}, const llvm::Instruction *I=nullptr)
BPFTTIImpl(const BPFTargetMachine *TM, const Function &F)
TTI::MemCmpExpansionOptions enableMemCmpExpansion(bool OptSize, bool IsZeroCmp) const
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, TTI::OperandValueInfo Op1Info={TTI::OK_AnyValue, TTI::OP_None}, TTI::OperandValueInfo Op2Info={TTI::OK_AnyValue, TTI::OP_None}, 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={}, const Instruction *CxtI=nullptr)
Definition: BasicTTIImpl.h:932
Predicate
This enumeration lists the possible predicates for CmpInst subclasses.
Definition: InstrTypes.h:673
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:246
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.