[llvm] [Attributor]: AApointerInfo - store the full chain of instructions that make up the access (PR #96526)
Vidush Singhal via llvm-commits
llvm-commits at lists.llvm.org
Sun Jun 30 21:32:14 PDT 2024
https://github.com/vidsinghal updated https://github.com/llvm/llvm-project/pull/96526
>From e7958d87babb7f417f5fe3e6f5998d692683746d Mon Sep 17 00:00:00 2001
From: vidsinghal <vidush.sl at gmail.com>
Date: Mon, 24 Jun 2024 11:00:52 -0400
Subject: [PATCH] Store the full chain of instructions that make up the access.
---
llvm/include/llvm/Transforms/IPO/Attributor.h | 236 ++++++++++++++-
.../Transforms/IPO/AttributorAttributes.cpp | 168 +++++------
.../pointer-info-track-access-chain.ll | 274 ++++++++++++++++++
.../Attributor/value-simplify-pointer-info.ll | 64 +---
4 files changed, 594 insertions(+), 148 deletions(-)
create mode 100644 llvm/test/Transforms/Attributor/pointer-info-track-access-chain.ll
diff --git a/llvm/include/llvm/Transforms/IPO/Attributor.h b/llvm/include/llvm/Transforms/IPO/Attributor.h
index 6ba04dbc31db3..42ea52f151304 100644
--- a/llvm/include/llvm/Transforms/IPO/Attributor.h
+++ b/llvm/include/llvm/Transforms/IPO/Attributor.h
@@ -103,7 +103,9 @@
#include "llvm/ADT/STLExtras.h"
#include "llvm/ADT/SetOperations.h"
#include "llvm/ADT/SetVector.h"
+#include "llvm/ADT/SmallPtrSet.h"
#include "llvm/ADT/SmallSet.h"
+#include "llvm/ADT/SmallVector.h"
#include "llvm/ADT/iterator.h"
#include "llvm/Analysis/AssumeBundleQueries.h"
#include "llvm/Analysis/CFG.h"
@@ -137,6 +139,8 @@
#include "llvm/TargetParser/Triple.h"
#include "llvm/Transforms/Utils/CallGraphUpdater.h"
+#include <cstddef>
+#include <cstdint>
#include <limits>
#include <map>
#include <optional>
@@ -5784,6 +5788,120 @@ struct AAPointerInfo : public AbstractAttribute {
AK_MUST_READ_WRITE = AK_MUST | AK_R | AK_W,
};
+ /// A helper containing a list of offsets computed for a Use. Ideally this
+ /// list should be strictly ascending, but we ensure that only when we
+ /// actually translate the list of offsets to a RangeList.
+ struct OffsetInfo {
+ using VecTy = SmallVector<int64_t>;
+ using OriginsTy = SmallVector<SmallPtrSet<Value *, 4>>;
+ using const_iterator = VecTy::const_iterator;
+ OriginsTy Origins;
+ VecTy Offsets;
+
+ const_iterator begin() const { return Offsets.begin(); }
+ const_iterator end() const { return Offsets.end(); }
+
+ bool operator==(const OffsetInfo &RHS) const {
+ return Offsets == RHS.Offsets && Origins == RHS.Origins;
+ }
+
+ bool operator!=(const OffsetInfo &RHS) const { return !(*this == RHS); }
+
+ void insert(int64_t Offset, Value &V) {
+ Offsets.push_back(Offset);
+
+ auto *It = std::find(Offsets.begin(), Offsets.end(), Offsets.size());
+ // Offset exists in Offsets map
+ if (It != Offsets.end()) {
+ size_t Index = It - Offsets.begin();
+ if (Index < Origins.size())
+ Origins[Index].insert(&V);
+ }
+
+ Origins.emplace_back();
+ Origins.back().insert(&V);
+ }
+
+ bool isUnassigned() const { return Offsets.empty(); }
+
+ bool isUnknown() const {
+ if (isUnassigned())
+ return false;
+ if (Offsets.size() == 1)
+ return Offsets.front() == AA::RangeTy::Unknown;
+ return false;
+ }
+
+ void setUnknown(Value &V) {
+ Offsets.clear();
+ Origins.clear();
+ insert(AA::RangeTy::Unknown, V);
+ }
+
+ void addToAll(int64_t Inc, Value &V) {
+ for (auto &Offset : Offsets)
+ Offset += Inc;
+
+ if (!Origins.empty()) {
+ for (auto &Origin : Origins)
+ Origin.insert(&V);
+ } else {
+ for (size_t Index = 0; Index < Offsets.size(); Index++) {
+ Origins.emplace_back();
+ Origins[Index].insert(&V);
+ }
+ }
+ }
+
+ void addToAll(int64_t Inc) {
+ for (auto &Offset : Offsets)
+ Offset += Inc;
+ }
+
+ /// Copy offsets from \p R into the current list.
+ ///
+ /// Ideally all lists should be strictly ascending, but we defer that to the
+ /// actual use of the list. So we just blindly append here.
+ void merge(const OffsetInfo &R) {
+ Offsets.append(R.Offsets);
+ // ensure elements are unique.
+ sort(Offsets.begin(), Offsets.end());
+ Offsets.erase(std::unique(Offsets.begin(), Offsets.end()), Offsets.end());
+
+ OriginsTy ToBeMergeOrigins = R.Origins;
+ for (auto &Origin : ToBeMergeOrigins) {
+ Origins.emplace_back(Origin);
+ }
+ }
+
+ void mergeWithOffset(const OffsetInfo &R, Value &CurPtr) {
+
+ Offsets.append(R.Offsets);
+ // ensure elements are unique.
+ sort(Offsets.begin(), Offsets.end());
+ Offsets.erase(std::unique(Offsets.begin(), Offsets.end()), Offsets.end());
+
+ auto &ROffsets = R.Offsets;
+ for (auto Offset : ROffsets) {
+
+ auto *It = std::find(Offsets.begin(), Offsets.end(), Offset);
+ if (It == Offsets.end())
+ continue;
+
+ size_t Index = It - Offsets.begin();
+
+ if (Index >= Origins.size()) {
+ Origins.emplace_back();
+ Origins.back().insert(&CurPtr);
+ } else {
+ Origins[Index].insert(&CurPtr);
+ }
+ }
+ }
+ };
+
+ using OffsetInfoMapTy = DenseMap<Value *, OffsetInfo>;
+
/// A container for a list of ranges.
struct RangeList {
// The set of ranges rarely contains more than one element, and is unlikely
@@ -5938,15 +6056,17 @@ struct AAPointerInfo : public AbstractAttribute {
/// An access description.
struct Access {
Access(Instruction *I, int64_t Offset, int64_t Size,
- std::optional<Value *> Content, AccessKind Kind, Type *Ty)
+ std::optional<Value *> Content, AccessKind Kind, Type *Ty,
+ OffsetInfoMapTy &OffsetInfoMap)
: LocalI(I), RemoteI(I), Content(Content), Ranges(Offset, Size),
- Kind(Kind), Ty(Ty) {
+ Kind(Kind), Ty(Ty), AccessPaths(findAllAccessPaths(OffsetInfoMap)) {
verify();
}
Access(Instruction *LocalI, Instruction *RemoteI, const RangeList &Ranges,
- std::optional<Value *> Content, AccessKind K, Type *Ty)
+ std::optional<Value *> Content, AccessKind K, Type *Ty,
+ OffsetInfoMapTy &OffsetInfoMap)
: LocalI(LocalI), RemoteI(RemoteI), Content(Content), Ranges(Ranges),
- Kind(K), Ty(Ty) {
+ Kind(K), Ty(Ty), AccessPaths(findAllAccessPaths(OffsetInfoMap)) {
if (Ranges.size() > 1) {
Kind = AccessKind(Kind | AK_MAY);
Kind = AccessKind(Kind & ~AK_MUST);
@@ -5955,9 +6075,10 @@ struct AAPointerInfo : public AbstractAttribute {
}
Access(Instruction *LocalI, Instruction *RemoteI, int64_t Offset,
int64_t Size, std::optional<Value *> Content, AccessKind Kind,
- Type *Ty)
+ Type *Ty, OffsetInfoMapTy &OffsetInfoMap)
: LocalI(LocalI), RemoteI(RemoteI), Content(Content),
- Ranges(Offset, Size), Kind(Kind), Ty(Ty) {
+ Ranges(Offset, Size), Kind(Kind), Ty(Ty),
+ AccessPaths(findAllAccessPaths(OffsetInfoMap)) {
verify();
}
Access(const Access &Other) = default;
@@ -6077,11 +6198,110 @@ struct AAPointerInfo : public AbstractAttribute {
}
}
+ using AccessPathTy = SmallVector<Value *, 4>;
+ using AccessPathSetTy = SmallPtrSet<AccessPathTy *, 4>;
+
+ void mergeAccessPaths(const AccessPathSetTy *AccessPathsNew) {
+
+ for (auto *Path : *AccessPathsNew) {
+ if (!existsChain(Path))
+ AccessPaths->insert(Path);
+ }
+ }
+
+ bool existsChain(AccessPathTy *NewPath) {
+
+ for (auto *OldPath : *AccessPaths) {
+ if (*OldPath == *NewPath)
+ return true;
+ }
+ return false;
+ }
+
+ AccessPathSetTy *findAllAccessPaths(OffsetInfoMapTy &OffsetInfoMap) {
+
+ AccessPathSetTy *AccessPathsSet = new AccessPathSetTy();
+ SmallPtrSet<Value *, 16> Visited;
+ AccessPathTy *Start = new AccessPathTy();
+ AccessPathsSet->insert(Start);
+ Start->push_back(LocalI);
+ for (auto *It = LocalI->op_begin(); It != LocalI->op_end(); It++)
+ if (Instruction *I = dyn_cast<Instruction>(It))
+ findAccessPathsHelper(OffsetInfoMap, Visited, I, Start,
+ AccessPathsSet);
+
+ return AccessPathsSet;
+ }
+
+ void findAccessPathsHelper(OffsetInfoMapTy &OffsetInfoMap,
+ SmallPtrSet<Value *, 16> &Visited,
+ Value *Instruction, AccessPathTy *CurrentChain,
+ AccessPathSetTy *AccessPathsSet) {
+ // Add all the successors
+ if (!OffsetInfoMap.contains(Instruction))
+ return;
+
+ Visited.insert(Instruction);
+ CurrentChain->push_back(Instruction);
+
+ // Recurse on the successors of the Current Instruction.
+
+ auto OI = OffsetInfoMap.lookup(Instruction);
+ auto &Origins = OI.Origins;
+
+ SmallPtrSet<Value *, 16> Successors;
+ for (auto &Origin : Origins) {
+ for (auto *Ins : Origin) {
+ // Recurse on each instruction.
+ if (Ins != Instruction && !Visited.contains(Ins))
+ Successors.insert(Ins);
+ }
+ }
+
+ if (Successors.size() == 0) {
+ Visited.erase(Instruction);
+ return;
+ }
+
+ if (Successors.size() > 1) {
+
+ for (auto *Ins : Successors) {
+ AccessPathTy *NextChain =
+ new AccessPathTy(CurrentChain->begin(), CurrentChain->end());
+ AccessPathsSet->insert(NextChain);
+ findAccessPathsHelper(OffsetInfoMap, Visited, Ins, NextChain,
+ AccessPathsSet);
+ }
+ AccessPathsSet->erase(CurrentChain);
+ } else {
+ Value *Successor = *Successors.begin();
+ findAccessPathsHelper(OffsetInfoMap, Visited, Successor, CurrentChain,
+ AccessPathsSet);
+ }
+
+ Visited.erase(Instruction);
+ }
+
+ void dumpAccessPaths(raw_ostream &O) {
+
+ O << "Dump all access paths:"
+ << "\n";
+ for (auto *It : *AccessPaths) {
+ O << "Printing a unique access path:\n";
+ for (Value *Ins : *It) {
+ O << *Ins << "\n";
+ }
+ }
+ }
+
+ const AccessPathSetTy *getAccessChain() const { return AccessPaths; }
+
const RangeList &getRanges() const { return Ranges; }
using const_iterator = RangeList::const_iterator;
const_iterator begin() const { return Ranges.begin(); }
const_iterator end() const { return Ranges.end(); }
+ size_t size() const { return Ranges.size(); }
private:
/// The instruction responsible for the access with respect to the local
@@ -6104,6 +6324,10 @@ struct AAPointerInfo : public AbstractAttribute {
/// The type of the content, thus the type read/written, can be null if not
/// available.
Type *Ty;
+
+ /// The full chain of instructions that participate in the Access.
+ /// There may be more than one access chain.
+ AccessPathSetTy *AccessPaths;
};
/// Create an abstract attribute view for the position \p IRP.
diff --git a/llvm/lib/Transforms/IPO/AttributorAttributes.cpp b/llvm/lib/Transforms/IPO/AttributorAttributes.cpp
index c4b9375a53a27..f46c6d57fdee5 100644
--- a/llvm/lib/Transforms/IPO/AttributorAttributes.cpp
+++ b/llvm/lib/Transforms/IPO/AttributorAttributes.cpp
@@ -72,6 +72,7 @@
#include "llvm/Transforms/Utils/Local.h"
#include "llvm/Transforms/Utils/ValueMapper.h"
#include <cassert>
+#include <cstddef>
#include <numeric>
#include <optional>
#include <string>
@@ -214,7 +215,7 @@ ChangeStatus clampStateAndIndicateChange<DerefState>(DerefState &S,
static bool mayBeInCycle(const CycleInfo *CI, const Instruction *I,
bool HeaderOnly, Cycle **CPtr = nullptr) {
if (!CI)
- return true;
+ return false;
auto *BB = I->getParent();
auto *C = CI->getCycle(BB);
if (!C)
@@ -850,6 +851,7 @@ struct AA::PointerInfo::State : public AbstractState {
ChangeStatus addAccess(Attributor &A, const AAPointerInfo::RangeList &Ranges,
Instruction &I, std::optional<Value *> Content,
AAPointerInfo::AccessKind Kind, Type *Ty,
+ AAPointerInfo::OffsetInfoMapTy &OffsetInfoMap,
Instruction *RemoteI = nullptr);
AAPointerInfo::const_bin_iterator begin() const { return OffsetBins.begin(); }
@@ -929,7 +931,7 @@ struct AA::PointerInfo::State : public AbstractState {
ChangeStatus AA::PointerInfo::State::addAccess(
Attributor &A, const AAPointerInfo::RangeList &Ranges, Instruction &I,
std::optional<Value *> Content, AAPointerInfo::AccessKind Kind, Type *Ty,
- Instruction *RemoteI) {
+ AAPointerInfo::OffsetInfoMapTy &OffsetInfoMap, Instruction *RemoteI) {
RemoteI = RemoteI ? RemoteI : &I;
// Check if we have an access for this instruction, if not, simply add it.
@@ -956,7 +958,9 @@ ChangeStatus AA::PointerInfo::State::addAccess(
};
if (!AccExists) {
- AccessList.emplace_back(&I, RemoteI, Ranges, Content, Kind, Ty);
+ AccessList.emplace_back(&I, RemoteI, Ranges, Content, Kind, Ty,
+ OffsetInfoMap);
+
assert((AccessList.size() == AccIndex + 1) &&
"New Access should have been at AccIndex");
LocalList.push_back(AccIndex);
@@ -966,9 +970,14 @@ ChangeStatus AA::PointerInfo::State::addAccess(
// Combine the new Access with the existing Access, and then update the
// mapping in the offset bins.
- AAPointerInfo::Access Acc(&I, RemoteI, Ranges, Content, Kind, Ty);
+ AAPointerInfo::Access Acc(&I, RemoteI, Ranges, Content, Kind, Ty,
+ OffsetInfoMap);
auto &Current = AccessList[AccIndex];
auto Before = Current;
+
+ // Merge the newly generated access paths with the old access paths.
+ Before.mergeAccessPaths(Acc.getAccessChain());
+
Current &= Acc;
if (Current == Before)
return ChangeStatus::UNCHANGED;
@@ -1002,54 +1011,9 @@ ChangeStatus AA::PointerInfo::State::addAccess(
namespace {
-/// A helper containing a list of offsets computed for a Use. Ideally this
-/// list should be strictly ascending, but we ensure that only when we
-/// actually translate the list of offsets to a RangeList.
-struct OffsetInfo {
- using VecTy = SmallVector<int64_t>;
- using const_iterator = VecTy::const_iterator;
- VecTy Offsets;
-
- const_iterator begin() const { return Offsets.begin(); }
- const_iterator end() const { return Offsets.end(); }
-
- bool operator==(const OffsetInfo &RHS) const {
- return Offsets == RHS.Offsets;
- }
-
- bool operator!=(const OffsetInfo &RHS) const { return !(*this == RHS); }
-
- void insert(int64_t Offset) { Offsets.push_back(Offset); }
- bool isUnassigned() const { return Offsets.size() == 0; }
-
- bool isUnknown() const {
- if (isUnassigned())
- return false;
- if (Offsets.size() == 1)
- return Offsets.front() == AA::RangeTy::Unknown;
- return false;
- }
-
- void setUnknown() {
- Offsets.clear();
- Offsets.push_back(AA::RangeTy::Unknown);
- }
-
- void addToAll(int64_t Inc) {
- for (auto &Offset : Offsets) {
- Offset += Inc;
- }
- }
-
- /// Copy offsets from \p R into the current list.
- ///
- /// Ideally all lists should be strictly ascending, but we defer that to the
- /// actual use of the list. So we just blindly append here.
- void merge(const OffsetInfo &R) { Offsets.append(R.Offsets); }
-};
-
#ifndef NDEBUG
-static raw_ostream &operator<<(raw_ostream &OS, const OffsetInfo &OI) {
+static raw_ostream &operator<<(raw_ostream &OS,
+ const AAPointerInfo::OffsetInfo &OI) {
ListSeparator LS;
OS << "[";
for (auto Offset : OI) {
@@ -1365,7 +1329,8 @@ struct AAPointerInfoImpl
ChangeStatus translateAndAddStateFromCallee(Attributor &A,
const AAPointerInfo &OtherAA,
- CallBase &CB) {
+ CallBase &CB,
+ OffsetInfoMapTy &OffsetInfoMap) {
using namespace AA::PointerInfo;
if (!OtherAA.getState().isValidState() || !isValidState())
return indicatePessimisticFixpoint();
@@ -1388,8 +1353,9 @@ struct AAPointerInfoImpl
AK = AccessKind(AK & (IsByval ? AccessKind::AK_R : AccessKind::AK_RW));
AK = AccessKind(AK | (RAcc.isMayAccess() ? AK_MAY : AK_MUST));
- Changed |= addAccess(A, RAcc.getRanges(), CB, Content, AK,
- RAcc.getType(), RAcc.getRemoteInst());
+ Changed |=
+ addAccess(A, RAcc.getRanges(), CB, Content, AK, RAcc.getType(),
+ OffsetInfoMap, RAcc.getRemoteInst());
}
}
return Changed;
@@ -1418,7 +1384,7 @@ struct AAPointerInfoImpl
}
Changed |=
addAccess(A, NewRanges, CB, RAcc.getContent(), RAcc.getKind(),
- RAcc.getType(), RAcc.getRemoteInst());
+ RAcc.getType(), OffsetInfoMap, RAcc.getRemoteInst());
}
}
}
@@ -1449,9 +1415,12 @@ struct AAPointerInfoImpl
else
O << " - c: <unknown>\n";
}
+ Acc.dumpAccessPaths(O);
}
}
}
+
+ OffsetInfoMapTy OffsetInfoMap;
};
struct AAPointerInfoFloating : public AAPointerInfoImpl {
@@ -1462,8 +1431,8 @@ struct AAPointerInfoFloating : public AAPointerInfoImpl {
/// Deal with an access and signal if it was handled successfully.
bool handleAccess(Attributor &A, Instruction &I,
std::optional<Value *> Content, AccessKind Kind,
- SmallVectorImpl<int64_t> &Offsets, ChangeStatus &Changed,
- Type &Ty) {
+ OffsetInfo &OI, ChangeStatus &Changed, Type &Ty,
+ OffsetInfoMapTy &OffsetInfoMap) {
using namespace AA::PointerInfo;
auto Size = AA::RangeTy::Unknown;
const DataLayout &DL = A.getDataLayout();
@@ -1472,6 +1441,9 @@ struct AAPointerInfoFloating : public AAPointerInfoImpl {
Size = AccessSize.getFixedValue();
// Make a strictly ascending list of offsets as required by addAccess()
+ auto Offsets = OI.Offsets;
+ auto Origins = OI.Origins;
+
llvm::sort(Offsets);
auto *Last = llvm::unique(Offsets);
Offsets.erase(Last, Offsets.end());
@@ -1481,7 +1453,8 @@ struct AAPointerInfoFloating : public AAPointerInfoImpl {
!Content.value_or(nullptr) || !isa<Constant>(*Content) ||
(*Content)->getType() != VT ||
DL.getTypeStoreSize(VT->getElementType()).isScalable()) {
- Changed = Changed | addAccess(A, {Offsets, Size}, I, Content, Kind, &Ty);
+ Changed = Changed | addAccess(A, {Offsets, Size}, I, Content, Kind, &Ty,
+ OffsetInfoMap);
} else {
// Handle vector stores with constant content element-wise.
// TODO: We could look for the elements or create instructions
@@ -1501,7 +1474,8 @@ struct AAPointerInfoFloating : public AAPointerInfoImpl {
// Add the element access.
Changed = Changed | addAccess(A, {ElementOffsets, ElementSize}, I,
- ElementContent, Kind, ElementType);
+ ElementContent, Kind, ElementType,
+ OffsetInfoMap);
// Advance the offsets for the next element.
for (auto &ElementOffset : ElementOffsets)
@@ -1520,7 +1494,7 @@ struct AAPointerInfoFloating : public AAPointerInfoImpl {
/// \return true iff \p UsrOI is updated.
bool collectConstantsForGEP(Attributor &A, const DataLayout &DL,
OffsetInfo &UsrOI, const OffsetInfo &PtrOI,
- const GEPOperator *GEP);
+ GEPOperator *GEP, Value *CurPtr);
/// See AbstractAttribute::trackStatistics()
void trackStatistics() const override {
@@ -1528,11 +1502,9 @@ struct AAPointerInfoFloating : public AAPointerInfoImpl {
}
};
-bool AAPointerInfoFloating::collectConstantsForGEP(Attributor &A,
- const DataLayout &DL,
- OffsetInfo &UsrOI,
- const OffsetInfo &PtrOI,
- const GEPOperator *GEP) {
+bool AAPointerInfoFloating::collectConstantsForGEP(
+ Attributor &A, const DataLayout &DL, OffsetInfo &UsrOI,
+ const OffsetInfo &PtrOI, GEPOperator *GEP, Value *CurPtr) {
unsigned BitWidth = DL.getIndexTypeSizeInBits(GEP->getType());
MapVector<Value *, APInt> VariableOffsets;
APInt ConstantOffset(BitWidth, 0);
@@ -1542,7 +1514,7 @@ bool AAPointerInfoFloating::collectConstantsForGEP(Attributor &A,
"determined to be unknown.");
if (!GEP->collectOffset(DL, BitWidth, VariableOffsets, ConstantOffset)) {
- UsrOI.setUnknown();
+ UsrOI.setUnknown(*CurPtr);
return true;
}
@@ -1551,7 +1523,9 @@ bool AAPointerInfoFloating::collectConstantsForGEP(Attributor &A,
<< *GEP << "\n");
auto Union = PtrOI;
- Union.addToAll(ConstantOffset.getSExtValue());
+ // clear the origins since we just want to keep only one predecessor.
+ Union.Origins.clear();
+ Union.addToAll(ConstantOffset.getSExtValue(), *CurPtr);
// Each VI in VariableOffsets has a set of potential constant values. Every
// combination of elements, picked one each from these sets, is separately
@@ -1560,7 +1534,7 @@ bool AAPointerInfoFloating::collectConstantsForGEP(Attributor &A,
auto *PotentialConstantsAA = A.getAAFor<AAPotentialConstantValues>(
*this, IRPosition::value(*VI.first), DepClassTy::OPTIONAL);
if (!PotentialConstantsAA || !PotentialConstantsAA->isValidState()) {
- UsrOI.setUnknown();
+ UsrOI.setUnknown(*CurPtr);
return true;
}
@@ -1579,8 +1553,8 @@ bool AAPointerInfoFloating::collectConstantsForGEP(Attributor &A,
OffsetInfo Product;
for (const auto &ConstOffset : AssumedSet) {
auto CopyPerOffset = Union;
- CopyPerOffset.addToAll(ConstOffset.getSExtValue() *
- VI.second.getZExtValue());
+ CopyPerOffset.addToAll(
+ ConstOffset.getSExtValue() * VI.second.getZExtValue(), *CurPtr);
Product.merge(CopyPerOffset);
}
Union = Product;
@@ -1596,8 +1570,8 @@ ChangeStatus AAPointerInfoFloating::updateImpl(Attributor &A) {
const DataLayout &DL = A.getDataLayout();
Value &AssociatedValue = getAssociatedValue();
- DenseMap<Value *, OffsetInfo> OffsetInfoMap;
- OffsetInfoMap[&AssociatedValue].insert(0);
+ OffsetInfoMap.clear();
+ OffsetInfoMap[&AssociatedValue].insert(0, AssociatedValue);
auto HandlePassthroughUser = [&](Value *Usr, Value *CurPtr, bool &Follow) {
// One does not simply walk into a map and assign a reference to a possibly
@@ -1616,7 +1590,14 @@ ChangeStatus AAPointerInfoFloating::updateImpl(Attributor &A) {
auto &PtrOI = OffsetInfoMap[CurPtr];
assert(!PtrOI.isUnassigned() &&
"Cannot pass through if the input Ptr was not visited!");
- UsrOI.merge(PtrOI);
+ if (isa<PHINode>(Usr) || isa<SelectInst>(Usr)) {
+ UsrOI.mergeWithOffset(PtrOI, *CurPtr);
+ } else {
+ UsrOI = PtrOI;
+ UsrOI.Origins.clear();
+ UsrOI.addToAll(0, *CurPtr);
+ }
+
Follow = true;
return true;
};
@@ -1631,6 +1612,7 @@ ChangeStatus AAPointerInfoFloating::updateImpl(Attributor &A) {
auto UsePred = [&](const Use &U, bool &Follow) -> bool {
Value *CurPtr = U.get();
User *Usr = U.getUser();
+
LLVM_DEBUG(dbgs() << "[AAPointerInfo] Analyze " << *CurPtr << " in " << *Usr
<< "\n");
assert(OffsetInfoMap.count(CurPtr) &&
@@ -1656,11 +1638,11 @@ ChangeStatus AAPointerInfoFloating::updateImpl(Attributor &A) {
if (PtrOI.isUnknown()) {
Follow = true;
- UsrOI.setUnknown();
+ UsrOI.setUnknown(*GEP);
return true;
}
- Follow = collectConstantsForGEP(A, DL, UsrOI, PtrOI, GEP);
+ Follow = collectConstantsForGEP(A, DL, UsrOI, PtrOI, GEP, CurPtr);
return true;
}
if (isa<PtrToIntInst>(Usr))
@@ -1674,6 +1656,7 @@ ChangeStatus AAPointerInfoFloating::updateImpl(Attributor &A) {
if (isa<PHINode>(Usr)) {
// Note the order here, the Usr access might change the map, CurPtr is
// already in it though.
+
bool IsFirstPHIUser = !OffsetInfoMap.count(Usr);
auto &UsrOI = OffsetInfoMap[Usr];
auto &PtrOI = OffsetInfoMap[CurPtr];
@@ -1684,7 +1667,7 @@ ChangeStatus AAPointerInfoFloating::updateImpl(Attributor &A) {
LLVM_DEBUG(dbgs() << "[AAPointerInfo] PHI operand offset unknown "
<< *CurPtr << " in " << *Usr << "\n");
Follow = !UsrOI.isUnknown();
- UsrOI.setUnknown();
+ UsrOI.setUnknown(*CurPtr);
return true;
}
@@ -1693,6 +1676,7 @@ ChangeStatus AAPointerInfoFloating::updateImpl(Attributor &A) {
assert(!PtrOI.isUnassigned() &&
"Cannot assign if the current Ptr was not visited!");
LLVM_DEBUG(dbgs() << "[AAPointerInfo] PHI is invariant (so far)");
+
return true;
}
@@ -1706,7 +1690,7 @@ ChangeStatus AAPointerInfoFloating::updateImpl(Attributor &A) {
if (It == OffsetInfoMap.end()) {
LLVM_DEBUG(dbgs() << "[AAPointerInfo] PHI operand is too complex "
<< *CurPtr << " in " << *Usr << "\n");
- UsrOI.setUnknown();
+ UsrOI.setUnknown(*CurPtr);
Follow = true;
return true;
}
@@ -1720,7 +1704,7 @@ ChangeStatus AAPointerInfoFloating::updateImpl(Attributor &A) {
// eventually propagate through the whole net of PHIs in the recurrence.
if (mayBeInCycle(CI, cast<Instruction>(Usr), /* HeaderOnly */ true)) {
auto BaseOI = It->getSecond();
- BaseOI.addToAll(Offset.getZExtValue());
+ BaseOI.addToAll(Offset.getZExtValue(), *CurPtr);
if (IsFirstPHIUser || BaseOI == UsrOI) {
LLVM_DEBUG(dbgs() << "[AAPointerInfo] PHI is invariant " << *CurPtr
<< " in " << *Usr << "\n");
@@ -1730,12 +1714,12 @@ ChangeStatus AAPointerInfoFloating::updateImpl(Attributor &A) {
LLVM_DEBUG(
dbgs() << "[AAPointerInfo] PHI operand pointer offset mismatch "
<< *CurPtr << " in " << *Usr << "\n");
- UsrOI.setUnknown();
+ UsrOI.setUnknown(*CurPtr);
Follow = true;
return true;
}
- UsrOI.merge(PtrOI);
+ UsrOI.mergeWithOffset(PtrOI, *CurPtr);
Follow = true;
return true;
}
@@ -1749,8 +1733,8 @@ ChangeStatus AAPointerInfoFloating::updateImpl(Attributor &A) {
else
AK = AccessKind(AK | AccessKind::AK_MAY);
if (!handleAccess(A, *LoadI, /* Content */ nullptr, AK,
- OffsetInfoMap[CurPtr].Offsets, Changed,
- *LoadI->getType()))
+ OffsetInfoMap[CurPtr], Changed, *LoadI->getType(),
+ OffsetInfoMap))
return false;
auto IsAssumption = [](Instruction &I) {
@@ -1834,9 +1818,9 @@ ChangeStatus AAPointerInfoFloating::updateImpl(Attributor &A) {
Content =
A.getAssumedSimplified(*Assumption.first, *this,
UsedAssumedInformation, AA::Interprocedural);
- return handleAccess(
- A, *Assumption.second, Content, AccessKind::AK_ASSUMPTION,
- OffsetInfoMap[CurPtr].Offsets, Changed, *LoadI->getType());
+ return handleAccess(A, *Assumption.second, Content,
+ AccessKind::AK_ASSUMPTION, OffsetInfoMap[CurPtr],
+ Changed, *LoadI->getType(), OffsetInfoMap);
}
auto HandleStoreLike = [&](Instruction &I, Value *ValueOp, Type &ValueTy,
@@ -1862,8 +1846,8 @@ ChangeStatus AAPointerInfoFloating::updateImpl(Attributor &A) {
if (ValueOp)
Content = A.getAssumedSimplified(
*ValueOp, *this, UsedAssumedInformation, AA::Interprocedural);
- return handleAccess(A, I, Content, AK, OffsetInfoMap[CurPtr].Offsets,
- Changed, ValueTy);
+ return handleAccess(A, I, Content, AK, OffsetInfoMap[CurPtr], Changed,
+ ValueTy, OffsetInfoMap);
};
if (auto *StoreI = dyn_cast<StoreInst>(Usr))
@@ -1984,8 +1968,8 @@ struct AAPointerInfoCallSiteArgument final : AAPointerInfoFloating {
} else {
auto Kind =
ArgNo == 0 ? AccessKind::AK_MUST_WRITE : AccessKind::AK_MUST_READ;
- Changed =
- Changed | addAccess(A, {0, LengthVal}, *MI, nullptr, Kind, nullptr);
+ Changed = Changed | addAccess(A, {0, LengthVal}, *MI, nullptr, Kind,
+ nullptr, OffsetInfoMap);
}
LLVM_DEBUG({
dbgs() << "Accesses by bin after update:\n";
@@ -2005,8 +1989,8 @@ struct AAPointerInfoCallSiteArgument final : AAPointerInfoFloating {
auto *ArgAA =
A.getAAFor<AAPointerInfo>(*this, ArgPos, DepClassTy::REQUIRED);
if (ArgAA && ArgAA->getState().isValidState())
- return translateAndAddStateFromCallee(A, *ArgAA,
- *cast<CallBase>(getCtxI()));
+ return translateAndAddStateFromCallee(
+ A, *ArgAA, *cast<CallBase>(getCtxI()), OffsetInfoMap);
if (!Arg->getParent()->isDeclaration())
return indicatePessimisticFixpoint();
}
@@ -2023,7 +2007,7 @@ struct AAPointerInfoCallSiteArgument final : AAPointerInfoFloating {
auto Kind =
ReadOnly ? AccessKind::AK_MAY_READ : AccessKind::AK_MAY_READ_WRITE;
return addAccess(A, AA::RangeTy::getUnknown(), *getCtxI(), nullptr, Kind,
- nullptr);
+ nullptr, OffsetInfoMap);
}
/// See AbstractAttribute::trackStatistics()
diff --git a/llvm/test/Transforms/Attributor/pointer-info-track-access-chain.ll b/llvm/test/Transforms/Attributor/pointer-info-track-access-chain.ll
new file mode 100644
index 0000000000000..5d787b849ebcb
--- /dev/null
+++ b/llvm/test/Transforms/Attributor/pointer-info-track-access-chain.ll
@@ -0,0 +1,274 @@
+; NOTE: Assertions have been autogenerated by utils/update_test_checks.py UTC_ARGS: --check-attributes --check-globals --version 2
+; RUN: opt -aa-pipeline=basic-aa -passes=attributor -debug-only=attributor -attributor-manifest-internal -attributor-annotate-decl-cs -S < %s 2>&1 | FileCheck %s
+; RUN: opt -aa-pipeline=basic-aa -passes=attributor-cgscc -debug-only=attributor -attributor-manifest-internal -attributor-annotate-decl-cs -S < %s 2>&1 | FileCheck %s
+; REQUIRES: asserts
+
+; CHECK: Accesses by bin after update:
+; CHECK: [8-12] : 1
+; CHECK: - 5 - %1 = load i32, ptr %field22, align 4
+; CHECK: - c: <unknown>
+; CHECK: Print the full access chain:
+; CHECK-DAG: %1 = load i32, ptr %field22, align 4
+; CHECK-DAG: %field22 = getelementptr i32, ptr %field2, i32 0
+; CHECK-DAG: %field2 = getelementptr inbounds [10 x i32], ptr %f, i32 0, i32 2
+; CHECK: [4-5] : 1
+; CHECK: - 9 - store i8 10, ptr %field11, align 4
+; CHECK: - c: i8 10
+; CHECK: Print the full access chain:
+; CHECK-DAG: store i8 10, ptr %field11, align 4
+; CHECK-DAG: %field11 = getelementptr i32, ptr %field1, i32 0
+; CHECK-DAG: %field1 = getelementptr inbounds [10 x i32], ptr %f, i32 0, i32 1
+; CHECK: [32-36] : 1
+; CHECK: - 9 - store i32 %3, ptr %field8, align 4
+; CHECK: - c: %3 = load i32, ptr %val, align 4
+; CHECK: Print the full access chain:
+; CHECK-DAG: store i32 %3, ptr %field8, align 4
+; CHECK-DAG: %field8 = getelementptr inbounds [10 x i32], ptr %f, i32 0, i32 8
+; CHECK: [4-8] : 1
+; CHECK: - 5 - %0 = load i32, ptr %field11, align 4
+; CHECK: - c: <unknown>
+; CHECK: Print the full access chain:
+; CHECK-DAG: %0 = load i32, ptr %field11, align 4
+; CHECK-DAG: %field11 = getelementptr i32, ptr %field1, i32 0
+; CHECK-DAG: %field1 = getelementptr inbounds [10 x i32], ptr %f, i32 0, i32 1
+; CHECK: [8-9] : 1
+; CHECK: - 9 - store i8 12, ptr %field22, align 4
+; CHECK: - c: i8 12
+; CHECK: Print the full access chain:
+; CHECK-DAG: store i8 12, ptr %field22, align 4
+; CHECK-DAG: %field22 = getelementptr i32, ptr %field2, i32 0
+; CHECK-DAG: %field2 = getelementptr inbounds [10 x i32], ptr %f, i32 0, i32 2
+define dso_local i32 @track_chain(ptr nocapture %val) #0 {
+entry:
+ %f = alloca [10 x i32]
+ %field1 = getelementptr inbounds [10 x i32], ptr %f, i32 0, i32 1
+ %field2 = getelementptr inbounds [10 x i32], ptr %f, i32 0, i32 2
+ %field3 = getelementptr inbounds [10 x i32], ptr %f, i32 0, i32 3
+ %field8 = getelementptr inbounds [10 x i32], ptr %f, i32 0, i32 8
+
+ %field11 = getelementptr i32, ptr %field1, i32 0
+ %field22 = getelementptr i32, ptr %field2, i32 0
+ store i8 10, ptr %field11, align 4
+ store i8 12, ptr %field22, align 4
+
+ %1 = load i32, ptr %field11, align 4
+ %2 = load i32, ptr %field22, align 4
+ %3 = add i32 %1, %2
+
+ %4 = load i32, ptr %val, align 4
+ store i32 %4, ptr %field8, align 4
+
+ %5 = add i32 %4, %3
+
+ ret i32 %5
+}
+
+; TODO: Should %field11 be backtracked further in this case?
+; It is not currently because, for example the offsets of the load
+; at [12-16] are different than the %field1 GEP. But we could
+; store it since it is a pointer operand, ie, comes form a GEP.
+; It could also be a function argument, (a ptr passed to a function).
+; CHECK: Accesses by bin after update:
+; CHECK: [12-16] : 1
+; CHECK: - 5 - %0 = load i32, ptr %field11, align 4
+; CHECK: - c: <unknown>
+; CHECK: Print the full access chain:
+; CHECK-DAG: %0 = load i32, ptr %field11, align 4
+; CHECK-DAG: %field11 = getelementptr i32, ptr %field1, i32 2
+; CHECK: [16-17] : 1
+; CHECK: - 9 - store i8 12, ptr %field22, align 4
+; CHECK: - c: i8 12
+; CHECK: Print the full access chain:
+; CHECK-DAG: store i8 12, ptr %field22, align 4
+; CHECK-DAG: %field22 = getelementptr i32, ptr %field2, i32 2
+; CHECK: [32-36] : 1
+; CHECK: - 9 - store i32 %3, ptr %field8, align 4
+; CHECK: - c: %3 = load i32, ptr %val, align 4
+; CHECK: Print the full access chain:
+; CHECK-DAG: store i32 %3, ptr %field8, align 4
+; CHECK-DAG: %field8 = getelementptr inbounds [10 x i32], ptr %f, i32 0, i32 8
+; CHECK: [16-20] : 1
+; CHECK: - 5 - %1 = load i32, ptr %field22, align 4
+; CHECK: - c: <unknown>
+; CHECK: Print the full access chain:
+; CHECK-DAG: %1 = load i32, ptr %field22, align 4
+; CHECK-DAG: %field22 = getelementptr i32, ptr %field2, i32 2
+; CHECK: [12-13] : 1
+; CHECK: - 9 - store i8 10, ptr %field11, align 4
+; CHECK: - c: i8 10
+; CHECK: Print the full access chain:
+; CHECK-DAG: store i8 10, ptr %field11, align 4
+; CHECK-DAG: %field11 = getelementptr i32, ptr %field1, i32 2
+define dso_local i32 @track_chain_2(ptr nocapture %val) #0 {
+entry:
+ %f = alloca [10 x i32]
+ %field1 = getelementptr inbounds [10 x i32], ptr %f, i32 0, i32 1
+ %field2 = getelementptr inbounds [10 x i32], ptr %f, i32 0, i32 2
+ %field3 = getelementptr inbounds [10 x i32], ptr %f, i32 0, i32 3
+ %field8 = getelementptr inbounds [10 x i32], ptr %f, i32 0, i32 8
+
+ %field11 = getelementptr i32, ptr %field1, i32 2
+ %field22 = getelementptr i32, ptr %field2, i32 2
+ store i8 10, ptr %field11, align 4
+ store i8 12, ptr %field22, align 4
+
+ %1 = load i32, ptr %field11, align 4
+ %2 = load i32, ptr %field22, align 4
+ %3 = add i32 %1, %2
+
+ %4 = load i32, ptr %val, align 4
+ store i32 %4, ptr %field8, align 4
+
+ %5 = add i32 %4, %3
+
+ ret i32 %5
+}
+
+define dso_local i32 @track_chain_3(ptr nocapture %val, i1 %cond) #0 {
+; CHECK: Function Attrs: mustprogress nofree norecurse nosync nounwind willreturn
+; CHECK-LABEL: define dso_local i32 @track_chain_3
+; CHECK-SAME: (ptr nocapture nofree noundef nonnull readonly align 4 dereferenceable(4) [[VAL:%.*]], i1 [[COND:%.*]]) #[[ATTR0:[0-9]+]] {
+; CHECK-NEXT: entry:
+; CHECK-NEXT: [[F:%.*]] = alloca [10 x i32], align 4
+; CHECK-NEXT: [[FIELD1:%.*]] = getelementptr inbounds [10 x i32], ptr [[F]], i32 0, i32 1
+; CHECK-NEXT: [[FIELD2:%.*]] = getelementptr inbounds [10 x i32], ptr [[F]], i32 0, i32 2
+; CHECK-NEXT: [[FIELD3:%.*]] = getelementptr inbounds [10 x i32], ptr [[F]], i32 0, i32 3
+; CHECK-NEXT: [[FIELD8:%.*]] = getelementptr inbounds [10 x i32], ptr [[F]], i32 0, i32 8
+; CHECK-NEXT: [[FIELD11:%.*]] = getelementptr i32, ptr [[FIELD1]], i32 2
+; CHECK-NEXT: [[FIELD22:%.*]] = getelementptr i32, ptr [[FIELD2]], i32 2
+; CHECK-NEXT: store i8 10, ptr [[FIELD11]], align 4
+; CHECK-NEXT: store i8 12, ptr [[FIELD22]], align 4
+; CHECK-NEXT: [[TMP0:%.*]] = load i32, ptr [[FIELD11]], align 4
+; CHECK-NEXT: [[TMP1:%.*]] = load i32, ptr [[FIELD22]], align 4
+; CHECK-NEXT: [[TMP2:%.*]] = add i32 [[TMP0]], [[TMP1]]
+; CHECK-NEXT: [[TMP3:%.*]] = load i32, ptr [[VAL]], align 4
+; CHECK-NEXT: store i32 [[TMP3]], ptr [[FIELD8]], align 4
+; CHECK-NEXT: [[TMP4:%.*]] = add i32 [[TMP3]], [[TMP2]]
+; CHECK-NEXT: [[B:%.*]] = load i32, ptr [[FIELD3]], align 4
+; CHECK-NEXT: [[TMP5:%.*]] = select i1 [[COND]], ptr [[FIELD3]], ptr [[FIELD8]]
+; CHECK-NEXT: store i32 1000, ptr [[TMP5]], align 4
+; CHECK-NEXT: [[TMP6:%.*]] = add i32 [[TMP4]], [[B]]
+; CHECK-NEXT: [[TMP7:%.*]] = load i32, ptr [[FIELD8]], align 4
+; CHECK-NEXT: [[TMP8:%.*]] = add i32 [[TMP7]], [[TMP6]]
+; CHECK-NEXT: ret i32 [[TMP8]]
+;
+entry:
+ %f = alloca [10 x i32]
+ %field1 = getelementptr inbounds [10 x i32], ptr %f, i32 0, i32 1
+ %field2 = getelementptr inbounds [10 x i32], ptr %f, i32 0, i32 2
+ %field3 = getelementptr inbounds [10 x i32], ptr %f, i32 0, i32 3
+ %field8 = getelementptr inbounds [10 x i32], ptr %f, i32 0, i32 8
+
+ %field11 = getelementptr i32, ptr %field1, i32 2
+ %field22 = getelementptr i32, ptr %field2, i32 2
+ store i8 10, ptr %field11, align 4
+ store i8 12, ptr %field22, align 4
+ %1 = load i32, ptr %field11, align 4
+ %2 = load i32, ptr %field22, align 4
+ %3 = add i32 %1, %2
+ %4 = load i32, ptr %val, align 4
+ store i32 %4, ptr %field8, align 4
+ %5 = add i32 %4, %3
+ %6 = load i32, ptr %val
+ %a1 = load i32, ptr %field8
+ %a = add i32 %a1, %6
+ %b = load i32, ptr %field3
+ ;%b = sub i32 %b1, %6
+ %7 = select i1 %cond, ptr %field3, ptr %field8
+ store i32 1000, ptr %7
+ %8 = add i32 %5, %b
+ %9 = load i32, ptr %field8
+ %10 = add i32 %9, %8
+ ret i32 %10
+}
+
+ at globalBytes = internal global [1024 x i8] zeroinitializer, align 16
+
+;.
+; CHECK: @globalBytes = internal global [1024 x i8] zeroinitializer, align 16
+;.
+define dso_local i32 @phi_different_offsets(ptr nocapture %val, ptr nocapture %val2, i1 %cmp) {
+; CHECK: Function Attrs: mustprogress nofree norecurse nosync nounwind willreturn
+; CHECK-LABEL: define dso_local i32 @phi
+; CHECK-SAME: (ptr nocapture nofree readonly [[VAL:%.*]], ptr nocapture nofree readonly [[VAL2:%.*]], i1 noundef [[CMP:%.*]]) #[[ATTR0:[0-9]+]] {
+; CHECK-NEXT: entry:
+; CHECK-NEXT: br i1 [[CMP]], label [[THEN:%.*]], label [[ELSE:%.*]]
+; CHECK: then:
+; CHECK-NEXT: [[FIELD2:%.*]] = getelementptr i32, ptr @globalBytes, i32 2
+; CHECK-NEXT: [[TMP0:%.*]] = load i32, ptr [[VAL]], align 4
+; CHECK-NEXT: store i32 [[TMP0]], ptr [[FIELD2]], align 8
+; CHECK-NEXT: br label [[END:%.*]]
+; CHECK: else:
+; CHECK-NEXT: [[FIELD8:%.*]] = getelementptr i32, ptr @globalBytes, i32 8
+; CHECK-NEXT: [[TMP1:%.*]] = load i32, ptr [[VAL2]], align 4
+; CHECK-NEXT: store i32 [[TMP1]], ptr [[FIELD8]], align 16
+; CHECK-NEXT: br label [[END]]
+; CHECK: end:
+; CHECK-NEXT: [[X:%.*]] = phi ptr [ [[FIELD2]], [[THEN]] ], [ [[FIELD8]], [[ELSE]] ]
+; CHECK-NEXT: [[RET:%.*]] = load i32, ptr [[X]], align 8
+; CHECK-NEXT: ret i32 [[RET]]
+;
+entry:
+ br i1 %cmp, label %then, label %else
+
+then:
+ %field2 = getelementptr i32, ptr @globalBytes, i32 2
+ %1 = load i32, ptr %val
+ store i32 %1, ptr %field2
+ br label %end
+
+else:
+ %field8 = getelementptr i32, ptr @globalBytes, i32 8
+ %2 = load i32, ptr %val2
+ store i32 %2, ptr %field8
+ br label %end
+
+end:
+ %x = phi ptr [ %field2, %then ], [ %field8, %else ]
+ %ret = load i32, ptr %x
+ ret i32 %ret
+
+}
+
+define dso_local i32 @phi_same_offsets(ptr nocapture %val, ptr nocapture %val2, i1 %cmp) {
+; CHECK: Function Attrs: mustprogress nofree norecurse nosync nounwind willreturn
+; CHECK-LABEL: define dso_local i32 @phi
+; CHECK-SAME: (ptr nocapture nofree readonly [[VAL:%.*]], ptr nocapture nofree readonly [[VAL2:%.*]], i1 noundef [[CMP:%.*]]) #[[ATTR0:[0-9]+]] {
+; CHECK-NEXT: entry:
+; CHECK-NEXT: br i1 [[CMP]], label [[THEN:%.*]], label [[ELSE:%.*]]
+; CHECK: then:
+; CHECK-NEXT: [[FIELD2:%.*]] = getelementptr i32, ptr @globalBytes, i32 8
+; CHECK-NEXT: [[TMP0:%.*]] = load i32, ptr [[VAL]], align 4
+; CHECK-NEXT: store i32 [[TMP0]], ptr [[FIELD2]], align 16
+; CHECK-NEXT: br label [[END:%.*]]
+; CHECK: else:
+; CHECK-NEXT: [[FIELD8:%.*]] = getelementptr i32, ptr @globalBytes, i32 8
+; CHECK-NEXT: [[TMP1:%.*]] = load i32, ptr [[VAL2]], align 4
+; CHECK-NEXT: store i32 [[TMP1]], ptr [[FIELD8]], align 16
+; CHECK-NEXT: br label [[END]]
+; CHECK: end:
+; CHECK-NEXT: [[X:%.*]] = phi ptr [ [[FIELD2]], [[THEN]] ], [ [[FIELD8]], [[ELSE]] ]
+; CHECK-NEXT: [[RET:%.*]] = load i32, ptr [[X]], align 16
+; CHECK-NEXT: ret i32 [[RET]]
+;
+entry:
+ br i1 %cmp, label %then, label %else
+
+then:
+ %field2 = getelementptr i32, ptr @globalBytes, i32 8
+ %1 = load i32, ptr %val
+ store i32 %1, ptr %field2
+ br label %end
+
+else:
+ %field8 = getelementptr i32, ptr @globalBytes, i32 8
+ %2 = load i32, ptr %val2
+ store i32 %2, ptr %field8
+ br label %end
+
+end:
+ %x = phi ptr [ %field2, %then ], [ %field8, %else ]
+ %ret = load i32, ptr %x
+ ret i32 %ret
+
+}
\ No newline at end of file
diff --git a/llvm/test/Transforms/Attributor/value-simplify-pointer-info.ll b/llvm/test/Transforms/Attributor/value-simplify-pointer-info.ll
index 7a35b5c856097..1dce6e105bf29 100644
--- a/llvm/test/Transforms/Attributor/value-simplify-pointer-info.ll
+++ b/llvm/test/Transforms/Attributor/value-simplify-pointer-info.ll
@@ -2092,47 +2092,35 @@ end:
; FIXME: This function returns 1.
define i8 @phi_no_store_1() {
;
-; TUNIT: Function Attrs: mustprogress nofree norecurse nosync nounwind willreturn
+; TUNIT: Function Attrs: mustprogress nofree norecurse nosync nounwind willreturn memory(write)
; TUNIT-LABEL: define {{[^@]+}}@phi_no_store_1
-; TUNIT-SAME: () #[[ATTR3]] {
+; TUNIT-SAME: () #[[ATTR5]] {
; TUNIT-NEXT: entry:
; TUNIT-NEXT: br label [[LOOP:%.*]]
; TUNIT: loop:
; TUNIT-NEXT: [[P:%.*]] = phi ptr [ @a1, [[ENTRY:%.*]] ], [ [[G:%.*]], [[LOOP]] ]
; TUNIT-NEXT: [[I:%.*]] = phi i8 [ 0, [[ENTRY]] ], [ [[O:%.*]], [[LOOP]] ]
-; TUNIT-NEXT: store i8 1, ptr [[P]], align 1
; TUNIT-NEXT: [[G]] = getelementptr i8, ptr [[P]], i64 1
; TUNIT-NEXT: [[O]] = add nsw i8 [[I]], 1
; TUNIT-NEXT: [[C:%.*]] = icmp eq i8 [[O]], 3
; TUNIT-NEXT: br i1 [[C]], label [[END:%.*]], label [[LOOP]]
; TUNIT: end:
-; TUNIT-NEXT: [[S11:%.*]] = getelementptr i8, ptr @a1, i64 2
-; TUNIT-NEXT: [[L11:%.*]] = load i8, ptr [[S11]], align 2
-; TUNIT-NEXT: [[S12:%.*]] = getelementptr i8, ptr @a1, i64 3
-; TUNIT-NEXT: [[L12:%.*]] = load i8, ptr [[S12]], align 1
-; TUNIT-NEXT: [[ADD:%.*]] = add i8 [[L11]], [[L12]]
-; TUNIT-NEXT: ret i8 [[ADD]]
+; TUNIT-NEXT: ret i8 0
;
-; CGSCC: Function Attrs: mustprogress nofree norecurse nosync nounwind willreturn
+; CGSCC: Function Attrs: mustprogress nofree norecurse nosync nounwind willreturn memory(write)
; CGSCC-LABEL: define {{[^@]+}}@phi_no_store_1
-; CGSCC-SAME: () #[[ATTR5]] {
+; CGSCC-SAME: () #[[ATTR6]] {
; CGSCC-NEXT: entry:
; CGSCC-NEXT: br label [[LOOP:%.*]]
; CGSCC: loop:
; CGSCC-NEXT: [[P:%.*]] = phi ptr [ @a1, [[ENTRY:%.*]] ], [ [[G:%.*]], [[LOOP]] ]
; CGSCC-NEXT: [[I:%.*]] = phi i8 [ 0, [[ENTRY]] ], [ [[O:%.*]], [[LOOP]] ]
-; CGSCC-NEXT: store i8 1, ptr [[P]], align 1
; CGSCC-NEXT: [[G]] = getelementptr i8, ptr [[P]], i64 1
; CGSCC-NEXT: [[O]] = add nsw i8 [[I]], 1
; CGSCC-NEXT: [[C:%.*]] = icmp eq i8 [[O]], 3
; CGSCC-NEXT: br i1 [[C]], label [[END:%.*]], label [[LOOP]]
; CGSCC: end:
-; CGSCC-NEXT: [[S11:%.*]] = getelementptr i8, ptr @a1, i64 2
-; CGSCC-NEXT: [[L11:%.*]] = load i8, ptr [[S11]], align 2
-; CGSCC-NEXT: [[S12:%.*]] = getelementptr i8, ptr @a1, i64 3
-; CGSCC-NEXT: [[L12:%.*]] = load i8, ptr [[S12]], align 1
-; CGSCC-NEXT: [[ADD:%.*]] = add i8 [[L11]], [[L12]]
-; CGSCC-NEXT: ret i8 [[ADD]]
+; CGSCC-NEXT: ret i8 0
;
entry:
br label %loop
@@ -2172,9 +2160,7 @@ define i8 @phi_no_store_2() {
; TUNIT: end:
; TUNIT-NEXT: [[S21:%.*]] = getelementptr i8, ptr @a2, i64 2
; TUNIT-NEXT: [[L21:%.*]] = load i8, ptr [[S21]], align 2
-; TUNIT-NEXT: [[S22:%.*]] = getelementptr i8, ptr @a2, i64 3
-; TUNIT-NEXT: [[L22:%.*]] = load i8, ptr [[S22]], align 1
-; TUNIT-NEXT: [[ADD:%.*]] = add i8 [[L21]], [[L22]]
+; TUNIT-NEXT: [[ADD:%.*]] = add i8 [[L21]], 0
; TUNIT-NEXT: ret i8 [[ADD]]
;
; CGSCC: Function Attrs: mustprogress nofree norecurse nosync nounwind willreturn
@@ -2193,9 +2179,7 @@ define i8 @phi_no_store_2() {
; CGSCC: end:
; CGSCC-NEXT: [[S21:%.*]] = getelementptr i8, ptr @a2, i64 2
; CGSCC-NEXT: [[L21:%.*]] = load i8, ptr [[S21]], align 2
-; CGSCC-NEXT: [[S22:%.*]] = getelementptr i8, ptr @a2, i64 3
-; CGSCC-NEXT: [[L22:%.*]] = load i8, ptr [[S22]], align 1
-; CGSCC-NEXT: [[ADD:%.*]] = add i8 [[L21]], [[L22]]
+; CGSCC-NEXT: [[ADD:%.*]] = add i8 [[L21]], 0
; CGSCC-NEXT: ret i8 [[ADD]]
;
entry:
@@ -2218,57 +2202,37 @@ end:
}
define i8 @phi_no_store_3() {
-; TUNIT: Function Attrs: mustprogress nofree norecurse nosync nounwind willreturn
+; TUNIT: Function Attrs: mustprogress nofree norecurse nosync nounwind willreturn memory(write)
; TUNIT-LABEL: define {{[^@]+}}@phi_no_store_3
-; TUNIT-SAME: () #[[ATTR3]] {
+; TUNIT-SAME: () #[[ATTR5]] {
; TUNIT-NEXT: entry:
; TUNIT-NEXT: [[S30:%.*]] = getelementptr i8, ptr @a3, i64 3
-; TUNIT-NEXT: store i8 0, ptr [[S30]], align 1
; TUNIT-NEXT: br label [[LOOP:%.*]]
; TUNIT: loop:
; TUNIT-NEXT: [[P:%.*]] = phi ptr [ @a3, [[ENTRY:%.*]] ], [ [[G:%.*]], [[LOOP]] ]
; TUNIT-NEXT: [[I:%.*]] = phi i8 [ 0, [[ENTRY]] ], [ [[O:%.*]], [[LOOP]] ]
-; TUNIT-NEXT: store i8 1, ptr [[P]], align 1
; TUNIT-NEXT: [[G]] = getelementptr i8, ptr @a3, i64 2
; TUNIT-NEXT: [[O]] = add nsw i8 [[I]], 1
; TUNIT-NEXT: [[C:%.*]] = icmp eq i8 [[O]], 7
; TUNIT-NEXT: br i1 [[C]], label [[END:%.*]], label [[LOOP]]
; TUNIT: end:
-; TUNIT-NEXT: [[S31:%.*]] = getelementptr i8, ptr @a3, i64 2
-; TUNIT-NEXT: [[L31:%.*]] = load i8, ptr [[S31]], align 2
-; TUNIT-NEXT: [[S32:%.*]] = getelementptr i8, ptr @a3, i64 3
-; TUNIT-NEXT: [[L32:%.*]] = load i8, ptr [[S32]], align 1
-; TUNIT-NEXT: [[ADD:%.*]] = add i8 [[L31]], [[L32]]
-; TUNIT-NEXT: [[S34:%.*]] = getelementptr i8, ptr @a3, i64 4
-; TUNIT-NEXT: [[L34:%.*]] = load i8, ptr [[S34]], align 4
-; TUNIT-NEXT: [[ADD2:%.*]] = add i8 [[ADD]], [[L34]]
-; TUNIT-NEXT: ret i8 [[ADD2]]
+; TUNIT-NEXT: ret i8 poison
;
-; CGSCC: Function Attrs: mustprogress nofree norecurse nosync nounwind willreturn
+; CGSCC: Function Attrs: mustprogress nofree norecurse nosync nounwind willreturn memory(write)
; CGSCC-LABEL: define {{[^@]+}}@phi_no_store_3
-; CGSCC-SAME: () #[[ATTR5]] {
+; CGSCC-SAME: () #[[ATTR6]] {
; CGSCC-NEXT: entry:
; CGSCC-NEXT: [[S30:%.*]] = getelementptr i8, ptr @a3, i64 3
-; CGSCC-NEXT: store i8 0, ptr [[S30]], align 1
; CGSCC-NEXT: br label [[LOOP:%.*]]
; CGSCC: loop:
; CGSCC-NEXT: [[P:%.*]] = phi ptr [ @a3, [[ENTRY:%.*]] ], [ [[G:%.*]], [[LOOP]] ]
; CGSCC-NEXT: [[I:%.*]] = phi i8 [ 0, [[ENTRY]] ], [ [[O:%.*]], [[LOOP]] ]
-; CGSCC-NEXT: store i8 1, ptr [[P]], align 1
; CGSCC-NEXT: [[G]] = getelementptr i8, ptr @a3, i64 2
; CGSCC-NEXT: [[O]] = add nsw i8 [[I]], 1
; CGSCC-NEXT: [[C:%.*]] = icmp eq i8 [[O]], 7
; CGSCC-NEXT: br i1 [[C]], label [[END:%.*]], label [[LOOP]]
; CGSCC: end:
-; CGSCC-NEXT: [[S31:%.*]] = getelementptr i8, ptr @a3, i64 2
-; CGSCC-NEXT: [[L31:%.*]] = load i8, ptr [[S31]], align 2
-; CGSCC-NEXT: [[S32:%.*]] = getelementptr i8, ptr @a3, i64 3
-; CGSCC-NEXT: [[L32:%.*]] = load i8, ptr [[S32]], align 1
-; CGSCC-NEXT: [[ADD:%.*]] = add i8 [[L31]], [[L32]]
-; CGSCC-NEXT: [[S34:%.*]] = getelementptr i8, ptr @a3, i64 4
-; CGSCC-NEXT: [[L34:%.*]] = load i8, ptr [[S34]], align 4
-; CGSCC-NEXT: [[ADD2:%.*]] = add i8 [[ADD]], [[L34]]
-; CGSCC-NEXT: ret i8 [[ADD2]]
+; CGSCC-NEXT: ret i8 poison
;
entry:
%s30 = getelementptr i8, ptr @a3, i64 3
More information about the llvm-commits
mailing list