27using namespace PatternMatch;
29#define DEBUG_TYPE "instcombine"
31STATISTIC(NumDeadStore,
"Number of dead stores eliminated");
32STATISTIC(NumGlobalCopies,
"Number of allocas copied from constant global");
35 "instcombine-max-copied-from-constant-users",
cl::init(300),
36 cl::desc(
"Maximum users to visit in copy from constant transform"),
42 cl::desc(
"Enable the InferAlignment pass, disabling alignment inference in "
65 while (!Worklist.
empty()) {
67 if (!Visited.
insert(Elem).second)
72 const auto [
Value, IsOffset] = Elem;
74 auto *
I = cast<Instruction>(U.getUser());
76 if (
auto *LI = dyn_cast<LoadInst>(
I)) {
78 if (!LI->isSimple())
return false;
82 if (isa<PHINode, SelectInst>(
I)) {
89 if (isa<BitCastInst, AddrSpaceCastInst>(
I)) {
94 if (
auto *
GEP = dyn_cast<GetElementPtrInst>(
I)) {
101 if (
auto *Call = dyn_cast<CallBase>(
I)) {
104 if (Call->isCallee(&U))
107 unsigned DataOpNo = Call->getDataOperandNo(&U);
108 bool IsArgOperand = Call->isArgOperand(&U);
111 if (IsArgOperand && Call->isInAllocaArgument(DataOpNo))
117 bool NoCapture = Call->doesNotCapture(DataOpNo);
118 if ((Call->onlyReadsMemory() && (Call->use_empty() || NoCapture)) ||
119 (Call->onlyReadsMemory(DataOpNo) && NoCapture))
124 if (IsArgOperand && Call->isByValArgument(DataOpNo))
129 if (
I->isLifetimeStartOrEnd()) {
130 assert(
I->use_empty() &&
"Lifetime markers have no result to use!");
142 if (
MI->isVolatile())
147 if (U.getOperandNo() == 1)
151 if (TheCopy)
return false;
155 if (IsOffset)
return false;
158 if (U.getOperandNo() != 0)
return false;
211 if (
C->getValue().getActiveBits() <= 64) {
223 while (isa<AllocaInst>(*It) || isa<DbgInfoIntrinsic>(*It))
233 NewTy, New,
Idx, New->getName() +
".sub");
268class PointerReplacer {
271 : IC(IC), Root(Root), FromAS(SrcAS) {}
274 void replacePointer(
Value *V);
281 return I == &Root || Worklist.contains(
I);
285 unsigned FromAS)
const {
286 const auto *ASC = dyn_cast<AddrSpaceCastInst>(
I);
289 unsigned ToAS = ASC->getDestAddressSpace();
290 return (FromAS == ToAS) || IC.isValidAddrSpaceCast(FromAS, ToAS);
302bool PointerReplacer::collectUsers() {
303 if (!collectUsersRecursive(Root))
309 for (
auto *Inst : ValuesToRevisit)
310 if (!Worklist.contains(Inst))
315bool PointerReplacer::collectUsersRecursive(
Instruction &
I) {
316 for (
auto *U :
I.users()) {
317 auto *Inst = cast<Instruction>(&*U);
318 if (
auto *Load = dyn_cast<LoadInst>(Inst)) {
319 if (
Load->isVolatile())
321 Worklist.insert(Load);
322 }
else if (
auto *
PHI = dyn_cast<PHINode>(Inst)) {
325 [](
Value *V) { return !isa<Instruction>(V); }))
332 return !isAvailable(cast<Instruction>(V));
334 ValuesToRevisit.insert(Inst);
338 Worklist.insert(
PHI);
339 if (!collectUsersRecursive(*
PHI))
341 }
else if (
auto *SI = dyn_cast<SelectInst>(Inst)) {
342 if (!isa<Instruction>(
SI->getTrueValue()) ||
343 !isa<Instruction>(
SI->getFalseValue()))
348 ValuesToRevisit.insert(Inst);
352 if (!collectUsersRecursive(*SI))
354 }
else if (isa<GetElementPtrInst, BitCastInst>(Inst)) {
355 Worklist.insert(Inst);
356 if (!collectUsersRecursive(*Inst))
358 }
else if (
auto *
MI = dyn_cast<MemTransferInst>(Inst)) {
359 if (
MI->isVolatile())
361 Worklist.insert(Inst);
362 }
else if (isEqualOrValidAddrSpaceCast(Inst, FromAS)) {
363 Worklist.insert(Inst);
364 }
else if (Inst->isLifetimeStartOrEnd()) {
367 LLVM_DEBUG(
dbgs() <<
"Cannot handle pointer user: " << *U <<
'\n');
375Value *PointerReplacer::getReplacement(
Value *V) {
return WorkMap.lookup(V); }
378 if (getReplacement(
I))
381 if (
auto *LT = dyn_cast<LoadInst>(
I)) {
382 auto *
V = getReplacement(
LT->getPointerOperand());
383 assert(V &&
"Operand not replaced");
384 auto *NewI =
new LoadInst(
LT->getType(), V,
"",
LT->isVolatile(),
385 LT->getAlign(),
LT->getOrdering(),
386 LT->getSyncScopeID());
390 IC.InsertNewInstWith(NewI,
LT->getIterator());
391 IC.replaceInstUsesWith(*LT, NewI);
393 }
else if (
auto *
PHI = dyn_cast<PHINode>(
I)) {
394 Type *NewTy = getReplacement(
PHI->getIncomingValue(0))->getType();
397 for (
unsigned int I = 0;
I <
PHI->getNumIncomingValues(); ++
I)
398 NewPHI->addIncoming(getReplacement(
PHI->getIncomingValue(
I)),
399 PHI->getIncomingBlock(
I));
400 WorkMap[
PHI] = NewPHI;
401 }
else if (
auto *
GEP = dyn_cast<GetElementPtrInst>(
I)) {
402 auto *
V = getReplacement(
GEP->getPointerOperand());
403 assert(V &&
"Operand not replaced");
408 IC.InsertNewInstWith(NewI,
GEP->getIterator());
411 }
else if (
auto *BC = dyn_cast<BitCastInst>(
I)) {
412 auto *
V = getReplacement(BC->getOperand(0));
413 assert(V &&
"Operand not replaced");
414 auto *NewT = PointerType::get(BC->getType()->getContext(),
415 V->getType()->getPointerAddressSpace());
417 IC.InsertNewInstWith(NewI, BC->getIterator());
420 }
else if (
auto *SI = dyn_cast<SelectInst>(
I)) {
422 SI->getCondition(), getReplacement(
SI->getTrueValue()),
423 getReplacement(
SI->getFalseValue()),
SI->getName(),
nullptr, SI);
424 IC.InsertNewInstWith(NewSI,
SI->getIterator());
427 }
else if (
auto *MemCpy = dyn_cast<MemTransferInst>(
I)) {
428 auto *SrcV = getReplacement(MemCpy->getRawSource());
432 assert(getReplacement(MemCpy->getRawDest()) &&
433 "destination not in replace list");
437 IC.Builder.SetInsertPoint(MemCpy);
438 auto *NewI = IC.Builder.CreateMemTransferInst(
439 MemCpy->getIntrinsicID(), MemCpy->getRawDest(), MemCpy->getDestAlign(),
440 SrcV, MemCpy->getSourceAlign(), MemCpy->getLength(),
441 MemCpy->isVolatile());
442 AAMDNodes AAMD = MemCpy->getAAMetadata();
444 NewI->setAAMetadata(AAMD);
446 IC.eraseInstFromFunction(*MemCpy);
447 WorkMap[MemCpy] = NewI;
448 }
else if (
auto *ASC = dyn_cast<AddrSpaceCastInst>(
I)) {
449 auto *
V = getReplacement(ASC->getPointerOperand());
450 assert(V &&
"Operand not replaced");
451 assert(isEqualOrValidAddrSpaceCast(
452 ASC,
V->getType()->getPointerAddressSpace()) &&
453 "Invalid address space cast!");
455 if (
V->getType()->getPointerAddressSpace() !=
456 ASC->getType()->getPointerAddressSpace()) {
459 IC.InsertNewInstWith(NewI, ASC->getIterator());
462 IC.replaceInstUsesWith(*ASC, NewV);
463 IC.eraseInstFromFunction(*ASC);
469void PointerReplacer::replacePointer(
Value *V) {
471 auto *PT = cast<PointerType>(Root.getType());
472 auto *
NT = cast<PointerType>(
V->getType());
473 assert(PT != NT &&
"Invalid usage");
500 if (FirstInst != &AI) {
504 AllocaInst *EntryAI = dyn_cast<AllocaInst>(FirstInst);
530 Value *TheSrc = Copy->getSource();
533 TheSrc, AllocaAlign,
DL, &AI, &
AC, &
DT);
534 if (AllocaAlign <= SourceAlign &&
536 !isa<Instruction>(TheSrc)) {
539 LLVM_DEBUG(
dbgs() <<
"Found alloca equal to global: " << AI <<
'\n');
552 PointerReplacer PtrReplacer(*
this, AI, SrcAddrSpace);
553 if (PtrReplacer.collectUsers()) {
557 PtrReplacer.replacePointer(TheSrc);
583 const Twine &Suffix) {
585 "can't fold an atomic load to requested type");
589 LI.isVolatile(),
LI.getName() + Suffix);
601 "can't fold an atomic store of requested type");
603 Value *
Ptr = SI.getPointerOperand();
605 SI.getAllMetadata(MD);
609 NewStore->
setAtomic(SI.getOrdering(), SI.getSyncScopeID());
610 for (
const auto &MDPair : MD) {
611 unsigned ID = MDPair.first;
622 case LLVMContext::MD_dbg:
623 case LLVMContext::MD_DIAssignID:
624 case LLVMContext::MD_tbaa:
625 case LLVMContext::MD_prof:
626 case LLVMContext::MD_fpmath:
627 case LLVMContext::MD_tbaa_struct:
628 case LLVMContext::MD_alias_scope:
629 case LLVMContext::MD_noalias:
630 case LLVMContext::MD_nontemporal:
631 case LLVMContext::MD_mem_parallel_loop_access:
632 case LLVMContext::MD_access_group:
636 case LLVMContext::MD_invariant_load:
637 case LLVMContext::MD_nonnull:
638 case LLVMContext::MD_noundef:
639 case LLVMContext::MD_range:
640 case LLVMContext::MD_align:
641 case LLVMContext::MD_dereferenceable:
642 case LLVMContext::MD_dereferenceable_or_null:
672 if (!Load.isUnordered())
675 if (Load.use_empty())
679 if (Load.getPointerOperand()->isSwiftError())
685 if (Load.hasOneUse()) {
688 Type *LoadTy = Load.getType();
689 if (
auto *BC = dyn_cast<BitCastInst>(Load.user_back())) {
691 if (BC->getType()->isX86_AMXTy())
695 if (
auto *CastUser = dyn_cast<CastInst>(Load.user_back())) {
696 Type *DestTy = CastUser->getDestTy();
720 if (!
T->isAggregateType())
725 if (
auto *ST = dyn_cast<StructType>(
T)) {
727 auto NumElements = ST->getNumElements();
728 if (NumElements == 1) {
739 auto *SL =
DL.getStructLayout(ST);
742 if (SL->getSizeInBits().isScalable())
745 if (SL->hasPadding())
754 for (
unsigned i = 0; i < NumElements; i++) {
755 Value *Indices[2] = {
762 ST->getElementType(i),
Ptr,
773 if (
auto *AT = dyn_cast<ArrayType>(
T)) {
774 auto *ET = AT->getElementType();
775 auto NumElements = AT->getNumElements();
776 if (NumElements == 1) {
800 for (
uint64_t i = 0; i < NumElements; i++) {
801 Value *Indices[2] = {
809 EltAlign,
Name +
".unpack");
835 P =
P->stripPointerCasts();
846 if (
PHINode *PN = dyn_cast<PHINode>(
P)) {
852 if (GA->isInterposable())
861 if (!AI->getAllocatedType()->isSized())
864 ConstantInt *CS = dyn_cast<ConstantInt>(AI->getArraySize());
868 TypeSize TS =
DL.getTypeAllocSize(AI->getAllocatedType());
880 if (!GV->hasDefinitiveInitializer() || !GV->isConstant())
883 uint64_t InitSize =
DL.getTypeAllocSize(GV->getValueType());
884 if (InitSize > MaxSize)
890 }
while (!Worklist.
empty());
922 if (
const ConstantInt *CI = dyn_cast<ConstantInt>(V))
934 Idx = FirstNZIdx(GEPI);
948 if (!AllocTy || !AllocTy->
isSized())
951 uint64_t TyAllocSize =
DL.getTypeAllocSize(AllocTy).getFixedValue();
957 auto IsAllNonNegative = [&]() {
1005 auto *
Ptr = SI.getPointerOperand();
1007 Ptr = GEPI->getOperand(0);
1008 return (isa<ConstantPointerNull>(
Ptr) &&
1014 const Value *GEPI0 = GEPI->getOperand(0);
1015 if (isa<ConstantPointerNull>(GEPI0) &&
1019 if (isa<UndefValue>(
Op) ||
1020 (isa<ConstantPointerNull>(
Op) &&
1039 if (KnownAlign >
LI.getAlign())
1040 LI.setAlignment(KnownAlign);
1053 bool IsLoadCSE =
false;
1060 LI.getName() +
".cast"));
1065 if (!
LI.isUnordered())
return nullptr;
1075 if (
Op->hasOneUse()) {
1088 Align Alignment =
LI.getAlign();
1090 Alignment,
DL, SI) &&
1092 Alignment,
DL, SI)) {
1095 SI->getOperand(1)->getName() +
".val");
1098 SI->getOperand(2)->getName() +
".val");
1099 assert(
LI.isUnordered() &&
"implied by above");
1102 V2->setAlignment(Alignment);
1103 V2->setAtomic(
LI.getOrdering(),
LI.getSyncScopeID());
1108 if (isa<ConstantPointerNull>(SI->getOperand(1)) &&
1110 LI.getPointerAddressSpace()))
1114 if (isa<ConstantPointerNull>(SI->getOperand(2)) &&
1116 LI.getPointerAddressSpace()))
1139 while (
auto *
IV = dyn_cast<InsertValueInst>(V)) {
1140 auto *
E = dyn_cast<ExtractElementInst>(
IV->getInsertedValueOperand());
1143 auto *W =
E->getVectorOperand();
1148 auto *CI = dyn_cast<ConstantInt>(
E->getIndexOperand());
1149 if (!CI ||
IV->getNumIndices() != 1 || CI->getZExtValue() != *
IV->idx_begin())
1151 V =
IV->getAggregateOperand();
1156 auto *UT = cast<VectorType>(U->getType());
1157 auto *VT = V->getType();
1160 if (
DL.getTypeStoreSizeInBits(UT) !=
DL.getTypeStoreSizeInBits(VT)) {
1163 if (
auto *AT = dyn_cast<ArrayType>(VT)) {
1164 if (AT->getNumElements() != cast<FixedVectorType>(UT)->getNumElements())
1167 auto *ST = cast<StructType>(VT);
1168 if (ST->getNumElements() != cast<FixedVectorType>(UT)->getNumElements())
1170 for (
const auto *EltT : ST->elements()) {
1171 if (EltT != UT->getElementType())
1201 if (!SI.isUnordered())
1205 if (SI.getPointerOperand()->isSwiftError())
1208 Value *V = SI.getValueOperand();
1211 if (
auto *BC = dyn_cast<BitCastInst>(V)) {
1212 assert(!BC->getType()->isX86_AMXTy() &&
1213 "store to x86_amx* should not happen!");
1214 V = BC->getOperand(0);
1217 if (V->getType()->isX86_AMXTy())
1242 Value *V = SI.getValueOperand();
1243 Type *
T = V->getType();
1245 if (!
T->isAggregateType())
1248 if (
auto *ST = dyn_cast<StructType>(
T)) {
1250 unsigned Count = ST->getNumElements();
1260 auto *SL =
DL.getStructLayout(ST);
1263 if (SL->getSizeInBits().isScalable())
1266 if (SL->hasPadding())
1269 const auto Align = SI.getAlign();
1273 auto *
Addr = SI.getPointerOperand();
1275 AddrName +=
".repack";
1279 for (
unsigned i = 0; i < Count; i++) {
1280 Value *Indices[2] = {
1295 if (
auto *AT = dyn_cast<ArrayType>(
T)) {
1297 auto NumElements = AT->getNumElements();
1298 if (NumElements == 1) {
1312 TypeSize EltSize =
DL.getTypeAllocSize(AT->getElementType());
1313 const auto Align = SI.getAlign();
1317 auto *
Addr = SI.getPointerOperand();
1319 AddrName +=
".repack";
1325 for (
uint64_t i = 0; i < NumElements; i++) {
1326 Value *Indices[2] = {
1355 if (
A ==
B)
return true;
1362 if (isa<BinaryOperator>(
A) ||
1365 isa<GetElementPtrInst>(
A))
1367 if (cast<Instruction>(
A)->isIdenticalToWhenDefined(BI))
1375 Value *Val = SI.getOperand(0);
1386 if (KnownAlign > SI.getAlign())
1387 SI.setAlignment(KnownAlign);
1400 if (!SI.isUnordered())
return nullptr;
1404 if (
Ptr->hasOneUse()) {
1405 if (isa<AllocaInst>(
Ptr))
1408 if (isa<AllocaInst>(
GEP->getOperand(0))) {
1409 if (
GEP->getOperand(0)->hasOneUse())
1425 for (
unsigned ScanInsts = 6; BBI != SI.getParent()->begin() && ScanInsts;
1430 if (BBI->isDebugOrPseudoInst()) {
1435 if (
StoreInst *PrevSI = dyn_cast<StoreInst>(BBI)) {
1437 if (PrevSI->isUnordered() &&
1439 PrevSI->getValueOperand()->getType() ==
1440 SI.getValueOperand()->getType()) {
1455 if (
LoadInst *
LI = dyn_cast<LoadInst>(BBI)) {
1457 assert(SI.isUnordered() &&
"can't eliminate ordering operation");
1467 if (BBI->mayWriteToMemory() || BBI->mayReadFromMemory() || BBI->mayThrow())
1474 if (!isa<PoisonValue>(Val))
1480 if (isa<UndefValue>(
Ptr)) {
1496 if (isa<UndefValue>(Val))
1508 if (!SI.isUnordered())
1519 if (*PredIter == StoreBB)
1525 if (StoreBB == DestBB || OtherBB == DestBB)
1530 BranchInst *OtherBr = dyn_cast<BranchInst>(BBI);
1531 if (!OtherBr || BBI == OtherBB->
begin())
1534 auto OtherStoreIsMergeable = [&](
StoreInst *OtherStore) ->
bool {
1536 OtherStore->getPointerOperand() != SI.getPointerOperand())
1539 auto *SIVTy = SI.getValueOperand()->getType();
1540 auto *OSVTy = OtherStore->getValueOperand()->getType();
1542 SI.hasSameSpecialState(OtherStore);
1551 while (BBI->isDebugOrPseudoInst()) {
1552 if (BBI==OtherBB->
begin())
1558 OtherStore = dyn_cast<StoreInst>(BBI);
1559 if (!OtherStoreIsMergeable(OtherStore))
1573 OtherStore = dyn_cast<StoreInst>(BBI);
1574 if (OtherStoreIsMergeable(OtherStore))
1579 if (BBI->mayReadFromMemory() || BBI->mayThrow() ||
1580 BBI->mayWriteToMemory() || BBI == OtherBB->
begin())
1588 if (
I->mayReadFromMemory() ||
I->mayThrow() ||
I->mayWriteToMemory())
1598 if (MergedVal != SI.getValueOperand()) {
1601 PN->
addIncoming(SI.getValueOperand(), SI.getParent());
1612 new StoreInst(MergedVal, SI.getOperand(1), SI.isVolatile(), SI.getAlign(),
1613 SI.getOrdering(), SI.getSyncScopeID());
MachineBasicBlock MachineBasicBlock::iterator DebugLoc DL
static GCRegistry::Add< OcamlGC > B("ocaml", "ocaml 3.10-compatible GC")
static GCRegistry::Add< ErlangGC > A("erlang", "erlang-compatible garbage collector")
static GCRegistry::Add< CoreCLRGC > E("coreclr", "CoreCLR-compatible GC")
Returns the sub type a function will return at a given Idx Should correspond to the result type of an ExtractValue instruction executed with just that one unsigned Idx
This file provides internal interfaces used to implement the InstCombine.
static StoreInst * combineStoreToNewValue(InstCombinerImpl &IC, StoreInst &SI, Value *V)
Combine a store to a new type.
static Instruction * combineLoadToOperationType(InstCombinerImpl &IC, LoadInst &Load)
Combine loads to match the type of their uses' value after looking through intervening bitcasts.
static Instruction * replaceGEPIdxWithZero(InstCombinerImpl &IC, Value *Ptr, Instruction &MemI)
static Instruction * simplifyAllocaArraySize(InstCombinerImpl &IC, AllocaInst &AI, DominatorTree &DT)
static bool canSimplifyNullStoreOrGEP(StoreInst &SI)
static bool equivalentAddressValues(Value *A, Value *B)
equivalentAddressValues - Test if A and B will obviously have the same value.
static bool canReplaceGEPIdxWithZero(InstCombinerImpl &IC, GetElementPtrInst *GEPI, Instruction *MemI, unsigned &Idx)
static bool canSimplifyNullLoadOrGEP(LoadInst &LI, Value *Op)
static bool isSupportedAtomicType(Type *Ty)
static bool isDereferenceableForAllocaSize(const Value *V, const AllocaInst *AI, const DataLayout &DL)
Returns true if V is dereferenceable for size of alloca.
static Instruction * unpackLoadToAggregate(InstCombinerImpl &IC, LoadInst &LI)
static cl::opt< unsigned > MaxCopiedFromConstantUsers("instcombine-max-copied-from-constant-users", cl::init(300), cl::desc("Maximum users to visit in copy from constant transform"), cl::Hidden)
static bool combineStoreToValueType(InstCombinerImpl &IC, StoreInst &SI)
Combine stores to match the type of value being stored.
static bool unpackStoreToAggregate(InstCombinerImpl &IC, StoreInst &SI)
static Value * likeBitCastFromVector(InstCombinerImpl &IC, Value *V)
Look for extractelement/insertvalue sequence that acts like a bitcast.
static bool isOnlyCopiedFromConstantMemory(AAResults *AA, AllocaInst *V, MemTransferInst *&TheCopy, SmallVectorImpl< Instruction * > &ToDelete)
isOnlyCopiedFromConstantMemory - Recursively walk the uses of a (derived) pointer to an alloca.
static bool isObjectSizeLessThanOrEq(Value *V, uint64_t MaxSize, const DataLayout &DL)
This file provides the interface for the instcombine pass implementation.
This file implements a map that provides insertion order iteration.
assert(ImpDefSCC.getReg()==AMDGPU::SCC &&ImpDefSCC.isDef())
This file defines the SmallString class.
This file defines the 'Statistic' class, which is designed to be an easy way to expose various metric...
#define STATISTIC(VARNAME, DESC)
static const uint32_t IV[8]
ModRefInfo getModRefInfoMask(const MemoryLocation &Loc, bool IgnoreLocals=false)
Returns a bitmask that should be unconditionally applied to the ModRef info of a memory location.
Class for arbitrary precision integers.
APInt zext(unsigned width) const
Zero extend to a new width.
This class represents a conversion between pointers from one address space to another.
an instruction to allocate memory on the stack
Align getAlign() const
Return the alignment of the memory that is being allocated by the instruction.
PointerType * getType() const
Overload to return most specific pointer type.
Type * getAllocatedType() const
Return the type that is being allocated by the instruction.
unsigned getAddressSpace() const
Return the address space for the allocation.
bool isArrayAllocation() const
Return true if there is an allocation size parameter to the allocation instruction that is not 1.
void setAlignment(Align Align)
const Value * getArraySize() const
Get the number of elements allocated.
ArrayRef - Represent a constant reference to an array (0 or more elements consecutively in memory),...
LLVM Basic Block Representation.
iterator begin()
Instruction iterator methods.
const_iterator getFirstInsertionPt() const
Returns an iterator to the first instruction in this block that is suitable for inserting a non-PHI i...
bool hasNPredecessors(unsigned N) const
Return true if this block has exactly N predecessors.
const Function * getParent() const
Return the enclosing method, or null if none.
const Instruction * getFirstNonPHIOrDbg(bool SkipPseudoOp=true) const
Returns a pointer to the first instruction in this block that is not a PHINode or a debug intrinsic,...
InstListType::iterator iterator
Instruction iterators...
const Instruction * getTerminator() const LLVM_READONLY
Returns the terminator instruction if the block is well formed or null if the block is not well forme...
This class represents a no-op cast from one type to another.
Conditional or Unconditional Branch instruction.
BasicBlock * getSuccessor(unsigned i) const
bool isUnconditional() const
static bool isBitOrNoopPointerCastable(Type *SrcTy, Type *DestTy, const DataLayout &DL)
Check whether a bitcast, inttoptr, or ptrtoint cast between these types is valid and a no-op.
This is the shared class of boolean and integer constants.
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 APInt & getValue() const
Return the constant as an APInt value reference.
static Constant * getNullValue(Type *Ty)
Constructor to create a '0' constant of arbitrary type.
static DILocation * getMergedLocation(DILocation *LocA, DILocation *LocB)
When two instructions are combined into a single instruction we also need to combine the original loc...
This class represents an Operation in the Expression.
A parsed version of the target data layout string in and methods for querying it.
IntegerType * getIndexType(LLVMContext &C, unsigned AddressSpace) const
Returns the type of a GEP index in AddressSpace.
TypeSize getTypeAllocSize(Type *Ty) const
Returns the offset in bytes between successive objects of the specified type, including alignment pad...
Align getPrefTypeAlign(Type *Ty) const
Returns the preferred stack/global alignment for the specified type.
Concrete subclass of DominatorTreeBase that is used to compute a normal dominator tree.
const BasicBlock & getEntryBlock() const
an instruction for type-safe pointer arithmetic to access elements of arrays and structs
bool isInBounds() const
Determine whether the GEP has the inbounds flag.
static GetElementPtrInst * CreateInBounds(Type *PointeeType, Value *Ptr, ArrayRef< Value * > IdxList, const Twine &NameStr="", Instruction *InsertBefore=nullptr)
Create an "inbounds" getelementptr.
static Type * getIndexedType(Type *Ty, ArrayRef< Value * > IdxList)
Returns the result type of a getelementptr with the given source element type and indexes.
Type * getSourceElementType() const
static GetElementPtrInst * Create(Type *PointeeType, Value *Ptr, ArrayRef< Value * > IdxList, const Twine &NameStr="", Instruction *InsertBefore=nullptr)
AllocaInst * CreateAlloca(Type *Ty, unsigned AddrSpace, Value *ArraySize=nullptr, const Twine &Name="")
Value * CreateInsertValue(Value *Agg, Value *Val, ArrayRef< unsigned > Idxs, const Twine &Name="")
LoadInst * CreateAlignedLoad(Type *Ty, Value *Ptr, MaybeAlign Align, const char *Name)
Value * CreateExtractValue(Value *Agg, ArrayRef< unsigned > Idxs, const Twine &Name="")
Value * CreateInBoundsGEP(Type *Ty, Value *Ptr, ArrayRef< Value * > IdxList, const Twine &Name="")
ConstantInt * getInt32(uint32_t C)
Get a constant 32-bit value.
Value * CreateBitOrPointerCast(Value *V, Type *DestTy, const Twine &Name="")
LoadInst * CreateLoad(Type *Ty, Value *Ptr, const char *Name)
Provided to resolve 'CreateLoad(Ty, Ptr, "...")' correctly, instead of converting the string to 'bool...
Value * CreateIntCast(Value *V, Type *DestTy, bool isSigned, const Twine &Name="")
void SetInsertPoint(BasicBlock *TheBB)
This specifies that created instructions should be appended to the end of the specified block.
StoreInst * CreateAlignedStore(Value *Val, Value *Ptr, MaybeAlign Align, bool isVolatile=false)
void handleUnreachableFrom(Instruction *I, SmallVectorImpl< BasicBlock * > &Worklist)
Instruction * visitLoadInst(LoadInst &LI)
void handlePotentiallyDeadBlocks(SmallVectorImpl< BasicBlock * > &Worklist)
Instruction * eraseInstFromFunction(Instruction &I) override
Combiner aware instruction erasure.
Instruction * visitStoreInst(StoreInst &SI)
bool mergeStoreIntoSuccessor(StoreInst &SI)
Try to transform: if () { *P = v1; } else { *P = v2 } or: *P = v1; if () { *P = v2; } into a phi node...
void CreateNonTerminatorUnreachable(Instruction *InsertAt)
Create and insert the idiom we use to indicate a block is unreachable without having to rewrite the C...
bool removeInstructionsBeforeUnreachable(Instruction &I)
LoadInst * combineLoadToNewType(LoadInst &LI, Type *NewTy, const Twine &Suffix="")
Helper to combine a load to a new type.
Instruction * visitAllocSite(Instruction &FI)
Instruction * visitAllocaInst(AllocaInst &AI)
const DataLayout & getDataLayout() const
Instruction * InsertNewInstBefore(Instruction *New, BasicBlock::iterator Old)
Inserts an instruction New before instruction Old.
Instruction * replaceInstUsesWith(Instruction &I, Value *V)
A combiner-aware RAUW-like routine.
uint64_t MaxArraySizeForCombine
Maximum size of array considered when transforming.
InstructionWorklist & Worklist
A worklist of the instructions that need to be simplified.
Instruction * replaceOperand(Instruction &I, unsigned OpNum, Value *V)
Replace operand of instruction and add old operand to the worklist.
void computeKnownBits(const Value *V, KnownBits &Known, unsigned Depth, const Instruction *CxtI) const
void push(Instruction *I)
Push the instruction onto the worklist stack.
Instruction * clone() const
Create a copy of 'this' instruction that is identical in all ways except the following:
void mergeDIAssignID(ArrayRef< const Instruction * > SourceInstructions)
Merge the DIAssignID metadata from this instruction and those attached to instructions in SourceInstr...
const DebugLoc & getDebugLoc() const
Return the debug location for this node as a DebugLoc.
void setAAMetadata(const AAMDNodes &N)
Sets the AA metadata on this instruction from the AAMDNodes structure.
const BasicBlock * getParent() const
const Function * getFunction() const
Return the function this instruction belongs to.
BasicBlock * getSuccessor(unsigned Idx) const LLVM_READONLY
Return the specified successor. This instruction must be a terminator.
void setMetadata(unsigned KindID, MDNode *Node)
Set the metadata of the specified kind to the specified node.
AAMDNodes getAAMetadata() const
Returns the AA metadata for this instruction.
void setDebugLoc(DebugLoc Loc)
Set the debug location information for this instruction.
void moveBefore(Instruction *MovePos)
Unlink this instruction from its current basic block and insert it into the basic block that MovePos ...
An instruction for reading from memory.
unsigned getPointerAddressSpace() const
Returns the address space of the pointer operand.
void setAlignment(Align Align)
Value * getPointerOperand()
void setAtomic(AtomicOrdering Ordering, SyncScope::ID SSID=SyncScope::System)
Sets the ordering constraint and the synchronization scope ID of this load instruction.
Align getAlign() const
Return the alignment of the access that is being performed.
This class implements a map that also provides access to all stored values in a deterministic order.
This class wraps the llvm.memcpy/memmove intrinsics.
void addIncoming(Value *V, BasicBlock *BB)
Add an incoming value to the end of the PHI list.
static PHINode * Create(Type *Ty, unsigned NumReservedValues, const Twine &NameStr="", Instruction *InsertBefore=nullptr)
Constructors - NumReservedValues is a hint for the number of incoming edges that this phi node will h...
PointerIntPair - This class implements a pair of a pointer and small integer.
static PoisonValue * get(Type *T)
Static factory methods - Return an 'poison' object of the specified type.
This class represents the LLVM 'select' instruction.
static SelectInst * Create(Value *C, Value *S1, Value *S2, const Twine &NameStr="", Instruction *InsertBefore=nullptr, Instruction *MDFrom=nullptr)
std::pair< iterator, bool > insert(PtrType Ptr)
Inserts Ptr if and only if there is no element in the container equal to Ptr.
SmallPtrSet - This class implements a set which is optimized for holding SmallSize or less elements.
A SetVector that performs no allocations if smaller than a certain size.
SmallString - A SmallString is just a SmallVector with methods and accessors that make it work better...
This class consists of common code factored out of the SmallVector class to reduce code duplication b...
reference emplace_back(ArgTypes &&... Args)
void append(ItTy in_start, ItTy in_end)
Add the specified range to the end of the SmallVector.
void push_back(const T &Elt)
This is a 'vector' (really, a variable-sized array), optimized for the case when the array is small.
An instruction for storing to memory.
Value * getValueOperand()
void setAtomic(AtomicOrdering Ordering, SyncScope::ID SSID=SyncScope::System)
Sets the ordering constraint and the synchronization scope ID of this store instruction.
StringRef - Represent a constant reference to a string, i.e.
Twine - A lightweight data structure for efficiently representing the concatenation of temporary valu...
static constexpr TypeSize get(ScalarTy Quantity, bool Scalable)
The instances of the Type class are immutable: once they are created, they are never changed.
unsigned getPointerAddressSpace() const
Get the address space of this pointer or pointer vector type.
bool isSized(SmallPtrSetImpl< Type * > *Visited=nullptr) const
Return true if it makes sense to take the size of this type.
bool isFloatingPointTy() const
Return true if this is one of the floating-point types.
bool isPtrOrPtrVectorTy() const
Return true if this is a pointer type or a vector of pointer types.
bool isX86_AMXTy() const
Return true if this is X86 AMX.
bool isScalableTy() const
Return true if this is a type whose size is a known multiple of vscale.
bool isIntOrPtrTy() const
Return true if this is an integer type or a pointer type.
static IntegerType * getInt32Ty(LLVMContext &C)
static IntegerType * getInt64Ty(LLVMContext &C)
bool isIntegerTy() const
True if this is an instance of IntegerType.
void setOperand(unsigned i, Value *Val)
Value * getOperand(unsigned i) const
unsigned getNumOperands() const
LLVM Value Representation.
Type * getType() const
All values are typed, get the type of this value.
void replaceAllUsesWith(Value *V)
Change all uses of this to point to a new Value.
iterator_range< use_iterator > uses()
StringRef getName() const
Return a constant reference to the value's name.
constexpr ScalarTy getFixedValue() const
constexpr bool isScalable() const
Returns whether the quantity is scaled by a runtime quantity (vscale).
constexpr ScalarTy getKnownMinValue() const
Returns the minimum value this quantity can represent.
self_iterator getIterator()
#define llvm_unreachable(msg)
Marks that the current location is not supposed to be reachable.
@ C
The default llvm calling convention, compatible with C.
bool match(Val *V, const Pattern &P)
auto m_Undef()
Match an arbitrary undef constant.
initializer< Ty > init(const Ty &Val)
This is an optimization pass for GlobalISel generic memory operations.
bool isDereferenceableAndAlignedPointer(const Value *V, Type *Ty, Align Alignment, const DataLayout &DL, const Instruction *CtxI=nullptr, AssumptionCache *AC=nullptr, const DominatorTree *DT=nullptr, const TargetLibraryInfo *TLI=nullptr)
Returns true if V is always a dereferenceable pointer with alignment greater or equal than requested.
void copyMetadataForLoad(LoadInst &Dest, const LoadInst &Source)
Copy the metadata from the source instruction to the destination (the replacement for the source inst...
void append_range(Container &C, Range &&R)
Wrapper function to append range R to container C.
Value * FindAvailableLoadedValue(LoadInst *Load, BasicBlock *ScanBB, BasicBlock::iterator &ScanFrom, unsigned MaxInstsToScan=DefMaxInstsToScan, AAResults *AA=nullptr, bool *IsLoadCSE=nullptr, unsigned *NumScanedInst=nullptr)
Scan backwards to see if we have the value of the given load available locally within a small number ...
bool any_of(R &&range, UnaryPredicate P)
Provide wrappers to std::any_of which take ranges instead of having to pass begin/end explicitly.
Align getOrEnforceKnownAlignment(Value *V, MaybeAlign PrefAlign, const DataLayout &DL, const Instruction *CxtI=nullptr, AssumptionCache *AC=nullptr, const DominatorTree *DT=nullptr)
Try to ensure that the alignment of V is at least PrefAlign bytes.
bool isModSet(const ModRefInfo MRI)
bool NullPointerIsDefined(const Function *F, unsigned AS=0)
Check whether null pointer dereferencing is considered undefined behavior for a given function or an ...
raw_ostream & dbgs()
dbgs() - This returns a reference to a raw_ostream for debugging messages.
Interval::pred_iterator pred_begin(Interval *I)
pred_begin/pred_end - define methods so that Intervals may be used just like BasicBlocks can with the...
bool replaceAllDbgUsesWith(Instruction &From, Value &To, Instruction &DomPoint, DominatorTree &DT)
Point debug users of From to To or salvage them.
Value * simplifyLoadInst(LoadInst *LI, Value *PtrOp, const SimplifyQuery &Q)
Given a load instruction and its pointer operand, fold the result or return null.
void combineMetadataForCSE(Instruction *K, const Instruction *J, bool DoesKMove)
Combine the metadata of two instructions so that K can replace J.
cl::opt< bool > EnableInferAlignmentPass
void replace(Container &Cont, typename Container::iterator ContIt, typename Container::iterator ContEnd, RandomAccessIterator ValIt, RandomAccessIterator ValEnd)
Given a sequence container Cont, replace the range [ContIt, ContEnd) with the range [ValIt,...
Align commonAlignment(Align A, uint64_t Offset)
Returns the alignment that satisfies both alignments.
bool isSafeToLoadUnconditionally(Value *V, Align Alignment, APInt &Size, const DataLayout &DL, Instruction *ScanFrom=nullptr, AssumptionCache *AC=nullptr, const DominatorTree *DT=nullptr, const TargetLibraryInfo *TLI=nullptr)
Return true if we know that executing a load from this value cannot trap.
A collection of metadata nodes that might be associated with a memory access used by the alias-analys...
AAMDNodes merge(const AAMDNodes &Other) const
Given two sets of AAMDNodes applying to potentially different locations, determine the best AAMDNodes...
This struct is a compact representation of a valid (non-zero power of two) alignment.
bool isNonNegative() const
Returns true if this value is known to be non-negative.
SimplifyQuery getWithInstruction(const Instruction *I) const