[llvm] 9ef6aa0 - Plumb AssumeInst through operand bundle apis [nfc]
Philip Reames via llvm-commits
llvm-commits at lists.llvm.org
Tue Apr 6 12:54:02 PDT 2021
Author: Philip Reames
Date: 2021-04-06T12:53:53-07:00
New Revision: 9ef6aa020b6fb9c7672919985b0ed2a6953a3596
URL: https://github.com/llvm/llvm-project/commit/9ef6aa020b6fb9c7672919985b0ed2a6953a3596
DIFF: https://github.com/llvm/llvm-project/commit/9ef6aa020b6fb9c7672919985b0ed2a6953a3596.diff
LOG: Plumb AssumeInst through operand bundle apis [nfc]
Follow up to a6d2a8d6f5. This covers all the public interfaces of the bundle related code. I tried to cleanup the internals where the changes were obvious, but there's definitely more room for improvement.
Added:
Modified:
llvm/include/llvm/Analysis/AssumeBundleQueries.h
llvm/include/llvm/Transforms/Scalar/GVN.h
llvm/include/llvm/Transforms/Utils/AssumeBundleBuilder.h
llvm/lib/Analysis/AssumeBundleQueries.cpp
llvm/lib/Transforms/IPO/Attributor.cpp
llvm/lib/Transforms/InstCombine/InstCombineCalls.cpp
llvm/lib/Transforms/Scalar/GVN.cpp
llvm/lib/Transforms/Utils/AssumeBundleBuilder.cpp
llvm/lib/Transforms/Utils/Local.cpp
llvm/unittests/Analysis/AssumeBundleQueriesTest.cpp
Removed:
################################################################################
diff --git a/llvm/include/llvm/Analysis/AssumeBundleQueries.h b/llvm/include/llvm/Analysis/AssumeBundleQueries.h
index 3577ea3b7c760..49c0cd89a4dbf 100644
--- a/llvm/include/llvm/Analysis/AssumeBundleQueries.h
+++ b/llvm/include/llvm/Analysis/AssumeBundleQueries.h
@@ -16,6 +16,7 @@
#include "llvm/IR/Attributes.h"
#include "llvm/IR/Instructions.h"
+#include "llvm/IR/IntrinsicInst.h"
#include "llvm/ADT/DenseMap.h"
namespace llvm {
@@ -39,12 +40,12 @@ enum AssumeBundleArg {
///
/// Return true iff the queried attribute was found.
/// If ArgVal is set. the argument will be stored to ArgVal.
-bool hasAttributeInAssume(CallInst &AssumeCI, Value *IsOn, StringRef AttrName,
+bool hasAttributeInAssume(AssumeInst &Assume, Value *IsOn, StringRef AttrName,
uint64_t *ArgVal = nullptr);
-inline bool hasAttributeInAssume(CallInst &AssumeCI, Value *IsOn,
+inline bool hasAttributeInAssume(AssumeInst &Assume, Value *IsOn,
Attribute::AttrKind Kind,
uint64_t *ArgVal = nullptr) {
- return hasAttributeInAssume(AssumeCI, IsOn,
+ return hasAttributeInAssume(Assume, IsOn,
Attribute::getNameFromAttrKind(Kind), ArgVal);
}
@@ -87,7 +88,7 @@ using RetainedKnowledgeMap =
/// many queries are going to be made on the same llvm.assume.
/// String attributes are not inserted in the map.
/// If the IR changes the map will be outdated.
-void fillMapFromAssume(CallInst &AssumeCI, RetainedKnowledgeMap &Result);
+void fillMapFromAssume(AssumeInst &Assume, RetainedKnowledgeMap &Result);
/// Represent one information held inside an operand bundle of an llvm.assume.
/// AttrKind is the property that holds.
@@ -121,13 +122,13 @@ struct RetainedKnowledge {
/// Retreive the information help by Assume on the operand at index Idx.
/// Assume should be an llvm.assume and Idx should be in the operand bundle.
-RetainedKnowledge getKnowledgeFromOperandInAssume(CallInst &Assume,
+RetainedKnowledge getKnowledgeFromOperandInAssume(AssumeInst &Assume,
unsigned Idx);
/// Retreive the information help by the Use U of an llvm.assume. the use should
/// be in the operand bundle.
inline RetainedKnowledge getKnowledgeFromUseInAssume(const Use *U) {
- return getKnowledgeFromOperandInAssume(*cast<CallInst>(U->getUser()),
+ return getKnowledgeFromOperandInAssume(*cast<AssumeInst>(U->getUser()),
U->getOperandNo());
}
@@ -142,7 +143,7 @@ constexpr StringRef IgnoreBundleTag = "ignore";
///
/// the argument to the call of llvm.assume may still be useful even if the
/// function returned true.
-bool isAssumeWithEmptyBundle(CallInst &Assume);
+bool isAssumeWithEmptyBundle(AssumeInst &Assume);
/// Return a valid Knowledge associated to the Use U if its Attribute kind is
/// in AttrKinds.
@@ -168,7 +169,7 @@ RetainedKnowledge getKnowledgeValidInContext(
/// This extracts the Knowledge from an element of an operand bundle.
/// This is mostly for use in the assume builder.
-RetainedKnowledge getKnowledgeFromBundle(CallInst &Assume,
+RetainedKnowledge getKnowledgeFromBundle(AssumeInst &Assume,
const CallBase::BundleOpInfo &BOI);
} // namespace llvm
diff --git a/llvm/include/llvm/Transforms/Scalar/GVN.h b/llvm/include/llvm/Transforms/Scalar/GVN.h
index 97a0efec58e12..8560ede44b27c 100644
--- a/llvm/include/llvm/Transforms/Scalar/GVN.h
+++ b/llvm/include/llvm/Transforms/Scalar/GVN.h
@@ -35,6 +35,7 @@
namespace llvm {
class AAResults;
+class AssumeInst;
class AssumptionCache;
class BasicBlock;
class BranchInst;
@@ -309,7 +310,7 @@ class GVN : public PassInfoMixin<GVN> {
// Helper functions of redundant load elimination
bool processLoad(LoadInst *L);
bool processNonLocalLoad(LoadInst *L);
- bool processAssumeIntrinsic(IntrinsicInst *II);
+ bool processAssumeIntrinsic(AssumeInst *II);
/// Given a local dependency (Def or Clobber) determine if a value is
/// available for the load. Returns true if an value is known to be
diff --git a/llvm/include/llvm/Transforms/Utils/AssumeBundleBuilder.h b/llvm/include/llvm/Transforms/Utils/AssumeBundleBuilder.h
index 1b19fd0c171e2..5c06af9bc84ca 100644
--- a/llvm/include/llvm/Transforms/Utils/AssumeBundleBuilder.h
+++ b/llvm/include/llvm/Transforms/Utils/AssumeBundleBuilder.h
@@ -30,7 +30,7 @@ class DominatorTree;
/// from the given instruction.
/// If no information derived from \p I, this call returns null.
/// The returned instruction is not inserted anywhere.
-IntrinsicInst *buildAssumeFromInst(Instruction *I);
+AssumeInst *buildAssumeFromInst(Instruction *I);
/// Calls BuildAssumeFromInst and if the resulting llvm.assume is valid insert
/// if before I. This is usually what need to be done to salvage the knowledge
@@ -44,10 +44,10 @@ void salvageKnowledge(Instruction *I, AssumptionCache *AC = nullptr,
/// Build and return a new assume created from the provided knowledge
/// if the knowledge in the assume is fully redundant this will return nullptr
-IntrinsicInst *buildAssumeFromKnowledge(ArrayRef<RetainedKnowledge> Knowledge,
- Instruction *CtxI,
- AssumptionCache *AC = nullptr,
- DominatorTree *DT = nullptr);
+AssumeInst *buildAssumeFromKnowledge(ArrayRef<RetainedKnowledge> Knowledge,
+ Instruction *CtxI,
+ AssumptionCache *AC = nullptr,
+ DominatorTree *DT = nullptr);
/// This pass attempts to minimize the number of assume without loosing any
/// information.
@@ -66,7 +66,7 @@ struct AssumeBuilderPass : public PassInfoMixin<AssumeBuilderPass> {
/// canonicalize the RetainedKnowledge RK. it is assumed that RK is part of
/// Assume. This will return an empty RetainedKnowledge if the knowledge is
/// useless.
-RetainedKnowledge simplifyRetainedKnowledge(CallBase *Assume,
+RetainedKnowledge simplifyRetainedKnowledge(AssumeInst *Assume,
RetainedKnowledge RK,
AssumptionCache *AC,
DominatorTree *DT);
diff --git a/llvm/lib/Analysis/AssumeBundleQueries.cpp b/llvm/lib/Analysis/AssumeBundleQueries.cpp
index 9cb5b10570b3b..ae36dd105ae75 100644
--- a/llvm/lib/Analysis/AssumeBundleQueries.cpp
+++ b/llvm/lib/Analysis/AssumeBundleQueries.cpp
@@ -33,20 +33,15 @@ static bool bundleHasArgument(const CallBase::BundleOpInfo &BOI, unsigned Idx) {
return BOI.End - BOI.Begin > Idx;
}
-static Value *getValueFromBundleOpInfo(CallInst &Assume,
+static Value *getValueFromBundleOpInfo(AssumeInst &Assume,
const CallBase::BundleOpInfo &BOI,
unsigned Idx) {
assert(bundleHasArgument(BOI, Idx) && "index out of range");
return (Assume.op_begin() + BOI.Begin + Idx)->get();
}
-bool llvm::hasAttributeInAssume(CallInst &AssumeCI, Value *IsOn,
+bool llvm::hasAttributeInAssume(AssumeInst &Assume, Value *IsOn,
StringRef AttrName, uint64_t *ArgVal) {
- assert(isa<IntrinsicInst>(AssumeCI) &&
- "this function is intended to be used on llvm.assume");
- IntrinsicInst &Assume = cast<IntrinsicInst>(AssumeCI);
- assert(Assume.getIntrinsicID() == Intrinsic::assume &&
- "this function is intended to be used on llvm.assume");
assert(Attribute::isExistingAttribute(AttrName) &&
"this attribute doesn't exist");
assert((ArgVal == nullptr || Attribute::doesAttrKindHaveArgument(
@@ -72,10 +67,7 @@ bool llvm::hasAttributeInAssume(CallInst &AssumeCI, Value *IsOn,
return false;
}
-void llvm::fillMapFromAssume(CallInst &AssumeCI, RetainedKnowledgeMap &Result) {
- IntrinsicInst &Assume = cast<IntrinsicInst>(AssumeCI);
- assert(Assume.getIntrinsicID() == Intrinsic::assume &&
- "this function is intended to be used on llvm.assume");
+void llvm::fillMapFromAssume(AssumeInst &Assume, RetainedKnowledgeMap &Result) {
for (auto &Bundles : Assume.bundle_op_infos()) {
std::pair<Value *, Attribute::AttrKind> Key{
nullptr, Attribute::getAttrKindFromName(Bundles.Tag->getKey())};
@@ -104,7 +96,7 @@ void llvm::fillMapFromAssume(CallInst &AssumeCI, RetainedKnowledgeMap &Result) {
}
RetainedKnowledge
-llvm::getKnowledgeFromBundle(CallInst &Assume,
+llvm::getKnowledgeFromBundle(AssumeInst &Assume,
const CallBase::BundleOpInfo &BOI) {
RetainedKnowledge Result;
Result.AttrKind = Attribute::getAttrKindFromName(BOI.Tag->getKey());
@@ -124,19 +116,13 @@ llvm::getKnowledgeFromBundle(CallInst &Assume,
return Result;
}
-RetainedKnowledge llvm::getKnowledgeFromOperandInAssume(CallInst &AssumeCI,
+RetainedKnowledge llvm::getKnowledgeFromOperandInAssume(AssumeInst &Assume,
unsigned Idx) {
- IntrinsicInst &Assume = cast<IntrinsicInst>(AssumeCI);
- assert(Assume.getIntrinsicID() == Intrinsic::assume &&
- "this function is intended to be used on llvm.assume");
CallBase::BundleOpInfo BOI = Assume.getBundleOpInfoForOperand(Idx);
- return getKnowledgeFromBundle(AssumeCI, BOI);
+ return getKnowledgeFromBundle(Assume, BOI);
}
-bool llvm::isAssumeWithEmptyBundle(CallInst &CI) {
- IntrinsicInst &Assume = cast<IntrinsicInst>(CI);
- assert(Assume.getIntrinsicID() == Intrinsic::assume &&
- "this function is intended to be used on llvm.assume");
+bool llvm::isAssumeWithEmptyBundle(AssumeInst &Assume) {
return none_of(Assume.bundle_op_infos(),
[](const CallBase::BundleOpInfo &BOI) {
return BOI.Tag->getKey() != IgnoreBundleTag;
@@ -158,7 +144,7 @@ llvm::getKnowledgeFromUse(const Use *U,
if (!Bundle)
return RetainedKnowledge::none();
RetainedKnowledge RK =
- getKnowledgeFromBundle(*cast<CallInst>(U->getUser()), *Bundle);
+ getKnowledgeFromBundle(*cast<AssumeInst>(U->getUser()), *Bundle);
if (llvm::is_contained(AttrKinds, RK.AttrKind))
return RK;
return RetainedKnowledge::none();
@@ -176,7 +162,7 @@ llvm::getKnowledgeForValue(const Value *V,
return RetainedKnowledge::none();
if (AC) {
for (AssumptionCache::ResultElem &Elem : AC->assumptionsFor(V)) {
- IntrinsicInst *II = cast_or_null<IntrinsicInst>(Elem.Assume);
+ auto *II = cast_or_null<AssumeInst>(Elem.Assume);
if (!II || Elem.Index == AssumptionCache::ExprResultIdx)
continue;
if (RetainedKnowledge RK = getKnowledgeFromBundle(
@@ -197,7 +183,7 @@ llvm::getKnowledgeForValue(const Value *V,
if (!Bundle)
continue;
if (RetainedKnowledge RK =
- getKnowledgeFromBundle(*cast<CallInst>(U.getUser()), *Bundle))
+ getKnowledgeFromBundle(*cast<AssumeInst>(U.getUser()), *Bundle))
if (is_contained(AttrKinds, RK.AttrKind) &&
Filter(RK, cast<Instruction>(U.getUser()), Bundle)) {
NumUsefullAssumeQueries++;
diff --git a/llvm/lib/Transforms/IPO/Attributor.cpp b/llvm/lib/Transforms/IPO/Attributor.cpp
index 0223ff97ac9a8..665abfa210ce1 100644
--- a/llvm/lib/Transforms/IPO/Attributor.cpp
+++ b/llvm/lib/Transforms/IPO/Attributor.cpp
@@ -1910,9 +1910,8 @@ void InformationCache::initializeInformationCache(const Function &CF,
// Calls are interesting on their own, additionally:
// For `llvm.assume` calls we also fill the KnowledgeMap as we find them.
// For `must-tail` calls we remember the caller and callee.
- if (IntrinsicInst *Assume = dyn_cast<IntrinsicInst>(&I)) {
- if (Assume->getIntrinsicID() == Intrinsic::assume)
- fillMapFromAssume(*Assume, KnowledgeMap);
+ if (auto *Assume = dyn_cast<AssumeInst>(&I)) {
+ fillMapFromAssume(*Assume, KnowledgeMap);
} else if (cast<CallInst>(I).isMustTailCall()) {
FI.ContainsMustTailCall = true;
if (const Function *Callee = cast<CallInst>(I).getCalledFunction())
diff --git a/llvm/lib/Transforms/InstCombine/InstCombineCalls.cpp b/llvm/lib/Transforms/InstCombine/InstCombineCalls.cpp
index 7afcc5c27062a..4d9005840b4b6 100644
--- a/llvm/lib/Transforms/InstCombine/InstCombineCalls.cpp
+++ b/llvm/lib/Transforms/InstCombine/InstCombineCalls.cpp
@@ -1557,8 +1557,8 @@ Instruction *InstCombinerImpl::visitCallInst(CallInst &CI) {
/// argument and remove the assume if it becomes useless.
/// always returns nullptr for use as a return values.
auto RemoveConditionFromAssume = [&](Instruction *Assume) -> Instruction * {
- assert(isa<IntrinsicInst>(Assume));
- if (isAssumeWithEmptyBundle(*cast<IntrinsicInst>(II)))
+ assert(isa<AssumeInst>(Assume));
+ if (isAssumeWithEmptyBundle(*cast<AssumeInst>(II)))
return eraseInstFromFunction(CI);
replaceUse(II->getOperandUse(0), ConstantInt::getTrue(II->getContext()));
return nullptr;
@@ -1615,11 +1615,11 @@ Instruction *InstCombinerImpl::visitCallInst(CallInst &CI) {
if (EnableKnowledgeRetention &&
match(IIOperand, m_Cmp(Pred, m_Value(A), m_Zero())) &&
Pred == CmpInst::ICMP_NE && A->getType()->isPointerTy()) {
- if (IntrinsicInst *Replacement = buildAssumeFromKnowledge(
+ if (auto *Replacement = buildAssumeFromKnowledge(
{RetainedKnowledge{Attribute::NonNull, 0, A}}, Next, &AC, &DT)) {
Replacement->insertBefore(Next);
- AC.registerAssumption(cast<AssumeInst>(Replacement));
+ AC.registerAssumption(Replacement);
return RemoveConditionFromAssume(II);
}
}
@@ -1647,11 +1647,11 @@ Instruction *InstCombinerImpl::visitCallInst(CallInst &CI) {
/// the offset.
RetainedKnowledge RK{Attribute::Alignment,
(unsigned)MinAlign(Offset, AlignMask + 1), A};
- if (IntrinsicInst *Replacement =
+ if (auto *Replacement =
buildAssumeFromKnowledge(RK, Next, &AC, &DT)) {
Replacement->insertAfter(II);
- AC.registerAssumption(cast<AssumeInst>(Replacement));
+ AC.registerAssumption(Replacement);
}
return RemoveConditionFromAssume(II);
}
@@ -1662,13 +1662,16 @@ Instruction *InstCombinerImpl::visitCallInst(CallInst &CI) {
if (EnableKnowledgeRetention && II->hasOperandBundles()) {
for (unsigned Idx = 0; Idx < II->getNumOperandBundles(); Idx++) {
auto &BOI = II->bundle_op_info_begin()[Idx];
- RetainedKnowledge RK = llvm::getKnowledgeFromBundle(*II, BOI);
+ RetainedKnowledge RK =
+ llvm::getKnowledgeFromBundle(cast<AssumeInst>(*II), BOI);
if (BOI.End - BOI.Begin > 2)
continue; // Prevent reducing knowledge in an align with offset since
// extracting a RetainedKnowledge form them looses offset
// information
- RetainedKnowledge CanonRK = llvm::simplifyRetainedKnowledge(
- II, RK, &getAssumptionCache(), &getDominatorTree());
+ RetainedKnowledge CanonRK =
+ llvm::simplifyRetainedKnowledge(cast<AssumeInst>(II), RK,
+ &getAssumptionCache(),
+ &getDominatorTree());
if (CanonRK == RK)
continue;
if (!CanonRK) {
@@ -1694,7 +1697,7 @@ Instruction *InstCombinerImpl::visitCallInst(CallInst &CI) {
// then this one is redundant, and should be removed.
KnownBits Known(1);
computeKnownBits(IIOperand, Known, 0, II);
- if (Known.isAllOnes() && isAssumeWithEmptyBundle(*II))
+ if (Known.isAllOnes() && isAssumeWithEmptyBundle(cast<AssumeInst>(*II)))
return eraseInstFromFunction(*II);
// Update the cache of affected values for this assumption (we might be
diff --git a/llvm/lib/Transforms/Scalar/GVN.cpp b/llvm/lib/Transforms/Scalar/GVN.cpp
index 8a50920c9d59d..cafb6ad94a2eb 100644
--- a/llvm/lib/Transforms/Scalar/GVN.cpp
+++ b/llvm/lib/Transforms/Scalar/GVN.cpp
@@ -1602,9 +1602,7 @@ static bool hasUsersIn(Value *V, BasicBlock *BB) {
return false;
}
-bool GVN::processAssumeIntrinsic(IntrinsicInst *IntrinsicI) {
- assert(IntrinsicI->getIntrinsicID() == Intrinsic::assume &&
- "This function can only be called with llvm.assume intrinsic");
+bool GVN::processAssumeIntrinsic(AssumeInst *IntrinsicI) {
Value *V = IntrinsicI->getArgOperand(0);
if (ConstantInt *Cond = dyn_cast<ConstantInt>(V)) {
@@ -2185,9 +2183,8 @@ bool GVN::processInstruction(Instruction *I) {
}
}
- if (IntrinsicInst *IntrinsicI = dyn_cast<IntrinsicInst>(I))
- if (IntrinsicI->getIntrinsicID() == Intrinsic::assume)
- return processAssumeIntrinsic(IntrinsicI);
+ if (auto *Assume = dyn_cast<AssumeInst>(I))
+ return processAssumeIntrinsic(Assume);
if (LoadInst *Load = dyn_cast<LoadInst>(I)) {
if (processLoad(Load))
diff --git a/llvm/lib/Transforms/Utils/AssumeBundleBuilder.cpp b/llvm/lib/Transforms/Utils/AssumeBundleBuilder.cpp
index ca99d410f1576..2804c3c523da3 100644
--- a/llvm/lib/Transforms/Utils/AssumeBundleBuilder.cpp
+++ b/llvm/lib/Transforms/Utils/AssumeBundleBuilder.cpp
@@ -218,7 +218,7 @@ struct AssumeBuilderState {
addAttrList(Fn->getAttributes());
}
- IntrinsicInst *build() {
+ AssumeInst *build() {
if (AssumedKnowledgeMap.empty())
return nullptr;
if (!DebugCounter::shouldExecute(BuildAssumeCounter))
@@ -242,7 +242,7 @@ struct AssumeBuilderState {
NumBundlesInAssumes++;
}
NumAssumeBuilt++;
- return cast<IntrinsicInst>(CallInst::Create(
+ return cast<AssumeInst>(CallInst::Create(
FnAssume, ArrayRef<Value *>({ConstantInt::getTrue(C)}), OpBundle));
}
@@ -280,7 +280,7 @@ struct AssumeBuilderState {
} // namespace
-IntrinsicInst *llvm::buildAssumeFromInst(Instruction *I) {
+AssumeInst *llvm::buildAssumeFromInst(Instruction *I) {
if (!EnableKnowledgeRetention)
return nullptr;
AssumeBuilderState Builder(I->getModule());
@@ -294,14 +294,14 @@ void llvm::salvageKnowledge(Instruction *I, AssumptionCache *AC,
return;
AssumeBuilderState Builder(I->getModule(), I, AC, DT);
Builder.addInstruction(I);
- if (IntrinsicInst *Intr = Builder.build()) {
+ if (auto *Intr = Builder.build()) {
Intr->insertBefore(I);
if (AC)
- AC->registerAssumption(cast<AssumeInst>(Intr));
+ AC->registerAssumption(Intr);
}
}
-IntrinsicInst *
+AssumeInst *
llvm::buildAssumeFromKnowledge(ArrayRef<RetainedKnowledge> Knowledge,
Instruction *CtxI, AssumptionCache *AC,
DominatorTree *DT) {
@@ -311,11 +311,10 @@ llvm::buildAssumeFromKnowledge(ArrayRef<RetainedKnowledge> Knowledge,
return Builder.build();
}
-RetainedKnowledge llvm::simplifyRetainedKnowledge(CallBase *Assume,
+RetainedKnowledge llvm::simplifyRetainedKnowledge(AssumeInst *Assume,
RetainedKnowledge RK,
AssumptionCache *AC,
DominatorTree *DT) {
- assert(Assume->getIntrinsicID() == Intrinsic::assume);
AssumeBuilderState Builder(Assume->getModule(), Assume, AC, DT);
RK = canonicalizedKnowledge(RK, Assume->getModule()->getDataLayout());
@@ -372,7 +371,8 @@ struct AssumeSimplify {
for (IntrinsicInst *Assume : CleanupToDo) {
auto *Arg = dyn_cast<ConstantInt>(Assume->getOperand(0));
if (!Arg || Arg->isZero() ||
- (!ForceCleanup && !isAssumeWithEmptyBundle(*Assume)))
+ (!ForceCleanup &&
+ !isAssumeWithEmptyBundle(cast<AssumeInst>(*Assume))))
continue;
MadeChange = true;
if (ForceCleanup)
@@ -415,7 +415,8 @@ struct AssumeSimplify {
CleanupToDo.insert(Assume);
continue;
}
- RetainedKnowledge RK = getKnowledgeFromBundle(*Assume, BOI);
+ RetainedKnowledge RK =
+ getKnowledgeFromBundle(cast<AssumeInst>(*Assume), BOI);
if (auto *Arg = dyn_cast_or_null<Argument>(RK.WasOn)) {
bool HasSameKindAttr = Arg->hasAttribute(RK.AttrKind);
if (HasSameKindAttr)
@@ -474,7 +475,8 @@ struct AssumeSimplify {
for (IntrinsicInst *I : make_range(Begin, End)) {
CleanupToDo.insert(I);
for (CallInst::BundleOpInfo &BOI : I->bundle_op_infos()) {
- RetainedKnowledge RK = getKnowledgeFromBundle(*I, BOI);
+ RetainedKnowledge RK =
+ getKnowledgeFromBundle(cast<AssumeInst>(*I), BOI);
if (!RK)
continue;
Builder.addKnowledge(RK);
@@ -494,12 +496,12 @@ struct AssumeSimplify {
InsertPt = It->getNextNode();
break;
}
- IntrinsicInst *MergedAssume = Builder.build();
+ auto *MergedAssume = Builder.build();
if (!MergedAssume)
return;
MadeChange = true;
MergedAssume->insertBefore(InsertPt);
- AC.registerAssumption(cast<AssumeInst>(MergedAssume));
+ AC.registerAssumption(MergedAssume);
}
/// Merge assume when they are in the same BasicBlock and for all instruction
diff --git a/llvm/lib/Transforms/Utils/Local.cpp b/llvm/lib/Transforms/Utils/Local.cpp
index 5eabb1056bc4e..6f30d17e87c63 100644
--- a/llvm/lib/Transforms/Utils/Local.cpp
+++ b/llvm/lib/Transforms/Utils/Local.cpp
@@ -457,7 +457,7 @@ bool llvm::wouldInstructionBeTriviallyDead(Instruction *I,
// sophisticated tradeoffs for guards considering potential for check
// widening, but for now we keep things simple.
if ((II->getIntrinsicID() == Intrinsic::assume &&
- isAssumeWithEmptyBundle(*II)) ||
+ isAssumeWithEmptyBundle(cast<AssumeInst>(*II))) ||
II->getIntrinsicID() == Intrinsic::experimental_guard) {
if (ConstantInt *Cond = dyn_cast<ConstantInt>(II->getArgOperand(0)))
return !Cond->isZero();
diff --git a/llvm/unittests/Analysis/AssumeBundleQueriesTest.cpp b/llvm/unittests/Analysis/AssumeBundleQueriesTest.cpp
index a72761c569bb4..c33e20671bebc 100644
--- a/llvm/unittests/Analysis/AssumeBundleQueriesTest.cpp
+++ b/llvm/unittests/Analysis/AssumeBundleQueriesTest.cpp
@@ -41,8 +41,8 @@ static void RunTest(
}
}
-bool hasMatchesExactlyAttributes(IntrinsicInst *Assume, Value *WasOn,
- StringRef AttrToMatch) {
+bool hasMatchesExactlyAttributes(AssumeInst *Assume, Value *WasOn,
+ StringRef AttrToMatch) {
Regex Reg(AttrToMatch);
SmallVector<StringRef, 1> Matches;
for (StringRef Attr : {
@@ -57,7 +57,7 @@ bool hasMatchesExactlyAttributes(IntrinsicInst *Assume, Value *WasOn,
return true;
}
-bool hasTheRightValue(IntrinsicInst *Assume, Value *WasOn,
+bool hasTheRightValue(AssumeInst *Assume, Value *WasOn,
Attribute::AttrKind Kind, unsigned Value) {
uint64_t ArgVal = 0;
if (!hasAttributeInAssume(*Assume, WasOn, Kind, &ArgVal))
@@ -84,7 +84,7 @@ TEST(AssumeQueryAPI, hasAttributeInAssume) {
"call void @func(i32* nonnull align 4 dereferenceable(16) %P, i32* align "
"8 noalias %P1, i32* align 8 noundef %P2)\n",
[](Instruction *I) {
- IntrinsicInst *Assume = buildAssumeFromInst(I);
+ auto *Assume = buildAssumeFromInst(I);
Assume->insertBefore(I);
ASSERT_TRUE(hasMatchesExactlyAttributes(Assume, I->getOperand(0),
"(nonnull|align|dereferenceable)"));
@@ -106,7 +106,7 @@ TEST(AssumeQueryAPI, hasAttributeInAssume) {
"dereferenceable(4) "
"%P, i32* nonnull align 16 dereferenceable(12) %P)\n",
[](Instruction *I) {
- IntrinsicInst *Assume = buildAssumeFromInst(I);
+ auto *Assume = buildAssumeFromInst(I);
Assume->insertBefore(I);
ASSERT_TRUE(hasMatchesExactlyAttributes(Assume, I->getOperand(0),
"(nonnull|align|dereferenceable)"));
@@ -126,7 +126,7 @@ TEST(AssumeQueryAPI, hasAttributeInAssume) {
Tests.push_back(std::make_pair(
"call void @func_many(i32* align 8 noundef %P1) cold\n", [](Instruction *I) {
ShouldPreserveAllAttributes.setValue(true);
- IntrinsicInst *Assume = buildAssumeFromInst(I);
+ auto *Assume = buildAssumeFromInst(I);
Assume->insertBefore(I);
ASSERT_TRUE(hasMatchesExactlyAttributes(
Assume, nullptr,
@@ -135,7 +135,7 @@ TEST(AssumeQueryAPI, hasAttributeInAssume) {
}));
Tests.push_back(
std::make_pair("call void @llvm.assume(i1 true)\n", [](Instruction *I) {
- IntrinsicInst *Assume = cast<IntrinsicInst>(I);
+ auto *Assume = cast<AssumeInst>(I);
ASSERT_TRUE(hasMatchesExactlyAttributes(Assume, nullptr, ""));
}));
Tests.push_back(std::make_pair(
@@ -145,7 +145,7 @@ TEST(AssumeQueryAPI, hasAttributeInAssume) {
"dereferenceable(4) "
"%P2, i32* nonnull align 16 dereferenceable(12) %P3)\n",
[](Instruction *I) {
- IntrinsicInst *Assume = buildAssumeFromInst(I);
+ auto *Assume = buildAssumeFromInst(I);
Assume->insertBefore(I);
ASSERT_TRUE(hasMatchesExactlyAttributes(
Assume, I->getOperand(0),
@@ -181,7 +181,7 @@ TEST(AssumeQueryAPI, hasAttributeInAssume) {
"dereferenceable(4) "
"%P2, i32* nonnull align 16 dereferenceable(12) %P3)\n",
[](Instruction *I) {
- IntrinsicInst *Assume = buildAssumeFromInst(I);
+ auto *Assume = buildAssumeFromInst(I);
Assume->insertBefore(I);
I->getOperand(1)->dropDroppableUses();
I->getOperand(2)->dropDroppableUses();
@@ -204,7 +204,7 @@ TEST(AssumeQueryAPI, hasAttributeInAssume) {
"call void @func(i32* nonnull align 4 dereferenceable(16) %P, i32* align "
"8 noalias %P1, i32* %P1)\n",
[](Instruction *I) {
- IntrinsicInst *Assume = buildAssumeFromInst(I);
+ auto *Assume = buildAssumeFromInst(I);
Assume->insertBefore(I);
Value *New = I->getFunction()->getArg(3);
Value *Old = I->getOperand(0);
@@ -236,7 +236,7 @@ static bool FindExactlyAttributes(RetainedKnowledgeMap &Map, Value *WasOn,
return true;
}
-static bool MapHasRightValue(RetainedKnowledgeMap &Map, IntrinsicInst *II,
+static bool MapHasRightValue(RetainedKnowledgeMap &Map, AssumeInst *II,
RetainedKnowledgeKey Key, MinMax MM) {
auto LookupIt = Map.find(Key);
return (LookupIt != Map.end()) && (LookupIt->second[II].Min == MM.Min) &&
@@ -260,7 +260,7 @@ TEST(AssumeQueryAPI, fillMapFromAssume) {
"call void @func(i32* nonnull align 4 dereferenceable(16) %P, i32* align "
"8 noalias %P1, i32* align 8 dereferenceable(8) %P2)\n",
[](Instruction *I) {
- IntrinsicInst *Assume = buildAssumeFromInst(I);
+ auto *Assume = buildAssumeFromInst(I);
Assume->insertBefore(I);
RetainedKnowledgeMap Map;
@@ -285,7 +285,7 @@ TEST(AssumeQueryAPI, fillMapFromAssume) {
"dereferenceable(4) "
"%P, i32* nonnull align 16 dereferenceable(12) %P)\n",
[](Instruction *I) {
- IntrinsicInst *Assume = buildAssumeFromInst(I);
+ auto *Assume = buildAssumeFromInst(I);
Assume->insertBefore(I);
RetainedKnowledgeMap Map;
@@ -308,7 +308,7 @@ TEST(AssumeQueryAPI, fillMapFromAssume) {
Tests.push_back(std::make_pair(
"call void @func_many(i32* align 8 %P1) cold\n", [](Instruction *I) {
ShouldPreserveAllAttributes.setValue(true);
- IntrinsicInst *Assume = buildAssumeFromInst(I);
+ auto *Assume = buildAssumeFromInst(I);
Assume->insertBefore(I);
RetainedKnowledgeMap Map;
@@ -321,7 +321,7 @@ TEST(AssumeQueryAPI, fillMapFromAssume) {
Tests.push_back(
std::make_pair("call void @llvm.assume(i1 true)\n", [](Instruction *I) {
RetainedKnowledgeMap Map;
- fillMapFromAssume(*cast<IntrinsicInst>(I), Map);
+ fillMapFromAssume(*cast<AssumeInst>(I), Map);
ASSERT_TRUE(FindExactlyAttributes(Map, nullptr, ""));
ASSERT_TRUE(Map.empty());
@@ -333,7 +333,7 @@ TEST(AssumeQueryAPI, fillMapFromAssume) {
"dereferenceable(4) "
"%P2, i32* nonnull align 16 dereferenceable(12) %P3)\n",
[](Instruction *I) {
- IntrinsicInst *Assume = buildAssumeFromInst(I);
+ auto *Assume = buildAssumeFromInst(I);
Assume->insertBefore(I);
RetainedKnowledgeMap Map;
@@ -370,7 +370,7 @@ TEST(AssumeQueryAPI, fillMapFromAssume) {
"call void @func(i32* nonnull align 4 dereferenceable(16) %P, i32* align "
"8 noalias %P1, i32* %P2)\n",
[](Instruction *I) {
- IntrinsicInst *Assume = buildAssumeFromInst(I);
+ auto *Assume = buildAssumeFromInst(I);
Assume->insertBefore(I);
RetainedKnowledgeMap Map;
@@ -393,7 +393,7 @@ TEST(AssumeQueryAPI, fillMapFromAssume) {
[](Instruction *I) {
// Don't crash but don't learn from undef.
RetainedKnowledgeMap Map;
- fillMapFromAssume(*cast<IntrinsicInst>(I), Map);
+ fillMapFromAssume(*cast<AssumeInst>(I), Map);
ASSERT_TRUE(Map.empty());
}));
@@ -463,7 +463,7 @@ static void RunRandTest(uint64_t Seed, int Size, int MinCount, int MaxCount,
OpBundle.push_back(OperandBundleDef{ss.str().c_str(), std::move(Args)});
}
- auto *Assume = cast<IntrinsicInst>(IntrinsicInst::Create(
+ auto *Assume = cast<AssumeInst>(CallInst::Create(
FnAssume, ArrayRef<Value *>({ConstantInt::getTrue(C)}), OpBundle));
Assume->insertBefore(&F->begin()->front());
RetainedKnowledgeMap Map;
@@ -578,21 +578,21 @@ TEST(AssumeQueryAPI, Alignment) {
Function *F = Mod->getFunction("test");
BasicBlock::iterator Start = F->begin()->begin();
- IntrinsicInst *II;
+ AssumeInst *II;
RetainedKnowledge RK;
- II = cast<IntrinsicInst>(&*Start);
+ II = cast<AssumeInst>(&*Start);
RK = getKnowledgeFromBundle(*II, II->bundle_op_info_begin()[0]);
ASSERT_EQ(RK.AttrKind, Attribute::Alignment);
ASSERT_EQ(RK.WasOn, F->getArg(0));
ASSERT_EQ(RK.ArgValue, 1u);
Start++;
- II = cast<IntrinsicInst>(&*Start);
+ II = cast<AssumeInst>(&*Start);
RK = getKnowledgeFromBundle(*II, II->bundle_op_info_begin()[0]);
ASSERT_EQ(RK.AttrKind, Attribute::Alignment);
ASSERT_EQ(RK.WasOn, F->getArg(1));
ASSERT_EQ(RK.ArgValue, 1u);
Start++;
- II = cast<IntrinsicInst>(&*Start);
+ II = cast<AssumeInst>(&*Start);
RK = getKnowledgeFromBundle(*II, II->bundle_op_info_begin()[0]);
ASSERT_EQ(RK.AttrKind, Attribute::Alignment);
ASSERT_EQ(RK.WasOn, F->getArg(2));
More information about the llvm-commits
mailing list