[llvm] 335e137 - [Attributor][FIX] Track returned pointer offsets (#110534)
via llvm-commits
llvm-commits at lists.llvm.org
Tue Oct 1 10:41:19 PDT 2024
Author: Johannes Doerfert
Date: 2024-10-01T12:41:15-05:00
New Revision: 335e1372671c78a8cc6f023f962d621ad48703bb
URL: https://github.com/llvm/llvm-project/commit/335e1372671c78a8cc6f023f962d621ad48703bb
DIFF: https://github.com/llvm/llvm-project/commit/335e1372671c78a8cc6f023f962d621ad48703bb.diff
LOG: [Attributor][FIX] Track returned pointer offsets (#110534)
If the pointer returned by a function is not "the base pointer" but has
an offset, we need to track the offset such that users can apply it to
their offset chain when they create accesses.
This was reported by @ye-luo and reduced test cases are included. The
OffsetInfo was moved and the container was replaced with a set to avoid
excessive growth. Otherwise, the patch just replaces the "returns
pointer" flag with the "returned offsets", and deals with the applying
to offsets at the call site.
---------
Co-authored-by: Johannes Doerfert <jdoerfert at llnl.gov>
Added:
Modified:
llvm/include/llvm/Transforms/IPO/Attributor.h
llvm/lib/Transforms/IPO/AttributorAttributes.cpp
llvm/test/Transforms/Attributor/value-simplify-pointer-info.ll
Removed:
################################################################################
diff --git a/llvm/include/llvm/Transforms/IPO/Attributor.h b/llvm/include/llvm/Transforms/IPO/Attributor.h
index b32f07e6427e8d..8915969f75466c 100644
--- a/llvm/include/llvm/Transforms/IPO/Attributor.h
+++ b/llvm/include/llvm/Transforms/IPO/Attributor.h
@@ -5786,6 +5786,53 @@ 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 = SmallSet<int64_t, 4>;
+ 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); }
+
+ bool insert(int64_t Offset) { return Offsets.insert(Offset).second; }
+ bool isUnassigned() const { return Offsets.size() == 0; }
+
+ bool isUnknown() const {
+ if (isUnassigned())
+ return false;
+ if (Offsets.size() == 1)
+ return *Offsets.begin() == AA::RangeTy::Unknown;
+ return false;
+ }
+
+ void setUnknown() {
+ Offsets.clear();
+ Offsets.insert(AA::RangeTy::Unknown);
+ }
+
+ void addToAll(int64_t Inc) {
+ VecTy NewOffsets;
+ for (auto &Offset : Offsets)
+ NewOffsets.insert(Offset + Inc);
+ Offsets = std::move(NewOffsets);
+ }
+
+ /// 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.
+ bool merge(const OffsetInfo &R) { return set_union(Offsets, R.Offsets); }
+ };
+
/// A container for a list of ranges.
struct RangeList {
// The set of ranges rarely contains more than one element, and is unlikely
@@ -6123,6 +6170,7 @@ struct AAPointerInfo : public AbstractAttribute {
virtual const_bin_iterator end() const = 0;
virtual int64_t numOffsetBins() const = 0;
virtual bool reachesReturn() const = 0;
+ virtual void addReturnedOffsetsTo(OffsetInfo &) const = 0;
/// Call \p CB on all accesses that might interfere with \p Range and return
/// true if all such accesses were known and the callback returned true for
diff --git a/llvm/lib/Transforms/IPO/AttributorAttributes.cpp b/llvm/lib/Transforms/IPO/AttributorAttributes.cpp
index 238bdf9c344b08..45e2a0d0b93363 100644
--- a/llvm/lib/Transforms/IPO/AttributorAttributes.cpp
+++ b/llvm/lib/Transforms/IPO/AttributorAttributes.cpp
@@ -827,7 +827,7 @@ struct AA::PointerInfo::State : public AbstractState {
AccessList = R.AccessList;
OffsetBins = R.OffsetBins;
RemoteIMap = R.RemoteIMap;
- ReachesReturn = R.ReachesReturn;
+ ReturnedOffsets = R.ReturnedOffsets;
return *this;
}
@@ -838,7 +838,7 @@ struct AA::PointerInfo::State : public AbstractState {
std::swap(AccessList, R.AccessList);
std::swap(OffsetBins, R.OffsetBins);
std::swap(RemoteIMap, R.RemoteIMap);
- std::swap(ReachesReturn, R.ReachesReturn);
+ std::swap(ReturnedOffsets, R.ReturnedOffsets);
return *this;
}
@@ -883,13 +883,13 @@ struct AA::PointerInfo::State : public AbstractState {
/// Flag to determine if the underlying pointer is reaching a return statement
/// in the associated function or not. Returns in other functions cause
/// invalidation.
- bool ReachesReturn = false;
+ AAPointerInfo::OffsetInfo ReturnedOffsets;
/// See AAPointerInfo::forallInterferingAccesses.
bool forallInterferingAccesses(
AA::RangeTy Range,
function_ref<bool(const AAPointerInfo::Access &, bool)> CB) const {
- if (!isValidState() || ReachesReturn)
+ if (!isValidState() || !ReturnedOffsets.isUnassigned())
return false;
for (const auto &It : OffsetBins) {
@@ -911,7 +911,7 @@ struct AA::PointerInfo::State : public AbstractState {
Instruction &I,
function_ref<bool(const AAPointerInfo::Access &, bool)> CB,
AA::RangeTy &Range) const {
- if (!isValidState() || ReachesReturn)
+ if (!isValidState() || !ReturnedOffsets.isUnassigned())
return false;
auto LocalList = RemoteIMap.find(&I);
@@ -1010,54 +1010,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) {
@@ -1079,7 +1034,13 @@ struct AAPointerInfoImpl
(isValidState() ? (std::string("#") +
std::to_string(OffsetBins.size()) + " bins")
: "<invalid>") +
- (ReachesReturn ? " (returned)" : "");
+ (reachesReturn()
+ ? (" (returned:" +
+ join(map_range(ReturnedOffsets,
+ [](int64_t O) { return std::to_string(O); }),
+ ", ") +
+ ")")
+ : "");
}
/// See AbstractAttribute::manifest(...).
@@ -1092,13 +1053,34 @@ struct AAPointerInfoImpl
virtual int64_t numOffsetBins() const override {
return State::numOffsetBins();
}
- virtual bool reachesReturn() const override { return ReachesReturn; }
- ChangeStatus setReachesReturn(bool Val) {
- if (ReachesReturn == Val)
- return ChangeStatus::UNCHANGED;
+ virtual bool reachesReturn() const override {
+ return !ReturnedOffsets.isUnassigned();
+ }
+ virtual void addReturnedOffsetsTo(OffsetInfo &OI) const override {
+ if (ReturnedOffsets.isUnknown()) {
+ OI.setUnknown();
+ return;
+ }
- ReachesReturn = Val;
- return ChangeStatus::CHANGED;
+ OffsetInfo MergedOI;
+ for (auto Offset : ReturnedOffsets) {
+ OffsetInfo TmpOI = OI;
+ TmpOI.addToAll(Offset);
+ MergedOI.merge(TmpOI);
+ }
+ OI = std::move(MergedOI);
+ }
+
+ ChangeStatus setReachesReturn(const OffsetInfo &ReachedReturnedOffsets) {
+ if (ReturnedOffsets.isUnknown())
+ return ChangeStatus::UNCHANGED;
+ if (ReachedReturnedOffsets.isUnknown()) {
+ ReturnedOffsets.setUnknown();
+ return ChangeStatus::CHANGED;
+ }
+ if (ReturnedOffsets.merge(ReachedReturnedOffsets))
+ return ChangeStatus::CHANGED;
+ return ChangeStatus::UNCHANGED;
}
bool forallInterferingAccesses(
@@ -1390,7 +1372,7 @@ struct AAPointerInfoImpl
ChangeStatus Changed = ChangeStatus::UNCHANGED;
const auto &OtherAAImpl = static_cast<const AAPointerInfoImpl &>(OtherAA);
bool IsByval = OtherAAImpl.getAssociatedArgument()->hasByValAttr();
- Changed |= setReachesReturn(OtherAAImpl.ReachesReturn);
+ Changed |= setReachesReturn(OtherAAImpl.ReturnedOffsets);
// Combine the accesses bin by bin.
const auto &State = OtherAAImpl.getState();
@@ -1485,7 +1467,7 @@ 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,
+ OffsetInfo::VecTy &Offsets, ChangeStatus &Changed,
Type &Ty) {
using namespace AA::PointerInfo;
auto Size = AA::RangeTy::Unknown;
@@ -1495,16 +1477,16 @@ struct AAPointerInfoFloating : public AAPointerInfoImpl {
Size = AccessSize.getFixedValue();
// Make a strictly ascending list of offsets as required by addAccess()
- llvm::sort(Offsets);
- auto *Last = llvm::unique(Offsets);
- Offsets.erase(Last, Offsets.end());
+ SmallVector<int64_t> OffsetsSorted(Offsets.begin(), Offsets.end());
+ llvm::sort(OffsetsSorted);
VectorType *VT = dyn_cast<VectorType>(&Ty);
if (!VT || VT->getElementCount().isScalable() ||
!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, {OffsetsSorted, Size}, I, Content, Kind, &Ty);
} else {
// Handle vector stores with constant content element-wise.
// TODO: We could look for the elements or create instructions
@@ -1689,8 +1671,12 @@ ChangeStatus AAPointerInfoFloating::updateImpl(Attributor &A) {
// then check the call site return. Returns from other functions can't be
// tracked and are cause for invalidation.
if (auto *RI = dyn_cast<ReturnInst>(Usr)) {
- Changed |= setReachesReturn(RI->getFunction() == getAssociatedFunction());
- return ReachesReturn;
+ if (RI->getFunction() == getAssociatedFunction()) {
+ auto &PtrOI = OffsetInfoMap[CurPtr];
+ Changed |= setReachesReturn(PtrOI);
+ return true;
+ }
+ return false;
}
// For PHIs we need to take care of the recurrence explicitly as the value
@@ -1946,9 +1932,10 @@ ChangeStatus AAPointerInfoFloating::updateImpl(Attributor &A) {
*this, IRPosition::callsite_returned(*CB), DepClassTy::REQUIRED);
if (!CSRetPI)
return false;
- Changed = translateAndAddState(A, *CSRetPI, OffsetInfoMap[CurPtr], *CB,
- IsRetMustAcc) |
- Changed;
+ OffsetInfo OI = OffsetInfoMap[CurPtr];
+ CSArgPI->addReturnedOffsetsTo(OI);
+ Changed =
+ translateAndAddState(A, *CSRetPI, OI, *CB, IsRetMustAcc) | Changed;
return isValidState();
}
LLVM_DEBUG(dbgs() << "[AAPointerInfo] Call user not handled " << *CB
diff --git a/llvm/test/Transforms/Attributor/value-simplify-pointer-info.ll b/llvm/test/Transforms/Attributor/value-simplify-pointer-info.ll
index 378560cc89cd12..adcee750cae6e5 100644
--- a/llvm/test/Transforms/Attributor/value-simplify-pointer-info.ll
+++ b/llvm/test/Transforms/Attributor/value-simplify-pointer-info.ll
@@ -3389,6 +3389,197 @@ entry:
ret ptr %R
}
+define ptr @move2(ptr %p) {
+; CHECK: Function Attrs: mustprogress nofree norecurse nosync nounwind willreturn memory(none)
+; CHECK-LABEL: define {{[^@]+}}@move2
+; CHECK-SAME: (ptr nofree readnone "no-capture-maybe-returned" [[P:%.*]]) #[[ATTR4]] {
+; CHECK-NEXT: [[G:%.*]] = getelementptr i8, ptr [[P]], i32 2
+; CHECK-NEXT: ret ptr [[G]]
+;
+ %g = getelementptr i8, ptr %p, i32 2
+ ret ptr %g
+}
+define internal ptr @move4(ptr %p) {
+; CHECK: Function Attrs: mustprogress nofree norecurse nosync nounwind willreturn memory(none)
+; CHECK-LABEL: define {{[^@]+}}@move4
+; CHECK-SAME: (ptr noalias nofree readnone "no-capture-maybe-returned" [[P:%.*]]) #[[ATTR4]] {
+; CHECK-NEXT: [[G:%.*]] = getelementptr i8, ptr [[P]], i32 4
+; CHECK-NEXT: ret ptr [[G]]
+;
+ %g = getelementptr i8, ptr %p, i32 4
+ ret ptr %g
+}
+
+define ptr @move246(i32 %i, ptr %p) {
+; CHECK: Function Attrs: mustprogress nofree norecurse nosync nounwind willreturn memory(none)
+; CHECK-LABEL: define {{[^@]+}}@move246
+; CHECK-SAME: (i32 [[I:%.*]], ptr nofree readnone "no-capture-maybe-returned" [[P:%.*]]) #[[ATTR4]] {
+; CHECK-NEXT: [[C0:%.*]] = icmp eq i32 [[I]], 0
+; CHECK-NEXT: br i1 [[C0]], label [[BG2:%.*]], label [[BG46:%.*]]
+; CHECK: bg2:
+; CHECK-NEXT: [[G2:%.*]] = getelementptr i8, ptr [[P]], i32 2
+; CHECK-NEXT: ret ptr [[G2]]
+; CHECK: bg46:
+; CHECK-NEXT: [[C1:%.*]] = icmp eq i32 [[I]], 1
+; CHECK-NEXT: br i1 [[C1]], label [[BG4:%.*]], label [[BG6:%.*]]
+; CHECK: bg4:
+; CHECK-NEXT: [[G4:%.*]] = getelementptr i8, ptr [[P]], i32 4
+; CHECK-NEXT: ret ptr [[G4]]
+; CHECK: bg6:
+; CHECK-NEXT: [[G6:%.*]] = getelementptr i8, ptr [[P]], i32 6
+; CHECK-NEXT: ret ptr [[G6]]
+;
+ %c0 = icmp eq i32 %i, 0
+ br i1 %c0, label %bg2, label %bg46
+bg2:
+ %g2 = getelementptr i8, ptr %p, i32 2
+ ret ptr %g2
+bg46:
+ %c1 = icmp eq i32 %i, 1
+ br i1 %c1, label %bg4, label %bg6
+bg4:
+ %g4 = getelementptr i8, ptr %p, i32 4
+ ret ptr %g4
+bg6:
+ %g6 = getelementptr i8, ptr %p, i32 6
+ ret ptr %g6
+}
+
+declare void @use3i8(i8, i8, i8)
+
+define void @returnedPtrAccesses() {
+; TUNIT-LABEL: define {{[^@]+}}@returnedPtrAccesses() {
+; TUNIT-NEXT: [[A:%.*]] = alloca i64, align 8
+; TUNIT-NEXT: [[A2:%.*]] = call ptr @move2(ptr noalias nofree noundef nonnull readnone align 8 dereferenceable(8) "no-capture-maybe-returned" [[A]]) #[[ATTR23]]
+; TUNIT-NEXT: [[A4:%.*]] = call ptr @move4(ptr noalias nofree noundef nonnull readnone align 8 dereferenceable(8) "no-capture-maybe-returned" [[A]]) #[[ATTR23]]
+; TUNIT-NEXT: [[A6:%.*]] = call ptr @move4(ptr noalias nofree readnone "no-capture-maybe-returned" [[A2]]) #[[ATTR23]]
+; TUNIT-NEXT: store i8 2, ptr [[A2]], align 1
+; TUNIT-NEXT: store i8 4, ptr [[A4]], align 1
+; TUNIT-NEXT: store i8 6, ptr [[A6]], align 1
+; TUNIT-NEXT: call void @use3i8(i8 2, i8 4, i8 6)
+; TUNIT-NEXT: ret void
+;
+; CGSCC-LABEL: define {{[^@]+}}@returnedPtrAccesses() {
+; CGSCC-NEXT: [[A:%.*]] = alloca i64, align 8
+; CGSCC-NEXT: [[A2:%.*]] = call nonnull dereferenceable(1) ptr @move2(ptr noalias nofree noundef nonnull readnone align 8 dereferenceable(8) [[A]]) #[[ATTR20]]
+; CGSCC-NEXT: [[A4:%.*]] = call ptr @move4(ptr noalias nofree noundef nonnull readnone align 8 dereferenceable(8) [[A]]) #[[ATTR20]]
+; CGSCC-NEXT: [[A6:%.*]] = call ptr @move4(ptr noalias nofree noundef nonnull readnone dereferenceable(1) [[A2]]) #[[ATTR20]]
+; CGSCC-NEXT: [[G2:%.*]] = getelementptr i8, ptr [[A]], i32 2
+; CGSCC-NEXT: [[G4:%.*]] = getelementptr i8, ptr [[A]], i32 4
+; CGSCC-NEXT: [[G6:%.*]] = getelementptr i8, ptr [[A]], i32 6
+; CGSCC-NEXT: store i8 2, ptr [[A2]], align 1
+; CGSCC-NEXT: store i8 4, ptr [[A4]], align 1
+; CGSCC-NEXT: store i8 6, ptr [[A6]], align 1
+; CGSCC-NEXT: [[L2:%.*]] = load i8, ptr [[G2]], align 2
+; CGSCC-NEXT: [[L4:%.*]] = load i8, ptr [[G4]], align 4
+; CGSCC-NEXT: [[L6:%.*]] = load i8, ptr [[G6]], align 2
+; CGSCC-NEXT: call void @use3i8(i8 [[L2]], i8 [[L4]], i8 [[L6]])
+; CGSCC-NEXT: ret void
+;
+ %a = alloca i64
+ %a2 = call ptr @move2(ptr %a)
+ %a4 = call ptr @move4(ptr %a)
+ %a6 = call ptr @move4(ptr %a2)
+ %g2 = getelementptr i8, ptr %a, i32 2
+ %g4 = getelementptr i8, ptr %a, i32 4
+ %g6 = getelementptr i8, ptr %a, i32 6
+ store i8 2, ptr %a2
+ store i8 4, ptr %a4
+ store i8 6, ptr %a6
+ %l2 = load i8, ptr %g2
+ %l4 = load i8, ptr %g4
+ %l6 = load i8, ptr %g6
+ call void @use3i8(i8 %l2, i8 %l4, i8 %l6)
+ ret void
+}
+
+define void @returnedPtrAccessesMultiple(i32 %i) {
+; TUNIT-LABEL: define {{[^@]+}}@returnedPtrAccessesMultiple
+; TUNIT-SAME: (i32 [[I:%.*]]) {
+; TUNIT-NEXT: [[A:%.*]] = alloca i64, align 8
+; TUNIT-NEXT: [[AP:%.*]] = call ptr @move246(i32 [[I]], ptr noalias nofree noundef nonnull readnone align 8 dereferenceable(8) "no-capture-maybe-returned" [[A]]) #[[ATTR23]]
+; TUNIT-NEXT: store i8 2, ptr [[AP]], align 1
+; TUNIT-NEXT: call void @use3i8(i8 2, i8 2, i8 2)
+; TUNIT-NEXT: ret void
+;
+; CGSCC-LABEL: define {{[^@]+}}@returnedPtrAccessesMultiple
+; CGSCC-SAME: (i32 [[I:%.*]]) {
+; CGSCC-NEXT: [[A:%.*]] = alloca i64, align 8
+; CGSCC-NEXT: [[AP:%.*]] = call ptr @move246(i32 [[I]], ptr noalias nofree noundef nonnull readnone align 8 dereferenceable(8) [[A]]) #[[ATTR20]]
+; CGSCC-NEXT: [[G2:%.*]] = getelementptr i8, ptr [[A]], i32 2
+; CGSCC-NEXT: [[G4:%.*]] = getelementptr i8, ptr [[A]], i32 4
+; CGSCC-NEXT: [[G6:%.*]] = getelementptr i8, ptr [[A]], i32 6
+; CGSCC-NEXT: store i8 2, ptr [[AP]], align 1
+; CGSCC-NEXT: [[L2:%.*]] = load i8, ptr [[G2]], align 2
+; CGSCC-NEXT: [[L4:%.*]] = load i8, ptr [[G4]], align 4
+; CGSCC-NEXT: [[L6:%.*]] = load i8, ptr [[G6]], align 2
+; CGSCC-NEXT: call void @use3i8(i8 [[L2]], i8 [[L4]], i8 [[L6]])
+; CGSCC-NEXT: ret void
+;
+ %a = alloca i64
+ %ap = call ptr @move246(i32 %i, ptr %a)
+ %g2 = getelementptr i8, ptr %a, i32 2
+ %g4 = getelementptr i8, ptr %a, i32 4
+ %g6 = getelementptr i8, ptr %a, i32 6
+ store i8 2, ptr %ap
+ %l2 = load i8, ptr %g2
+ %l4 = load i8, ptr %g4
+ %l6 = load i8, ptr %g6
+ call void @use3i8(i8 %l2, i8 %l4, i8 %l6)
+ ret void
+}
+
+define void @returnedPtrAccessesMultiple2(i32 %i) {
+; TUNIT-LABEL: define {{[^@]+}}@returnedPtrAccessesMultiple2
+; TUNIT-SAME: (i32 [[I:%.*]]) {
+; TUNIT-NEXT: [[A:%.*]] = alloca i64, align 8
+; TUNIT-NEXT: [[G2:%.*]] = getelementptr i8, ptr [[A]], i32 2
+; TUNIT-NEXT: [[G4:%.*]] = getelementptr i8, ptr [[A]], i32 4
+; TUNIT-NEXT: [[G6:%.*]] = getelementptr i8, ptr [[A]], i32 6
+; TUNIT-NEXT: store i8 0, ptr [[G2]], align 2
+; TUNIT-NEXT: store i8 0, ptr [[G4]], align 4
+; TUNIT-NEXT: store i8 0, ptr [[G6]], align 2
+; TUNIT-NEXT: [[AP:%.*]] = call ptr @move246(i32 [[I]], ptr noalias nofree noundef nonnull readnone align 8 dereferenceable(8) "no-capture-maybe-returned" [[A]]) #[[ATTR23]]
+; TUNIT-NEXT: store i8 2, ptr [[AP]], align 1
+; TUNIT-NEXT: [[L2:%.*]] = load i8, ptr [[G2]], align 2
+; TUNIT-NEXT: [[L4:%.*]] = load i8, ptr [[G4]], align 4
+; TUNIT-NEXT: [[L6:%.*]] = load i8, ptr [[G6]], align 2
+; TUNIT-NEXT: call void @use3i8(i8 noundef [[L2]], i8 noundef [[L4]], i8 noundef [[L6]])
+; TUNIT-NEXT: ret void
+;
+; CGSCC-LABEL: define {{[^@]+}}@returnedPtrAccessesMultiple2
+; CGSCC-SAME: (i32 [[I:%.*]]) {
+; CGSCC-NEXT: [[A:%.*]] = alloca i64, align 8
+; CGSCC-NEXT: [[G2:%.*]] = getelementptr i8, ptr [[A]], i32 2
+; CGSCC-NEXT: [[G4:%.*]] = getelementptr i8, ptr [[A]], i32 4
+; CGSCC-NEXT: [[G6:%.*]] = getelementptr i8, ptr [[A]], i32 6
+; CGSCC-NEXT: store i8 0, ptr [[G2]], align 2
+; CGSCC-NEXT: store i8 0, ptr [[G4]], align 4
+; CGSCC-NEXT: store i8 0, ptr [[G6]], align 2
+; CGSCC-NEXT: [[AP:%.*]] = call ptr @move246(i32 [[I]], ptr noalias nofree noundef nonnull readnone align 8 dereferenceable(8) [[A]]) #[[ATTR20]]
+; CGSCC-NEXT: store i8 2, ptr [[AP]], align 1
+; CGSCC-NEXT: [[L2:%.*]] = load i8, ptr [[G2]], align 2
+; CGSCC-NEXT: [[L4:%.*]] = load i8, ptr [[G4]], align 4
+; CGSCC-NEXT: [[L6:%.*]] = load i8, ptr [[G6]], align 2
+; CGSCC-NEXT: call void @use3i8(i8 [[L2]], i8 [[L4]], i8 [[L6]])
+; CGSCC-NEXT: ret void
+;
+ %a = alloca i64
+ %g2 = getelementptr i8, ptr %a, i32 2
+ %g4 = getelementptr i8, ptr %a, i32 4
+ %g6 = getelementptr i8, ptr %a, i32 6
+ store i8 0, ptr %g2
+ store i8 0, ptr %g4
+ store i8 0, ptr %g6
+ %ap = call ptr @move246(i32 %i, ptr %a)
+ store i8 2, ptr %ap
+ %l2 = load i8, ptr %g2
+ %l4 = load i8, ptr %g4
+ %l6 = load i8, ptr %g6
+ call void @use3i8(i8 %l2, i8 %l4, i8 %l6)
+ ret void
+}
+
declare void @llvm.assume(i1 noundef)
More information about the llvm-commits
mailing list