Go to the documentation of this file.
14 #ifndef LLVM_FRONTEND_OPENMP_OMPIRBUILDER_H
15 #define LLVM_FRONTEND_OPENMP_OMPIRBUILDER_H
21 #include <forward_list>
24 class CanonicalLoopInfo;
204 :
IP(IRB.saveIP()),
DL(IRB.getCurrentDebugLocation()) {}
226 bool ForceSimpleCall =
false,
227 bool CheckCancelFlag =
true);
237 omp::Directive CanceledDirective);
256 Value *NumThreads, omp::ProcBindKind ProcBind,
334 bool IsSigned,
bool InclusiveStop,
468 Value *Chunk =
nullptr);
506 llvm::omp::ScheduleKind SchedKind = llvm::omp::OMP_SCHEDULE_Default,
507 Value *ChunkSize =
nullptr,
bool HasSimdModifier =
false,
508 bool HasMonotonicModifier =
false,
bool HasNonmonotonicModifier =
false,
509 bool HasOrderedClause =
false);
554 std::vector<CanonicalLoopInfo *>
631 bool Tied =
true,
Value *Final =
nullptr);
655 ->isOpaqueOrPointeeTypeMatches(
ElementType) &&
"Invalid elem type");
743 bool IsNoWait =
false);
754 return Loc.
IP.getBlock() !=
nullptr;
772 unsigned Line,
unsigned Column,
788 unsigned Reserve2Flags = 0);
821 omp::Directive CanceledDirective,
834 omp::Directive DK,
bool ForceSimpleCall,
835 bool CheckCancelFlag);
840 void emitFlush(
const LocationDescription &Loc);
948 unsigned NumOperands);
1028 const Twine &
Name,
bool IsDependSource);
1087 bool BranchtoEnd =
true);
1138 Value *NumDependences,
1139 Value *DependenceAddress,
1140 bool HaveNowaitClause);
1154 Value *NumDependences,
1155 Value *DependenceAddress,
1156 bool HaveNowaitClause);
1170 Value *NumDependences,
Value *DependenceAddress,
1171 bool HaveNowaitClause);
1186 bool RequiresFullRuntime);
1194 bool RequiresFullRuntime);
1204 #define OMP_TYPE(VarName, InitValue) Type *VarName = nullptr;
1205 #define OMP_ARRAY_TYPE(VarName, ElemTy, ArraySize) \
1206 ArrayType *VarName##Ty = nullptr; \
1207 PointerType *VarName##PtrTy = nullptr;
1208 #define OMP_FUNCTION_TYPE(VarName, IsVarArg, ReturnType, ...) \
1209 FunctionType *VarName = nullptr; \
1210 PointerType *VarName##Ptr = nullptr;
1211 #define OMP_STRUCT_TYPE(VarName, StrName, ...) \
1212 StructType *VarName = nullptr; \
1213 PointerType *VarName##Ptr = nullptr;
1214 #include "llvm/Frontend/OpenMP/OMPKinds.def"
1221 void initializeTypes(
Module &
M);
1237 bool Conditional =
false);
1251 Instruction *ExitCall,
1252 bool HasFinalize =
true);
1272 EmitOMPInlinedRegion(omp::Directive OMPD, Instruction *EntryCall,
1275 bool HasFinalize =
true,
bool IsCancellable =
false);
1283 static std::string getNameWithSeparators(ArrayRef<StringRef> Parts,
1284 StringRef FirstSeparator,
1285 StringRef Separator);
1293 Constant *getOrCreateOMPInternalVariable(Type *Ty,
const Twine &
Name,
1301 Value *getOMPCriticalRegionLock(StringRef CriticalName);
1315 using AtomicUpdateCallbackTy =
1319 enum AtomicKind { Read, Write, Update, Capture, Compare };
1328 bool checkAndEmitFlushAfterAtomic(
const LocationDescription &Loc,
1355 std::pair<Value *, Value *>
1358 AtomicUpdateCallbackTy &UpdateOp,
bool VolatileX,
1464 bool IsPostfixUpdate,
bool IsXBinopExpr);
1515 bool IsXBinopExpr,
bool IsPostfixUpdate,
bool IsFailOnly);
1660 void setTripCount(
Value *TripCount);
1709 return cast<BranchInst>(
Cond->getTerminator())->getSuccessor(0);
1742 assert(isa<CmpInst>(CmpI) &&
"First inst must compare IV with TripCount");
1751 assert(isa<PHINode>(IndVarPHI) &&
"First inst must be the IV PHI");
1765 return {Preheader, std::prev(Preheader->
end())};
1772 return {Body, Body->
begin()};
1779 return {After, After->
begin()};
1797 #endif // LLVM_FRONTEND_OPENMP_OMPIRBUILDER_H
OpenMPIRBuilder::InsertPointTy getPreheaderIP() const
Return the insertion point for user code before the loop.
CallInst * createCachedThreadPrivate(const LocationDescription &Loc, llvm::Value *Pointer, llvm::ConstantInt *Size, const llvm::Twine &Name=Twine(""))
Create a runtime call for kmpc_threadprivate_cached.
void restoreIP(InsertPoint IP)
Sets the current insert point to a previously-saved location.
Description of a LLVM-IR insertion point (IP) and a debug/source location (filename,...
This is an optimization pass for GlobalISel generic memory operations.
InsertPointTy createSection(const LocationDescription &Loc, BodyGenCallbackTy BodyGenCB, FinalizeCallbackTy FiniCB)
Generator for '#omp section'.
InsertPointTy createCritical(const LocationDescription &Loc, BodyGenCallbackTy BodyGenCB, FinalizeCallbackTy FiniCB, StringRef CriticalName, Value *HintInst)
Generator for '#omp critical'.
BasicBlock * getAfter() const
The after block is intended for clean-up code such as lifetime end markers.
SmallVector< Value *, 2 > ExcludeArgsFromAggregate
const Function * getParent() const
Return the enclosing method, or null if none.
CanonicalLoopInfo * createLoopSkeleton(DebugLoc DL, Value *TripCount, Function *F, BasicBlock *PreInsertBefore, BasicBlock *PostInsertBefore, const Twine &Name={})
Create the control flow structure of a canonical OpenMP loop.
BasicBlock * getPreheader() const
The preheader ensures that there is only a single edge entering the loop.
void pushFinalizationCB(const FinalizationInfo &FI)
Push a finalization callback on the finalization stack.
Represents a single loop in the control flow graph.
CallInst * createOMPInteropUse(const LocationDescription &Loc, Value *InteropVar, Value *Device, Value *NumDependences, Value *DependenceAddress, bool HaveNowaitClause)
Create a runtime call for __tgt_interop_use.
BinOp
This enumeration lists the possible modifications atomicrmw can make.
This is a 'vector' (really, a variable-sized array), optimized for the case when the array is small.
std::vector< CanonicalLoopInfo * > tileLoops(DebugLoc DL, ArrayRef< CanonicalLoopInfo * > Loops, ArrayRef< Value * > TileSizes)
Tile a loop nest.
IRBuilder<>::InsertPoint InsertPointTy
Type used throughout for insertion points.
Value * getOrCreateThreadID(Value *Ident)
Return the current thread ID.
InsertPointTy createAtomicUpdate(const LocationDescription &Loc, InsertPointTy AllocaIP, AtomicOpValue &X, Value *Expr, AtomicOrdering AO, AtomicRMWInst::BinOp RMWOp, AtomicUpdateCallbackTy &UpdateOp, bool IsXBinopExpr)
Emit atomic update for constructs: X = X BinOp Expr ,or X = Expr BinOp X For complex Operations: X = ...
bool IsCancellable
Flag to indicate if the directive is cancellable.
The instances of the Type class are immutable: once they are created, they are never changed.
std::function< void(InsertPointTy AllocaIP, InsertPointTy CodeGenIP)> StorableBodyGenCallbackTy
a struct to pack relevant information while generating atomic Ops
FinalizeCallbackTy FiniCB
The finalization callback provided by the last in-flight invocation of createXXXX for the directive o...
OpenMPIRBuilder::InsertPointTy getAfterIP() const
Return the insertion point for user code after the loop.
const BasicBlock * getSingleSuccessor() const
Return the successor of this block if it has a single successor.
void spliceBB(IRBuilderBase::InsertPoint IP, BasicBlock *New, bool CreateBranch)
Move the instruction after an InsertPoint to the beginning of another BasicBlock.
InsertPointTy createSingle(const LocationDescription &Loc, BodyGenCallbackTy BodyGenCB, FinalizeCallbackTy FiniCB, bool IsNowait, llvm::Value *DidIt)
Generator for '#omp single'.
Value * Variable
Reduction variable of pointer type.
std::function< void(InsertPointTy CodeGenIP)> FinalizeCallbackTy
Callback type for variable finalization (think destructors).
Function * getFunction() const
void emitTaskyieldImpl(const LocationDescription &Loc)
Generate a taskyield runtime call.
InsertPointTy createReductions(const LocationDescription &Loc, InsertPointTy AllocaIP, ArrayRef< ReductionInfo > ReductionInfos, bool IsNoWait=false)
Generator for '#omp reduction'.
CanonicalLoopInfo * collapseLoops(DebugLoc DL, ArrayRef< CanonicalLoopInfo * > Loops, InsertPointTy ComputeIP)
Collapse a loop nest into a single loop.
InsertPointTy createTask(const LocationDescription &Loc, InsertPointTy AllocaIP, BodyGenCallbackTy BodyGenCB, bool Tied=true, Value *Final=nullptr)
Generator for #omp task
Instruction * getIndVar() const
Returns the instruction representing the current logical induction variable.
LLVM Basic Block Representation.
InsertPointTy createOrderedDepend(const LocationDescription &Loc, InsertPointTy AllocaIP, unsigned NumLoops, ArrayRef< llvm::Value * > StoreValues, const Twine &Name, bool IsDependSource)
Generator for '#omp ordered depend (source | sink)'.
This is the shared class of boolean and integer constants.
void popFinalizationCB()
Pop the last finalization callback from the finalization stack.
void emitMapperCall(const LocationDescription &Loc, Function *MapperFunc, Value *SrcLocInfo, Value *MaptypesArg, Value *MapnamesArg, struct MapperAllocas &MapperAllocas, int64_t DeviceID, unsigned NumOperands)
Create the call for the target mapper function.
Module & M
The underlying LLVM-IR module.
static GCRegistry::Add< CoreCLRGC > E("coreclr", "CoreCLR-compatible GC")
void assertOK() const
Consistency self-check.
BasicBlock * getCond() const
The condition block computes whether there is another loop iteration.
An interface to create LLVM-IR for OpenMP directives.
SmallVector< OutlineInfo, 16 > OutlineInfos
Collection of regions that need to be outlined during finalization.
CallInst * createOMPFree(const LocationDescription &Loc, Value *Addr, Value *Allocator, std::string Name="")
Create a runtime call for kmpc_free.
Constant * getOrCreateDefaultSrcLocStr(uint32_t &SrcLocStrSize)
Return the (LLVM-IR) string describing the default source location.
void emitOffloadingEntry(Constant *Addr, StringRef Name, uint64_t Size, int32_t Flags, StringRef SectionName="omp_offloading_entries")
Create an offloading section struct used to register this global at runtime.
iterator begin()
Instruction iterator methods.
void createMapperAllocas(const LocationDescription &Loc, InsertPointTy AllocaIP, unsigned NumOperands, struct MapperAllocas &MapperAllocas)
Create the allocas instruction used in call to mapper functions.
InsertPointTy createBarrier(const LocationDescription &Loc, omp::Directive DK, bool ForceSimpleCall=false, bool CheckCancelFlag=true)
Emitter methods for OpenMP directives.
InsertPointTy createAtomicRead(const LocationDescription &Loc, AtomicOpValue &X, AtomicOpValue &V, AtomicOrdering AO)
Emit atomic Read for : V = X — Only Scalar data types.
DenseMap< std::pair< Constant *, uint64_t >, Constant * > IdentMap
Map to remember existing ident_t*.
InsertPointTy getInsertionPoint()
}
void SetCurrentDebugLocation(DebugLoc L)
Set location information used by debugging information.
Class to represent integer types.
bool isValid() const
Returns whether this object currently represents the IR of a loop.
Constant * getOrCreateSrcLocStr(StringRef LocStr, uint32_t &SrcLocStrSize)
Return the (LLVM-IR) string describing the source location LocStr.
LocationDescription(const InsertPointTy &IP)
InsertPointTy createAtomicCompare(const LocationDescription &Loc, AtomicOpValue &X, AtomicOpValue &V, AtomicOpValue &R, Value *E, Value *D, AtomicOrdering AO, omp::OMPAtomicCompareOp Op, bool IsXBinopExpr, bool IsPostfixUpdate, bool IsFailOnly)
Emit atomic compare for constructs: — Only scalar data types cond-expr-stmt: x = x ordop expr ?...
BasicBlock * splitBBWithSuffix(IRBuilderBase &Builder, bool CreateBranch, llvm::Twine Suffix=".split")
Like splitBB, but reuses the current block's name for the new name.
void applySimd(DebugLoc DL, CanonicalLoopInfo *Loop)
Add metadata to simd-ize a loop.
LocationDescription(const InsertPointTy &IP, const DebugLoc &DL)
OpenMPIRBuilder::InsertPointTy getBodyIP() const
Return the insertion point for user code in the body.
IdentFlag
IDs for all omp runtime library ident_t flag encodings (see their defintion in openmp/runtime/src/kmp...
OpenMPIRBuilder(Module &M)
Create a new OpenMPIRBuilder operating on the given module M.
void unrollLoopFull(DebugLoc DL, CanonicalLoopInfo *Loop)
Fully unroll a loop.
void emitTaskwaitImpl(const LocationDescription &Loc)
Generate a taskwait runtime call.
CallInst * createOMPAlloc(const LocationDescription &Loc, Value *Size, Value *Allocator, std::string Name="")
Create a runtime call for kmpc_Alloc.
void addAttributes(omp::RuntimeFunction FnID, Function &Fn)
Add attributes known for FnID to Fn.
static GCMetadataPrinterRegistry::Add< ErlangGCPrinter > X("erlang", "erlang-compatible garbage collector")
StringMap - This is an unconventional map that is specialized for handling keys that are "strings",...
IRBuilder Builder
The LLVM-IR Builder used to create IR.
An efficient, type-erasing, non-owning reference to a callable.
RuntimeFunction
IDs for all omp runtime library (RTL) functions.
AtomicOrdering
Atomic ordering for LLVM's memory model.
void createTaskyield(const LocationDescription &Loc)
Generator for '#omp taskyield'.
GlobalVariable * createOffloadMaptypes(SmallVectorImpl< uint64_t > &Mappings, std::string VarName)
Create the global variable holding the offload mappings information.
InsertPointTy createSections(const LocationDescription &Loc, InsertPointTy AllocaIP, ArrayRef< StorableBodyGenCallbackTy > SectionCBs, PrivatizeCallbackTy PrivCB, FinalizeCallbackTy FiniCB, bool IsCancellable, bool IsNowait)
Generator for '#omp sections'.
CallInst * createOMPInteropDestroy(const LocationDescription &Loc, Value *InteropVar, Value *Device, Value *NumDependences, Value *DependenceAddress, bool HaveNowaitClause)
Create a runtime call for __tgt_interop_destroy.
This is an important base class in LLVM.
Value * PrivateVariable
Thread-private partial reduction variable.
InsertPointTy createOrderedThreadsSimd(const LocationDescription &Loc, BodyGenCallbackTy BodyGenCB, FinalizeCallbackTy FiniCB, bool IsThreads)
Generator for '#omp ordered [threads | simd]'.
Function * getFunction() const
Return the function that contains the region to be outlined.
static GCRegistry::Add< StatepointGC > D("statepoint-example", "an example strategy for statepoint")
LocationDescription(const IRBuilderBase &IRB)
Allocate memory in an ever growing pool, as if by bump-pointer.
bool isLastFinalizationInfoCancellable(omp::Directive DK)
Return true if the last entry in the finalization stack is of kind DK and cancellable.
omp::Directive DK
The directive kind of the innermost directive that has an associated region which might require final...
void emitCancelationCheckImpl(Value *CancelFlag, omp::Directive CanceledDirective, FinalizeCallbackTy ExitCB={})
Generate control flow and cleanup for cancellation.
CanonicalLoopInfo * createCanonicalLoop(const LocationDescription &Loc, LoopBodyGenCallbackTy BodyGenCB, Value *TripCount, const Twine &Name="loop")
Generator for the control flow structure of an OpenMP canonical loop.
InsertPointTy createTargetInit(const LocationDescription &Loc, bool IsSPMD, bool RequiresFullRuntime)
The omp target interface.
Constant * getOrCreateIdent(Constant *SrcLocStr, uint32_t SrcLocStrSize, omp::IdentFlag Flags=omp::IdentFlag(0), unsigned Reserve2Flags=0)
Return an ident_t* encoding the source location SrcLocStr and Flags.
IRBuilder ::InsertPoint createParallel(const LocationDescription &Loc, InsertPointTy AllocaIP, BodyGenCallbackTy BodyGenCB, PrivatizeCallbackTy PrivCB, FinalizeCallbackTy FiniCB, Value *IfCondition, Value *NumThreads, omp::ProcBindKind ProcBind, bool IsCancellable)
Generator for '#omp parallel'.
BasicBlock * OuterAllocaBB
void finalize(Function *Fn=nullptr)
Finalize the underlying module, e.g., by outlining regions.
assert(ImpDefSCC.getReg()==AMDGPU::SCC &&ImpDefSCC.isDef())
function_ref< InsertPointTy(InsertPointTy, Value *, Value *, Value *&)> ReductionGenTy
Functions used to generate reductions.
@ BasicBlock
Various leaf nodes.
print Print MemDeps of function
void unrollLoopHeuristic(DebugLoc DL, CanonicalLoopInfo *Loop)
Fully or partially unroll a loop.
Function * getOrCreateRuntimeFunctionPtr(omp::RuntimeFunction FnID)
A Module instance is used to store all the information related to an LLVM module.
InsertPointTy createMaster(const LocationDescription &Loc, BodyGenCallbackTy BodyGenCB, FinalizeCallbackTy FiniCB)
Generator for '#omp master'.
void createFlush(const LocationDescription &Loc)
Generator for '#omp flush'.
Helper that contains information about regions we need to outline during finalization.
Class to represented the control flow structure of an OpenMP canonical loop.
GlobalValue * createGlobalFlag(unsigned Value, StringRef Name)
Create a hidden global flag Name in the module with initial value Value.
CallInst * createOMPInteropInit(const LocationDescription &Loc, Value *InteropVar, omp::OMPInteropType InteropType, Value *Device, Value *NumDependences, Value *DependenceAddress, bool HaveNowaitClause)
Create a runtime call for __tgt_interop_init.
OMPAtomicCompareOp
Atomic compare operations. Currently OpenMP only supports ==, >, and <.
ArrayRef - Represent a constant reference to an array (0 or more elements consecutively in memory),...
SmallVector< MachineOperand, 4 > Cond
StringRef - Represent a constant reference to a string, i.e.
Type * getType() const
All values are typed, get the type of this value.
GlobalVariable * createOffloadMapnames(SmallVectorImpl< llvm::Constant * > &Names, std::string VarName)
Create the global variable holding the offload names information.
Common base class shared among various IRBuilders.
MachineBasicBlock MachineBasicBlock::iterator DebugLoc DL
Machine Check Debug Module
BasicBlock * splitBB(IRBuilderBase::InsertPoint IP, bool CreateBranch, llvm::Twine Name={})
Split a BasicBlock at an InsertPoint, even if the block is degenerate (missing the terminator).
PostOutlineCBTy PostOutlineCB
void unrollLoopPartial(DebugLoc DL, CanonicalLoopInfo *Loop, int32_t Factor, CanonicalLoopInfo **UnrolledCLI)
Partially unroll a loop.
void addOutlineInfo(OutlineInfo &&OI)
Add a new region that will be outlined later.
InsertPointTy createMasked(const LocationDescription &Loc, BodyGenCallbackTy BodyGenCB, FinalizeCallbackTy FiniCB, Value *Filter)
Generator for '#omp masked'.
bool updateToLocation(const LocationDescription &Loc)
Update the internal location to Loc.
SmallVector< FinalizationInfo, 8 > FinalizationStack
The finalization stack made up of finalize callbacks currently in-flight, wrapped into FinalizationIn...
const Instruction & front() const
BasicBlock * getExit() const
Reaching the exit indicates no more iterations are being executed.
std::forward_list< CanonicalLoopInfo > LoopInfos
Collection of owned canonical loop objects that eventually need to be free'd.
void createTaskwait(const LocationDescription &Loc)
Generator for '#omp taskwait'.
Twine - A lightweight data structure for efficiently representing the concatenation of temporary valu...
ReductionGenTy ReductionGen
Callback for generating the reduction body.
Type * ElementType
Reduction element type, must match pointee type of variable.
InsertPointTy createAtomicWrite(const LocationDescription &Loc, AtomicOpValue &X, Value *Expr, AtomicOrdering AO)
Emit atomic write for : X = Expr — Only Scalar data types.
InsertPointTy createAtomicCapture(const LocationDescription &Loc, InsertPointTy AllocaIP, AtomicOpValue &X, AtomicOpValue &V, Value *Expr, AtomicOrdering AO, AtomicRMWInst::BinOp RMWOp, AtomicUpdateCallbackTy &UpdateOp, bool UpdateExpr, bool IsPostfixUpdate, bool IsXBinopExpr)
Emit atomic update for constructs: — Only Scalar data types V = X; X = X BinOp Expr ,...
void invalidate()
Invalidate this loop.
InsertPointTy createCancel(const LocationDescription &Loc, Value *IfCondition, omp::Directive CanceledDirective)
Generator for '#omp cancel'.
std::function< void(Function &)> PostOutlineCBTy
BasicBlock * getHeader() const
The header is the entry for each iteration.
InsertPointTy applyWorkshareLoop(DebugLoc DL, CanonicalLoopInfo *CLI, InsertPointTy AllocaIP, bool NeedsBarrier, llvm::omp::ScheduleKind SchedKind=llvm::omp::OMP_SCHEDULE_Default, Value *ChunkSize=nullptr, bool HasSimdModifier=false, bool HasMonotonicModifier=false, bool HasNonmonotonicModifier=false, bool HasOrderedClause=false)
Modifies the canonical loop to be a workshare loop.
void createTargetDeinit(const LocationDescription &Loc, bool IsSPMD, bool RequiresFullRuntime)
Create a runtime call for kmpc_target_deinit.
Information about an OpenMP reduction.
InsertPoint saveIP() const
Returns the current insert point.
void initialize()
Initialize the internal state, this will put structures types and potentially other helpers into the ...
BasicBlock * getLatch() const
Reaching the latch indicates the end of the loop body code.
function_ref< void(InsertPointTy AllocaIP, InsertPointTy CodeGenIP)> BodyGenCallbackTy
Callback type for body (=inner region) code generation.
Type * getIndVarType() const
Return the type of the induction variable (and the trip count).
StringMap< Constant * > SrcLocStrMap
Map to remember source location strings.
InsertPointTy emitBarrierImpl(const LocationDescription &Loc, omp::Directive DK, bool ForceSimpleCall, bool CheckCancelFlag)
Generate a barrier runtime call.
StringMap< AssertingVH< Constant >, BumpPtrAllocator > InternalVars
An ordered map of auto-generated variables to their unique names.
A handy container for a FunctionType+Callee-pointer pair, which can be passed around as a single enti...
Value * getTripCount() const
Returns the llvm::Value containing the number of loop iterations.
A templated base class for SmallPtrSet which provides the typesafe interface that is common across al...
void emitFlush(const LocationDescription &Loc)
Generate a flush runtime call.
This class represents a function call, abstracting a target machine's calling convention.
void collectBlocks(SmallPtrSetImpl< BasicBlock * > &BlockSet, SmallVectorImpl< BasicBlock * > &BlockVector)
Collect all blocks in between EntryBB and ExitBB in both the given vector and set.
ReductionInfo(Type *ElementType, Value *Variable, Value *PrivateVariable, ReductionGenTy ReductionGen, AtomicReductionGenTy AtomicReductionGen)
an instruction to allocate memory on the stack
Value * getOperand(unsigned i) const
InsertPointTy createCopyinClauseBlocks(InsertPointTy IP, Value *MasterAddr, Value *PrivateAddr, llvm::IntegerType *IntPtrTy, bool BranchtoEnd=true)
Generate conditional branch and relevant BasicBlocks through which private threads copy the 'copyin' ...
InsertPointTy createCopyPrivate(const LocationDescription &Loc, llvm::Value *BufSize, llvm::Value *CpyBuf, llvm::Value *CpyFn, llvm::Value *DidIt)
Generator for __kmpc_copyprivate.
FunctionCallee getOrCreateRuntimeFunction(Module &M, omp::RuntimeFunction FnID)
Return the function declaration for the runtime function with FnID.
AtomicReductionGenTy AtomicReductionGen
Callback for generating the atomic reduction body, may be null.
BasicBlock * getBody() const
The body block is the single entry for a loop iteration and not controlled by CanonicalLoopInfo.
LLVM Value Representation.