LLVM 24.0.0git
LoadStoreVec.cpp
Go to the documentation of this file.
1//===- LoadStoreVec.cpp - Vectorizer pass short load-store chains ---------===//
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
11#include "llvm/ADT/STLExtras.h"
21
22namespace llvm {
23
24namespace sandboxir {
25
26#define DEBUG_PREFIX_LOCAL DEBUG_PREFIX "LoadStoreVec: "
27
28/// \returns true if \p Ty is a pointer, or a vector of pointers, in a
29/// non-integral address space, which has no stable integer representation.
30static bool isNonIntegralPtr(Type *Ty, const DataLayout &DL) {
31 Type *ScalarTy = Ty->getScalarType();
32 return ScalarTy->isPointerTy() &&
33 DL.isNonIntegralAddressSpace(ScalarTy->getPointerAddressSpace());
34}
35
36std::optional<Type *> LoadStoreVec::canVectorize(BndlRef<Instruction *> Bndl) {
37 LLVM_DEBUG(dbgs() << DEBUG_PREFIX << "canVectorize() Bundle:\n";
38 VecUtils::dump(Bndl));
39 const auto &LegalityRes = Legality->canVectorizeLSV(Bndl);
40 LLVM_DEBUG(dbgs() << DEBUG_PREFIX << "Legality: " << LegalityRes << "\n");
41
42 if (LegalityRes.getSubclassID() != LegalityResultID::Widen)
43 return std::nullopt;
45}
46
47void LoadStoreVec::saveIR(Region &R) {
48 Rgn = &R;
49 const auto &SB = cast<RegionWithScore>(Rgn)->getScoreboard();
50 CostBefore = SB.getAfterCost() - SB.getBeforeCost();
51 Rgn->getContext().save();
52}
53
54bool LoadStoreVec::acceptOrRevert() {
55 const auto &SB = cast<RegionWithScore>(*Rgn).getScoreboard();
56 InstructionCost CostAfter = SB.getAfterCost() - SB.getBeforeCost();
57 InstructionCost CostGain = CostAfter - CostBefore;
58 LLVM_DEBUG(dbgs() << DEBUG_PREFIX_LOCAL << "CostGain=" << CostGain
59 << " (After=" << CostAfter << " Before=" << CostBefore
60 << ")\n");
61 const VectorizeOptions &Opts = getVectorizeOptions(*Ctx);
62 if (CostGain > Opts.sbvec_cost_threshold) {
63 LLVM_DEBUG(dbgs() << DEBUG_PREFIX_LOCAL << "Not profitable, reverting.\n");
64 Ctx->revert();
65 return false;
66 }
67 LLVM_DEBUG(dbgs() << DEBUG_PREFIX_LOCAL << "Profitable accepting.\n");
68 Ctx->accept();
69 return true;
70}
71
72LoadInst *LoadStoreVec::createVectorLoad(BndlRef<Instruction *> Loads) {
74 Value *LdPtr = cast<LoadInst>(Loads[0])->getPointerOperand();
75 Align LdAlign = VecUtils::getVecAlignment(Loads);
76 auto LdWhereIt = std::next(VecUtils::getLowest(Loads)->getIterator());
77 auto *VecL =
78 LoadInst::create(Ty, LdPtr, LdAlign, LdWhereIt, *Ctx, "VecIinitL");
79 Utils::propagateMetadata(VecL, Loads);
80 return VecL;
81}
82
84 const DataLayout &DL) {
85 return !isNonIntegralPtr(SrcTy, DL) && !isNonIntegralPtr(DestTy, DL);
86}
87
88Type *SameSizeReinterpret::getIntTypeFor(Type *Ty, const DataLayout &DL) {
89 Context &Ctx = Ty->getContext();
90 if (auto *VecTy = dyn_cast<FixedVectorType>(Ty)) {
91 auto *ElmIntTy =
92 IntegerType::get(Ctx, Utils::getNumBits(VecTy->getElementType(), DL));
93 return FixedVectorType::get(ElmIntTy, VecTy->getNumElements());
94 }
95 return IntegerType::get(Ctx, Utils::getNumBits(Ty, DL));
96}
97
99SameSizeReinterpret::getCastChain(Type *SrcTy, Type *DestTy,
100 const DataLayout &DL) {
101 assert(canReinterpret(SrcTy, DestTy, DL) &&
102 "Cannot reinterpret a non-integral pointer!");
103 assert(Utils::getNumBits(SrcTy, DL) == Utils::getNumBits(DestTy, DL) &&
104 "Expected types of the same size!");
106 if (SrcTy == DestTy)
107 return Chain;
108 Type *Ty = SrcTy;
109 if (Ty->getScalarType()->isPointerTy()) {
110 Ty = getIntTypeFor(Ty, DL);
111 Chain.emplace_back(Instruction::Opcode::PtrToInt, Ty);
112 }
113 bool DestIsPtr = DestTy->getScalarType()->isPointerTy();
114 Type *BitCastTy = DestIsPtr ? getIntTypeFor(DestTy, DL) : DestTy;
115 if (Ty != BitCastTy)
116 Chain.emplace_back(Instruction::Opcode::BitCast, BitCastTy);
117 if (DestIsPtr)
118 Chain.emplace_back(Instruction::Opcode::IntToPtr, DestTy);
119 // ptrtoint, bitcast, and inttoptr, with any step omitted. A vector of
120 // pointers and a scalar pointer of the same width need all three.
121 assert(Chain.size() <= 3 && "Unexpected reinterpret cast chain!");
122 return Chain;
123}
124
126 const DataLayout &DL) {
127 if (!canReinterpret(C->getType(), DestTy, DL))
128 return nullptr;
129 Constant *NewC = C;
130 for (auto [Opc, Ty] : getCastChain(C->getType(), DestTy, DL)) {
131 switch (Opc) {
132 case Instruction::Opcode::PtrToInt:
133 NewC = ConstantExpr::getPtrToInt(NewC, Ty);
134 break;
135 case Instruction::Opcode::BitCast:
136 NewC = ConstantExpr::getBitCast(NewC, Ty);
137 break;
138 case Instruction::Opcode::IntToPtr:
139 NewC = ConstantExpr::getIntToPtr(NewC, Ty);
140 break;
141 default:
142 llvm_unreachable("Unexpected cast in reinterpret chain!");
143 }
144 }
145 return NewC;
146}
147
148Constant *LoadStoreVec::createConstantVector(BndlRef<Constant *> Constants) {
149 auto *VecTy =
151 auto *LaneTy = VecTy->getScalarType();
152 unsigned LaneBits = Utils::getNumBits(LaneTy, *DL);
153 assert(all_of(Constants,
154 [&](Value *V) {
155 return Utils::getNumBits(V, *DL) % LaneBits == 0;
156 }) &&
157 "Chain contains a constant which cannot be converted or split");
158
159 // Some of the contents of Constants may be vectors, like <i8 1, i8 2>.
160 // Collect each scalar element in ConstantElements.
161 SmallVector<Constant *, 4> ConstantElements;
162 for (Constant *COp : Constants) {
163 if (auto *AggrCOp = dyn_cast<ConstantAggregate>(COp)) {
164 // If the operand is a constant aggregate, then append all its elements.
165 // TODO: Flatten nested aggregates such as {i32, {i32, <2 x i32>}} in a
166 // follow-up.
167 for (Value *Elm : AggrCOp->operands())
168 ConstantElements.push_back(cast<Constant>(Elm));
169 } else if (auto *SeqCOp = dyn_cast<ConstantDataSequential>(COp)) {
170 for (auto ElmIdx : seq<unsigned>(SeqCOp->getNumElements()))
171 ConstantElements.push_back(SeqCOp->getElementAsConstant(ElmIdx));
172 } else if (auto *Zero = dyn_cast<ConstantAggregateZero>(COp)) {
173 auto *ZeroElm = Zero->getSequentialElement();
174 for ([[maybe_unused]] auto Cnt :
175 seq<unsigned>(Zero->getElementCount().getFixedValue()))
176 ConstantElements.push_back(ZeroElm);
177 } else if (isa<ConstantInt>(COp) && isa<VectorType>(COp->getType())) {
178 auto *Elm = ConstantInt::get(*Ctx, cast<ConstantInt>(COp)->getValue());
179 for ([[maybe_unused]] auto Cnt :
180 seq<unsigned>(cast<VectorType>(COp->getType())
181 ->getElementCount()
182 .getFixedValue()))
183 ConstantElements.push_back(Elm);
184 } else if (isa<ConstantFP>(COp) && isa<VectorType>(COp->getType())) {
185 auto *Elm = ConstantFP::get(cast<ConstantFP>(COp)->getValue(), *Ctx);
186 for ([[maybe_unused]] auto Cnt :
187 seq<unsigned>(cast<VectorType>(COp->getType())
188 ->getElementCount()
189 .getFixedValue()))
190 ConstantElements.push_back(Elm);
191 } else if (isa<PoisonValue>(COp) && isa<VectorType>(COp->getType())) {
192 auto *Elm =
193 PoisonValue::get(cast<VectorType>(COp->getType())->getElementType());
194 for ([[maybe_unused]] auto Cnt :
195 seq<unsigned>(cast<VectorType>(COp->getType())
196 ->getElementCount()
197 .getFixedValue()))
198 ConstantElements.push_back(Elm);
199 } else if (isa<VectorType>(COp->getType())) {
200 // TODO: Flatten the remaining vector constants.
201 return nullptr;
202 } else {
203 ConstantElements.push_back(COp);
204 }
205 }
206
207 // The elements in ConstantElements may not be of the same type, so we need to
208 // convert them to LaneTy such that we end up getting a vector
209 // <ConstantElements.size() x LaneTy>. This may involve converting integers to
210 // floats (e.g., float 1.0 to i32 0x3f800000), widening or slicing values if
211 // not at LaneTy bit-width (e.g., i16 0x0101 to i8 0x01, i8 0x01 on
212 // little-endian), or a combination of the two.
213 SmallVector<Constant *, 8> LaneTyConstants;
214 LaneTyConstants.reserve(ConstantElements.size());
215 for (Constant *C : ConstantElements) {
216 unsigned Bits = Utils::getNumBits(C, *DL);
217 if (Bits == LaneBits) {
219 if (Lane == nullptr)
220 return nullptr;
221 LaneTyConstants.push_back(Lane);
222 } else if (Bits > LaneBits) {
223 // C is wider than LaneTy, so slice it into LaneTy-sized pieces. That
224 // needs a known bit pattern. A ConstantExpr (for example, ptrtoint of a
225 // global) or a global's address is only known at link time and cannot
226 // be sliced.
228 return nullptr;
229 APInt Val;
230 if (auto *CI = dyn_cast<ConstantInt>(C))
231 Val = CI->getValue();
232 else if (auto *CFP = dyn_cast<ConstantFP>(C))
233 Val = CFP->getValue().bitcastToAPInt();
234 else
235 Val = APInt::getZero(Bits);
236 unsigned NumSlices = Bits / LaneBits;
237 for (unsigned SliceIdx : seq<unsigned>(NumSlices)) {
238 unsigned EndianAwareSlice =
239 DL->isLittleEndian() ? SliceIdx : NumSlices - 1 - SliceIdx;
240 // extractBits returns an integer. Convert that slice back to LaneTy
241 // without changing its bits, so a float lane stays a float.
242 Constant *SliceCInt = ConstantInt::get(
243 *Ctx, Val.extractBits(LaneBits, EndianAwareSlice * LaneBits));
244 Constant *SliceC =
245 SameSizeReinterpret::reinterpretConstant(SliceCInt, LaneTy, *DL);
246 if (SliceC == nullptr)
247 return nullptr;
248 LaneTyConstants.push_back(SliceC);
249 }
250 } else {
251 llvm_unreachable("Vector element type size was calculated incorrectly");
252 }
253 }
254 return ConstantVector::get(LaneTyConstants);
255}
256
257bool LoadStoreVec::vectorizeStores(BndlRef<Instruction *> Stores, Region &Rgn) {
258 if (!canVectorize(Stores))
259 return false;
260 SmallVector<Value *, 4> Operands;
261 Operands.reserve(Stores.size());
262 for (auto *I : Stores) {
263 auto *Op = cast<StoreInst>(I)->getValueOperand();
264 Operands.push_back(Op);
265 }
266 BasicBlock *BB = Stores[0]->getParent();
267 // TODO: For now we only support load operands.
268 // TODO: For now we don't cross BBs.
269 // TODO: For now don't vectorize if the loads have external uses.
270 bool AllLoads = all_of(Operands, [BB](Value *V) {
271 auto *LI = dyn_cast<LoadInst>(V);
272 if (LI == nullptr)
273 return false;
274 // TODO: For now we don't cross BBs.
275 if (LI->getParent() != BB)
276 return false;
277 if (LI->hasNUsesOrMore(2))
278 return false;
279 return true;
280 });
281 bool AllConstants =
282 all_of(Operands, [](Value *V) { return isa<Constant>(V); });
283 if (!AllLoads && !AllConstants)
284 return false;
285
286 // Vectorizing mixed floats and integers with external uses may not be
287 // profitable on some targets, so save state here.
288 saveIR(Rgn);
289 Value *VecOp = nullptr;
290 SmallVector<Instruction *, 8> Loads;
291 if (AllLoads) {
292 Loads.reserve(Operands.size());
293 for (Value *Op : Operands)
294 Loads.push_back(cast<Instruction>(Op));
295 if (!canVectorize(Loads)) {
296 Ctx->accept();
297 return false;
298 }
299 VecOp = createVectorLoad(Loads);
300 assert(VecOp != nullptr && "Expected vector value!");
301 } else if (AllConstants) {
303 Constants.reserve(Operands.size());
304 for (Value *Op : Operands)
305 Constants.push_back(cast<Constant>(Op));
306 VecOp = createConstantVector(Constants);
307 if (VecOp == nullptr) {
308 Ctx->accept();
309 return false;
310 }
311 }
312
313 // Generate vector store.
314 Value *StPtr = cast<StoreInst>(Stores[0])->getPointerOperand();
315 Align StAlign = VecUtils::getVecAlignment(Stores);
316 auto StWhereIt = std::next(VecUtils::getLowest(Stores)->getIterator());
317 auto *VecS = StoreInst::create(VecOp, StPtr, StAlign, StWhereIt, *Ctx);
318 Utils::propagateMetadata(VecS, Stores);
319
320 DeadInstrMorgue.collectPotentiallyDeadInstrs(Stores);
321 if (AllLoads)
322 DeadInstrMorgue.collectPotentiallyDeadInstrs<Instruction>(Loads);
323 DeadInstrMorgue.tryEraseDeadInstrs();
324
325 return acceptOrRevert();
326}
327
328LoadInst *LoadStoreVec::vectorizeLoads(BndlRef<Instruction *> Loads,
329 Region &Rgn) {
330 auto VecTy = canVectorize(Loads);
331 if (!VecTy)
332 return nullptr;
333
334 // TODO: Support mixed-type top-level load chains.
335 Type *VecElemTy = cast<FixedVectorType>(*VecTy)->getElementType();
336 if (!all_of(Loads, [VecElemTy](Instruction *I) {
337 return VecUtils::getElementType(I->getType()) == VecElemTy;
338 }))
339 return nullptr;
340
341 saveIR(Rgn);
342
343 auto *VecLoad = createVectorLoad(Loads);
344 assert(VecLoad != nullptr && "Expected vector load");
345
346 BasicBlock::iterator WhereIt = std::next(VecLoad->getIterator());
347 for (auto [Lane, OrigV] : VecUtils::enumerateLanes(Loads)) {
348 auto *OrigLoad = cast<LoadInst>(OrigV);
349 if (OrigLoad->hasNUses(0))
350 continue;
351 Value *Unpacked =
352 VecUtils::unpack(VecLoad, OrigLoad->getType(), Lane, WhereIt);
353 OrigLoad->replaceAllUsesWith(Unpacked);
354 }
355
356 DeadInstrMorgue.collectPotentiallyDeadInstrs(Loads);
357 DeadInstrMorgue.tryEraseDeadInstrs();
358
359 if (!acceptOrRevert())
360 return nullptr;
361 return VecLoad;
362}
363
364bool LoadStoreVec::runOnRegion(Region &Rgn, const Analyses &RegionAnalyses) {
365 SmallVector<Instruction *, 8> Bndl(Rgn.getAux().begin(), Rgn.getAux().end());
366 if (Bndl.size() < 2)
367 return false;
368 Function &F = *Bndl[0]->getParent()->getParent();
369 DL = &F.getParent()->getDataLayout();
370 Ctx = &F.getContext();
371 A = &RegionAnalyses;
372 InstrMaps IMaps;
373 auto Opc = Bndl[0]->getOpcode();
374 assert(
375 all_of(Bndl, [Opc](Instruction *I) { return I->getOpcode() == Opc; }) &&
376 "Expected a homogeneous seed slice!");
377
378 SchedDirection Dir;
379 switch (Opc) {
380 case Instruction::Opcode::Load:
382 break;
383 case Instruction::Opcode::Store:
385 break;
386 default:
387 llvm_unreachable("Expected Load or Store");
388 }
389
390 Legality = std::make_unique<LegalityAnalysis>(
391 A->getAA(), A->getScalarEvolution(), F.getParent()->getDataLayout(),
392 A->getTTI(), F.getContext(), IMaps, Dir);
393
394 bool Changed = false;
395 switch (Opc) {
396 case Instruction::Opcode::Load:
397 Changed = vectorizeLoads(Bndl, Rgn) != nullptr;
398 break;
399 case Instruction::Opcode::Store:
400 Changed = vectorizeStores(Bndl, Rgn);
401 break;
402 default:
403 llvm_unreachable("Expected Load or Store");
404 }
405 return Changed;
406}
407
408} // namespace sandboxir
409
410} // namespace llvm
assert(UImm &&(UImm !=~static_cast< T >(0)) &&"Invalid immediate!")
MachineBasicBlock MachineBasicBlock::iterator DebugLoc DL
static GCRegistry::Add< ShadowStackGC > C("shadow-stack", "Very portable GC for uncooperative code generators")
decltype(auto) dyn_cast(const From &Val)
dyn_cast<X> - Return the argument parameter cast to the specified type.
Definition Casting.h:643
This file defines an InstructionCost class that is used when calculating the cost of an instruction,...
static constexpr Value * getValue(Ty &ValueOrUse)
#define DEBUG_PREFIX_LOCAL
#define F(x, y, z)
Definition MD5.cpp:54
#define I(x, y, z)
Definition MD5.cpp:57
SI Fold Operands
This file contains some templates that are useful if you are working with the STL at all.
#define LLVM_DEBUG(...)
Definition Debug.h:119
#define DEBUG_PREFIX
Definition Debug.h:19
static APInt getZero(unsigned numBits)
Get the '0' value for the specified bit-width.
Definition APInt.h:196
InstListType::iterator iterator
Instruction iterators...
Definition BasicBlock.h:170
This is an important base class in LLVM.
Definition Constant.h:44
A parsed version of the target data layout string in and methods for querying it.
Definition DataLayout.h:64
void reserve(size_type N)
This is a 'vector' (really, a variable-sized array), optimized for the case when the array is small.
LLVM Value Representation.
Definition Value.h:75
An ArrayRef of Values or Instructions that we can print/dump for debugging.
Definition VecUtils.h:39
static LLVM_ABI Constant * getBitCast(Constant *C, Type *Ty)
Definition Constant.cpp:482
static LLVM_ABI Constant * getPtrToInt(Constant *C, Type *Ty)
Definition Constant.cpp:470
static LLVM_ABI Constant * getIntToPtr(Constant *C, Type *Ty)
Definition Constant.cpp:476
static LLVM_ABI Constant * get(Type *Ty, double V)
This returns a ConstantFP, or a vector containing a splat of a ConstantFP, for the specified value in...
Definition Constant.cpp:90
static LLVM_ABI Constant * get(Type *Ty, uint64_t V, bool IsSigned=false)
If Ty is a vector type, return a Constant with a splat of the given value.
Definition Constant.cpp:48
static LLVM_ABI Constant * get(ArrayRef< Constant * > V)
Definition Constant.cpp:176
void save()
Convenience function for getTracker().save()
Definition Context.h:245
static LLVM_ABI FixedVectorType * get(Type *ElementType, unsigned NumElts)
Maps the original instructions to the vectorized instrs and the reverse.
Definition InstrMaps.h:49
A sandboxir::User with operands, opcode and linked with previous/next instructions in an instruction ...
Definition Instruction.h:43
static LLVM_ABI IntegerType * get(Context &C, unsigned NumBits)
static LLVM_ABI LoadInst * create(Type *Ty, Value *Ptr, MaybeAlign Align, InsertPosition Pos, bool IsVolatile, Context &Ctx, const Twine &Name="")
bool runOnRegion(Region &Rgn, const Analyses &A) final
\Returns true if it modifies R.
static LLVM_ABI PoisonValue * get(Type *T)
Static factory methods - Return an 'poison' object of the specified type.
Definition Constant.cpp:263
Context & getContext() const
Definition Region.h:169
static LLVM_ABI Constant * reinterpretConstant(Constant *C, Type *DestTy, const DataLayout &DL)
Reinterprets constant C as DestTy, e.g., float 1.0 to i32 0x3f800000, or a null pointer to i64 0.
static LLVM_ABI bool canReinterpret(Type *SrcTy, Type *DestTy, const DataLayout &DL)
static LLVM_ABI StoreInst * create(Value *V, Value *Ptr, MaybeAlign Align, InsertPosition Pos, bool IsVolatile, Context &Ctx)
Just like llvm::Type these are immutable, unique, never get freed and can only be created via static ...
Definition Type.h:48
unsigned getPointerAddressSpace() const
Get the address space of this pointer or pointer vector type.
Definition Type.h:301
LLVM_ABI Type * getScalarType() const
If this is a vector type, return the element type, otherwise return 'this'.
bool isPointerTy() const
True if this is an instance of PointerType.
Definition Type.h:206
static void propagateMetadata(Instruction *I, const ValueRangeT &VL)
Definition Utils.h:148
static unsigned getNumBits(Type *Ty, const DataLayout &DL)
\Returns the number of bits of Ty.
Definition Utils.h:68
A SandboxIR Value has users. This is the base class.
Definition Value.h:72
static Instruction * getLowest(ArrayRef< Instruction * > Instrs)
\Returns the instruction in Instrs that is lowest in the BB.
Definition VecUtils.h:240
static Value * unpack(Value *FromVec, Type *ExtrTy, unsigned Lane, BasicBlock::iterator WhereIt)
Emits the necessary instruction sequence to extract element of type ExtrTy at Lane from FromVec.
Definition VecUtils.h:418
static LLVM_DUMP_METHOD void dump(ArrayRef< Value * > Bndl)
Helper dump function for debugging.
Definition VecUtils.cpp:166
static auto enumerateLanes(const ValueContainerT &Range)
Helper for creating LaneValueEnumerator ranges.
Definition VecUtils.h:536
static Type * getElementType(Type *Ty)
Returns Ty if scalar or its element type if vector.
Definition VecUtils.h:94
static Align getVecAlignment(AlignRangeT AlignRange, TypeRangeT TypeRange)
Given the alignments of the instructions before vectorization, this returns the alignment of the vect...
Definition VecUtils.h:547
static Type * getCombinedVectorTypeFor(BndlRef< T * > Bndl, const DataLayout &DL)
\Returns the combined vector type for Bndl, even when the element types differ.
Definition VecUtils.h:205
#define llvm_unreachable(msg)
Marks that the current location is not supposed to be reachable.
constexpr char Align[]
Key for Kernel::Arg::Metadata::mAlign.
BndlRef(const T &OneElt) -> BndlRef< T >
BasicBlock(llvm::BasicBlock *BB, Context &SBCtx)
Definition BasicBlock.h:75
friend class Instruction
Iterator for Instructions in a `BasicBlock.
Definition BasicBlock.h:73
static bool isNonIntegralPtr(Type *Ty, const DataLayout &DL)
This is an optimization pass for GlobalISel generic memory operations.
bool all_of(R &&range, UnaryPredicate P)
Provide wrappers to std::all_of which take ranges instead of having to pass begin/end explicitly.
Definition STLExtras.h:1755
decltype(auto) dyn_cast(const From &Val)
dyn_cast<X> - Return the argument parameter cast to the specified type.
Definition Casting.h:643
RelativeUniformCounterPtr ValuesPtrExpr VTableAddr Value
Definition InstrProf.h:143
LLVM_ABI raw_ostream & dbgs()
dbgs() - This returns a reference to a raw_ostream for debugging messages.
Definition Debug.cpp:209
class LLVM_GSL_OWNER SmallVector
Forward declaration of SmallVector so that calculateSmallVectorDefaultInlinedElements can reference s...
bool isa(const From &Val)
isa<X> - Return true if the parameter to the template is an instance of one of the template type argu...
Definition Casting.h:547
DWARFExpression::Operation Op
const VectorizeOptions & getVectorizeOptions(const LLVMContext &C)
decltype(auto) cast(const From &Val)
cast<X> - Return the argument parameter cast to the specified type.
Definition Casting.h:559
constexpr auto seq(T Begin, T End)
Iterate over an integral type from Begin up to - but not including - End.
Definition Sequence.h:341