LLVM 18.0.0git
IVDescriptors.h
Go to the documentation of this file.
1//===- llvm/Analysis/IVDescriptors.h - IndVar Descriptors -------*- 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 "describes" induction and recurrence variables.
10//
11//===----------------------------------------------------------------------===//
12
13#ifndef LLVM_ANALYSIS_IVDESCRIPTORS_H
14#define LLVM_ANALYSIS_IVDESCRIPTORS_H
15
16#include "llvm/ADT/MapVector.h"
20#include "llvm/IR/ValueHandle.h"
21
22namespace llvm {
23
24class AssumptionCache;
25class DemandedBits;
26class DominatorTree;
27class Instruction;
28class Loop;
29class PredicatedScalarEvolution;
30class ScalarEvolution;
31class SCEV;
32class StoreInst;
33
34/// These are the kinds of recurrences that we support.
35enum class RecurKind {
36 None, ///< Not a recurrence.
37 Add, ///< Sum of integers.
38 Mul, ///< Product of integers.
39 Or, ///< Bitwise or logical OR of integers.
40 And, ///< Bitwise or logical AND of integers.
41 Xor, ///< Bitwise or logical XOR of integers.
42 SMin, ///< Signed integer min implemented in terms of select(cmp()).
43 SMax, ///< Signed integer max implemented in terms of select(cmp()).
44 UMin, ///< Unsigned integer min implemented in terms of select(cmp()).
45 UMax, ///< Unsigned integer max implemented in terms of select(cmp()).
46 FAdd, ///< Sum of floats.
47 FMul, ///< Product of floats.
48 FMin, ///< FP min implemented in terms of select(cmp()).
49 FMax, ///< FP max implemented in terms of select(cmp()).
50 FMinimum, ///< FP min with llvm.minimum semantics
51 FMaximum, ///< FP max with llvm.maximum semantics
52 FMulAdd, ///< Sum of float products with llvm.fmuladd(a * b + sum).
53 IAnyOf, ///< Any_of reduction with select(icmp(),x,y) where one of (x,y) is
54 ///< loop invariant, and both x and y are integer type.
55 FAnyOf ///< Any_of reduction with select(fcmp(),x,y) where one of (x,y) is
56 ///< loop invariant, and both x and y are integer type.
57 // TODO: Any_of reduction need not be restricted to integer type only.
58};
59
60/// The RecurrenceDescriptor is used to identify recurrences variables in a
61/// loop. Reduction is a special case of recurrence that has uses of the
62/// recurrence variable outside the loop. The method isReductionPHI identifies
63/// reductions that are basic recurrences.
64///
65/// Basic recurrences are defined as the summation, product, OR, AND, XOR, min,
66/// or max of a set of terms. For example: for(i=0; i<n; i++) { total +=
67/// array[i]; } is a summation of array elements. Basic recurrences are a
68/// special case of chains of recurrences (CR). See ScalarEvolution for CR
69/// references.
70
71/// This struct holds information about recurrence variables.
73public:
75
77 RecurKind K, FastMathFlags FMF, Instruction *ExactFP,
78 Type *RT, bool Signed, bool Ordered,
80 unsigned MinWidthCastToRecurTy)
81 : IntermediateStore(Store), StartValue(Start), LoopExitInstr(Exit),
82 Kind(K), FMF(FMF), ExactFPMathInst(ExactFP), RecurrenceType(RT),
83 IsSigned(Signed), IsOrdered(Ordered),
84 MinWidthCastToRecurrenceType(MinWidthCastToRecurTy) {
85 CastInsts.insert(CI.begin(), CI.end());
86 }
87
88 /// This POD struct holds information about a potential recurrence operation.
89 class InstDesc {
90 public:
91 InstDesc(bool IsRecur, Instruction *I, Instruction *ExactFP = nullptr)
92 : IsRecurrence(IsRecur), PatternLastInst(I),
93 RecKind(RecurKind::None), ExactFPMathInst(ExactFP) {}
94
95 InstDesc(Instruction *I, RecurKind K, Instruction *ExactFP = nullptr)
96 : IsRecurrence(true), PatternLastInst(I), RecKind(K),
97 ExactFPMathInst(ExactFP) {}
98
99 bool isRecurrence() const { return IsRecurrence; }
100
101 bool needsExactFPMath() const { return ExactFPMathInst != nullptr; }
102
103 Instruction *getExactFPMathInst() const { return ExactFPMathInst; }
104
105 RecurKind getRecKind() const { return RecKind; }
106
107 Instruction *getPatternInst() const { return PatternLastInst; }
108
109 private:
110 // Is this instruction a recurrence candidate.
111 bool IsRecurrence;
112 // The last instruction in a min/max pattern (select of the select(icmp())
113 // pattern), or the current recurrence instruction otherwise.
114 Instruction *PatternLastInst;
115 // If this is a min/max pattern.
116 RecurKind RecKind;
117 // Recurrence does not allow floating-point reassociation.
118 Instruction *ExactFPMathInst;
119 };
120
121 /// Returns a struct describing if the instruction 'I' can be a recurrence
122 /// variable of type 'Kind' for a Loop \p L and reduction PHI \p Phi.
123 /// If the recurrence is a min/max pattern of select(icmp()) this function
124 /// advances the instruction pointer 'I' from the compare instruction to the
125 /// select instruction and stores this pointer in 'PatternLastInst' member of
126 /// the returned struct.
127 static InstDesc isRecurrenceInstr(Loop *L, PHINode *Phi, Instruction *I,
128 RecurKind Kind, InstDesc &Prev,
129 FastMathFlags FuncFMF);
130
131 /// Returns true if instruction I has multiple uses in Insts
132 static bool hasMultipleUsesOf(Instruction *I,
134 unsigned MaxNumUses);
135
136 /// Returns true if all uses of the instruction I is within the Set.
138
139 /// Returns a struct describing if the instruction is a llvm.(s/u)(min/max),
140 /// llvm.minnum/maxnum or a Select(ICmp(X, Y), X, Y) pair of instructions
141 /// corresponding to a min(X, Y) or max(X, Y), matching the recurrence kind \p
142 /// Kind. \p Prev specifies the description of an already processed select
143 /// instruction, so its corresponding cmp can be matched to it.
144 static InstDesc isMinMaxPattern(Instruction *I, RecurKind Kind,
145 const InstDesc &Prev);
146
147 /// Returns a struct describing whether the instruction is either a
148 /// Select(ICmp(A, B), X, Y), or
149 /// Select(FCmp(A, B), X, Y)
150 /// where one of (X, Y) is a loop invariant integer and the other is a PHI
151 /// value. \p Prev specifies the description of an already processed select
152 /// instruction, so its corresponding cmp can be matched to it.
153 static InstDesc isAnyOfPattern(Loop *Loop, PHINode *OrigPhi, Instruction *I,
154 InstDesc &Prev);
155
156 /// Returns a struct describing if the instruction is a
157 /// Select(FCmp(X, Y), (Z = X op PHINode), PHINode) instruction pattern.
158 static InstDesc isConditionalRdxPattern(RecurKind Kind, Instruction *I);
159
160 /// Returns identity corresponding to the RecurrenceKind.
162
163 /// Returns the opcode corresponding to the RecurrenceKind.
164 static unsigned getOpcode(RecurKind Kind);
165
166 /// Returns true if Phi is a reduction of type Kind and adds it to the
167 /// RecurrenceDescriptor. If either \p DB is non-null or \p AC and \p DT are
168 /// non-null, the minimal bit width needed to compute the reduction will be
169 /// computed.
170 static bool
171 AddReductionVar(PHINode *Phi, RecurKind Kind, Loop *TheLoop,
172 FastMathFlags FuncFMF, RecurrenceDescriptor &RedDes,
173 DemandedBits *DB = nullptr, AssumptionCache *AC = nullptr,
174 DominatorTree *DT = nullptr, ScalarEvolution *SE = nullptr);
175
176 /// Returns true if Phi is a reduction in TheLoop. The RecurrenceDescriptor
177 /// is returned in RedDes. If either \p DB is non-null or \p AC and \p DT are
178 /// non-null, the minimal bit width needed to compute the reduction will be
179 /// computed. If \p SE is non-null, store instructions to loop invariant
180 /// addresses are processed.
181 static bool
182 isReductionPHI(PHINode *Phi, Loop *TheLoop, RecurrenceDescriptor &RedDes,
183 DemandedBits *DB = nullptr, AssumptionCache *AC = nullptr,
184 DominatorTree *DT = nullptr, ScalarEvolution *SE = nullptr);
185
186 /// Returns true if Phi is a fixed-order recurrence. A fixed-order recurrence
187 /// is a non-reduction recurrence relation in which the value of the
188 /// recurrence in the current loop iteration equals a value defined in a
189 /// previous iteration (e.g. if the value is defined in the previous
190 /// iteration, we refer to it as first-order recurrence, if it is defined in
191 /// the iteration before the previous, we refer to it as second-order
192 /// recurrence and so on). Note that this function optimistically assumes that
193 /// uses of the recurrence can be re-ordered if necessary and users need to
194 /// check and perform the re-ordering.
195 static bool isFixedOrderRecurrence(PHINode *Phi, Loop *TheLoop,
196 DominatorTree *DT);
197
198 RecurKind getRecurrenceKind() const { return Kind; }
199
200 unsigned getOpcode() const { return getOpcode(getRecurrenceKind()); }
201
202 FastMathFlags getFastMathFlags() const { return FMF; }
203
204 TrackingVH<Value> getRecurrenceStartValue() const { return StartValue; }
205
206 Instruction *getLoopExitInstr() const { return LoopExitInstr; }
207
208 /// Returns true if the recurrence has floating-point math that requires
209 /// precise (ordered) operations.
210 bool hasExactFPMath() const { return ExactFPMathInst != nullptr; }
211
212 /// Returns 1st non-reassociative FP instruction in the PHI node's use-chain.
213 Instruction *getExactFPMathInst() const { return ExactFPMathInst; }
214
215 /// Returns true if the recurrence kind is an integer kind.
216 static bool isIntegerRecurrenceKind(RecurKind Kind);
217
218 /// Returns true if the recurrence kind is a floating point kind.
220
221 /// Returns true if the recurrence kind is an integer min/max kind.
223 return Kind == RecurKind::UMin || Kind == RecurKind::UMax ||
224 Kind == RecurKind::SMin || Kind == RecurKind::SMax;
225 }
226
227 /// Returns true if the recurrence kind is a floating-point min/max kind.
229 return Kind == RecurKind::FMin || Kind == RecurKind::FMax ||
230 Kind == RecurKind::FMinimum || Kind == RecurKind::FMaximum;
231 }
232
233 /// Returns true if the recurrence kind is any min/max kind.
236 }
237
238 /// Returns true if the recurrence kind is of the form
239 /// select(cmp(),x,y) where one of (x,y) is loop invariant.
241 return Kind == RecurKind::IAnyOf || Kind == RecurKind::FAnyOf;
242 }
243
244 /// Returns the type of the recurrence. This type can be narrower than the
245 /// actual type of the Phi if the recurrence has been type-promoted.
246 Type *getRecurrenceType() const { return RecurrenceType; }
247
248 /// Returns a reference to the instructions used for type-promoting the
249 /// recurrence.
250 const SmallPtrSet<Instruction *, 8> &getCastInsts() const { return CastInsts; }
251
252 /// Returns the minimum width used by the recurrence in bits.
254 return MinWidthCastToRecurrenceType;
255 }
256
257 /// Returns true if all source operands of the recurrence are SExtInsts.
258 bool isSigned() const { return IsSigned; }
259
260 /// Expose an ordered FP reduction to the instance users.
261 bool isOrdered() const { return IsOrdered; }
262
263 /// Attempts to find a chain of operations from Phi to LoopExitInst that can
264 /// be treated as a set of reductions instructions for in-loop reductions.
266 Loop *L) const;
267
268 /// Returns true if the instruction is a call to the llvm.fmuladd intrinsic.
270 return isa<IntrinsicInst>(I) &&
271 cast<IntrinsicInst>(I)->getIntrinsicID() == Intrinsic::fmuladd;
272 }
273
274 /// Reductions may store temporary or final result to an invariant address.
275 /// If there is such a store in the loop then, after successfull run of
276 /// AddReductionVar method, this field will be assigned the last met store.
278
279private:
280 // The starting value of the recurrence.
281 // It does not have to be zero!
282 TrackingVH<Value> StartValue;
283 // The instruction who's value is used outside the loop.
284 Instruction *LoopExitInstr = nullptr;
285 // The kind of the recurrence.
287 // The fast-math flags on the recurrent instructions. We propagate these
288 // fast-math flags into the vectorized FP instructions we generate.
289 FastMathFlags FMF;
290 // First instance of non-reassociative floating-point in the PHI's use-chain.
291 Instruction *ExactFPMathInst = nullptr;
292 // The type of the recurrence.
293 Type *RecurrenceType = nullptr;
294 // True if all source operands of the recurrence are SExtInsts.
295 bool IsSigned = false;
296 // True if this recurrence can be treated as an in-order reduction.
297 // Currently only a non-reassociative FAdd can be considered in-order,
298 // if it is also the only FAdd in the PHI's use chain.
299 bool IsOrdered = false;
300 // Instructions used for type-promoting the recurrence.
302 // The minimum width used by the recurrence.
303 unsigned MinWidthCastToRecurrenceType;
304};
305
306/// A struct for saving information about induction variables.
308public:
309 /// This enum represents the kinds of inductions that we support.
311 IK_NoInduction, ///< Not an induction variable.
312 IK_IntInduction, ///< Integer induction variable. Step = C.
313 IK_PtrInduction, ///< Pointer induction var. Step = C.
314 IK_FpInduction ///< Floating point induction variable.
315 };
316
317public:
318 /// Default constructor - creates an invalid induction.
320
321 Value *getStartValue() const { return StartValue; }
322 InductionKind getKind() const { return IK; }
323 const SCEV *getStep() const { return Step; }
324 BinaryOperator *getInductionBinOp() const { return InductionBinOp; }
326
327 /// Returns true if \p Phi is an induction in the loop \p L. If \p Phi is an
328 /// induction, the induction descriptor \p D will contain the data describing
329 /// this induction. Since Induction Phis can only be present inside loop
330 /// headers, the function will assert if it is passed a Phi whose parent is
331 /// not the loop header. If by some other means the caller has a better SCEV
332 /// expression for \p Phi than the one returned by the ScalarEvolution
333 /// analysis, it can be passed through \p Expr. If the def-use chain
334 /// associated with the phi includes casts (that we know we can ignore
335 /// under proper runtime checks), they are passed through \p CastsToIgnore.
336 static bool
337 isInductionPHI(PHINode *Phi, const Loop *L, ScalarEvolution *SE,
338 InductionDescriptor &D, const SCEV *Expr = nullptr,
339 SmallVectorImpl<Instruction *> *CastsToIgnore = nullptr);
340
341 /// Returns true if \p Phi is a floating point induction in the loop \p L.
342 /// If \p Phi is an induction, the induction descriptor \p D will contain
343 /// the data describing this induction.
344 static bool isFPInductionPHI(PHINode *Phi, const Loop *L, ScalarEvolution *SE,
346
347 /// Returns true if \p Phi is a loop \p L induction, in the context associated
348 /// with the run-time predicate of PSE. If \p Assume is true, this can add
349 /// further SCEV predicates to \p PSE in order to prove that \p Phi is an
350 /// induction.
351 /// If \p Phi is an induction, \p D will contain the data describing this
352 /// induction.
353 static bool isInductionPHI(PHINode *Phi, const Loop *L,
355 InductionDescriptor &D, bool Assume = false);
356
357 /// Returns floating-point induction operator that does not allow
358 /// reassociation (transforming the induction requires an override of normal
359 /// floating-point rules).
361 if (IK == IK_FpInduction && InductionBinOp &&
362 !InductionBinOp->hasAllowReassoc())
363 return InductionBinOp;
364 return nullptr;
365 }
366
367 /// Returns binary opcode of the induction operator.
369 return InductionBinOp ? InductionBinOp->getOpcode()
370 : Instruction::BinaryOpsEnd;
371 }
372
373 /// Returns a reference to the type cast instructions in the induction
374 /// update chain, that are redundant when guarded with a runtime
375 /// SCEV overflow check.
377 return RedundantCasts;
378 }
379
380private:
381 /// Private constructor - used by \c isInductionPHI.
382 InductionDescriptor(Value *Start, InductionKind K, const SCEV *Step,
383 BinaryOperator *InductionBinOp = nullptr,
384 SmallVectorImpl<Instruction *> *Casts = nullptr);
385
386 /// Start value.
387 TrackingVH<Value> StartValue;
388 /// Induction kind.
390 /// Step value.
391 const SCEV *Step = nullptr;
392 // Instruction that advances induction variable.
393 BinaryOperator *InductionBinOp = nullptr;
394 // Instructions used for type-casts of the induction variable,
395 // that are redundant when guarded with a runtime SCEV overflow check.
396 SmallVector<Instruction *, 2> RedundantCasts;
397};
398
399} // end namespace llvm
400
401#endif // LLVM_ANALYSIS_IVDESCRIPTORS_H
basic Basic Alias true
static GCRegistry::Add< StatepointGC > D("statepoint-example", "an example strategy for statepoint")
#define I(x, y, z)
Definition: MD5.cpp:58
This file implements a map that provides insertion order iteration.
This file defines the SmallPtrSet class.
This file defines the SmallVector class.
A cache of @llvm.assume calls within a function.
BinaryOps getOpcode() const
Definition: InstrTypes.h:391
This is the shared class of boolean and integer constants.
Definition: Constants.h:78
Concrete subclass of DominatorTreeBase that is used to compute a normal dominator tree.
Definition: Dominators.h:166
Convenience struct for specifying and reasoning about fast-math flags.
Definition: FMF.h:20
A struct for saving information about induction variables.
BinaryOperator * getInductionBinOp() const
InductionKind getKind() const
const SCEV * getStep() const
InductionKind
This enum represents the kinds of inductions that we support.
@ IK_NoInduction
Not an induction variable.
@ IK_FpInduction
Floating point induction variable.
@ IK_PtrInduction
Pointer induction var. Step = C.
@ IK_IntInduction
Integer induction variable. Step = C.
static bool isInductionPHI(PHINode *Phi, const Loop *L, ScalarEvolution *SE, InductionDescriptor &D, const SCEV *Expr=nullptr, SmallVectorImpl< Instruction * > *CastsToIgnore=nullptr)
Returns true if Phi is an induction in the loop L.
static bool isFPInductionPHI(PHINode *Phi, const Loop *L, ScalarEvolution *SE, InductionDescriptor &D)
Returns true if Phi is a floating point induction in the loop L.
Instruction::BinaryOps getInductionOpcode() const
Returns binary opcode of the induction operator.
const SmallVectorImpl< Instruction * > & getCastInsts() const
Returns a reference to the type cast instructions in the induction update chain, that are redundant w...
Value * getStartValue() const
Instruction * getExactFPMathInst()
Returns floating-point induction operator that does not allow reassociation (transforming the inducti...
InductionDescriptor()=default
Default constructor - creates an invalid induction.
ConstantInt * getConstIntStepValue() const
bool hasAllowReassoc() const LLVM_READONLY
Determine whether the allow-reassociation flag is set.
Represents a single loop in the control flow graph.
Definition: LoopInfo.h:47
An interface layer with SCEV used to manage how we see SCEV expressions for values in the context of ...
This POD struct holds information about a potential recurrence operation.
Definition: IVDescriptors.h:89
InstDesc(bool IsRecur, Instruction *I, Instruction *ExactFP=nullptr)
Definition: IVDescriptors.h:91
Instruction * getPatternInst() const
InstDesc(Instruction *I, RecurKind K, Instruction *ExactFP=nullptr)
Definition: IVDescriptors.h:95
Instruction * getExactFPMathInst() const
The RecurrenceDescriptor is used to identify recurrences variables in a loop.
Definition: IVDescriptors.h:72
static bool isFPMinMaxRecurrenceKind(RecurKind Kind)
Returns true if the recurrence kind is a floating-point min/max kind.
Instruction * getExactFPMathInst() const
Returns 1st non-reassociative FP instruction in the PHI node's use-chain.
static bool isFMulAddIntrinsic(Instruction *I)
Returns true if the instruction is a call to the llvm.fmuladd intrinsic.
FastMathFlags getFastMathFlags() const
static bool isFixedOrderRecurrence(PHINode *Phi, Loop *TheLoop, DominatorTree *DT)
Returns true if Phi is a fixed-order recurrence.
bool hasExactFPMath() const
Returns true if the recurrence has floating-point math that requires precise (ordered) operations.
Instruction * getLoopExitInstr() const
unsigned getOpcode() const
static bool hasMultipleUsesOf(Instruction *I, SmallPtrSetImpl< Instruction * > &Insts, unsigned MaxNumUses)
Returns true if instruction I has multiple uses in Insts.
static bool isReductionPHI(PHINode *Phi, Loop *TheLoop, RecurrenceDescriptor &RedDes, DemandedBits *DB=nullptr, AssumptionCache *AC=nullptr, DominatorTree *DT=nullptr, ScalarEvolution *SE=nullptr)
Returns true if Phi is a reduction in TheLoop.
RecurrenceDescriptor(Value *Start, Instruction *Exit, StoreInst *Store, RecurKind K, FastMathFlags FMF, Instruction *ExactFP, Type *RT, bool Signed, bool Ordered, SmallPtrSetImpl< Instruction * > &CI, unsigned MinWidthCastToRecurTy)
Definition: IVDescriptors.h:76
Type * getRecurrenceType() const
Returns the type of the recurrence.
const SmallPtrSet< Instruction *, 8 > & getCastInsts() const
Returns a reference to the instructions used for type-promoting the recurrence.
static bool areAllUsesIn(Instruction *I, SmallPtrSetImpl< Instruction * > &Set)
Returns true if all uses of the instruction I is within the Set.
unsigned getMinWidthCastToRecurrenceTypeInBits() const
Returns the minimum width used by the recurrence in bits.
TrackingVH< Value > getRecurrenceStartValue() const
SmallVector< Instruction *, 4 > getReductionOpChain(PHINode *Phi, Loop *L) const
Attempts to find a chain of operations from Phi to LoopExitInst that can be treated as a set of reduc...
static bool isAnyOfRecurrenceKind(RecurKind Kind)
Returns true if the recurrence kind is of the form select(cmp(),x,y) where one of (x,...
static InstDesc isAnyOfPattern(Loop *Loop, PHINode *OrigPhi, Instruction *I, InstDesc &Prev)
Returns a struct describing whether the instruction is either a Select(ICmp(A, B),...
bool isSigned() const
Returns true if all source operands of the recurrence are SExtInsts.
static InstDesc isConditionalRdxPattern(RecurKind Kind, Instruction *I)
Returns a struct describing if the instruction is a Select(FCmp(X, Y), (Z = X op PHINode),...
RecurKind getRecurrenceKind() const
bool isOrdered() const
Expose an ordered FP reduction to the instance users.
Value * getRecurrenceIdentity(RecurKind K, Type *Tp, FastMathFlags FMF) const
Returns identity corresponding to the RecurrenceKind.
StoreInst * IntermediateStore
Reductions may store temporary or final result to an invariant address.
static bool isFloatingPointRecurrenceKind(RecurKind Kind)
Returns true if the recurrence kind is a floating point kind.
static InstDesc isRecurrenceInstr(Loop *L, PHINode *Phi, Instruction *I, RecurKind Kind, InstDesc &Prev, FastMathFlags FuncFMF)
Returns a struct describing if the instruction 'I' can be a recurrence variable of type 'Kind' for a ...
static InstDesc isMinMaxPattern(Instruction *I, RecurKind Kind, const InstDesc &Prev)
Returns a struct describing if the instruction is a llvm.
static bool AddReductionVar(PHINode *Phi, RecurKind Kind, Loop *TheLoop, FastMathFlags FuncFMF, RecurrenceDescriptor &RedDes, DemandedBits *DB=nullptr, AssumptionCache *AC=nullptr, DominatorTree *DT=nullptr, ScalarEvolution *SE=nullptr)
Returns true if Phi is a reduction of type Kind and adds it to the RecurrenceDescriptor.
static bool isIntegerRecurrenceKind(RecurKind Kind)
Returns true if the recurrence kind is an integer kind.
static bool isIntMinMaxRecurrenceKind(RecurKind Kind)
Returns true if the recurrence kind is an integer min/max kind.
static bool isMinMaxRecurrenceKind(RecurKind Kind)
Returns true if the recurrence kind is any min/max kind.
This class represents an analyzed expression in the program.
The main scalar evolution driver.
A templated base class for SmallPtrSet which provides the typesafe interface that is common across al...
Definition: SmallPtrSet.h:345
iterator end() const
Definition: SmallPtrSet.h:409
iterator begin() const
Definition: SmallPtrSet.h:404
SmallPtrSet - This class implements a set which is optimized for holding SmallSize or less elements.
Definition: SmallPtrSet.h:451
This class consists of common code factored out of the SmallVector class to reduce code duplication b...
Definition: SmallVector.h:577
This is a 'vector' (really, a variable-sized array), optimized for the case when the array is small.
Definition: SmallVector.h:1200
An instruction for storing to memory.
Definition: Instructions.h:301
Value handle that tracks a Value across RAUW.
Definition: ValueHandle.h:331
The instances of the Type class are immutable: once they are created, they are never changed.
Definition: Type.h:45
LLVM Value Representation.
Definition: Value.h:74
This is an optimization pass for GlobalISel generic memory operations.
Definition: AddressRanges.h:18
RecurKind
These are the kinds of recurrences that we support.
Definition: IVDescriptors.h:35
@ UMin
Unsigned integer min implemented in terms of select(cmp()).
@ FAnyOf
Any_of reduction with select(fcmp(),x,y) where one of (x,y) is loop invariant, and both x and y are i...
@ Or
Bitwise or logical OR of integers.
@ FMinimum
FP min with llvm.minimum semantics.
@ Mul
Product of integers.
@ None
Not a recurrence.
@ Xor
Bitwise or logical XOR of integers.
@ FMax
FP max implemented in terms of select(cmp()).
@ FMaximum
FP max with llvm.maximum semantics.
@ FMulAdd
Sum of float products with llvm.fmuladd(a * b + sum).
@ FMul
Product of floats.
@ SMax
Signed integer max implemented in terms of select(cmp()).
@ And
Bitwise or logical AND of integers.
@ SMin
Signed integer min implemented in terms of select(cmp()).
@ FMin
FP min implemented in terms of select(cmp()).
@ Add
Sum of integers.
@ FAdd
Sum of floats.
@ IAnyOf
Any_of reduction with select(icmp(),x,y) where one of (x,y) is loop invariant, and both x and y are i...
@ UMax
Unsigned integer max implemented in terms of select(cmp()).