[llvm] f086f38 - [Attributor][NFCI] Move attribute collection and manifest to Attributor
Johannes Doerfert via llvm-commits
llvm-commits at lists.llvm.org
Mon Jul 3 11:57:48 PDT 2023
Author: Johannes Doerfert
Date: 2023-07-03T11:57:30-07:00
New Revision: f086f383d882dc56d485470efdc306784f6e8ed9
URL: https://github.com/llvm/llvm-project/commit/f086f383d882dc56d485470efdc306784f6e8ed9
DIFF: https://github.com/llvm/llvm-project/commit/f086f383d882dc56d485470efdc306784f6e8ed9.diff
LOG: [Attributor][NFCI] Move attribute collection and manifest to Attributor
Before, we checked and manifested attributes right in the IR. This was
bad as we modified the IR before the manifest stage. Now we can
add/remove/inspect attributes w/o going to the IR (except for the
initial query).
Added:
Modified:
llvm/include/llvm/Transforms/IPO/Attributor.h
llvm/lib/Target/AMDGPU/AMDGPUAttributor.cpp
llvm/lib/Transforms/IPO/Attributor.cpp
llvm/lib/Transforms/IPO/AttributorAttributes.cpp
Removed:
################################################################################
diff --git a/llvm/include/llvm/Transforms/IPO/Attributor.h b/llvm/include/llvm/Transforms/IPO/Attributor.h
index 8d5575a55b908e..a43c4454763aeb 100644
--- a/llvm/include/llvm/Transforms/IPO/Attributor.h
+++ b/llvm/include/llvm/Transforms/IPO/Attributor.h
@@ -821,6 +821,13 @@ struct IRPosition {
"There is no attribute index for a floating or invalid position!");
}
+ /// Return the value attributes are attached to.
+ Value *getAttrListAnchor() const {
+ if (auto *CB = dyn_cast<CallBase>(&getAnchorValue()))
+ return CB;
+ return getAssociatedFunction();
+ }
+
/// Return the attributes associated with this function or call site scope.
AttributeList getAttrList() const {
if (auto *CB = dyn_cast<CallBase>(&getAnchorValue()))
@@ -878,51 +885,6 @@ struct IRPosition {
return IRP_FLOAT;
}
- /// TODO: Figure out if the attribute related helper functions should live
- /// here or somewhere else.
-
- /// Return true if any kind in \p AKs existing in the IR at a position that
- /// will affect this one. See also getAttrs(...).
- /// \param IgnoreSubsumingPositions Flag to determine if subsuming positions,
- /// e.g., the function position if this is an
- /// argument position, should be ignored.
- bool hasAttr(ArrayRef<Attribute::AttrKind> AKs,
- bool IgnoreSubsumingPositions = false,
- Attributor *A = nullptr) const;
-
- /// Return the attributes of any kind in \p AKs existing in the IR at a
- /// position that will affect this one. While each position can only have a
- /// single attribute of any kind in \p AKs, there are "subsuming" positions
- /// that could have an attribute as well. This method returns all attributes
- /// found in \p Attrs.
- /// \param IgnoreSubsumingPositions Flag to determine if subsuming positions,
- /// e.g., the function position if this is an
- /// argument position, should be ignored.
- void getAttrs(ArrayRef<Attribute::AttrKind> AKs,
- SmallVectorImpl<Attribute> &Attrs,
- bool IgnoreSubsumingPositions = false,
- Attributor *A = nullptr) const;
-
- /// Remove the attribute of kind \p AKs existing in the IR at this position.
- void removeAttrs(ArrayRef<Attribute::AttrKind> AKs) const {
- if (getPositionKind() == IRP_INVALID || getPositionKind() == IRP_FLOAT)
- return;
-
- AttributeList AttrList = getAttrList();
-
- bool Changed = false;
- unsigned Idx = getAttrIdx();
- LLVMContext &Ctx = getAnchorValue().getContext();
- for (Attribute::AttrKind AK : AKs) {
- if (!AttrList.hasAttributeAtIndex(Idx, AK))
- continue;
- Changed = true;
- AttrList = AttrList.removeAttributeAtIndex(Ctx, Idx, AK);
- }
- if (Changed)
- setAttrList(AttrList);
- }
-
bool isAnyCallSitePosition() const {
switch (getPositionKind()) {
case IRPosition::IRP_CALL_SITE:
@@ -1041,16 +1003,6 @@ struct IRPosition {
/// Verify internal invariants.
void verify();
- /// Return the attributes of kind \p AK existing in the IR as attribute.
- bool getAttrsFromIRAttr(Attribute::AttrKind AK,
- SmallVectorImpl<Attribute> &Attrs) const;
-
- /// Return the attributes of kind \p AK existing in the IR as operand bundles
- /// of an llvm.assume.
- bool getAttrsFromAssumes(Attribute::AttrKind AK,
- SmallVectorImpl<Attribute> &Attrs,
- Attributor &A) const;
-
/// Return the underlying pointer as Value *, valid for all positions but
/// IRP_CALL_SITE_ARGUMENT.
Value *getAsValuePtr() const {
@@ -1893,6 +1845,52 @@ struct Attributor {
ToBeDeletedFunctions.insert(&F);
}
+ /// Return the attributes of kind \p AK existing in the IR as operand bundles
+ /// of an llvm.assume.
+ bool getAttrsFromAssumes(const IRPosition &IRP, Attribute::AttrKind AK,
+ SmallVectorImpl<Attribute> &Attrs);
+
+ /// Return true if any kind in \p AKs existing in the IR at a position that
+ /// will affect this one. See also getAttrs(...).
+ /// \param IgnoreSubsumingPositions Flag to determine if subsuming positions,
+ /// e.g., the function position if this is an
+ /// argument position, should be ignored.
+ bool hasAttr(const IRPosition &IRP, ArrayRef<Attribute::AttrKind> AKs,
+ bool IgnoreSubsumingPositions = false,
+ Attribute::AttrKind ImpliedAttributeKind = Attribute::None);
+
+ /// Return the attributes of any kind in \p AKs existing in the IR at a
+ /// position that will affect this one. While each position can only have a
+ /// single attribute of any kind in \p AKs, there are "subsuming" positions
+ /// that could have an attribute as well. This method returns all attributes
+ /// found in \p Attrs.
+ /// \param IgnoreSubsumingPositions Flag to determine if subsuming positions,
+ /// e.g., the function position if this is an
+ /// argument position, should be ignored.
+ void getAttrs(const IRPosition &IRP, ArrayRef<Attribute::AttrKind> AKs,
+ SmallVectorImpl<Attribute> &Attrs,
+ bool IgnoreSubsumingPositions = false);
+
+ ChangeStatus removeAttrs(const IRPosition &IRP,
+ const ArrayRef<Attribute::AttrKind> &AttrKinds);
+
+ ChangeStatus manifestAttrs(const IRPosition &IRP,
+ const ArrayRef<Attribute> &DeducedAttrs,
+ bool ForceReplace = false);
+
+private:
+ /// Helper to apply \p CB on all attributes of type \p AttrDescs of \p IRP.
+ template <typename DescTy>
+ ChangeStatus updateAttrMap(const IRPosition &IRP,
+ const ArrayRef<DescTy> &AttrDescs,
+ function_ref<bool(const DescTy &, AttributeSet,
+ AttributeMask &, AttrBuilder &)>
+ CB);
+
+ /// Mapping from functions/call sites to their attributes.
+ DenseMap<Value *, AttributeList> AttrsMap;
+
+public:
/// If \p IRP is assumed to be a constant, return it, if it is unclear yet,
/// return std::nullopt, otherwise return `nullptr`.
std::optional<Constant *> getAssumedConstant(const IRPosition &IRP,
@@ -3095,14 +3093,6 @@ template <typename BaseTy> struct SetState : public AbstractState {
bool IsAtFixedpoint;
};
-/// Helper struct necessary as the modular build fails if the virtual method
-/// IRAttribute::manifest is defined in the Attributor.cpp.
-struct IRAttributeManifest {
- static ChangeStatus manifestAttrs(Attributor &A, const IRPosition &IRP,
- const ArrayRef<Attribute> &DeducedAttrs,
- bool ForceReplace = false);
-};
-
/// Helper to tie a abstract state implementation to an abstract attribute.
template <typename StateTy, typename BaseType, class... Ts>
struct StateWrapper : public BaseType, public StateTy {
@@ -3129,7 +3119,7 @@ struct IRAttribute : public BaseType {
bool IgnoreSubsumingPositions = false) {
if (isa<UndefValue>(IRP.getAssociatedValue()))
return true;
- return IRP.hasAttr(AttrKinds, IgnoreSubsumingPositions, &A);
+ return A.hasAttr(IRP, AttrKinds, IgnoreSubsumingPositions);
}
/// See AbstractAttribute::initialize(...).
@@ -3147,8 +3137,9 @@ struct IRAttribute : public BaseType {
return ChangeStatus::UNCHANGED;
SmallVector<Attribute, 4> DeducedAttrs;
getDeducedAttributes(this->getAnchorValue().getContext(), DeducedAttrs);
- return IRAttributeManifest::manifestAttrs(A, this->getIRPosition(),
- DeducedAttrs);
+ if (DeducedAttrs.empty())
+ return ChangeStatus::UNCHANGED;
+ return A.manifestAttrs(this->getIRPosition(), DeducedAttrs);
}
/// Return the kind that identifies the abstract attribute implementation.
@@ -3627,8 +3618,8 @@ struct AAWillReturn
return false;
SmallVector<Attribute, 1> Attrs;
- IRP.getAttrs({Attribute::Memory}, Attrs,
- /* IgnoreSubsumingPositions */ false);
+ A.getAttrs(IRP, {Attribute::Memory}, Attrs,
+ /* IgnoreSubsumingPositions */ false);
MemoryEffects ME = MemoryEffects::unknown();
for (const Attribute &Attr : Attrs)
diff --git a/llvm/lib/Target/AMDGPU/AMDGPUAttributor.cpp b/llvm/lib/Target/AMDGPU/AMDGPUAttributor.cpp
index cc6d00d6bfb7e1..887978e8872e6a 100644
--- a/llvm/lib/Target/AMDGPU/AMDGPUAttributor.cpp
+++ b/llvm/lib/Target/AMDGPU/AMDGPUAttributor.cpp
@@ -368,8 +368,8 @@ struct AAUniformWorkGroupSizeFunction : public AAUniformWorkGroupSize {
AttrList.push_back(Attribute::get(Ctx, "uniform-work-group-size",
getAssumed() ? "true" : "false"));
- return IRAttributeManifest::manifestAttrs(A, getIRPosition(), AttrList,
- /* ForceReplace */ true);
+ return A.manifestAttrs(getIRPosition(), AttrList,
+ /* ForceReplace */ true);
}
bool isValidState() const override {
@@ -526,8 +526,8 @@ struct AAAMDAttributesFunction : public AAAMDAttributes {
AttrList.push_back(Attribute::get(Ctx, Attr.second));
}
- return IRAttributeManifest::manifestAttrs(A, getIRPosition(), AttrList,
- /* ForceReplace */ true);
+ return A.manifestAttrs(getIRPosition(), AttrList,
+ /* ForceReplace */ true);
}
const std::string getAsStr() const override {
@@ -732,9 +732,9 @@ struct AAAMDSizeRangeAttribute
SmallString<10> Buffer;
raw_svector_ostream OS(Buffer);
OS << getAssumed().getLower() << ',' << getAssumed().getUpper() - 1;
- return IRAttributeManifest::manifestAttrs(
- A, getIRPosition(), {Attribute::get(Ctx, AttrName, OS.str())},
- /* ForceReplace */ true);
+ return A.manifestAttrs(getIRPosition(),
+ {Attribute::get(Ctx, AttrName, OS.str())},
+ /* ForceReplace */ true);
}
const std::string getAsStr() const override {
diff --git a/llvm/lib/Transforms/IPO/Attributor.cpp b/llvm/lib/Transforms/IPO/Attributor.cpp
index bdb4d49c714d7b..53688645621027 100644
--- a/llvm/lib/Transforms/IPO/Attributor.cpp
+++ b/llvm/lib/Transforms/IPO/Attributor.cpp
@@ -15,6 +15,7 @@
#include "llvm/Transforms/IPO/Attributor.h"
+#include "llvm/ADT/ArrayRef.h"
#include "llvm/ADT/PointerIntPair.h"
#include "llvm/ADT/STLExtras.h"
#include "llvm/ADT/Statistic.h"
@@ -24,6 +25,7 @@
#include "llvm/Analysis/InlineCost.h"
#include "llvm/Analysis/MemoryBuiltins.h"
#include "llvm/Analysis/MustExecute.h"
+#include "llvm/IR/AttributeMask.h"
#include "llvm/IR/Attributes.h"
#include "llvm/IR/Constant.h"
#include "llvm/IR/ConstantFold.h"
@@ -34,6 +36,7 @@
#include "llvm/IR/Instruction.h"
#include "llvm/IR/Instructions.h"
#include "llvm/IR/IntrinsicInst.h"
+#include "llvm/IR/LLVMContext.h"
#include "llvm/IR/ValueHandle.h"
#include "llvm/Support/Casting.h"
#include "llvm/Support/CommandLine.h"
@@ -905,51 +908,42 @@ static bool isEqualOrWorse(const Attribute &New, const Attribute &Old) {
}
/// Return true if the information provided by \p Attr was added to the
-/// attribute list \p Attrs. This is only the case if it was not already present
-/// in \p Attrs at the position describe by \p PK and \p AttrIdx.
+/// attribute set \p AttrSet. This is only the case if it was not already
+/// present in \p AttrSet.
static bool addIfNotExistent(LLVMContext &Ctx, const Attribute &Attr,
- AttributeList &Attrs, int AttrIdx,
- bool ForceReplace = false) {
+ AttributeSet AttrSet, bool ForceReplace,
+ AttrBuilder &AB) {
if (Attr.isEnumAttribute()) {
Attribute::AttrKind Kind = Attr.getKindAsEnum();
- if (Attrs.hasAttributeAtIndex(AttrIdx, Kind))
- if (!ForceReplace &&
- isEqualOrWorse(Attr, Attrs.getAttributeAtIndex(AttrIdx, Kind)))
- return false;
- Attrs = Attrs.addAttributeAtIndex(Ctx, AttrIdx, Attr);
+ if (AttrSet.hasAttribute(Kind))
+ return false;
+ AB.addAttribute(Kind);
return true;
}
if (Attr.isStringAttribute()) {
StringRef Kind = Attr.getKindAsString();
- if (Attrs.hasAttributeAtIndex(AttrIdx, Kind))
- if (!ForceReplace &&
- isEqualOrWorse(Attr, Attrs.getAttributeAtIndex(AttrIdx, Kind)))
+ if (AttrSet.hasAttribute(Kind)) {
+ if (!ForceReplace)
return false;
- Attrs = Attrs.addAttributeAtIndex(Ctx, AttrIdx, Attr);
+ }
+ AB.addAttribute(Kind, Attr.getValueAsString());
return true;
}
if (Attr.isIntAttribute()) {
Attribute::AttrKind Kind = Attr.getKindAsEnum();
- if (Attrs.hasAttributeAtIndex(AttrIdx, Kind)) {
- if (!ForceReplace && Kind == Attribute::Memory) {
- MemoryEffects ExistingME =
- Attrs.getAttributeAtIndex(AttrIdx, Attribute::Memory)
- .getMemoryEffects();
- MemoryEffects ME = Attr.getMemoryEffects() & ExistingME;
- if (ME == ExistingME)
- return false;
- Attrs = Attrs.removeAttributeAtIndex(Ctx, AttrIdx, Kind);
- Attrs = Attrs.addAttributesAtIndex(Ctx, AttrIdx,
- AttrBuilder(Ctx).addMemoryAttr(ME));
- return true;
- }
- if (!ForceReplace &&
- isEqualOrWorse(Attr, Attrs.getAttributeAtIndex(AttrIdx, Kind)))
+ if (!ForceReplace && Kind == Attribute::Memory) {
+ MemoryEffects ME = Attr.getMemoryEffects() & AttrSet.getMemoryEffects();
+ if (ME == AttrSet.getMemoryEffects())
+ return false;
+ AB.addMemoryAttr(ME);
+ return true;
+ }
+ if (AttrSet.hasAttribute(Kind)) {
+ if (!ForceReplace && isEqualOrWorse(Attr, AttrSet.getAttribute(Kind)))
return false;
}
- Attrs = Attrs.removeAttributeAtIndex(Ctx, AttrIdx, Kind);
- Attrs = Attrs.addAttributeAtIndex(Ctx, AttrIdx, Attr);
+ AB.addAttribute(Attr);
return true;
}
@@ -1025,11 +1019,44 @@ ChangeStatus AbstractAttribute::update(Attributor &A) {
return HasChanged;
}
+bool Attributor::getAttrsFromAssumes(const IRPosition &IRP,
+ Attribute::AttrKind AK,
+ SmallVectorImpl<Attribute> &Attrs) {
+ assert(IRP.getPositionKind() != IRPosition::IRP_INVALID &&
+ "Did expect a valid position!");
+ MustBeExecutedContextExplorer *Explorer =
+ getInfoCache().getMustBeExecutedContextExplorer();
+ if (!Explorer)
+ return false;
+
+ Value &AssociatedValue = IRP.getAssociatedValue();
+
+ const Assume2KnowledgeMap &A2K =
+ getInfoCache().getKnowledgeMap().lookup({&AssociatedValue, AK});
+
+ // Check if we found any potential assume use, if not we don't need to create
+ // explorer iterators.
+ if (A2K.empty())
+ return false;
+
+ LLVMContext &Ctx = AssociatedValue.getContext();
+ unsigned AttrsSize = Attrs.size();
+ auto EIt = Explorer->begin(IRP.getCtxI()),
+ EEnd = Explorer->end(IRP.getCtxI());
+ for (const auto &It : A2K)
+ if (Explorer->findInContextOf(It.first, EIt, EEnd))
+ Attrs.push_back(Attribute::get(Ctx, AK, It.second.Max));
+ return AttrsSize != Attrs.size();
+}
+
+template <typename DescTy>
ChangeStatus
-IRAttributeManifest::manifestAttrs(Attributor &A, const IRPosition &IRP,
- const ArrayRef<Attribute> &DeducedAttrs,
- bool ForceReplace) {
- if (DeducedAttrs.empty())
+Attributor::updateAttrMap(const IRPosition &IRP,
+ const ArrayRef<DescTy> &AttrDescs,
+ function_ref<bool(const DescTy &, AttributeSet,
+ AttributeMask &, AttrBuilder &)>
+ CB) {
+ if (AttrDescs.empty())
return ChangeStatus::UNCHANGED;
switch (IRP.getPositionKind()) {
case IRPosition::IRP_FLOAT:
@@ -1039,25 +1066,121 @@ IRAttributeManifest::manifestAttrs(Attributor &A, const IRPosition &IRP,
break;
};
- // In the following some generic code that will manifest attributes in
- // DeducedAttrs if they improve the current IR. Due to the
diff erent
- // annotation positions we use the underlying AttributeList interface.
- AttributeList Attrs = IRP.getAttrList();
+ AttributeList AL;
+ Value *AttrListAnchor = IRP.getAttrListAnchor();
+ auto It = AttrsMap.find(AttrListAnchor);
+ if (It == AttrsMap.end())
+ AL = IRP.getAttrList();
+ else
+ AL = It->getSecond();
- ChangeStatus HasChanged = ChangeStatus::UNCHANGED;
LLVMContext &Ctx = IRP.getAnchorValue().getContext();
- for (const Attribute &Attr : DeducedAttrs) {
- if (!addIfNotExistent(Ctx, Attr, Attrs, IRP.getAttrIdx(), ForceReplace))
- continue;
+ auto AttrIdx = IRP.getAttrIdx();
+ AttributeSet AS = AL.getAttributes(AttrIdx);
+ AttributeMask AM;
+ AttrBuilder AB(Ctx);
- HasChanged = ChangeStatus::CHANGED;
- }
+ ChangeStatus HasChanged = ChangeStatus::UNCHANGED;
+ for (const DescTy &AttrDesc : AttrDescs)
+ if (CB(AttrDesc, AS, AM, AB))
+ HasChanged = ChangeStatus::CHANGED;
if (HasChanged == ChangeStatus::UNCHANGED)
- return HasChanged;
+ return ChangeStatus::UNCHANGED;
- IRP.setAttrList(Attrs);
- return HasChanged;
+ AL = AL.removeAttributesAtIndex(Ctx, AttrIdx, AM);
+ AL = AL.addAttributesAtIndex(Ctx, AttrIdx, AB);
+ AttrsMap[AttrListAnchor] = AL;
+ return ChangeStatus::CHANGED;
+}
+
+bool Attributor::hasAttr(const IRPosition &IRP,
+ ArrayRef<Attribute::AttrKind> AttrKinds,
+ bool IgnoreSubsumingPositions,
+ Attribute::AttrKind ImpliedAttributeKind) {
+ bool Implied = false;
+ bool HasAttr = false;
+ auto HasAttrCB = [&](const Attribute::AttrKind &Kind, AttributeSet AttrSet,
+ AttributeMask &, AttrBuilder &) {
+ if (AttrSet.hasAttribute(Kind)) {
+ Implied |= Kind != ImpliedAttributeKind;
+ HasAttr = true;
+ }
+ return false;
+ };
+ for (const IRPosition &EquivIRP : SubsumingPositionIterator(IRP)) {
+ updateAttrMap<Attribute::AttrKind>(EquivIRP, AttrKinds, HasAttrCB);
+ if (HasAttr)
+ break;
+ // The first position returned by the SubsumingPositionIterator is
+ // always the position itself. If we ignore subsuming positions we
+ // are done after the first iteration.
+ if (IgnoreSubsumingPositions)
+ break;
+ Implied = true;
+ }
+ if (!HasAttr) {
+ Implied = true;
+ SmallVector<Attribute> Attrs;
+ for (Attribute::AttrKind AK : AttrKinds)
+ if (getAttrsFromAssumes(IRP, AK, Attrs)) {
+ HasAttr = true;
+ break;
+ }
+ }
+
+ // Check if we should manifest the implied attribute kind at the IRP.
+ if (ImpliedAttributeKind != Attribute::None && HasAttr && Implied)
+ manifestAttrs(IRP, {Attribute::get(IRP.getAnchorValue().getContext(),
+ ImpliedAttributeKind)});
+ return HasAttr;
+}
+
+void Attributor::getAttrs(const IRPosition &IRP,
+ ArrayRef<Attribute::AttrKind> AttrKinds,
+ SmallVectorImpl<Attribute> &Attrs,
+ bool IgnoreSubsumingPositions) {
+ auto CollectAttrCB = [&](const Attribute::AttrKind &Kind,
+ AttributeSet AttrSet, AttributeMask &,
+ AttrBuilder &) {
+ if (AttrSet.hasAttribute(Kind))
+ Attrs.push_back(AttrSet.getAttribute(Kind));
+ return false;
+ };
+ for (const IRPosition &EquivIRP : SubsumingPositionIterator(IRP)) {
+ updateAttrMap<Attribute::AttrKind>(EquivIRP, AttrKinds, CollectAttrCB);
+ // The first position returned by the SubsumingPositionIterator is
+ // always the position itself. If we ignore subsuming positions we
+ // are done after the first iteration.
+ if (IgnoreSubsumingPositions)
+ break;
+ }
+ for (Attribute::AttrKind AK : AttrKinds)
+ getAttrsFromAssumes(IRP, AK, Attrs);
+}
+
+ChangeStatus
+Attributor::removeAttrs(const IRPosition &IRP,
+ const ArrayRef<Attribute::AttrKind> &AttrKinds) {
+ auto RemoveAttrCB = [&](const Attribute::AttrKind &Kind, AttributeSet AttrSet,
+ AttributeMask &AM, AttrBuilder &) {
+ if (!AttrSet.hasAttribute(Kind))
+ return false;
+ AM.addAttribute(Kind);
+ return true;
+ };
+ return updateAttrMap<Attribute::AttrKind>(IRP, AttrKinds, RemoveAttrCB);
+}
+
+ChangeStatus Attributor::manifestAttrs(const IRPosition &IRP,
+ const ArrayRef<Attribute> &Attrs,
+ bool ForceReplace) {
+ LLVMContext &Ctx = IRP.getAnchorValue().getContext();
+ auto AddAttrCB = [&](const Attribute &Attr, AttributeSet AttrSet,
+ AttributeMask &, AttrBuilder &AB) {
+ return addIfNotExistent(Ctx, Attr, AttrSet, ForceReplace, AB);
+ };
+ return updateAttrMap<Attribute>(IRP, Attrs, AddAttrCB);
}
const IRPosition IRPosition::EmptyKey(DenseMapInfo<void *>::getEmptyKey());
@@ -1131,83 +1254,6 @@ SubsumingPositionIterator::SubsumingPositionIterator(const IRPosition &IRP) {
}
}
-bool IRPosition::hasAttr(ArrayRef<Attribute::AttrKind> AKs,
- bool IgnoreSubsumingPositions, Attributor *A) const {
- SmallVector<Attribute, 4> Attrs;
- for (const IRPosition &EquivIRP : SubsumingPositionIterator(*this)) {
- for (Attribute::AttrKind AK : AKs)
- if (EquivIRP.getAttrsFromIRAttr(AK, Attrs))
- return true;
- // The first position returned by the SubsumingPositionIterator is
- // always the position itself. If we ignore subsuming positions we
- // are done after the first iteration.
- if (IgnoreSubsumingPositions)
- break;
- }
- if (A)
- for (Attribute::AttrKind AK : AKs)
- if (getAttrsFromAssumes(AK, Attrs, *A))
- return true;
- return false;
-}
-
-void IRPosition::getAttrs(ArrayRef<Attribute::AttrKind> AKs,
- SmallVectorImpl<Attribute> &Attrs,
- bool IgnoreSubsumingPositions, Attributor *A) const {
- for (const IRPosition &EquivIRP : SubsumingPositionIterator(*this)) {
- for (Attribute::AttrKind AK : AKs)
- EquivIRP.getAttrsFromIRAttr(AK, Attrs);
- // The first position returned by the SubsumingPositionIterator is
- // always the position itself. If we ignore subsuming positions we
- // are done after the first iteration.
- if (IgnoreSubsumingPositions)
- break;
- }
- if (A)
- for (Attribute::AttrKind AK : AKs)
- getAttrsFromAssumes(AK, Attrs, *A);
-}
-
-bool IRPosition::getAttrsFromIRAttr(Attribute::AttrKind AK,
- SmallVectorImpl<Attribute> &Attrs) const {
- if (getPositionKind() == IRP_INVALID || getPositionKind() == IRP_FLOAT)
- return false;
-
- AttributeList AttrList = getAttrList();
-
- bool HasAttr = AttrList.hasAttributeAtIndex(getAttrIdx(), AK);
- if (HasAttr)
- Attrs.push_back(AttrList.getAttributeAtIndex(getAttrIdx(), AK));
- return HasAttr;
-}
-
-bool IRPosition::getAttrsFromAssumes(Attribute::AttrKind AK,
- SmallVectorImpl<Attribute> &Attrs,
- Attributor &A) const {
- assert(getPositionKind() != IRP_INVALID && "Did expect a valid position!");
- Value &AssociatedValue = getAssociatedValue();
-
- const Assume2KnowledgeMap &A2K =
- A.getInfoCache().getKnowledgeMap().lookup({&AssociatedValue, AK});
-
- // Check if we found any potential assume use, if not we don't need to create
- // explorer iterators.
- if (A2K.empty())
- return false;
-
- LLVMContext &Ctx = AssociatedValue.getContext();
- unsigned AttrsSize = Attrs.size();
- MustBeExecutedContextExplorer *Explorer =
- A.getInfoCache().getMustBeExecutedContextExplorer();
- if (!Explorer)
- return false;
- auto EIt = Explorer->begin(getCtxI()), EEnd = Explorer->end(getCtxI());
- for (const auto &It : A2K)
- if (Explorer->findInContextOf(It.first, EIt, EEnd))
- Attrs.push_back(Attribute::get(Ctx, AK, It.second.Max));
- return AttrsSize != Attrs.size();
-}
-
void IRPosition::verify() {
#ifdef EXPENSIVE_CHECKS
switch (getPositionKind()) {
@@ -2202,6 +2248,16 @@ ChangeStatus Attributor::manifestAttributes() {
llvm_unreachable("Expected the final number of abstract attributes to "
"remain unchanged!");
}
+
+ for (auto &It : AttrsMap) {
+ AttributeList &AL = It.getSecond();
+ const IRPosition &IRP =
+ isa<Function>(It.getFirst())
+ ? IRPosition::function(*cast<Function>(It.getFirst()))
+ : IRPosition::callsite_function(*cast<CallBase>(It.getFirst()));
+ IRP.setAttrList(AL);
+ }
+
return ManifestChange;
}
diff --git a/llvm/lib/Transforms/IPO/AttributorAttributes.cpp b/llvm/lib/Transforms/IPO/AttributorAttributes.cpp
index db973f7f1caec0..ad9d3c6ace3857 100644
--- a/llvm/lib/Transforms/IPO/AttributorAttributes.cpp
+++ b/llvm/lib/Transforms/IPO/AttributorAttributes.cpp
@@ -39,6 +39,7 @@
#include "llvm/Analysis/ValueTracking.h"
#include "llvm/IR/Argument.h"
#include "llvm/IR/Assumptions.h"
+#include "llvm/IR/Attributes.h"
#include "llvm/IR/BasicBlock.h"
#include "llvm/IR/Constant.h"
#include "llvm/IR/Constants.h"
@@ -2698,8 +2699,9 @@ struct AANonNullImpl : AANonNull {
void initialize(Attributor &A) override {
Value &V = *getAssociatedValue().stripPointerCasts();
if (!NullIsDefined &&
- hasAttr({Attribute::NonNull, Attribute::Dereferenceable},
- /* IgnoreSubsumingPositions */ false, &A)) {
+ A.hasAttr(getIRPosition(),
+ {Attribute::NonNull, Attribute::Dereferenceable},
+ /* IgnoreSubsumingPositions */ false)) {
indicateOptimisticFixpoint();
return;
}
@@ -3045,8 +3047,9 @@ struct AANonConvergentFunction final : AANonConvergentImpl {
}
ChangeStatus manifest(Attributor &A) override {
- if (isKnownNotConvergent() && hasAttr(Attribute::Convergent)) {
- removeAttrs({Attribute::Convergent});
+ if (isKnownNotConvergent() &&
+ A.hasAttr(getIRPosition(), Attribute::Convergent)) {
+ A.removeAttrs(getIRPosition(), {Attribute::Convergent});
return ChangeStatus::CHANGED;
}
return ChangeStatus::UNCHANGED;
@@ -3905,7 +3908,7 @@ struct AANoAliasArgument final
void initialize(Attributor &A) override {
Base::initialize(A);
// See callsite argument attribute and callee argument attribute.
- if (hasAttr({Attribute::ByVal}))
+ if (A.hasAttr(getIRPosition(), {Attribute::ByVal}))
indicateOptimisticFixpoint();
}
@@ -5026,8 +5029,9 @@ struct AADereferenceableImpl : AADereferenceable {
void initialize(Attributor &A) override {
Value &V = *getAssociatedValue().stripPointerCasts();
SmallVector<Attribute, 4> Attrs;
- getAttrs({Attribute::Dereferenceable, Attribute::DereferenceableOrNull},
- Attrs, /* IgnoreSubsumingPositions */ false, &A);
+ A.getAttrs(getIRPosition(),
+ {Attribute::Dereferenceable, Attribute::DereferenceableOrNull},
+ Attrs, /* IgnoreSubsumingPositions */ false);
for (const Attribute &Attr : Attrs)
takeKnownDerefBytesMaximum(Attr.getValueAsInt());
@@ -5084,8 +5088,9 @@ struct AADereferenceableImpl : AADereferenceable {
/// See AbstractAttribute::manifest(...).
ChangeStatus manifest(Attributor &A) override {
ChangeStatus Change = AADereferenceable::manifest(A);
- if (isAssumedNonNull() && hasAttr(Attribute::DereferenceableOrNull)) {
- removeAttrs({Attribute::DereferenceableOrNull});
+ if (isAssumedNonNull() &&
+ A.hasAttr(getIRPosition(), Attribute::DereferenceableOrNull)) {
+ A.removeAttrs(getIRPosition(), {Attribute::DereferenceableOrNull});
return ChangeStatus::CHANGED;
}
return Change;
@@ -5326,7 +5331,7 @@ struct AAAlignImpl : AAAlign {
/// See AbstractAttribute::initialize(...).
void initialize(Attributor &A) override {
SmallVector<Attribute, 4> Attrs;
- getAttrs({Attribute::Alignment}, Attrs);
+ A.getAttrs(getIRPosition(), {Attribute::Alignment}, Attrs);
for (const Attribute &Attr : Attrs)
takeKnownMaximum(Attr.getValueAsInt());
@@ -5805,7 +5810,8 @@ struct AANoCaptureImpl : public AANoCapture {
/// See AbstractAttribute::initialize(...).
void initialize(Attributor &A) override {
- if (hasAttr(getAttrKind(), /* IgnoreSubsumingPositions */ true)) {
+ if (A.hasAttr(getIRPosition(), getAttrKind(),
+ /* IgnoreSubsumingPositions */ true)) {
indicateOptimisticFixpoint();
return;
}
@@ -6388,9 +6394,10 @@ struct AAValueSimplifyArgument final : AAValueSimplifyImpl {
void initialize(Attributor &A) override {
AAValueSimplifyImpl::initialize(A);
- if (hasAttr({Attribute::InAlloca, Attribute::Preallocated,
- Attribute::StructRet, Attribute::Nest, Attribute::ByVal},
- /* IgnoreSubsumingPositions */ true))
+ if (A.hasAttr(getIRPosition(),
+ {Attribute::InAlloca, Attribute::Preallocated,
+ Attribute::StructRet, Attribute::Nest, Attribute::ByVal},
+ /* IgnoreSubsumingPositions */ true))
indicatePessimisticFixpoint();
}
@@ -7295,7 +7302,8 @@ struct AAPrivatizablePtrArgument final : public AAPrivatizablePtrImpl {
// rewrite them), there is no need to check them explicitly.
bool UsedAssumedInformation = false;
SmallVector<Attribute, 1> Attrs;
- getAttrs({Attribute::ByVal}, Attrs, /* IgnoreSubsumingPositions */ true);
+ A.getAttrs(getIRPosition(), {Attribute::ByVal}, Attrs,
+ /* IgnoreSubsumingPositions */ true);
if (!Attrs.empty() &&
A.checkForAllCallSites([](AbstractCallSite ACS) { return true; }, *this,
true, UsedAssumedInformation))
@@ -7370,7 +7378,7 @@ struct AAPrivatizablePtrArgument final : public AAPrivatizablePtrImpl {
DepClassTy::OPTIONAL);
// Avoid arguments with padding for now.
- if (!getIRPosition().hasAttr(Attribute::ByVal) &&
+ if (!A.hasAttr(getIRPosition(), Attribute::ByVal) &&
!isDenselyPacked(*PrivatizableType, A.getInfoCache().getDL())) {
LLVM_DEBUG(dbgs() << "[AAPrivatizablePtr] Padding detected\n");
return indicatePessimisticFixpoint();
@@ -7774,7 +7782,7 @@ struct AAPrivatizablePtrCallSiteArgument final
/// See AbstractAttribute::initialize(...).
void initialize(Attributor &A) override {
- if (getIRPosition().hasAttr(Attribute::ByVal))
+ if (A.hasAttr(getIRPosition(), Attribute::ByVal))
indicateOptimisticFixpoint();
}
@@ -7861,16 +7869,16 @@ struct AAMemoryBehaviorImpl : public AAMemoryBehavior {
/// See AbstractAttribute::initialize(...).
void initialize(Attributor &A) override {
intersectAssumedBits(BEST_STATE);
- getKnownStateFromValue(getIRPosition(), getState());
+ getKnownStateFromValue(A, getIRPosition(), getState());
AAMemoryBehavior::initialize(A);
}
/// Return the memory behavior information encoded in the IR for \p IRP.
- static void getKnownStateFromValue(const IRPosition &IRP,
+ static void getKnownStateFromValue(Attributor &A, const IRPosition &IRP,
BitIntegerState &State,
bool IgnoreSubsumingPositions = false) {
SmallVector<Attribute, 2> Attrs;
- IRP.getAttrs(AttrKinds, Attrs, IgnoreSubsumingPositions);
+ A.getAttrs(IRP, AttrKinds, Attrs, IgnoreSubsumingPositions);
for (const Attribute &Attr : Attrs) {
switch (Attr.getKindAsEnum()) {
case Attribute::ReadNone:
@@ -7910,22 +7918,23 @@ struct AAMemoryBehaviorImpl : public AAMemoryBehavior {
/// See AbstractAttribute::manifest(...).
ChangeStatus manifest(Attributor &A) override {
- if (hasAttr(Attribute::ReadNone, /* IgnoreSubsumingPositions */ true))
- return ChangeStatus::UNCHANGED;
-
const IRPosition &IRP = getIRPosition();
+ if (A.hasAttr(IRP, Attribute::ReadNone,
+ /* IgnoreSubsumingPositions */ true))
+ return ChangeStatus::UNCHANGED;
+
// Check if we would improve the existing attributes first.
SmallVector<Attribute, 4> DeducedAttrs;
getDeducedAttributes(IRP.getAnchorValue().getContext(), DeducedAttrs);
if (llvm::all_of(DeducedAttrs, [&](const Attribute &Attr) {
- return IRP.hasAttr(Attr.getKindAsEnum(),
- /* IgnoreSubsumingPositions */ true);
+ return A.hasAttr(IRP, Attr.getKindAsEnum(),
+ /* IgnoreSubsumingPositions */ true);
}))
return ChangeStatus::UNCHANGED;
// Clear existing attributes.
- IRP.removeAttrs(AttrKinds);
+ A.removeAttrs(IRP, AttrKinds);
// Use the generic manifest method.
return IRAttribute::manifest(A);
@@ -7989,9 +7998,9 @@ struct AAMemoryBehaviorArgument : AAMemoryBehaviorFloating {
// TODO: Make IgnoreSubsumingPositions a property of an IRAttribute so we
// can query it when we use has/getAttr. That would allow us to reuse the
// initialize of the base class here.
- bool HasByVal =
- IRP.hasAttr({Attribute::ByVal}, /* IgnoreSubsumingPositions */ true);
- getKnownStateFromValue(IRP, getState(),
+ bool HasByVal = A.hasAttr(IRP, {Attribute::ByVal},
+ /* IgnoreSubsumingPositions */ true);
+ getKnownStateFromValue(A, IRP, getState(),
/* IgnoreSubsumingPositions */ HasByVal);
}
@@ -8002,11 +8011,12 @@ struct AAMemoryBehaviorArgument : AAMemoryBehaviorFloating {
// TODO: From readattrs.ll: "inalloca parameters are always
// considered written"
- if (hasAttr({Attribute::InAlloca, Attribute::Preallocated})) {
+ if (A.hasAttr(getIRPosition(),
+ {Attribute::InAlloca, Attribute::Preallocated})) {
removeKnownBits(NO_WRITES);
removeAssumedBits(NO_WRITES);
}
- getIRPosition().removeAttrs(AttrKinds);
+ A.removeAttrs(getIRPosition(), AttrKinds);
return AAMemoryBehaviorFloating::manifest(A);
}
@@ -8111,9 +8121,9 @@ struct AAMemoryBehaviorFunction final : public AAMemoryBehaviorImpl {
else if (isAssumedWriteOnly())
ME = MemoryEffects::writeOnly();
- return IRAttributeManifest::manifestAttrs(
- A, getIRPosition(),
- Attribute::getWithMemoryEffects(F.getContext(), ME));
+ A.removeAttrs(getIRPosition(), AttrKinds);
+ return A.manifestAttrs(getIRPosition(),
+ Attribute::getWithMemoryEffects(F.getContext(), ME));
}
/// See AbstractAttribute::trackStatistics()
@@ -8159,10 +8169,9 @@ struct AAMemoryBehaviorCallSite final : AAMemoryBehaviorImpl {
else if (isAssumedWriteOnly())
ME = MemoryEffects::writeOnly();
- getIRPosition().removeAttrs(AttrKinds);
- return IRAttributeManifest::manifestAttrs(
- A, getIRPosition(),
- Attribute::getWithMemoryEffects(CB.getContext(), ME));
+ A.removeAttrs(getIRPosition(), AttrKinds);
+ return A.manifestAttrs(getIRPosition(),
+ Attribute::getWithMemoryEffects(CB.getContext(), ME));
}
/// See AbstractAttribute::trackStatistics()
@@ -8448,7 +8457,7 @@ struct AAMemoryLocationImpl : public AAMemoryLocation {
UseArgMemOnly = !AnchorFn->hasLocalLinkage();
SmallVector<Attribute, 2> Attrs;
- IRP.getAttrs({Attribute::Memory}, Attrs, IgnoreSubsumingPositions);
+ A.getAttrs(IRP, {Attribute::Memory}, Attrs, IgnoreSubsumingPositions);
for (const Attribute &Attr : Attrs) {
// TODO: We can map MemoryEffects to Attributor locations more precisely.
MemoryEffects ME = Attr.getMemoryEffects();
@@ -8466,11 +8475,10 @@ struct AAMemoryLocationImpl : public AAMemoryLocation {
else {
// Remove location information, only keep read/write info.
ME = MemoryEffects(ME.getModRef());
- IRAttributeManifest::manifestAttrs(
- A, IRP,
- Attribute::getWithMemoryEffects(IRP.getAnchorValue().getContext(),
- ME),
- /*ForceReplace*/ true);
+ A.manifestAttrs(IRP,
+ Attribute::getWithMemoryEffects(
+ IRP.getAnchorValue().getContext(), ME),
+ /*ForceReplace*/ true);
}
continue;
}
@@ -8481,11 +8489,10 @@ struct AAMemoryLocationImpl : public AAMemoryLocation {
else {
// Remove location information, only keep read/write info.
ME = MemoryEffects(ME.getModRef());
- IRAttributeManifest::manifestAttrs(
- A, IRP,
- Attribute::getWithMemoryEffects(IRP.getAnchorValue().getContext(),
- ME),
- /*ForceReplace*/ true);
+ A.manifestAttrs(IRP,
+ Attribute::getWithMemoryEffects(
+ IRP.getAnchorValue().getContext(), ME),
+ /*ForceReplace*/ true);
}
continue;
}
@@ -8526,8 +8533,8 @@ struct AAMemoryLocationImpl : public AAMemoryLocation {
return ChangeStatus::UNCHANGED;
MemoryEffects ME = DeducedAttrs[0].getMemoryEffects();
- return IRAttributeManifest::manifestAttrs(
- A, IRP,
+ return A.manifestAttrs(
+ IRP,
Attribute::getWithMemoryEffects(IRP.getAnchorValue().getContext(), ME));
}
@@ -10134,7 +10141,7 @@ struct AANoUndefImpl : AANoUndef {
/// See AbstractAttribute::initialize(...).
void initialize(Attributor &A) override {
- if (getIRPosition().hasAttr({Attribute::NoUndef})) {
+ if (A.hasAttr(getIRPosition(), {Attribute::NoUndef})) {
indicateOptimisticFixpoint();
return;
}
@@ -10291,7 +10298,7 @@ struct AANoFPClassImpl : AANoFPClass {
}
SmallVector<Attribute> Attrs;
- IRP.getAttrs({Attribute::NoFPClass}, Attrs, false, &A);
+ A.getAttrs(getIRPosition(), {Attribute::NoFPClass}, Attrs, false);
if (!Attrs.empty()) {
addKnownBits(Attrs[0].getNoFPClass());
return;
@@ -11566,8 +11573,8 @@ struct AAAssumptionInfoImpl : public AAAssumptionInfo {
return ChangeStatus::UNCHANGED;
const IRPosition &IRP = getIRPosition();
- return IRAttributeManifest::manifestAttrs(
- A, IRP,
+ return A.manifestAttrs(
+ IRP,
Attribute::get(IRP.getAnchorValue().getContext(), AssumptionAttrKey,
llvm::join(getAssumed().getSet(), ",")),
/* ForceReplace */ true);
More information about the llvm-commits
mailing list