25 :
User(ty,
Value::InstructionVal + it, Ops, NumOps), Parent(nullptr) {
30 assert(BB &&
"Instruction to insert before is not in a basic block!");
37 :
User(ty,
Value::InstructionVal + it, Ops, NumOps), Parent(nullptr) {
40 assert(InsertAtEnd &&
"Basic block to append to may not be NULL!");
45 assert(!Parent &&
"Instruction still linked in the program!");
46 if (hasMetadataHashEntry())
47 clearMetadataHashEntries();
96 assert(I == BB.
end() || I->getParent() == &BB);
109 cast<PossiblyExactOperator>(
this)->
setIsExact(b);
123 case Instruction::Sub:
124 case Instruction::Mul:
125 case Instruction::Shl:
130 case Instruction::UDiv:
131 case Instruction::SDiv:
132 case Instruction::AShr:
133 case Instruction::LShr:
134 cast<PossiblyExactOperator>(
this)->
setIsExact(
false);
137 case Instruction::GetElementPtr:
138 cast<GetElementPtrInst>(
this)->setIsInBounds(
false);
144 return cast<PossiblyExactOperator>(
this)->
isExact();
148 assert(isa<FPMathOperator>(
this) &&
"setting fast-math flag on invalid op");
149 cast<FPMathOperator>(
this)->
setFast(B);
153 assert(isa<FPMathOperator>(
this) &&
"setting fast-math flag on invalid op");
158 assert(isa<FPMathOperator>(
this) &&
"setting fast-math flag on invalid op");
163 assert(isa<FPMathOperator>(
this) &&
"setting fast-math flag on invalid op");
168 assert(isa<FPMathOperator>(
this) &&
"setting fast-math flag on invalid op");
173 assert(isa<FPMathOperator>(
this) &&
"setting fast-math flag on invalid op");
178 assert(isa<FPMathOperator>(
this) &&
"setting fast-math flag on invalid op");
183 assert(isa<FPMathOperator>(
this) &&
"setting fast-math flag on invalid op");
188 assert(isa<FPMathOperator>(
this) &&
"copying fast-math flag on invalid op");
193 assert(isa<FPMathOperator>(
this) &&
"getting fast-math flag on invalid op");
194 return cast<FPMathOperator>(
this)->
isFast();
198 assert(isa<FPMathOperator>(
this) &&
"getting fast-math flag on invalid op");
203 assert(isa<FPMathOperator>(
this) &&
"getting fast-math flag on invalid op");
204 return cast<FPMathOperator>(
this)->
hasNoNaNs();
208 assert(isa<FPMathOperator>(
this) &&
"getting fast-math flag on invalid op");
209 return cast<FPMathOperator>(
this)->
hasNoInfs();
213 assert(isa<FPMathOperator>(
this) &&
"getting fast-math flag on invalid op");
218 assert(isa<FPMathOperator>(
this) &&
"getting fast-math flag on invalid op");
223 assert(isa<FPMathOperator>(
this) &&
"getting fast-math flag on invalid op");
228 assert(isa<FPMathOperator>(
this) &&
"getting fast-math flag on invalid op");
233 assert(isa<FPMathOperator>(
this) &&
"getting fast-math flag on invalid op");
243 if (IncludeWrapFlags && isa<OverflowingBinaryOperator>(
this)) {
244 if (
auto *
OB = dyn_cast<OverflowingBinaryOperator>(V)) {
251 if (
auto *PE = dyn_cast<PossiblyExactOperator>(V))
252 if (isa<PossiblyExactOperator>(
this))
256 if (
auto *
FP = dyn_cast<FPMathOperator>(V))
257 if (isa<FPMathOperator>(
this))
260 if (
auto *SrcGEP = dyn_cast<GetElementPtrInst>(V))
261 if (
auto *DestGEP = dyn_cast<GetElementPtrInst>(
this))
262 DestGEP->setIsInBounds(SrcGEP->isInBounds() | DestGEP->isInBounds());
266 if (
auto *
OB = dyn_cast<OverflowingBinaryOperator>(V)) {
267 if (isa<OverflowingBinaryOperator>(
this)) {
273 if (
auto *PE = dyn_cast<PossiblyExactOperator>(V))
274 if (isa<PossiblyExactOperator>(
this))
277 if (
auto *
FP = dyn_cast<FPMathOperator>(V)) {
278 if (isa<FPMathOperator>(
this)) {
280 FM &=
FP->getFastMathFlags();
285 if (
auto *SrcGEP = dyn_cast<GetElementPtrInst>(V))
286 if (
auto *DestGEP = dyn_cast<GetElementPtrInst>(
this))
287 DestGEP->setIsInBounds(SrcGEP->isInBounds() & DestGEP->isInBounds());
293 case Ret:
return "ret";
294 case Br:
return "br";
295 case Switch:
return "switch";
296 case IndirectBr:
return "indirectbr";
297 case Invoke:
return "invoke";
298 case Resume:
return "resume";
299 case Unreachable:
return "unreachable";
300 case CleanupRet:
return "cleanupret";
301 case CatchRet:
return "catchret";
302 case CatchPad:
return "catchpad";
303 case CatchSwitch:
return "catchswitch";
304 case CallBr:
return "callbr";
307 case FNeg:
return "fneg";
310 case Add:
return "add";
311 case FAdd:
return "fadd";
312 case Sub:
return "sub";
313 case FSub:
return "fsub";
314 case Mul:
return "mul";
315 case FMul:
return "fmul";
316 case UDiv:
return "udiv";
317 case SDiv:
return "sdiv";
318 case FDiv:
return "fdiv";
319 case URem:
return "urem";
320 case SRem:
return "srem";
321 case FRem:
return "frem";
324 case And:
return "and";
325 case Or :
return "or";
326 case Xor:
return "xor";
329 case Alloca:
return "alloca";
330 case Load:
return "load";
331 case Store:
return "store";
332 case AtomicCmpXchg:
return "cmpxchg";
333 case AtomicRMW:
return "atomicrmw";
334 case Fence:
return "fence";
335 case GetElementPtr:
return "getelementptr";
338 case Trunc:
return "trunc";
339 case ZExt:
return "zext";
340 case SExt:
return "sext";
341 case FPTrunc:
return "fptrunc";
342 case FPExt:
return "fpext";
343 case FPToUI:
return "fptoui";
344 case FPToSI:
return "fptosi";
345 case UIToFP:
return "uitofp";
346 case SIToFP:
return "sitofp";
347 case IntToPtr:
return "inttoptr";
348 case PtrToInt:
return "ptrtoint";
349 case BitCast:
return "bitcast";
350 case AddrSpaceCast:
return "addrspacecast";
353 case ICmp:
return "icmp";
354 case FCmp:
return "fcmp";
355 case PHI:
return "phi";
356 case Select:
return "select";
357 case Call:
return "call";
358 case Shl:
return "shl";
359 case LShr:
return "lshr";
360 case AShr:
return "ashr";
361 case VAArg:
return "va_arg";
362 case ExtractElement:
return "extractelement";
363 case InsertElement:
return "insertelement";
364 case ShuffleVector:
return "shufflevector";
365 case ExtractValue:
return "extractvalue";
366 case InsertValue:
return "insertvalue";
367 case LandingPad:
return "landingpad";
368 case CleanupPad:
return "cleanuppad";
370 default:
return "<Invalid operator> ";
378 bool IgnoreAlignment =
false) {
380 "Can not compare special state of different instructions");
382 if (
const AllocaInst *AI = dyn_cast<AllocaInst>(I1))
383 return AI->getAllocatedType() == cast<AllocaInst>(I2)->getAllocatedType() &&
384 (AI->getAlignment() == cast<AllocaInst>(I2)->
getAlignment() ||
386 if (
const LoadInst *LI = dyn_cast<LoadInst>(I1))
387 return LI->isVolatile() == cast<LoadInst>(I2)->
isVolatile() &&
388 (LI->getAlignment() == cast<LoadInst>(I2)->
getAlignment() ||
390 LI->getOrdering() == cast<LoadInst>(I2)->getOrdering() &&
391 LI->getSyncScopeID() == cast<LoadInst>(I2)->getSyncScopeID();
393 return SI->isVolatile() == cast<StoreInst>(I2)->
isVolatile() &&
396 SI->getOrdering() == cast<StoreInst>(I2)->getOrdering() &&
397 SI->getSyncScopeID() == cast<StoreInst>(I2)->getSyncScopeID();
398 if (
const CmpInst *CI = dyn_cast<CmpInst>(I1))
399 return CI->getPredicate() == cast<CmpInst>(I2)->
getPredicate();
400 if (
const CallInst *CI = dyn_cast<CallInst>(I1))
401 return CI->isTailCall() == cast<CallInst>(I2)->isTailCall() &&
402 CI->getCallingConv() == cast<CallInst>(I2)->getCallingConv() &&
403 CI->getAttributes() == cast<CallInst>(I2)->
getAttributes() &&
404 CI->hasIdenticalOperandBundleSchema(*cast<CallInst>(I2));
405 if (
const InvokeInst *CI = dyn_cast<InvokeInst>(I1))
406 return CI->getCallingConv() == cast<InvokeInst>(I2)->getCallingConv() &&
408 CI->hasIdenticalOperandBundleSchema(*cast<InvokeInst>(I2));
409 if (
const CallBrInst *CI = dyn_cast<CallBrInst>(I1))
410 return CI->getCallingConv() == cast<CallBrInst>(I2)->getCallingConv() &&
412 CI->hasIdenticalOperandBundleSchema(*cast<CallBrInst>(I2));
414 return IVI->getIndices() == cast<InsertValueInst>(I2)->getIndices();
416 return EVI->getIndices() == cast<ExtractValueInst>(I2)->getIndices();
417 if (
const FenceInst *FI = dyn_cast<FenceInst>(I1))
418 return FI->getOrdering() == cast<FenceInst>(I2)->getOrdering() &&
419 FI->getSyncScopeID() == cast<FenceInst>(I2)->getSyncScopeID();
421 return CXI->isVolatile() == cast<AtomicCmpXchgInst>(I2)->
isVolatile() &&
422 CXI->isWeak() == cast<AtomicCmpXchgInst>(I2)->
isWeak() &&
423 CXI->getSuccessOrdering() ==
424 cast<AtomicCmpXchgInst>(I2)->getSuccessOrdering() &&
425 CXI->getFailureOrdering() ==
426 cast<AtomicCmpXchgInst>(I2)->getFailureOrdering() &&
427 CXI->getSyncScopeID() ==
428 cast<AtomicCmpXchgInst>(I2)->getSyncScopeID();
430 return RMWI->getOperation() == cast<AtomicRMWInst>(I2)->getOperation() &&
431 RMWI->isVolatile() == cast<AtomicRMWInst>(I2)->
isVolatile() &&
432 RMWI->getOrdering() == cast<AtomicRMWInst>(I2)->getOrdering() &&
433 RMWI->getSyncScopeID() == cast<AtomicRMWInst>(I2)->getSyncScopeID();
458 if (
const PHINode *thisPHI = dyn_cast<PHINode>(
this)) {
459 const PHINode *otherPHI = cast<PHINode>(
I);
460 return std::equal(thisPHI->block_begin(), thisPHI->block_end(),
470 unsigned flags)
const {
505 if (PN->getIncomingBlock(U) != BB)
513 default:
return false;
514 case Instruction::VAArg:
516 case Instruction::Fence:
517 case Instruction::AtomicCmpXchg:
518 case Instruction::AtomicRMW:
519 case Instruction::CatchPad:
520 case Instruction::CatchRet:
523 case Instruction::Invoke:
524 case Instruction::CallBr:
525 return !cast<CallBase>(
this)->doesNotAccessMemory();
527 return !cast<StoreInst>(
this)->isUnordered();
533 default:
return false;
534 case Instruction::Fence:
536 case Instruction::VAArg:
537 case Instruction::AtomicCmpXchg:
538 case Instruction::AtomicRMW:
539 case Instruction::CatchPad:
540 case Instruction::CatchRet:
543 case Instruction::Invoke:
544 case Instruction::CallBr:
545 return !cast<CallBase>(
this)->onlyReadsMemory();
547 return !cast<LoadInst>(
this)->isUnordered();
555 case Instruction::AtomicCmpXchg:
556 case Instruction::AtomicRMW:
557 case Instruction::Fence:
571 case Instruction::AtomicCmpXchg:
572 case Instruction::AtomicRMW:
583 case Instruction::AtomicCmpXchg:
584 case Instruction::AtomicRMW:
591 if (
const CallInst *CI = dyn_cast<CallInst>(
this))
592 return !CI->doesNotThrow();
593 if (
const auto *CRI = dyn_cast<CleanupReturnInst>(
this))
594 return CRI->unwindsToCaller();
595 if (
const auto *CatchSwitch = dyn_cast<CatchSwitchInst>(
this))
596 return CatchSwitch->unwindsToCaller();
597 return isa<ResumeInst>(
this);
610 return ID == Intrinsic::lifetime_start || ID == Intrinsic::lifetime_end;
615 if (!isa<DbgInfoIntrinsic>(
I))
622 if (!isa<DbgInfoIntrinsic>(
I))
644 #define HANDLE_TERM_INST(N, OPC, CLASS) \ 645 case Instruction::OPC: \ 646 return static_cast<const CLASS *>(this)->getNumSuccessors(); 647 #include "llvm/IR/Instruction.def" 656 #define HANDLE_TERM_INST(N, OPC, CLASS) \ 657 case Instruction::OPC: \ 658 return static_cast<const CLASS *>(this)->getSuccessor(idx); 659 #include "llvm/IR/Instruction.def" 668 #define HANDLE_TERM_INST(N, OPC, CLASS) \ 669 case Instruction::OPC: \ 670 return static_cast<CLASS *>(this)->setSuccessor(idx, B); 671 #include "llvm/IR/Instruction.def" 689 if (MDName->
getString() !=
"branch_weights")
705 for (
unsigned M : WL)
712 for (
const auto &MD : TheMDs) {
713 if (WL.empty() || WLS.
count(MD.first))
725 #define HANDLE_INST(num, opc, clas) \ 726 case Instruction::opc: \ 727 New = cast<clas>(this)->cloneImpl(); \ 729 #include "llvm/IR/Instruction.def" 740 if (ProfileData ==
nullptr)
744 if (!ProfDataName || (!ProfDataName->getString().equals(
"branch_weights") &&
745 !ProfDataName->getString().equals(
"VP")))
750 Vals.
push_back(ProfileData->getOperand(0));
751 APInt APS(128, S), APT(128, T);
752 if (ProfDataName->getString().equals(
"branch_weights"))
753 for (
unsigned i = 1; i < ProfileData->getNumOperands(); i++) {
756 mdconst::dyn_extract<ConstantInt>(ProfileData->getOperand(i))
762 Val.udiv(APT).getLimitedValue())));
764 else if (ProfDataName->getString().equals(
"VP"))
765 for (
unsigned i = 1; i < ProfileData->getNumOperands(); i += 2) {
767 Vals.
push_back(ProfileData->getOperand(i));
770 mdconst::dyn_extract<ConstantInt>(ProfileData->getOperand(i + 1))
776 Val.udiv(APT).getLimitedValue())));
782 assert(isa<CallBase>(
this) &&
783 "Can only set weights for call like instructions");
void getAllMetadataOtherThanDebugLoc(SmallVectorImpl< std::pair< unsigned, MDNode *>> &MDs) const
This does the same thing as getAllMetadata, except that it filters out the debug location.
SymbolTableList< Instruction >::iterator eraseFromParent()
This method unlinks 'this' from the containing basic block and deletes it.
bool hasNoInfs() const
Determine whether the no-infs flag is set.
void copyFastMathFlags(FastMathFlags FMF)
Convenience function for transferring all fast-math flag values to this instruction, which must be an operator which supports these flags.
This class is the base class for the comparison instructions.
const Instruction * getPrevNonDebugInstruction() const
Return a pointer to the previous non-debug instruction in the same basic block as 'this'...
void setFastMathFlags(FastMathFlags FMF)
Convenience function for setting multiple fast-math flags on this instruction, which must be an opera...
iterator_range< use_iterator > uses()
bool hasNoSignedZeros() const
Determine whether the no-signed-zeros flag is set.
bool isSameOperationAs(const Instruction *I, unsigned flags=0) const
This function determines if the specified instruction executes the same operation as the current one...
Instruction * getNextNode()
Get the next node, or nullptr for the list tail.
iterator erase(iterator where)
This class represents lattice values for constants.
bool isAtomic() const
Return true if this instruction has an AtomicOrdering of unordered or higher.
ConstantAsMetadata * createConstant(Constant *C)
Return the given constant as metadata.
A Module instance is used to store all the information related to an LLVM module. ...
BasicBlock * getSuccessor(unsigned Idx) const
Return the specified successor. This instruction must be a terminator.
An instruction for ordering other memory operations.
an instruction that atomically checks whether a specified value is in a memory location, and, if it is, stores a new value there.
void push_back(const T &Elt)
bool isSafeToRemove() const
Return true if the instruction can be removed if the result is unused.
void setProfWeight(uint64_t W)
Sets the branch_weights metadata to W for CallInst.
This class represents a function call, abstracting a target machine's calling convention.
void setHasNoNaNs(bool B)
Set or clear the no-nans flag on this instruction, which must be an operator which supports this flag...
bool mayWriteToMemory() const
Return true if this instruction may modify memory.
bool hasAtomicLoad() const
Return true if this atomic instruction loads from memory.
LLVMContext & getContext() const
All values hold a context through their type.
bool isTerminator() const
const MDOperand & getOperand(unsigned I) const
An instruction for reading from memory.
static IntegerType * getInt64Ty(LLVMContext &C)
an instruction that atomically reads a memory location, combines it with another value, and then stores the result back.
void setSuccessor(unsigned Idx, BasicBlock *BB)
Update the specified successor to point at the provided block.
void copyIRFlags(const Value *V, bool IncludeWrapFlags=true)
Convenience method to copy supported exact, fast-math, and (optionally) wrapping flags from V to this...
bool hasNoSignedWrap() const
Determine whether the no signed wrap flag is set.
Instruction * getPrevNode()
bool isIdenticalTo(const Instruction *I) const
Return true if the specified instruction is exactly identical to the current one. ...
bool hasAllowContract() const
Determine whether the allow-contract flag is set.
void setHasApproxFunc(bool B)
Set or clear the approximate-math-functions flag on this instruction, which must be an operator which...
const Module * getModule() const
Return the module owning the function this basic block belongs to, or nullptr if the function does no...
static uint32_t getAlignment(const MCSectionCOFF &Sec)
bool hasAllowReciprocal() const
Determine whether the allow-reciprocal flag is set.
A Use represents the edge between a Value definition and its users.
void dropPoisonGeneratingFlags()
Drops flags that may cause this instruction to evaluate to poison despite having non-poison inputs...
bool hasApproxFunc() const
Determine whether the approximate-math-functions flag is set.
bool hasMetadata() const
Return true if this instruction has any metadata attached to it.
Check for equivalence ignoring load/store alignment.
block_iterator block_begin()
AttributeList getAttributes(LLVMContext &C, ID id)
Return the attributes for an intrinsic.
Instruction * clone() const
Create a copy of 'this' instruction that is identical in all ways except the following: ...
FastMathFlags getFastMathFlags() const
Convenience function for getting all the fast-math flags, which must be an operator which supports th...
void setIsExact(bool b=true)
Set or clear the exact flag on this instruction, which must be an operator which supports this flag...
Type * getType() const
All values are typed, get the type of this value.
Check for equivalence treating a type and a vector of that type as equivalent.
LLVMContext & getContext() const
void andIRFlags(const Value *V)
Logical 'and' of any supported wrapping, exact, and fast-math flags of V and this instruction...
MDNode * getMetadata(unsigned KindID) const
Get the metadata of given kind attached to this Instruction.
unsigned getOpcode() const
Returns a member of one of the enums like Instruction::Add.
An instruction for storing to memory.
unsigned getNumSuccessors() const
Return the number of successors that this instruction has.
Value * getOperand(unsigned i) const
void setFast(bool B)
Set or clear all fast-math-flags on this instruction, which must be an operator which supports this f...
Type * getScalarType() const
If this is a vector type, return the element type, otherwise return 'this'.
AttributeSet getAttributes(unsigned Index) const
The attributes for the specified index are returned.
StringRef getString() const
static MDTuple * get(LLVMContext &Context, ArrayRef< Metadata *> MDs)
static GCRegistry::Add< OcamlGC > B("ocaml", "ocaml 3.10-compatible GC")
void setDebugLoc(DebugLoc Loc)
Set the debug location information for this instruction.
bool isIdenticalToWhenDefined(const Instruction *I) const
This is like isIdenticalTo, except that it ignores the SubclassOptionalData flags, which may specify conditions under which the instruction's result is undefined.
void insertBefore(Instruction *InsertPos)
Insert an unlinked instruction into a basic block immediately before the specified instruction...
LLVM Basic Block Representation.
The instances of the Type class are immutable: once they are created, they are never changed...
const char * getOpcodeName() const
static bool haveSameSpecialState(const Instruction *I1, const Instruction *I2, bool IgnoreAlignment=false)
Return true if both instructions have the same special state.
This file contains the declarations for the subclasses of Constant, which represent the different fla...
std::pair< iterator, bool > insert(const ValueT &V)
bool mayHaveSideEffects() const
Return true if the instruction may have side effects.
bool mayThrow() const
Return true if this instruction may throw an exception.
const Instruction * getNextNonDebugInstruction() const
Return a pointer to the next non-debug instruction in the same basic block as 'this', or nullptr if no such instruction exists.
bool isAssociative() const LLVM_READONLY
Return true if the instruction is associative:
bool isLifetimeStartOrEnd() const
Return true if the instruction is a llvm.lifetime.start or llvm.lifetime.end marker.
void splice(iterator where, iplist_impl &L2)
bool isFast() const
Determine whether all fast-math-flags are set.
self_iterator getIterator()
void setHasNoInfs(bool B)
Set or clear the no-infs flag on this instruction, which must be an operator which supports this flag...
const Function * getFunction() const
Return the function this instruction belongs to.
MDNode * createBranchWeights(uint32_t TrueWeight, uint32_t FalseWeight)
Return metadata containing two branch weights.
bool isExact() const
Determine whether the exact flag is set.
void swapProfMetadata()
If the instruction has "branch_weights" MD_prof metadata and the MDNode has three operands (including...
#define llvm_unreachable(msg)
Marks that the current location is not supposed to be reachable.
void setMetadata(unsigned KindID, MDNode *Node)
Set the metadata of the specified kind to the specified node.
unsigned char SubclassOptionalData
Hold subclass data that can be dropped.
CallBr instruction, tracking function calls that may not return control but instead transfer it to a ...
const InstListType & getInstList() const
Return the underlying instruction list container.
void setHasNoSignedWrap(bool b=true)
Set or clear the nsw flag on this instruction, which must be an operator which supports this flag...
Predicate getPredicate(unsigned Condition, unsigned Hint)
Return predicate consisting of specified condition and hint bits.
Iterator for intrusive lists based on ilist_node.
unsigned getNumOperands() const
void setHasAllowReassoc(bool B)
Set or clear the reassociation flag on this instruction, which must be an operator which supports thi...
This is a 'vector' (really, a variable-sized array), optimized for the case when the array is small...
bool isUsedOutsideOfBlock(const BasicBlock *BB) const
Return true if there are any uses of this instruction in blocks other than the specified block...
static 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.
const Module * getModule() const
Return the module owning the function this instruction belongs to or nullptr it the function does not...
Class for arbitrary precision integers.
void push_back(pointer val)
static bool isWeak(const MCSymbolELF &Sym)
void removeFromParent()
This method unlinks 'this' from the containing basic block, but does not delete it.
pointer remove(iterator &IT)
List that automatically updates parent links and symbol tables.
iterator insert(iterator where, pointer New)
const DebugLoc & getDebugLoc() const
Return the debug location for this node as a DebugLoc.
void updateProfWeight(uint64_t S, uint64_t T)
Updates branch_weights metadata by scaling it by S / T.
const Function * getParent() const
Return the enclosing method, or null if none.
void insertAfter(Instruction *InsertPos)
Insert an unlinked instruction into a basic block immediately after the specified instruction...
bool mayReadFromMemory() const
Return true if this instruction may read memory.
LLVM_NODISCARD std::enable_if<!is_simple_type< Y >::value, typename cast_retty< X, const Y >::ret_type >::type dyn_cast(const Y &Val)
size_type count(const_arg_type_t< ValueT > V) const
Return 1 if the specified key is in the set, 0 otherwise.
bool hasNoUnsignedWrap() const
Determine whether the no unsigned wrap flag is set.
Instruction(const Instruction &)=delete
void setHasNoUnsignedWrap(bool b=true)
Set or clear the nuw flag on this instruction, which must be an operator which supports this flag...
bool hasAtomicStore() const
Return true if this atomic instruction stores to memory.
assert(ImpDefSCC.getReg()==AMDGPU::SCC &&ImpDefSCC.isDef())
void moveAfter(Instruction *MovePos)
Unlink this instruction from its current basic block and insert it into the basic block that MovePos ...
LLVM Value Representation.
bool hasAllowReassoc() const
Determine whether the allow-reassociation flag is set.
void copyMetadata(const Instruction &SrcInst, ArrayRef< unsigned > WL=ArrayRef< unsigned >())
Copy metadata from SrcInst to this instruction.
void moveBefore(Instruction *MovePos)
Unlink this instruction from its current basic block and insert it into the basic block that MovePos ...
bool hasNoNaNs() const
Determine whether the no-NaNs flag is set.
Convenience struct for specifying and reasoning about fast-math flags.
static bool isVolatile(Instruction *Inst)
void setHasNoSignedZeros(bool B)
Set or clear the no-signed-zeros flag on this instruction, which must be an operator which supports t...
unsigned getNumOperands() const
Return number of MDNode operands.
iterator insertAfter(iterator where, pointer New)
void setHasAllowReciprocal(bool B)
Set or clear the allow-reciprocal flag on this instruction, which must be an operator which supports ...
A wrapper class for inspecting calls to intrinsic functions.
const BasicBlock * getParent() const
an instruction to allocate memory on the stack
This instruction inserts a struct field of array element value into an aggregate value.