LLVM 24.0.0git
AMDGPUTargetTransformInfo.h
Go to the documentation of this file.
1//===- AMDGPUTargetTransformInfo.h - AMDGPU 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/// \file
10/// This file a TargetTransformInfoImplBase conforming object specific to the
11/// AMDGPU target machine. It uses the target's detailed information to
12/// provide more precise answers to certain TTI queries, while letting the
13/// target independent and default TTI implementations handle the rest.
14//
15//===----------------------------------------------------------------------===//
16
17#ifndef LLVM_LIB_TARGET_AMDGPU_AMDGPUTARGETTRANSFORMINFO_H
18#define LLVM_LIB_TARGET_AMDGPU_AMDGPUTARGETTRANSFORMINFO_H
19
20#include "AMDGPU.h"
23#include <optional>
24
25namespace llvm {
26
28struct AMDGPUOptions;
29class GCNSubtarget;
30class InstCombiner;
31class Loop;
32class ScalarEvolution;
34class Type;
35class Value;
36
37class AMDGPUTTIImpl final : public BasicTTIImplBase<AMDGPUTTIImpl> {
39 using TTI = TargetTransformInfo;
40
41 friend BaseT;
42
43 const AMDGPUOptions &CLOpts;
44 Triple TargetTriple;
45
46 const TargetSubtargetInfo *ST;
47 const TargetLoweringBase *TLI;
48
49 const TargetSubtargetInfo *getST() const { return ST; }
50 const TargetLoweringBase *getTLI() const { return TLI; }
51
52public:
53 explicit AMDGPUTTIImpl(const AMDGPUTargetMachine *TM, const Function &F);
54
57 OptimizationRemarkEmitter *ORE) const override;
58
60 TTI::PeelingPreferences &PP) const override;
61
63};
64
65class GCNTTIImpl final : public BasicTTIImplBase<GCNTTIImpl> {
66 using BaseT = BasicTTIImplBase<GCNTTIImpl>;
67 using TTI = TargetTransformInfo;
68
69 friend BaseT;
70
71 const AMDGPUOptions &CLOpts;
72 const GCNSubtarget *ST;
73 const SITargetLowering *TLI;
74 AMDGPUTTIImpl CommonTTI;
75 bool IsGraphics;
76 bool HasFP32Denormals;
77 static constexpr bool InlinerVectorBonusPercent = 0;
78
79 static const FeatureBitset InlineFeatureIgnoreList;
80
81 const GCNSubtarget *getST() const { return ST; }
82 const SITargetLowering *getTLI() const { return TLI; }
83
84 static inline int getFullRateInstrCost() {
86 }
87
88 static inline int getHalfRateInstrCost(TTI::TargetCostKind CostKind) {
89 return CostKind == TTI::TCK_CodeSize ? 2
91 }
92
93 // TODO: The size is usually 8 bytes, but takes 4x as many cycles. Maybe
94 // should be 2 or 4.
95 static inline int getQuarterRateInstrCost(TTI::TargetCostKind CostKind) {
96 return CostKind == TTI::TCK_CodeSize ? 2
98 }
99
100 int getTransInstrCost(TTI::TargetCostKind CostKind) const;
101
102 // On some parts, normal fp64 operations are half rate, and others
103 // quarter. This also applies to some integer operations.
104 int get64BitInstrCost(TTI::TargetCostKind CostKind) const;
105
106 std::pair<InstructionCost, MVT> getTypeLegalizationCost(Type *Ty) const;
107
108 /// \returns true if V might be divergent even when all of its operands
109 /// are uniform.
110 bool isSourceOfDivergence(const Value *V) const;
111
112 /// Returns true for the target specific set of operations which produce
113 /// uniform result even taking non-uniform arguments.
114 bool isAlwaysUniform(const Value *V) const;
115
116public:
117 explicit GCNTTIImpl(const AMDGPUTargetMachine *TM, const Function &F);
118
119 bool hasBranchDivergence(const Function *F = nullptr) const override;
120
123 OptimizationRemarkEmitter *ORE) const override;
124
126 TTI::PeelingPreferences &PP) const override;
127
128 TTI::PopcntSupportKind getPopcntSupport(unsigned TyWidth) const override {
129 assert(isPowerOf2_32(TyWidth) && "Ty width must be power of 2");
131 }
132
133 unsigned getNumberOfRegisters(unsigned RCID) const override;
136 unsigned getMinVectorRegisterBitWidth() const override;
137 unsigned getMaximumVF(unsigned ElemWidth, unsigned Opcode) const override;
138 bool preferSLPInstCountCheck() const override;
139 unsigned getLoadVectorFactor(unsigned VF, unsigned LoadSize,
140 unsigned ChainSizeInBytes,
141 VectorType *VecTy) const override;
142 unsigned getStoreVectorFactor(unsigned VF, unsigned StoreSize,
143 unsigned ChainSizeInBytes,
144 VectorType *VecTy) const override;
145 unsigned getLoadStoreVecRegBitWidth(unsigned AddrSpace) const override;
146
147 bool isLegalToVectorizeMemChain(unsigned ChainSizeInBytes, Align Alignment,
148 unsigned AddrSpace) const;
149 bool isLegalToVectorizeLoadChain(unsigned ChainSizeInBytes, Align Alignment,
150 unsigned AddrSpace) const override;
151 bool isLegalToVectorizeStoreChain(unsigned ChainSizeInBytes, Align Alignment,
152 unsigned AddrSpace) const override;
153
156 LLVMContext &Context, Value *Length, unsigned SrcAddrSpace,
157 unsigned DestAddrSpace, Align SrcAlign, Align DestAlign,
158 std::optional<uint32_t> AtomicElementSize) const override;
159
161 SmallVectorImpl<Type *> &OpsOut, LLVMContext &Context,
162 unsigned RemainingBytes, unsigned SrcAddrSpace, unsigned DestAddrSpace,
163 Align SrcAlign, Align DestAlign,
164 std::optional<uint32_t> AtomicCpySize) const override;
166 bool HasUnorderedReductions) const override;
167
169 MemIntrinsicInfo &Info) const override;
170
172 unsigned Opcode, Type *Ty, TTI::TargetCostKind CostKind,
176 const Instruction *CtxI = nullptr) const override;
177
178 InstructionCost getCFInstrCost(unsigned Opcode, TTI::TargetCostKind CostKind,
179 const Instruction *I = nullptr) const override;
180
182 unsigned Opcode, Type *ValTy, Type *CondTy, CmpInst::Predicate VecPred,
183 TTI::TargetCostKind CostKind,
186 const Instruction *I = nullptr) const override;
187
188 bool isInlineAsmSourceOfDivergence(const CallBase *CB,
189 ArrayRef<unsigned> Indices = {}) const;
190
193 getVectorInstrCost(unsigned Opcode, Type *ValTy, TTI::TargetCostKind CostKind,
194 unsigned Index, const Value *Op0, const Value *Op1,
196 TTI::VectorInstrContext::None) const override;
197
198 bool isReadRegisterSourceOfDivergence(const IntrinsicInst *ReadReg) const;
199
200 bool isValidAddrSpaceCast(unsigned FromAS, unsigned ToAS) const override {
201 // Address space casts must cast between different address spaces.
202 if (FromAS == ToAS)
203 return false;
204
205 // Casts between any aliasing address spaces are valid.
206 return AMDGPU::addrspacesMayAlias(FromAS, ToAS);
207 }
208
209 bool addrspacesMayAlias(unsigned AS0, unsigned AS1) const override {
210 return AMDGPU::addrspacesMayAlias(AS0, AS1);
211 }
212
213 unsigned getFlatAddressSpace() const override {
214 // Don't bother running InferAddressSpaces pass on graphics shaders which
215 // don't use flat addressing.
216 if (IsGraphics)
217 return -1;
219 }
220
222 Intrinsic::ID IID) const override;
223
224 bool
229
231 Value *NewV) const override;
232
233 bool canSimplifyLegacyMulToMul(const Instruction &I, const Value *Op0,
234 const Value *Op1, InstCombiner &IC) const;
235
237 unsigned LaneAgIdx) const;
238
239 std::optional<Instruction *>
241
244 const APInt &DemandedElts,
245 APInt &UndefElts) const;
246
249 APInt DemandedElts) const;
250
252 IntrinsicInst &II) const;
253
254 std::optional<Value *> simplifyDemandedVectorEltsIntrinsic(
255 InstCombiner &IC, IntrinsicInst &II, APInt DemandedElts, APInt &UndefElts,
256 APInt &UndefElts2, APInt &UndefElts3,
257 std::function<void(Instruction *, unsigned, APInt, APInt &)>
258 SimplifyAndSetOp) const override;
259
261
264 TTI::TargetCostKind CostKind, ArrayRef<int> Mask, int Index,
265 VectorType *SubTp, ArrayRef<const Value *> Args = {},
266 const Instruction *CtxI = nullptr,
268 TTI::VectorInstrContext::None) const override;
269
270 bool isProfitableToSinkOperands(Instruction *I,
271 SmallVectorImpl<Use *> &Ops) const override;
272
273 bool areInlineCompatible(const Function *Caller,
274 const Function *Callee) const override;
275
276 int getInliningLastCallToStaticBonus() const override;
277 unsigned getInliningThresholdMultiplier() const override { return 11; }
278 unsigned adjustInliningThreshold(const CallBase *CB) const override;
279 unsigned getCallerAllocaCost(const CallBase *CB,
280 const AllocaInst *AI) const override;
281
282 int getInlinerVectorBonusPercent() const override {
283 return InlinerVectorBonusPercent;
284 }
285
287 getCastInstrCost(unsigned Opcode, Type *Dst, Type *Src,
289 const Instruction *I = nullptr) const override;
290
292 getArithmeticReductionCost(unsigned Opcode, VectorType *Ty,
293 std::optional<FastMathFlags> FMF,
294 TTI::TargetCostKind CostKind) const override;
295
297 unsigned Opcode, Type *InputTypeA, Type *InputTypeB, Type *AccumType,
299 TTI::PartialReductionExtendKind OpBExtend, std::optional<unsigned> BinOp,
300 TTI::TargetCostKind CostKind,
301 std::optional<FastMathFlags> FMF) const override {
303 }
304
307 TTI::TargetCostKind CostKind) const override;
310 TTI::TargetCostKind CostKind) const override;
311
312 /// Data cache line size for LoopDataPrefetch pass. Has no use before GFX12.
313 unsigned getCacheLineSize() const override;
314
315 /// How much before a load we should place the prefetch instruction.
316 /// This is currently measured in number of IR instructions.
317 unsigned getPrefetchDistance() const override;
318
319 /// \return if target want to issue a prefetch in address space \p AS.
320 bool shouldPrefetchAddressSpace(unsigned AS) const override;
322 const Function &F,
323 SmallVectorImpl<std::pair<StringRef, int64_t>> &LB) const override;
324
325 enum class KnownIEEEMode { Unknown, On, Off };
326
327 /// Return KnownIEEEMode::On if we know if the use context can assume
328 /// "amdgpu-ieee"="true" and KnownIEEEMode::Off if we can assume
329 /// "amdgpu-ieee"="false".
331
332 /// Account for loads of i8 vector types to have reduced cost. For
333 /// example the cost of load 4 i8s values is one is the cost of loading
334 /// a single i32 value.
336 unsigned Opcode, Type *Src, Align Alignment, unsigned AddressSpace,
337 TTI::TargetCostKind CostKind,
339 const Instruction *I = nullptr) const override;
340
341 /// When counting parts on AMD GPUs, account for i8s being grouped
342 /// together under a single i32 value. Otherwise fall back to base
343 /// implementation.
344 unsigned getNumberOfParts(Type *Tp) const override;
345
346 ValueUniformity getValueUniformity(const Value *V) const override;
347
348 InstructionCost getScalingFactorCost(Type *Ty, GlobalValue *BaseGV,
349 StackOffset BaseOffset, bool HasBaseReg,
350 int64_t Scale,
351 unsigned AddrSpace) const override;
352
353 bool isLSRCostLess(const TTI::LSRCost &A,
354 const TTI::LSRCost &B) const override;
355 bool isNumRegsMajorCostOfLSR() const override;
356 bool shouldDropLSRSolutionIfLessProfitable() const override;
357
358 bool isUniform(const Instruction *I,
359 const SmallBitVector &UniformArgs) const override;
360};
361
362} // end namespace llvm
363
364#endif // LLVM_LIB_TARGET_AMDGPU_AMDGPUTARGETTRANSFORMINFO_H
assert(UImm &&(UImm !=~static_cast< T >(0)) &&"Invalid immediate!")
AMDGPU address space definition.
uint64_t uint64_t
This file provides a helper that implements much of the TTI interface in terms of the target-independ...
static GCRegistry::Add< ErlangGC > A("erlang", "erlang-compatible garbage collector")
static GCRegistry::Add< OcamlGC > B("ocaml", "ocaml 3.10-compatible GC")
const AbstractManglingParser< Derived, Alloc >::OperatorInfo AbstractManglingParser< Derived, Alloc >::Ops[]
#define F(x, y, z)
Definition MD5.cpp:54
#define I(x, y, z)
Definition MD5.cpp:57
uint64_t IntrinsicInst * II
uint64_t getMaxMemIntrinsicInlineSizeThreshold() const override
AMDGPUTTIImpl(const AMDGPUTargetMachine *TM, const Function &F)
void getPeelingPreferences(Loop *L, ScalarEvolution &SE, TTI::PeelingPreferences &PP) const override
void getUnrollingPreferences(Loop *L, ScalarEvolution &SE, TTI::UnrollingPreferences &UP, OptimizationRemarkEmitter *ORE) const override
Class for arbitrary precision integers.
Definition APInt.h:78
an instruction to allocate memory on the stack
Represent a constant reference to an array (0 or more elements consecutively in memory),...
Definition ArrayRef.h:40
InstructionCost getVectorInstrCost(unsigned Opcode, Type *Val, TTI::TargetCostKind CostKind, unsigned Index, const Value *Op0, const Value *Op1, TTI::VectorInstrContext VIC=TTI::VectorInstrContext::None) const override
BasicTTIImplBase(const TargetMachine *TM, const DataLayout &DL)
Base class for all callable instructions (InvokeInst and CallInst) Holds everything related to callin...
Predicate
This enumeration lists the possible predicates for CmpInst subclasses.
Definition InstrTypes.h:740
Convenience struct for specifying and reasoning about fast-math flags.
Definition FMF.h:23
Container class for subtarget features.
bool simplifyDemandedLaneMaskArg(InstCombiner &IC, IntrinsicInst &II, unsigned LaneAgIdx) const
Simplify a lane index operand (e.g.
GCNTTIImpl(const AMDGPUTargetMachine *TM, const Function &F)
unsigned getLoadStoreVecRegBitWidth(unsigned AddrSpace) const override
InstructionCost getScalingFactorCost(Type *Ty, GlobalValue *BaseGV, StackOffset BaseOffset, bool HasBaseReg, int64_t Scale, unsigned AddrSpace) const override
InstructionCost getMemoryOpCost(unsigned Opcode, Type *Src, Align Alignment, unsigned AddressSpace, TTI::TargetCostKind CostKind, TTI::OperandValueInfo OpInfo={TTI::OK_AnyValue, TTI::OP_None}, const Instruction *I=nullptr) const override
Account for loads of i8 vector types to have reduced cost.
std::optional< Instruction * > instCombineIntrinsic(InstCombiner &IC, IntrinsicInst &II) const override
void collectKernelLaunchBounds(const Function &F, SmallVectorImpl< std::pair< StringRef, int64_t > > &LB) const override
bool addrspacesMayAlias(unsigned AS0, unsigned AS1) const override
Instruction * hoistLaneIntrinsicThroughOperand(InstCombiner &IC, IntrinsicInst &II) const
bool isUniform(const Instruction *I, const SmallBitVector &UniformArgs) const override
bool isLegalToVectorizeStoreChain(unsigned ChainSizeInBytes, Align Alignment, unsigned AddrSpace) const override
int getInlinerVectorBonusPercent() const override
bool isReadRegisterSourceOfDivergence(const IntrinsicInst *ReadReg) const
unsigned getMaximumVF(unsigned ElemWidth, unsigned Opcode) const override
unsigned getNumberOfRegisters(unsigned RCID) const override
bool canHaveNonUndefGlobalInitializerInAddressSpace(unsigned AS) const override
bool isLegalToVectorizeLoadChain(unsigned ChainSizeInBytes, Align Alignment, unsigned AddrSpace) const override
unsigned getCacheLineSize() const override
Data cache line size for LoopDataPrefetch pass. Has no use before GFX12.
InstructionCost getPartialReductionCost(unsigned Opcode, Type *InputTypeA, Type *InputTypeB, Type *AccumType, ElementCount VF, TTI::PartialReductionExtendKind OpAExtend, TTI::PartialReductionExtendKind OpBExtend, std::optional< unsigned > BinOp, TTI::TargetCostKind CostKind, std::optional< FastMathFlags > FMF) const override
unsigned getStoreVectorFactor(unsigned VF, unsigned StoreSize, unsigned ChainSizeInBytes, VectorType *VecTy) const override
bool isLegalToVectorizeMemChain(unsigned ChainSizeInBytes, Align Alignment, unsigned AddrSpace) const
bool isLSRCostLess(const TTI::LSRCost &A, const TTI::LSRCost &B) const override
bool shouldPrefetchAddressSpace(unsigned AS) const override
Value * simplifyAMDGCNMemoryIntrinsicDemanded(InstCombiner &IC, IntrinsicInst &II, APInt DemandedElts) const
Implement SimplifyDemandedVectorElts for amdgcn buffer and image intrinsics.
std::optional< Value * > simplifyDemandedVectorEltsIntrinsic(InstCombiner &IC, IntrinsicInst &II, APInt DemandedElts, APInt &UndefElts, APInt &UndefElts2, APInt &UndefElts3, std::function< void(Instruction *, unsigned, APInt, APInt &)> SimplifyAndSetOp) const override
InstructionCost getVectorInstrCost(unsigned Opcode, Type *ValTy, TTI::TargetCostKind CostKind, unsigned Index, const Value *Op0, const Value *Op1, TTI::VectorInstrContext VIC=TTI::VectorInstrContext::None) const override
bool hasBranchDivergence(const Function *F=nullptr) const override
Value * rewriteIntrinsicWithAddressSpace(IntrinsicInst *II, Value *OldV, Value *NewV) const override
InstructionCost getShuffleCost(TTI::ShuffleKind Kind, VectorType *DstTy, VectorType *SrcTy, TTI::TargetCostKind CostKind, ArrayRef< int > Mask, int Index, VectorType *SubTp, ArrayRef< const Value * > Args={}, const Instruction *CtxI=nullptr, TTI::VectorInstrContext VIC=TTI::VectorInstrContext::None) const override
unsigned getCallerAllocaCost(const CallBase *CB, const AllocaInst *AI) const override
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) const override
void getMemcpyLoopResidualLoweringType(SmallVectorImpl< Type * > &OpsOut, LLVMContext &Context, unsigned RemainingBytes, unsigned SrcAddrSpace, unsigned DestAddrSpace, Align SrcAlign, Align DestAlign, std::optional< uint32_t > AtomicCpySize) const override
InstructionCost getArithmeticReductionCost(unsigned Opcode, VectorType *Ty, std::optional< FastMathFlags > FMF, TTI::TargetCostKind CostKind) const override
InstructionCost getIntrinsicInstrCost(const IntrinsicCostAttributes &ICA, TTI::TargetCostKind CostKind) const override
Get intrinsic cost based on arguments.
unsigned getInliningThresholdMultiplier() const override
unsigned getLoadVectorFactor(unsigned VF, unsigned LoadSize, unsigned ChainSizeInBytes, VectorType *VecTy) const override
unsigned getPrefetchDistance() const override
How much before a load we should place the prefetch instruction.
InstructionCost getCFInstrCost(unsigned Opcode, TTI::TargetCostKind CostKind, const Instruction *I=nullptr) const override
KnownIEEEMode fpenvIEEEMode(const Instruction &I) const
Return KnownIEEEMode::On if we know if the use context can assume "amdgpu-ieee"="true" and KnownIEEEM...
unsigned adjustInliningThreshold(const CallBase *CB) const override
bool isProfitableToSinkOperands(Instruction *I, SmallVectorImpl< Use * > &Ops) const override
Whether it is profitable to sink the operands of an Instruction I to the basic block of I.
bool getTgtMemIntrinsic(IntrinsicInst *Inst, MemIntrinsicInfo &Info) const override
bool areInlineCompatible(const Function *Caller, const Function *Callee) const override
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 *CtxI=nullptr) const override
InstructionCost getMinMaxReductionCost(Intrinsic::ID IID, VectorType *Ty, FastMathFlags FMF, TTI::TargetCostKind CostKind) const override
Try to calculate op costs for min/max reduction operations.
InstructionCost getCastInstrCost(unsigned Opcode, Type *Dst, Type *Src, TTI::CastContextHint CCH, TTI::TargetCostKind CostKind, const Instruction *I=nullptr) const override
bool shouldDropLSRSolutionIfLessProfitable() const override
unsigned getMaxInterleaveFactor(ElementCount VF, bool HasUnorderedReductions) const override
int getInliningLastCallToStaticBonus() const override
unsigned getFlatAddressSpace() const override
bool isInlineAsmSourceOfDivergence(const CallBase *CB, ArrayRef< unsigned > Indices={}) const
Analyze if the results of inline asm are divergent.
InstructionCost getVectorSplitCost() const
Value * simplifyAMDGCNLaneIntrinsicDemanded(InstCombiner &IC, IntrinsicInst &II, const APInt &DemandedElts, APInt &UndefElts) const
bool collectFlatAddressOperands(SmallVectorImpl< int > &OpIndexes, Intrinsic::ID IID) const override
TTI::PopcntSupportKind getPopcntSupport(unsigned TyWidth) const override
ValueUniformity getValueUniformity(const Value *V) const override
unsigned getNumberOfParts(Type *Tp) const override
When counting parts on AMD GPUs, account for i8s being grouped together under a single i32 value.
bool preferSLPInstCountCheck() const override
void getPeelingPreferences(Loop *L, ScalarEvolution &SE, TTI::PeelingPreferences &PP) const override
bool canSimplifyLegacyMulToMul(const Instruction &I, const Value *Op0, const Value *Op1, InstCombiner &IC) const
unsigned getMinVectorRegisterBitWidth() const override
TypeSize getRegisterBitWidth(TargetTransformInfo::RegisterKind Vector) const override
bool isNumRegsMajorCostOfLSR() const override
void getUnrollingPreferences(Loop *L, ScalarEvolution &SE, TTI::UnrollingPreferences &UP, OptimizationRemarkEmitter *ORE) const override
Type * getMemcpyLoopLoweringType(LLVMContext &Context, Value *Length, unsigned SrcAddrSpace, unsigned DestAddrSpace, Align SrcAlign, Align DestAlign, std::optional< uint32_t > AtomicElementSize) const override
uint64_t getMaxMemIntrinsicInlineSizeThreshold() const override
bool isValidAddrSpaceCast(unsigned FromAS, unsigned ToAS) const override
The core instruction combiner logic.
static InstructionCost getInvalid(CostType Val=0)
A wrapper class for inspecting calls to intrinsic functions.
This is an important class for using LLVM in a threaded context.
Definition LLVMContext.h:76
Represents a single loop in the control flow graph.
Definition LoopInfo.h:40
The optimization diagnostic interface.
The main scalar evolution driver.
This class consists of common code factored out of the SmallVector class to reduce code duplication b...
This base class for TargetLowering contains the SelectionDAG-independent parts that can be used from ...
TargetSubtargetInfo - Generic base class for all target subtargets.
This pass provides access to the codegen interfaces that are needed for IR-level transformations.
TargetCostKind
The kind of cost model.
@ TCK_CodeSize
Instruction code size.
PopcntSupportKind
Flags indicating the kind of support for population count.
llvm::VectorInstrContext VectorInstrContext
@ TCC_Basic
The cost of a typical 'add' instruction.
ShuffleKind
The various kinds of shuffle patterns for vector queries.
CastContextHint
Represents a hint about the context in which a cast is used.
Triple - Helper class for working with autoconf configuration names.
Definition Triple.h:48
The instances of the Type class are immutable: once they are created, they are never changed.
Definition Type.h:46
LLVM Value Representation.
Definition Value.h:75
Base class of all SIMD vector types.
@ REGION_ADDRESS
Address space for region memory. (GDS)
@ LOCAL_ADDRESS
Address space for local memory.
@ FLAT_ADDRESS
Address space for flat memory.
@ PRIVATE_ADDRESS
Address space for private memory.
constexpr char Args[]
Key for Kernel::Metadata::mArgs.
static bool addrspacesMayAlias(unsigned AS1, unsigned AS2)
Definition AMDGPU.h:682
friend class Instruction
Iterator for Instructions in a `BasicBlock.
Definition BasicBlock.h:73
This is an optimization pass for GlobalISel generic memory operations.
@ Length
Definition DWP.cpp:577
RelativeUniformCounterPtr ValuesPtrExpr VTableAddr Value
Definition InstrProf.h:143
constexpr bool isPowerOf2_32(uint32_t Value)
Return true if the argument is a power of two > 0.
Definition MathExtras.h:280
ArrayRef(const T &OneElt) -> ArrayRef< T >
ValueUniformity
Enum describing how values behave with respect to uniformity and divergence, to answer the question: ...
Definition Uniformity.h:18
This struct is a compact representation of a valid (non-zero power of two) alignment.
Definition Alignment.h:39
Information about a load/store intrinsic defined by the target.
Parameters that control the generic loop unrolling transformation.