74#define DEBUG_TYPE "globalopt"
76STATISTIC(NumMarked ,
"Number of globals marked constant");
77STATISTIC(NumUnnamed ,
"Number of globals marked unnamed_addr");
78STATISTIC(NumSRA ,
"Number of aggregate globals broken into scalars");
79STATISTIC(NumSubstitute,
"Number of globals with initializers stored into them");
81STATISTIC(NumGlobUses ,
"Number of global uses devirtualized");
82STATISTIC(NumLocalized ,
"Number of globals localized");
83STATISTIC(NumShrunkToBool ,
"Number of global vars shrunk to booleans");
84STATISTIC(NumFastCallFns ,
"Number of functions converted to fastcc");
85STATISTIC(NumCtorsEvaluated,
"Number of static ctors evaluated");
86STATISTIC(NumNestRemoved ,
"Number of nest attributes removed");
87STATISTIC(NumAliasesResolved,
"Number of global aliases resolved");
88STATISTIC(NumAliasesRemoved,
"Number of global aliases eliminated");
89STATISTIC(NumCXXDtorsRemoved,
"Number of global C++ destructors removed");
90STATISTIC(NumAtExitRemoved,
"Number of atexit handlers removed");
91STATISTIC(NumInternalFunc,
"Number of internal functions");
92STATISTIC(NumColdCC,
"Number of functions marked coldcc");
93STATISTIC(NumIFuncsResolved,
"Number of statically resolved IFuncs");
94STATISTIC(NumIFuncsDeleted,
"Number of IFuncs removed");
98 cl::desc(
"Enable stress test of coldcc by adding "
99 "calling conv to all internal functions."),
105 "Maximum block frequency, expressed as a percentage of caller's "
106 "entry frequency, for a call site to be considered cold for enabling"
128 Type *Ty = Types.pop_back_val();
135 if (cast<VectorType>(Ty)->getElementType()->
isPointerTy())
139 Types.push_back(cast<ArrayType>(Ty)->getElementType());
145 if (isa<PointerType>(InnerTy))
return true;
146 if (isa<StructType>(InnerTy) || isa<ArrayType>(InnerTy) ||
147 isa<VectorType>(InnerTy))
148 Types.push_back(InnerTy);
153 if (--Limit == 0)
return true;
154 }
while (!Types.empty());
164 if (isa<Constant>(V))
168 if (isa<LoadInst>(V) || isa<InvokeInst>(V) || isa<Argument>(V) ||
175 if (
I->mayHaveSideEffects())
178 if (!
GEP->hasAllConstantIndices())
180 }
else if (
I->getNumOperands() != 1) {
184 V =
I->getOperand(0);
203 bool Changed =
false;
211 while (!Worklist.
empty()) {
213 if (
StoreInst *SI = dyn_cast<StoreInst>(U)) {
214 Value *V = SI->getValueOperand();
215 if (isa<Constant>(V)) {
217 SI->eraseFromParent();
220 Dead.push_back(std::make_pair(
I, SI));
222 }
else if (
MemSetInst *MSI = dyn_cast<MemSetInst>(U)) {
223 if (isa<Constant>(MSI->getValue())) {
225 MSI->eraseFromParent();
226 }
else if (
Instruction *
I = dyn_cast<Instruction>(MSI->getValue())) {
228 Dead.push_back(std::make_pair(
I, MSI));
231 GlobalVariable *MemSrc = dyn_cast<GlobalVariable>(MTI->getSource());
234 MTI->eraseFromParent();
235 }
else if (
Instruction *
I = dyn_cast<Instruction>(MTI->getSource())) {
237 Dead.push_back(std::make_pair(
I, MTI));
239 }
else if (
ConstantExpr *CE = dyn_cast<ConstantExpr>(U)) {
240 if (isa<GEPOperator>(CE))
245 for (
int i = 0, e = Dead.size(); i != e; ++i) {
247 Dead[i].second->eraseFromParent();
252 Instruction *J = dyn_cast<Instruction>(
I->getOperand(0));
255 I->eraseFromParent();
258 I->eraseFromParent();
275 bool Changed =
false;
280 if (
auto *OpI = dyn_cast<Instruction>(
Op))
282 I->eraseFromParent();
285 while (!WorkList.
empty()) {
287 if (!Visited.
insert(U).second)
290 if (
auto *BO = dyn_cast<BitCastOperator>(U))
292 if (
auto *ASC = dyn_cast<AddrSpaceCastOperator>(U))
294 else if (
auto *
GEP = dyn_cast<GEPOperator>(U))
296 else if (
auto *LI = dyn_cast<LoadInst>(U)) {
299 Type *Ty = LI->getType();
301 LI->replaceAllUsesWith(Res);
306 Value *PtrOp = LI->getPointerOperand();
311 if (
II->getIntrinsicID() == Intrinsic::threadlocal_address)
312 PtrOp =
II->getArgOperand(0);
316 LI->replaceAllUsesWith(
Value);
320 }
else if (
StoreInst *SI = dyn_cast<StoreInst>(U)) {
327 if (
II->getIntrinsicID() == Intrinsic::threadlocal_address)
353 auto AppendUses = [&](
Value *V) {
354 for (
Use &U : V->uses())
355 if (Visited.
insert(&U).second)
359 while (!Worklist.
empty()) {
361 User *V = U->getUser();
363 auto *
GEP = dyn_cast<GEPOperator>(V);
364 if (isa<BitCastOperator>(V) || isa<AddrSpaceCastOperator>(V) ||
365 (
GEP &&
GEP->hasAllConstantIndices())) {
373 if (isa<StoreInst>(V) && U->getOperandNo() == 0)
379 if (
Ptr != GV ||
Offset.getActiveBits() >= 64)
385 const auto &[It, Inserted] =
387 if (Ty != It->second.Ty)
391 It->second.Initializer =
393 if (!It->second.Initializer) {
394 LLVM_DEBUG(
dbgs() <<
"Global SRA: Failed to evaluate initializer of "
395 << *GV <<
" with type " << *Ty <<
" at offset "
396 <<
Offset.getZExtValue());
406 auto *SI = dyn_cast<StoreInst>(V);
410 Constant *StoredConst = dyn_cast<Constant>(SI->getOperand(0));
415 return Initializer != StoredConst;
418 It->second.IsLoaded |= isa<LoadInst>(V);
419 It->second.IsStored |= IsStored(V, It->second.Initializer);
424 if (
auto *
C = dyn_cast<Constant>(V)) {
444 for (
auto *GVE : GVs) {
447 int64_t CurVarOffsetInBytes = 0;
449 uint64_t FragmentEndInBits = FragmentOffsetInBits + FragmentSizeInBits;
456 if (CurVarOffsetInBytes < 0)
460 CurVarOffsetInBits = CHAR_BIT * (
uint64_t)CurVarOffsetInBytes;
463 if (CurVarOffsetInBits >= FragmentEndInBits)
467 uint64_t CurVarEndInBits = CurVarOffsetInBits + CurVarSize;
469 if (CurVarSize != 0 &&
470 CurVarEndInBits <= FragmentOffsetInBits)
475 if (CurVarSize != 0 &&
476 CurVarOffsetInBits >= FragmentOffsetInBits &&
477 CurVarEndInBits <= FragmentEndInBits) {
479 (CurVarOffsetInBits - FragmentOffsetInBits) / 8;
480 if (CurVarOffsetInFragment != 0)
481 Expr = DIExpression::get(Expr->
getContext(), {dwarf::DW_OP_plus_uconst,
482 CurVarOffsetInFragment});
484 Expr = DIExpression::get(Expr->
getContext(), {});
486 DIGlobalVariableExpression::get(GVE->getContext(), Var, Expr);
492 if (FragmentSizeInBits < VarSize) {
493 if (CurVarOffsetInBits > FragmentOffsetInBits)
495 uint64_t CurVarFragmentOffsetInBits =
496 FragmentOffsetInBits - CurVarOffsetInBits;
497 uint64_t CurVarFragmentSizeInBits = FragmentSizeInBits;
498 if (CurVarSize != 0 && CurVarEndInBits < FragmentEndInBits)
499 CurVarFragmentSizeInBits -= (FragmentEndInBits - CurVarEndInBits);
500 if (CurVarOffsetInBits)
501 Expr = DIExpression::get(Expr->
getContext(), {});
503 Expr, CurVarFragmentOffsetInBits, CurVarFragmentSizeInBits))
508 auto *NGVE = DIGlobalVariableExpression::get(GVE->getContext(), Var, Expr);
533 unsigned NumParts =
count_if(Parts, [](
const auto &Pair) {
534 return Pair.second.IsLoaded && Pair.second.IsStored;
541 for (
const auto &Pair : Parts) {
543 {Pair.first, Pair.second.Ty, Pair.second.Initializer});
549 for (
const auto &[OffsetForTy, Ty,
_] : TypesVector) {
554 Offset = OffsetForTy +
DL.getTypeAllocSize(Ty);
561 LLVM_DEBUG(
dbgs() <<
"PERFORMING GLOBAL SRA ON: " << *GV <<
"\n");
564 Align StartAlignment =
570 unsigned NameSuffix = 0;
571 for (
auto &[OffsetForTy, Ty, Initializer] : TypesVector) {
573 *GV->
getParent(), Ty,
false, GlobalVariable::InternalLinkage,
574 Initializer, GV->
getName() +
"." +
Twine(NameSuffix++), GV,
577 NewGlobals.
insert({OffsetForTy, NGV});
583 if (NewAlign >
DL.getABITypeAlign(Ty))
588 DL.getTypeAllocSizeInBits(Ty), VarSize);
595 auto AppendUsers = [&](
Value *V) {
596 for (
User *U : V->users())
597 if (Visited.
insert(U).second)
601 while (!Worklist.
empty()) {
603 if (isa<BitCastOperator>(V) || isa<AddrSpaceCastOperator>(V) ||
604 isa<GEPOperator>(V)) {
606 if (isa<Instruction>(V))
615 assert(
Ptr == GV &&
"Load/store must be from/to global");
617 assert(NGV &&
"Must have replacement global for this offset");
624 if (
auto *LI = dyn_cast<LoadInst>(V)) {
625 LI->setOperand(0, NGV);
626 LI->setAlignment(NewAlign);
628 auto *SI = cast<StoreInst>(V);
629 SI->setOperand(1, NGV);
630 SI->setAlignment(NewAlign);
636 "Other users can only be dead constants");
646 return NewGlobals.
begin()->second;
654 for (
const User *U : V->users()) {
661 if (isa<LoadInst>(U)) {
663 }
else if (
const StoreInst *SI = dyn_cast<StoreInst>(U)) {
664 if (SI->getOperand(0) == V) {
667 }
else if (
const CallInst *CI = dyn_cast<CallInst>(U)) {
668 if (CI->getCalledOperand() != V) {
671 }
else if (
const InvokeInst *
II = dyn_cast<InvokeInst>(U)) {
672 if (
II->getCalledOperand() != V) {
680 }
else if (
const PHINode *PN = dyn_cast<PHINode>(U)) {
685 }
else if (isa<ICmpInst>(U) &&
686 !ICmpInst::isSigned(cast<ICmpInst>(U)->getPredicate()) &&
687 isa<LoadInst>(U->getOperand(0)) &&
688 isa<ConstantPointerNull>(U->getOperand(1))) {
689 assert(isa<GlobalValue>(cast<LoadInst>(U->getOperand(0))
690 ->getPointerOperand()
691 ->stripPointerCasts()) &&
692 "Should be GlobalVariable");
709 while (!Worklist.
empty()) {
711 for (
const auto *U :
P->users()) {
712 if (
auto *LI = dyn_cast<LoadInst>(U)) {
716 }
else if (
auto *SI = dyn_cast<StoreInst>(U)) {
718 if (SI->getPointerOperand() !=
P)
720 }
else if (
auto *CE = dyn_cast<ConstantExpr>(U)) {
721 if (CE->stripPointerCasts() != GV)
740 while (!Worklist.
empty()) {
742 for (
auto *U :
P->users()) {
743 if (
auto *CE = dyn_cast<ConstantExpr>(U)) {
748 assert((isa<LoadInst>(U) || isa<StoreInst>(U)) &&
749 "Expect only load or store instructions");
756 bool Changed =
false;
757 for (
auto UI = V->user_begin(), E = V->user_end(); UI != E; ) {
763 if (
LoadInst *LI = dyn_cast<LoadInst>(
I)) {
764 LI->setOperand(0, NewV);
766 }
else if (
StoreInst *SI = dyn_cast<StoreInst>(
I)) {
767 if (SI->getOperand(1) == V) {
768 SI->setOperand(1, NewV);
771 }
else if (isa<CallInst>(
I) || isa<InvokeInst>(
I)) {
778 bool PassedAsArg =
false;
779 for (
unsigned i = 0, e = CB->
arg_size(); i != e; ++i)
787 UI = V->user_begin();
793 if (CI->use_empty()) {
795 CI->eraseFromParent();
800 Idxs.
reserve(GEPI->getNumOperands()-1);
803 if (
Constant *
C = dyn_cast<Constant>(*i))
807 if (Idxs.
size() == GEPI->getNumOperands()-1)
811 if (GEPI->use_empty()) {
813 GEPI->eraseFromParent();
828 bool Changed =
false;
832 bool AllNonStoreUsesGone =
true;
836 if (
LoadInst *LI = dyn_cast<LoadInst>(GlobalUser)) {
839 if (LI->use_empty()) {
840 LI->eraseFromParent();
843 AllNonStoreUsesGone =
false;
845 }
else if (isa<StoreInst>(GlobalUser)) {
847 assert(GlobalUser->getOperand(1) == GV &&
848 "Must be storing *to* the global");
850 AllNonStoreUsesGone =
false;
854 assert((isa<PHINode>(GlobalUser) || isa<SelectInst>(GlobalUser) ||
855 isa<ConstantExpr>(GlobalUser) || isa<CmpInst>(GlobalUser) ||
856 isa<BitCastInst>(GlobalUser) ||
857 isa<GetElementPtrInst>(GlobalUser) ||
858 isa<AddrSpaceCastInst>(GlobalUser)) &&
859 "Only expect load and stores!");
864 LLVM_DEBUG(
dbgs() <<
"OPTIMIZED LOADS FROM STORED ONCE POINTER: " << *GV
871 if (AllNonStoreUsesGone) {
895 I->replaceAllUsesWith(NewC);
899 while (UI != E && *UI ==
I)
902 I->eraseFromParent();
916 LLVM_DEBUG(
errs() <<
"PROMOTING GLOBAL: " << *GV <<
" CALL = " << *CI
935 if (!isa<UndefValue>(InitVal)) {
938 Builder.
CreateMemSet(NewGV, InitVal, AllocSize, std::nullopt);
951 bool InitBoolUsed =
false;
956 for (
auto *U : Guses) {
957 if (
StoreInst *SI = dyn_cast<StoreInst>(U)) {
962 !isa<ConstantPointerNull>(SI->getValueOperand())),
963 InitBool,
false,
Align(1), SI->getOrdering(),
964 SI->getSyncScopeID(), SI->getIterator());
965 SI->eraseFromParent();
986 case ICmpInst::ICMP_ULT:
989 case ICmpInst::ICMP_UGE:
992 case ICmpInst::ICMP_ULE:
993 case ICmpInst::ICMP_EQ:
996 case ICmpInst::ICMP_NE:
997 case ICmpInst::ICMP_UGT:
1007 if (!InitBoolUsed) {
1009 cast<StoreInst>(InitBool->
user_back())->eraseFromParent();
1036 while (!Worklist.
empty()) {
1038 if (!Visited.
insert(V).second)
1041 for (
const Use &VUse : V->uses()) {
1042 const User *U = VUse.getUser();
1043 if (isa<LoadInst>(U) || isa<CmpInst>(U))
1046 if (
auto *SI = dyn_cast<StoreInst>(U)) {
1047 if (SI->getValueOperand() == V &&
1048 SI->getPointerOperand()->stripPointerCasts() != GV)
1053 if (
auto *GEPI = dyn_cast<GetElementPtrInst>(U)) {
1090 if (AllocSize >= 2048)
1132 if (
Constant *SOVC = dyn_cast<Constant>(StoredOnceVal)) {
1137 if (
auto *CI = dyn_cast<CallInst>(StoredOnceVal)) {
1138 auto *TLI = &GetTLI(*CI->getFunction());
1168 if (!isa<LoadInst>(U) && !isa<StoreInst>(U))
1189 "No reason to shrink to bool!");
1196 bool IsOneZero =
false;
1197 bool EmitOneOrZero =
true;
1198 auto *CI = dyn_cast<ConstantInt>(OtherVal);
1199 if (CI && CI->getValue().getActiveBits() <= 64) {
1200 IsOneZero = InitVal->
isNullValue() && CI->isOne();
1203 if (CIInit && CIInit->getValue().getActiveBits() <= 64) {
1204 uint64_t ValInit = CIInit->getZExtValue();
1205 uint64_t ValOther = CI->getZExtValue();
1206 uint64_t ValMinus = ValOther - ValInit;
1208 for(
auto *GVe : GVs){
1212 unsigned SizeInOctets =
1224 dwarf::DW_OP_deref_size, SizeInOctets,
1225 dwarf::DW_OP_constu, ValMinus,
1226 dwarf::DW_OP_mul, dwarf::DW_OP_constu, ValInit,
1228 bool WithStackValue =
true;
1231 DIGlobalVariableExpression::get(NewGV->
getContext(), DGV, E);
1234 EmitOneOrZero =
false;
1238 if (EmitOneOrZero) {
1247 if (
StoreInst *SI = dyn_cast<StoreInst>(UI)) {
1249 bool StoringOther = SI->getOperand(0) == OtherVal;
1252 if (StoringOther || SI->getOperand(0) == InitVal) {
1259 Instruction *StoredVal = cast<Instruction>(SI->getOperand(0));
1264 if (
LoadInst *LI = dyn_cast<LoadInst>(StoredVal)) {
1265 assert(LI->getOperand(0) == GV &&
"Not a copy!");
1269 false,
Align(1), LI->getOrdering(),
1270 LI->getSyncScopeID(), LI->getIterator());
1272 assert((isa<CastInst>(StoredVal) || isa<SelectInst>(StoredVal)) &&
1273 "This is not a form that we understand!");
1275 assert(isa<LoadInst>(StoreVal) &&
"Not a load of NewGV!");
1279 new StoreInst(StoreVal, NewGV,
false,
Align(1), SI->getOrdering(),
1280 SI->getSyncScopeID(), SI->getIterator());
1324 if (
auto *
F = dyn_cast<Function>(&GV))
1325 Dead = (
F->isDeclaration() &&
F->use_empty()) ||
F->isDefTriviallyDead();
1332 if (
auto *
F = dyn_cast<Function>(&GV)) {
1333 if (DeleteFnCallback)
1334 DeleteFnCallback(*
F);
1358 for (
auto *U : GV->
users()) {
1362 assert(
I->getParent()->getParent() ==
F);
1364 if (
auto *LI = dyn_cast<LoadInst>(
I))
1366 else if (
auto *SI = dyn_cast<StoreInst>(
I))
1376 auto &DT = LookupDomTree(*
const_cast<Function *
>(
F));
1387 const unsigned Threshold = 100;
1388 if (Loads.
size() * Stores.
size() > Threshold)
1391 for (
auto *L : Loads) {
1392 auto *LTy = L->getType();
1398 return DT.dominates(S, L) &&
1399 DL.getTypeStoreSize(LTy).getFixedValue() <=
1400 DL.getTypeStoreSize(STy).getFixedValue();
1418 if (!isa<Constant>(StoredOnceValue))
1423 if (
auto *LI = dyn_cast<LoadInst>(U)) {
1424 if (LI->getFunction() ==
F &&
1425 LI->getType() == StoredOnceValue->
getType() && LI->isSimple())
1430 bool MadeChange =
false;
1431 if (!Loads.
empty()) {
1432 auto &DT = LookupDomTree(*
const_cast<Function *
>(
F));
1433 for (
auto *LI : Loads) {
1434 if (DT.dominates(StoredOnceStore, LI)) {
1435 LI->replaceAllUsesWith(
const_cast<Value *
>(StoredOnceValue));
1436 LI->eraseFromParent();
1460 if (!GS.HasMultipleAccessingFunctions &&
1461 GS.AccessingFunction &&
1465 GS.AccessingFunction->doesNotRecurse() &&
1472 GS.AccessingFunction->getEntryBlock().begin().getNonConst();
1476 nullptr, GV->
getName(), FirstI);
1486 bool Changed =
false;
1517 if (GS.Ordering == AtomicOrdering::NotAtomic) {
1528 LLVM_DEBUG(
dbgs() <<
" *** Marking constant allowed us to simplify "
1529 <<
"all users and delete global!\n");
1543 Value *StoredOnceValue = GS.getStoredOnceValue();
1546 const_cast<Function &
>(*GS.StoredOnceStore->getFunction());
1547 bool CanHaveNonUndefGlobalInitializer =
1548 GetTTI(StoreFn).canHaveNonUndefGlobalInitializerInAddressSpace(
1557 auto *SOVConstant = dyn_cast<Constant>(StoredOnceValue);
1559 DL.getTypeAllocSize(SOVConstant->getType()) ==
1561 CanHaveNonUndefGlobalInitializer) {
1572 NGV->copyAttributesFrom(GV);
1582 LLVM_DEBUG(
dbgs() <<
" *** Substituting initializer allowed us to "
1583 <<
"simplify all users and delete global!\n");
1598 if (GS.NumStores == 1)
1604 if (SOVConstant && GS.Ordering == AtomicOrdering::NotAtomic &&
1606 CanHaveNonUndefGlobalInitializer)) {
1632 bool Changed =
false;
1634 auto NewUnnamedAddr = GV.
hasLocalLinkage() ? GlobalValue::UnnamedAddr::Global
1635 : GlobalValue::UnnamedAddr::Local;
1647 auto *GVar = dyn_cast<GlobalVariable>(&GV);
1651 if (GVar->isConstant() || !GVar->hasInitializer())
1661 for (
User *U :
F->users()) {
1662 if (isa<BlockAddress>(U))
1671 if (Attrs.hasAttrSomewhere(
A, &AttrIndex))
1672 return Attrs.removeAttributeAtIndex(
C, AttrIndex,
A);
1677 F->setAttributes(
StripAttr(
F->getContext(),
F->getAttributes(),
A));
1678 for (
User *U :
F->users()) {
1679 if (isa<BlockAddress>(U))
1704 for (
User *U :
F->users()) {
1705 if (isa<BlockAddress>(U))
1707 CallInst* CI = dyn_cast<CallInst>(U);
1716 if (BB.getTerminatingMustTailCall())
1719 return !
F->hasAddressTaken();
1728 return Res.first->second;
1736 auto CallSiteFreq = CallerBFI.
getBlockFreq(CallSiteBB);
1737 auto CallerEntryFreq =
1739 return CallSiteFreq < CallerEntryFreq * ColdProb;
1749 const std::vector<Function *> &AllCallsCold) {
1754 for (
User *U :
F.users()) {
1755 if (isa<BlockAddress>(U))
1770 for (
User *U :
F->users()) {
1771 if (isa<BlockAddress>(U))
1786 if (
CallInst *CI = dyn_cast<CallInst>(&
I)) {
1788 if (CI->isInlineAsm())
1790 Function *CalledFn = CI->getCalledFunction();
1814 for (
User *U :
F->users()) {
1815 CallBase *CB = dyn_cast<CallBase>(U);
1817 assert(isa<BlockAddress>(U) &&
1818 "Expected either CallBase or BlockAddress");
1828 for (
User *U :
F->users())
1829 if (isa<InvokeInst>(U))
1837 auto *M =
F->getParent();
1843 for (
User *U : PreallocatedCalls) {
1844 CallBase *CB = dyn_cast<CallBase>(U);
1850 "Shouldn't call RemotePreallocated() on a musttail preallocated call");
1854 CallBase *PreallocatedSetup =
nullptr;
1855 for (
auto *It = OpBundles.
begin(); It != OpBundles.
end(); ++It) {
1856 if (It->getTag() ==
"preallocated") {
1857 PreallocatedSetup = cast<CallBase>(*It->input_begin());
1858 OpBundles.
erase(It);
1862 assert(PreallocatedSetup &&
"Did not find preallocated bundle");
1864 cast<ConstantInt>(PreallocatedSetup->
getArgOperand(0))->getZExtValue();
1866 assert((isa<CallInst>(CB) || isa<InvokeInst>(CB)) &&
1867 "Unknown indirect call type");
1887 for (
auto *
User : PreallocatedArgs) {
1888 auto *UseCall = cast<CallBase>(
User);
1889 assert(UseCall->getCalledFunction()->getIntrinsicID() ==
1890 Intrinsic::call_preallocated_arg &&
1891 "preallocated token use was not a llvm.call.preallocated.arg");
1893 cast<ConstantInt>(UseCall->getArgOperand(1))->getZExtValue();
1894 Value *AllocaReplacement = ArgAllocas[AllocArgIndex];
1895 if (!AllocaReplacement) {
1896 auto AddressSpace = UseCall->getType()->getPointerAddressSpace();
1898 UseCall->getFnAttr(Attribute::Preallocated).getValueAsType();
1903 ArgAllocas[AllocArgIndex] = Alloca;
1904 AllocaReplacement = Alloca;
1908 UseCall->eraseFromParent();
1911 cast<Instruction>(PreallocatedSetup)->eraseFromParent();
1925 bool Changed =
false;
1928 std::vector<Function *> AllCallsCold;
1931 AllCallsCold.push_back(&
F);
1937 if (
F.hasFnAttribute(Attribute::Naked))
1941 if (!
F.hasName() && !
F.isDeclaration() && !
F.hasLocalLinkage())
1944 if (
deleteIfDead(
F, NotDiscardableComdats, DeleteFnCallback)) {
1958 if (!
F.isDeclaration()) {
1961 ChangedCFGCallback(
F);
1967 if (!
F.hasLocalLinkage())
1975 if (
F.getAttributes().hasAttrSomewhere(Attribute::InAlloca) &&
1983 if (
F.getAttributes().hasAttrSomewhere(Attribute::Preallocated)) {
2002 ChangeableCCCache.
erase(&
F);
2020 if (
F.getAttributes().hasAttrSomewhere(Attribute::Nest) &&
2021 !
F.hasAddressTaken()) {
2038 bool Changed =
false;
2045 if (GV.hasInitializer())
2046 if (
auto *
C = dyn_cast<Constant>(GV.getInitializer())) {
2047 auto &
DL = M.getDataLayout();
2053 GV.setInitializer(New);
2061 Changed |=
processGlobal(GV, GetTTI, GetTLI, LookupDomTree);
2071 if (
F->isDeclaration())
2080 ++NumCtorsEvaluated;
2085 <<
F->getName() <<
"' to " << NewInitializers.size()
2087 for (
const auto &Pair : NewInitializers)
2088 Pair.first->setInitializer(Pair.second);
2090 GV->setConstant(
true);
2105 V.eraseFromParent();
2110 const Type *UsedArrayType = V.getValueType();
2111 const auto *VAT = cast<ArrayType>(UsedArrayType);
2112 const auto *VEPT = cast<PointerType>(VAT->getArrayElementType());
2116 PointerType::get(V.getContext(), VEPT->getAddressSpace());
2128 Module *M = V.getParent();
2129 V.removeFromParent();
2134 NV->setSection(
"llvm.metadata");
2154 CompilerUsed = {Vec.
begin(), Vec.
end()};
2160 iterator usedBegin() {
return Used.begin(); }
2161 iterator usedEnd() {
return Used.end(); }
2163 used_iterator_range used() {
2164 return used_iterator_range(usedBegin(), usedEnd());
2167 iterator compilerUsedBegin() {
return CompilerUsed.
begin(); }
2168 iterator compilerUsedEnd() {
return CompilerUsed.
end(); }
2170 used_iterator_range compilerUsed() {
2171 return used_iterator_range(compilerUsedBegin(), compilerUsedEnd());
2177 return CompilerUsed.
count(GV);
2185 return CompilerUsed.
insert(GV).second;
2188 void syncVariablesAndSets() {
2202 assert((!U.usedCount(&GA) || !U.compilerUsedCount(&GA)) &&
2203 "We should have removed the duplicated "
2204 "element from llvm.compiler.used");
2211 return !U.usedCount(&GA) && !U.compilerUsedCount(&GA);
2218 return U.usedCount(&GV) || U.compilerUsedCount(&GV);
2222 bool &RenameTarget) {
2226 RenameTarget =
false;
2247 RenameTarget =
true;
2254 bool Changed =
false;
2258 Used.compilerUsedErase(GV);
2269 if (!J.hasName() && !J.isDeclaration() && !J.hasLocalLinkage())
2278 if (!IsModuleLocal(J))
2281 Constant *Aliasee = J.getAliasee();
2292 Target->removeDeadConstantUsers();
2299 J.replaceAllUsesWith(Aliasee);
2300 ++NumAliasesResolved;
2306 Target->setLinkage(J.getLinkage());
2307 Target->setDSOLocal(J.isDSOLocal());
2308 Target->setVisibility(J.getVisibility());
2309 Target->setDLLStorageClass(J.getDLLStorageClass());
2311 if (Used.usedErase(&J))
2314 if (Used.compilerUsedErase(&J))
2315 Used.compilerUsedInsert(
Target);
2321 ++NumAliasesRemoved;
2325 Used.syncVariablesAndSets();
2335 auto FuncIter = M.begin();
2336 if (FuncIter == M.end())
2338 auto *TLI = &GetTLI(*FuncIter);
2340 if (!TLI->has(Func))
2343 Function *Fn = M.getFunction(TLI->getName(Func));
2352 if (!TLI->getLibFunc(*Fn,
F) ||
F != Func)
2369 if (
I.isDebugOrPseudoInst())
2371 if (isa<ReturnInst>(
I))
2393 bool Changed =
false;
2399 CallInst *CI = dyn_cast<CallInst>(U);
2413 ++NumCXXDtorsRemoved;
2424 if (IF.isInterposable())
2448 return dyn_cast<Function>(Ret->getReturnValue());
2454 bool Changed =
false;
2457 if (!IF.use_empty() &&
2458 (!Callee->isDeclaration() ||
2459 none_of(IF.users(), [](
User *U) { return isa<GlobalAlias>(U); }))) {
2460 IF.replaceAllUsesWith(Callee);
2461 NumIFuncsResolved++;
2470 bool Changed =
false;
2488 bool Changed =
false;
2489 bool LocalChange =
true;
2490 std::optional<uint32_t> FirstNotFullyEvaluatedPriority;
2492 while (LocalChange) {
2493 LocalChange =
false;
2495 NotDiscardableComdats.
clear();
2499 NotDiscardableComdats.
insert(
C);
2501 if (
const Comdat *
C =
F.getComdat())
2502 if (!
F.isDefTriviallyDead())
2503 NotDiscardableComdats.
insert(
C);
2505 if (
const Comdat *
C = GA.getComdat())
2506 if (!GA.isDiscardableIfUnused() || !GA.use_empty())
2507 NotDiscardableComdats.
insert(
C);
2511 NotDiscardableComdats, ChangedCFGCallback,
2517 if (FirstNotFullyEvaluatedPriority &&
2518 *FirstNotFullyEvaluatedPriority != Priority)
2522 FirstNotFullyEvaluatedPriority = Priority;
2528 NotDiscardableComdats);
2548 Changed |= LocalChange;
2558 auto &
DL = M.getDataLayout();
2580 ChangedCFGCallback, DeleteFnCallback))
MachineBasicBlock MachineBasicBlock::iterator DebugLoc DL
Atomic ordering constants.
This file contains the simple types necessary to represent the attributes associated with functions a...
static GCRegistry::Add< OcamlGC > B("ocaml", "ocaml 3.10-compatible GC")
static GCRegistry::Add< ErlangGC > A("erlang", "erlang-compatible garbage collector")
This file contains the declarations for the subclasses of Constant, which represent the different fla...
This file defines the DenseMap class.
This file contains constants used for implementing Dwarf debug support.
Rewrite Partial Register Uses
static bool IsSafeComputationToRemove(Value *V, function_ref< TargetLibraryInfo &(Function &)> GetTLI)
Given a value that is stored to a global but never read, determine whether it's safe to remove the st...
static Function * FindAtExitLibFunc(Module &M, function_ref< TargetLibraryInfo &(Function &)> GetTLI, LibFunc Func)
static bool optimizeOnceStoredGlobal(GlobalVariable *GV, Value *StoredOnceVal, const DataLayout &DL, function_ref< TargetLibraryInfo &(Function &)> GetTLI)
static Function * hasSideeffectFreeStaticResolution(GlobalIFunc &IF)
static bool tryToOptimizeStoreOfAllocationToGlobal(GlobalVariable *GV, CallInst *CI, const DataLayout &DL, TargetLibraryInfo *TLI)
If we have a global that is only initialized with a fixed size allocation try to transform the progra...
static void ConstantPropUsersOf(Value *V, const DataLayout &DL, TargetLibraryInfo *TLI)
Walk the use list of V, constant folding all of the instructions that are foldable.
static bool hasOnlyColdCalls(Function &F, function_ref< BlockFrequencyInfo &(Function &)> GetBFI, ChangeableCCCacheTy &ChangeableCCCache)
static bool allUsesOfLoadedValueWillTrapIfNull(const GlobalVariable *GV)
Return true if all uses of any loads from GV will trap if the loaded value is null.
static bool hasChangeableCCImpl(Function *F)
Return true if this is a calling convention that we'd like to change.
static bool AllUsesOfValueWillTrapIfNull(const Value *V, SmallPtrSetImpl< const PHINode * > &PHIs)
Return true if all users of the specified value will trap if the value is dynamically null.
static GlobalVariable * OptimizeGlobalAddressOfAllocation(GlobalVariable *GV, CallInst *CI, uint64_t AllocSize, Constant *InitVal, const DataLayout &DL, TargetLibraryInfo *TLI)
This function takes the specified global variable, and transforms the program as if it always contain...
Returns whether the given function is an empty C destructor or atexit handler and can therefore be eliminated Note that we assume that other optimization passes have already simplified the code so we simply check for static ret bool IsEmptyAtExitFunction(const Function &Fn)
static bool collectSRATypes(DenseMap< uint64_t, GlobalPart > &Parts, GlobalVariable *GV, const DataLayout &DL)
Look at all uses of the global and determine which (offset, type) pairs it can be split into.
static bool valueIsOnlyUsedLocallyOrStoredToOneGlobal(const CallInst *CI, const GlobalVariable *GV)
Scan the use-list of GV checking to make sure that there are no complex uses of GV.
static bool OptimizeFunctions(Module &M, function_ref< TargetLibraryInfo &(Function &)> GetTLI, function_ref< TargetTransformInfo &(Function &)> GetTTI, function_ref< BlockFrequencyInfo &(Function &)> GetBFI, function_ref< DominatorTree &(Function &)> LookupDomTree, SmallPtrSetImpl< const Comdat * > &NotDiscardableComdats, function_ref< void(Function &F)> ChangedCFGCallback, function_ref< void(Function &F)> DeleteFnCallback)
static bool DeleteDeadIFuncs(Module &M, SmallPtrSetImpl< const Comdat * > &NotDiscardableComdats)
static void RemoveAttribute(Function *F, Attribute::AttrKind A)
static cl::opt< int > ColdCCRelFreq("coldcc-rel-freq", cl::Hidden, cl::init(2), cl::desc("Maximum block frequency, expressed as a percentage of caller's " "entry frequency, for a call site to be considered cold for enabling" "coldcc"))
static bool hasChangeableCC(Function *F, ChangeableCCCacheTy &ChangeableCCCache)
static bool deleteIfDead(GlobalValue &GV, SmallPtrSetImpl< const Comdat * > &NotDiscardableComdats, function_ref< void(Function &)> DeleteFnCallback=nullptr)
static void RemovePreallocated(Function *F)
static bool processGlobal(GlobalValue &GV, function_ref< TargetTransformInfo &(Function &)> GetTTI, function_ref< TargetLibraryInfo &(Function &)> GetTLI, function_ref< DominatorTree &(Function &)> LookupDomTree)
Analyze the specified global variable and optimize it if possible.
static bool isColdCallSite(CallBase &CB, BlockFrequencyInfo &CallerBFI)
Return true if the block containing the call site has a BlockFrequency of less than ColdCCRelFreq% of...
static void transferSRADebugInfo(GlobalVariable *GV, GlobalVariable *NGV, uint64_t FragmentOffsetInBits, uint64_t FragmentSizeInBits, uint64_t VarSize)
Copy over the debug info for a variable to its SRA replacements.
static cl::opt< bool > EnableColdCCStressTest("enable-coldcc-stress-test", cl::desc("Enable stress test of coldcc by adding " "calling conv to all internal functions."), cl::init(false), cl::Hidden)
static bool OptimizeGlobalAliases(Module &M, SmallPtrSetImpl< const Comdat * > &NotDiscardableComdats)
static bool TryToShrinkGlobalToBoolean(GlobalVariable *GV, Constant *OtherVal)
At this point, we have learned that the only two values ever stored into GV are its initializer and O...
static void ChangeCalleesToFastCall(Function *F)
Walk all of the direct calls of the specified function, changing them to FastCC.
static bool hasMustTailCallers(Function *F)
static bool OptimizeGlobalVars(Module &M, function_ref< TargetTransformInfo &(Function &)> GetTTI, function_ref< TargetLibraryInfo &(Function &)> GetTLI, function_ref< DominatorTree &(Function &)> LookupDomTree, SmallPtrSetImpl< const Comdat * > &NotDiscardableComdats)
static void allUsesOfLoadAndStores(GlobalVariable *GV, SmallVector< Value *, 4 > &Uses)
Get all the loads/store uses for global variable GV.
static bool OptimizeEmptyGlobalAtExitDtors(Function *CXAAtExitFn, bool isCXX)
static bool mayHaveOtherReferences(GlobalValue &GV, const LLVMUsed &U)
static void changeCallSitesToColdCC(Function *F)
static AttributeList StripAttr(LLVMContext &C, AttributeList Attrs, Attribute::AttrKind A)
static bool hasInvokeCallers(Function *F)
static void setUsedInitializer(GlobalVariable &V, const SmallPtrSetImpl< GlobalValue * > &Init)
static bool OptimizeAwayTrappingUsesOfLoads(GlobalVariable *GV, Constant *LV, const DataLayout &DL, function_ref< TargetLibraryInfo &(Function &)> GetTLI)
The specified global has only one non-null value stored into it.
static bool isValidCandidateForColdCC(Function &F, function_ref< BlockFrequencyInfo &(Function &)> GetBFI, const std::vector< Function * > &AllCallsCold)
static bool optimizeGlobalsInModule(Module &M, const DataLayout &DL, function_ref< TargetLibraryInfo &(Function &)> GetTLI, function_ref< TargetTransformInfo &(Function &)> GetTTI, function_ref< BlockFrequencyInfo &(Function &)> GetBFI, function_ref< DominatorTree &(Function &)> LookupDomTree, function_ref< void(Function &F)> ChangedCFGCallback, function_ref< void(Function &F)> DeleteFnCallback)
static bool EvaluateStaticConstructor(Function *F, const DataLayout &DL, TargetLibraryInfo *TLI)
Evaluate static constructors in the function, if we can.
static bool CleanupConstantGlobalUsers(GlobalVariable *GV, const DataLayout &DL)
We just marked GV constant.
Find IFuncs that have resolvers that always point at the same statically known and replace their callers with a direct static call bool OptimizeStaticIFuncs(Module &M)
static bool isLeakCheckerRoot(GlobalVariable *GV)
Is this global variable possibly used by a leak checker as a root? If so, we might not really want to...
static bool forwardStoredOnceStore(GlobalVariable *GV, const StoreInst *StoredOnceStore, function_ref< DominatorTree &(Function &)> LookupDomTree)
static int compareNames(Constant *const *A, Constant *const *B)
static bool CleanupPointerRootUsers(GlobalVariable *GV, function_ref< TargetLibraryInfo &(Function &)> GetTLI)
This GV is a pointer root.
static bool isPointerValueDeadOnEntryToFunction(const Function *F, GlobalValue *GV, function_ref< DominatorTree &(Function &)> LookupDomTree)
static bool processInternalGlobal(GlobalVariable *GV, const GlobalStatus &GS, function_ref< TargetTransformInfo &(Function &)> GetTTI, function_ref< TargetLibraryInfo &(Function &)> GetTLI, function_ref< DominatorTree &(Function &)> LookupDomTree)
Analyze the specified global variable and optimize it if possible.
static bool hasUsesToReplace(GlobalAlias &GA, const LLVMUsed &U, bool &RenameTarget)
static bool OptimizeAwayTrappingUsesOfValue(Value *V, Constant *NewV)
static GlobalVariable * SRAGlobal(GlobalVariable *GV, const DataLayout &DL)
Perform scalar replacement of aggregates on the specified global variable.
static bool hasUseOtherThanLLVMUsed(GlobalAlias &GA, const LLVMUsed &U)
This defines the Use class.
Module.h This file contains the declarations for the Module class.
uint64_t IntrinsicInst * II
FunctionAnalysisManager FAM
assert(ImpDefSCC.getReg()==AMDGPU::SCC &&ImpDefSCC.isDef())
This file defines the SmallPtrSet class.
This file defines the SmallVector class.
This file defines the 'Statistic' class, which is designed to be an easy way to expose various metric...
#define STATISTIC(VARNAME, DESC)
static SymbolRef::Type getType(const Symbol *Sym)
Class for arbitrary precision integers.
This class represents a conversion between pointers from one address space to another.
an instruction to allocate memory on the stack
A container for analyses that lazily runs them and caches their results.
void clear(IRUnitT &IR, llvm::StringRef Name)
Clear any cached analysis results for a single unit of IR.
void invalidate(IRUnitT &IR, const PreservedAnalyses &PA)
Invalidate cached analyses for an IR unit.
PassT::Result & getResult(IRUnitT &IR, ExtraArgTs... ExtraArgs)
Get the result of an analysis pass for a given IR unit.
AttrKind
This enumeration lists the attributes that can be associated with parameters, function results,...
LLVM Basic Block Representation.
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...
static BinaryOperator * CreateNot(Value *Op, const Twine &Name="", InsertPosition InsertBefore=nullptr)
Analysis pass which computes BlockFrequencyInfo.
BlockFrequencyInfo pass uses BlockFrequencyInfoImpl implementation to estimate IR basic block frequen...
BlockFrequency getBlockFreq(const BasicBlock *BB) const
getblockFreq - Return block frequency.
Represents analyses that only rely on functions' control flow.
Base class for all callable instructions (InvokeInst and CallInst) Holds everything related to callin...
void getOperandBundlesAsDefs(SmallVectorImpl< OperandBundleDef > &Defs) const
Return the list of operand bundles attached to this instruction as a vector of OperandBundleDefs.
bool isMustTailCall() const
Tests if this call site must be tail call optimized.
Value * getCalledOperand() const
void setAttributes(AttributeList A)
Set the parameter attributes for this call.
Value * getArgOperand(unsigned i) const
void setArgOperand(unsigned i, Value *v)
static CallBase * Create(CallBase *CB, ArrayRef< OperandBundleDef > Bundles, InsertPosition InsertPt=nullptr)
Create a clone of CB with a different set of operand bundles and insert it before InsertPt.
void setCalledOperand(Value *V)
unsigned arg_size() const
AttributeList getAttributes() const
Return the parameter attributes for this call.
Function * getCaller()
Helper to get the caller (the parent function).
This class represents a function call, abstracting a target machine's calling convention.
bool isMustTailCall() const
Predicate getPredicate() const
Return the predicate for this instruction.
static Constant * get(ArrayType *T, ArrayRef< Constant * > V)
A constant value that is initialized with an expression using other constant values.
static Constant * getPointerBitCastOrAddrSpaceCast(Constant *C, Type *Ty)
Create a BitCast or AddrSpaceCast for a pointer type depending on the address space.
static Constant * getAddrSpaceCast(Constant *C, Type *Ty, bool OnlyIfReduced=false)
static Constant * getGetElementPtr(Type *Ty, Constant *C, ArrayRef< Constant * > IdxList, GEPNoWrapFlags NW=GEPNoWrapFlags::none(), std::optional< ConstantRange > InRange=std::nullopt, Type *OnlyIfReducedTy=nullptr)
Getelementptr form.
static ConstantInt * getTrue(LLVMContext &Context)
static ConstantInt * getFalse(LLVMContext &Context)
static ConstantInt * getBool(LLVMContext &Context, bool V)
This is an important base class in LLVM.
const Constant * stripPointerCasts() const
void removeDeadConstantUsers() const
If there are any dead constant users dangling off of this constant, remove them.
static Constant * getNullValue(Type *Ty)
Constructor to create a '0' constant of arbitrary type.
bool isNullValue() const
Return true if this is the value that would be returned by getNullValue.
bool extractIfOffset(int64_t &Offset) const
If this is a constant offset, extract it.
static std::optional< DIExpression * > createFragmentExpression(const DIExpression *Expr, unsigned OffsetInBits, unsigned SizeInBits)
Create a DIExpression to describe one part of an aggregate variable that is fragmented across multipl...
static DIExpression * prependOpcodes(const DIExpression *Expr, SmallVectorImpl< uint64_t > &Ops, bool StackValue=false, bool EntryValue=false)
Prepend DIExpr with the given opcodes and optionally turn it into a stack value.
A pair of DIGlobalVariable and DIExpression.
uint64_t getSizeInBits() const
Base class for variables.
This class represents an Operation in the Expression.
A parsed version of the target data layout string in and methods for querying it.
std::pair< iterator, bool > try_emplace(KeyT &&Key, Ts &&... Args)
bool erase(const KeyT &Val)
std::pair< iterator, bool > insert(const std::pair< KeyT, ValueT > &KV)
Analysis pass which computes a DominatorTree.
Concrete subclass of DominatorTreeBase that is used to compute a normal dominator tree.
This class evaluates LLVM IR, producing the Constant representing each SSA instruction.
DenseMap< GlobalVariable *, Constant * > getMutatedInitializers() const
bool EvaluateFunction(Function *F, Constant *&RetVal, const SmallVectorImpl< Constant * > &ActualArgs)
Evaluate a call to function F, returning true if successful, false if we can't evaluate it.
const SmallPtrSetImpl< GlobalVariable * > & getInvariants() const
const BasicBlock & getEntryBlock() const
Intrinsic::ID getIntrinsicID() const LLVM_READONLY
getIntrinsicID - This method returns the ID number of the specified function, or Intrinsic::not_intri...
LLVMContext & getContext() const
getContext - Return a reference to the LLVMContext associated with this function.
an instruction for type-safe pointer arithmetic to access elements of arrays and structs
const Constant * getAliasee() const
MaybeAlign getAlign() const
Returns the alignment of the given variable or function.
void setAlignment(Align Align)
Sets the alignment attribute of the GlobalObject.
PreservedAnalyses run(Module &M, ModuleAnalysisManager &AM)
bool isImplicitDSOLocal() const
bool isDeclaration() const
Return true if the primary definition of this global value is outside of the current translation unit...
LinkageTypes getLinkage() const
void setUnnamedAddr(UnnamedAddr Val)
bool hasLocalLinkage() const
bool hasPrivateLinkage() const
const Comdat * getComdat() const
ThreadLocalMode getThreadLocalMode() const
void setLinkage(LinkageTypes LT)
unsigned getAddressSpace() const
Module * getParent()
Get the module that this global value is contained inside of...
void eraseFromParent()
This method unlinks 'this' from the containing module and deletes it.
PointerType * getType() const
Global values are always pointers.
const DataLayout & getDataLayout() const
Get the data layout of the module this global belongs to.
static bool isInterposableLinkage(LinkageTypes Linkage)
Whether the definition of this global may be replaced by something non-equivalent at link time.
bool hasGlobalUnnamedAddr() const
UnnamedAddr getUnnamedAddr() const
static bool isWeakForLinker(LinkageTypes Linkage)
Whether the definition of this global may be replaced at link time.
static bool isDiscardableIfUnused(LinkageTypes Linkage)
Whether the definition of this global may be discarded if it is not used in its compilation unit.
@ InternalLinkage
Rename collisions when linking (static functions).
@ AppendingLinkage
Special purpose, only applies to global arrays.
Type * getValueType() const
const Constant * getInitializer() const
getInitializer - Return the initializer for this global variable.
void setInitializer(Constant *InitVal)
setInitializer - Sets the initializer for this global variable, removing any existing initializer if ...
bool isExternallyInitialized() const
void setConstant(bool Val)
void copyAttributesFrom(const GlobalVariable *Src)
copyAttributesFrom - copy all additional attributes (those not needed to create a GlobalVariable) fro...
void getDebugInfo(SmallVectorImpl< DIGlobalVariableExpression * > &GVs) const
Fill the vector with all debug info attachements.
bool isConstant() const
If the value is a global constant, its value is immutable throughout the runtime execution of the pro...
void eraseFromParent()
eraseFromParent - This method unlinks 'this' from the containing module and deletes it.
void addDebugInfo(DIGlobalVariableExpression *GV)
Attach a DIGlobalVariableExpression.
This instruction compares its operands according to the predicate given to the constructor.
AllocaInst * CreateAlloca(Type *Ty, unsigned AddrSpace, Value *ArraySize=nullptr, const Twine &Name="")
CallInst * CreateStackSave(const Twine &Name="")
Create a call to llvm.stacksave.
CallInst * CreateMemSet(Value *Ptr, Value *Val, uint64_t Size, MaybeAlign Align, bool isVolatile=false, MDNode *TBAATag=nullptr, MDNode *ScopeTag=nullptr, MDNode *NoAliasTag=nullptr)
Create and insert a memset to the specified pointer and the specified value.
CallInst * CreateStackRestore(Value *Ptr, const Twine &Name="")
Create a call to llvm.stackrestore.
void SetInsertPoint(BasicBlock *TheBB)
This specifies that created instructions should be appended to the end of the specified block.
This provides a uniform API for creating instructions and inserting them into a basic block: either a...
An analysis over an "outer" IR unit that provides access to an analysis manager over an "inner" IR un...
const DebugLoc & getDebugLoc() const
Return the debug location for this node as a DebugLoc.
InstListType::iterator eraseFromParent()
This method unlinks 'this' from the containing basic block and deletes it.
const Function * getFunction() const
Return the function this instruction belongs to.
const Instruction * getNextNonDebugInstruction(bool SkipPseudoOp=false) const
Return a pointer to the next non-debug instruction in the same basic block as 'this',...
void setDebugLoc(DebugLoc Loc)
Set the debug location information for this instruction.
A wrapper class for inspecting calls to intrinsic functions.
This is an important class for using LLVM in a threaded context.
An instruction for reading from memory.
AtomicOrdering getOrdering() const
Returns the ordering constraint of this load instruction.
SyncScope::ID getSyncScopeID() const
Returns the synchronization scope ID of this load instruction.
LLVMContext & getContext() const
This is the common base class for memset/memcpy/memmove.
This class wraps the llvm.memset and llvm.memset.inline intrinsics.
This class wraps the llvm.memcpy/memmove intrinsics.
A Module instance is used to store all the information related to an LLVM module.
void insertGlobalVariable(GlobalVariable *GV)
Insert global variable GV at the end of the global variable list and take ownership.
unsigned getAddressSpace() const
Return the address space of the Pointer type.
A set of analyses that are preserved following a run of a transformation pass.
static PreservedAnalyses none()
Convenience factory function for the empty preserved set.
static PreservedAnalyses all()
Construct a special preserved set that preserves all passes.
void preserveSet()
Mark an analysis set as preserved.
void preserve()
Mark an analysis as preserved.
Interface for looking up the initializer for a variable name, used by Init::resolveReferences.
static SelectInst * Create(Value *C, Value *S1, Value *S2, const Twine &NameStr="", InsertPosition InsertBefore=nullptr, Instruction *MDFrom=nullptr)
A templated base class for SmallPtrSet which provides the typesafe interface that is common across al...
bool erase(PtrType Ptr)
Remove pointer from the set.
size_type count(ConstPtrType Ptr) const
count - Return 1 if the specified pointer is in the set, 0 otherwise.
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.
void reserve(size_type N)
iterator erase(const_iterator CI)
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()
bool starts_with(StringRef Prefix) const
Check if this string starts with the given Prefix.
int compare(StringRef RHS) const
compare - Compare two strings; the result is negative, zero, or positive if this string is lexicograp...
Class to represent struct types.
ArrayRef< Type * > elements() const
bool isOpaque() const
Return true if this is a type with an identity that has no body specified yet.
Analysis pass providing the TargetTransformInfo.
Analysis pass providing the TargetLibraryInfo.
Provides information about what library functions are available for the current target.
Target - Wrapper for Target specific information.
Twine - A lightweight data structure for efficiently representing the concatenation of temporary valu...
The instances of the Type class are immutable: once they are created, they are never changed.
bool isVectorTy() const
True if this is an instance of VectorType.
bool isPointerTy() const
True if this is an instance of PointerType.
static IntegerType * getInt1Ty(LLVMContext &C)
unsigned getPointerAddressSpace() const
Get the address space of this pointer or pointer vector type.
@ ScalableVectorTyID
Scalable SIMD vector type.
@ FixedVectorTyID
Fixed width SIMD vector type.
bool isSingleValueType() const
Return true if the type is a valid type for a register in codegen.
static IntegerType * getInt8Ty(LLVMContext &C)
bool isFloatingPointTy() const
Return true if this is one of the floating-point types.
bool isScalableTy() const
Return true if this is a type whose size is a known multiple of vscale.
TypeID getTypeID() const
Return the type id for the type.
static UndefValue * get(Type *T)
Static factory methods - Return an 'undef' object of the specified type.
A Use represents the edge between a Value definition and its users.
User * getUser() const
Returns the User that contains this Use.
Value * getOperand(unsigned i) const
LLVM Value Representation.
Type * getType() const
All values are typed, get the type of this value.
const Value * stripAndAccumulateConstantOffsets(const DataLayout &DL, APInt &Offset, bool AllowNonInbounds, bool AllowInvariantGroup=false, function_ref< bool(Value &Value, APInt &Offset)> ExternalAnalysis=nullptr) const
Accumulate the constant offset this value has compared to a base pointer.
bool hasOneUse() const
Return true if there is exactly one use of this value.
void replaceAllUsesWith(Value *V)
Change all uses of this to point to a new Value.
iterator_range< user_iterator > users()
const Value * stripPointerCasts() const
Strip off pointer casts, all-zero GEPs and address space casts.
LLVMContext & getContext() const
All values hold a context through their type.
user_iterator_impl< User > user_iterator
StringRef getName() const
Return a constant reference to the value's name.
void takeName(Value *V)
Transfer the name from V to this value.
This class represents zero extension of integer types.
An efficient, type-erasing, non-owning reference to a callable.
const ParentTy * getParent() const
self_iterator getIterator()
NodeTy * getNextNode()
Get the next node, or nullptr for the list tail.
A range adaptor for a pair of iterators.
This provides a very simple, boring adaptor for a begin and end iterator into a range type.
#define llvm_unreachable(msg)
Marks that the current location is not supposed to be reachable.
@ Cold
Attempts to make code in the caller as efficient as possible under the assumption that the call is no...
@ X86_ThisCall
Similar to X86_StdCall.
@ Fast
Attempts to make calls as fast as possible (e.g.
@ C
The default llvm calling convention, compatible with C.
initializer< Ty > init(const Ty &Val)
This is an optimization pass for GlobalISel generic memory operations.
Constant * getInitialValueOfAllocation(const Value *V, const TargetLibraryInfo *TLI, Type *Ty)
If this is a call to an allocation function that initializes memory to a fixed value,...
bool RecursivelyDeleteTriviallyDeadInstructions(Value *V, const TargetLibraryInfo *TLI=nullptr, MemorySSAUpdater *MSSAU=nullptr, std::function< void(Value *)> AboutToDeleteCallback=std::function< void(Value *)>())
If the specified value is a trivially dead instruction, delete it.
bool isRemovableAlloc(const CallBase *V, const TargetLibraryInfo *TLI)
Return true if this is a call to an allocation function that does not have side effects that we are r...
const Value * getLoadStorePointerOperand(const Value *V)
A helper function that returns the pointer operand of a load or store instruction.
void append_range(Container &C, Range &&R)
Wrapper function to append range R to container C.
const Value * getUnderlyingObject(const Value *V, unsigned MaxLookup=6)
This method strips off any GEP address adjustments, pointer casts or llvm.threadlocal....
iterator_range< early_inc_iterator_impl< detail::IterOfRange< RangeT > > > make_early_inc_range(RangeT &&Range)
Make a range that does early increment to allow mutation of the underlying range without disrupting i...
Constant * ConstantFoldConstant(const Constant *C, const DataLayout &DL, const TargetLibraryInfo *TLI=nullptr)
ConstantFoldConstant - Fold the constant using the specified DataLayout.
bool any_of(R &&range, UnaryPredicate P)
Provide wrappers to std::any_of which take ranges instead of having to pass begin/end explicitly.
bool isInstructionTriviallyDead(Instruction *I, const TargetLibraryInfo *TLI=nullptr)
Return true if the result produced by the instruction is not used, and the instruction will return.
bool getObjectSize(const Value *Ptr, uint64_t &Size, const DataLayout &DL, const TargetLibraryInfo *TLI, ObjectSizeOpts Opts={})
Compute the size of the object pointed by Ptr.
Constant * ConstantFoldLoadFromUniformValue(Constant *C, Type *Ty, const DataLayout &DL)
If C is a uniform value where all bits are the same (either all zero, all ones, all undef or all pois...
bool isSafeToDestroyConstant(const Constant *C)
It is safe to destroy a constant iff it is only used by constants itself.
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 optimizeGlobalCtorsList(Module &M, function_ref< bool(uint32_t, Function *)> ShouldRemove)
Call "ShouldRemove" for every entry in M's global_ctor list and remove the entries for which it retur...
void sort(IteratorTy Start, IteratorTy End)
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.
bool isPointerTy(const Type *T)
bool none_of(R &&Range, UnaryPredicate P)
Provide wrappers to std::none_of which take ranges instead of having to pass begin/end explicitly.
Constant * ConstantFoldLoadFromConst(Constant *C, Type *Ty, const APInt &Offset, const DataLayout &DL)
Extract value of C at the given Offset reinterpreted as Ty.
raw_fd_ostream & errs()
This returns a reference to a raw_ostream for standard error.
Constant * ConstantFoldInstruction(Instruction *I, const DataLayout &DL, const TargetLibraryInfo *TLI=nullptr)
ConstantFoldInstruction - Try to constant fold the specified instruction.
bool RecursivelyDeleteTriviallyDeadInstructionsPermissive(SmallVectorImpl< WeakTrackingVH > &DeadInsts, const TargetLibraryInfo *TLI=nullptr, MemorySSAUpdater *MSSAU=nullptr, std::function< void(Value *)> AboutToDeleteCallback=std::function< void(Value *)>())
Same functionality as RecursivelyDeleteTriviallyDeadInstructions, but allow instructions that are not...
auto count_if(R &&Range, UnaryPredicate P)
Wrapper function around std::count_if to count the number of times an element satisfying a given pred...
bool isAllocationFn(const Value *V, const TargetLibraryInfo *TLI)
Tests if a value is a call or invoke to a library function that allocates or reallocates memory (eith...
bool is_contained(R &&Range, const E &Element)
Returns true if Element is found in Range.
Align commonAlignment(Align A, uint64_t Offset)
Returns the alignment that satisfies both alignments.
Type * getLoadStoreType(const Value *I)
A helper function that returns the type of a load or store instruction.
void array_pod_sort(IteratorTy Start, IteratorTy End)
array_pod_sort - This sorts an array with the specified start and end extent.
bool removeUnreachableBlocks(Function &F, DomTreeUpdater *DTU=nullptr, MemorySSAUpdater *MSSAU=nullptr)
Remove all blocks that can not be reached from the function's entry.
GlobalVariable * collectUsedGlobalVariables(const Module &M, SmallVectorImpl< GlobalValue * > &Vec, bool CompilerUsed)
Given "llvm.used" or "llvm.compiler.used" as a global name, collect the initializer elements of that ...
Part of the global at a specific offset, which is only accessed through loads and stores with the giv...
This struct is a compact representation of a valid (non-zero power of two) alignment.
As we analyze each global or thread-local variable, keep track of some information about it.
@ InitializerStored
This global is stored to, but the only thing stored is the constant it was initialized with.
@ StoredOnce
This global is stored to, but only its initializer and one other value is ever stored to it.
static bool analyzeGlobal(const Value *V, GlobalStatus &GS)
Look at all uses of the global and fill in the GlobalStatus structure.
Various options to control the behavior of getObjectSize.
Function object to check whether the first component of a container supported by std::get (like std::...