[NFC][AAPointerInfo] rename OffsetAndSize to RangeTy

[sameerds]

Summary

This is in preparation for future changes that introduce an actual list of
ranges per Access, to be called a RangeList.

[jdoerfert]

Generally LG, but let's wait with merging this until the follow ups are ready. I'm not 100% sure why we call it range in contrast to the explicit offset+size.

llvm/include/llvm/Transforms/IPO/Attributor.h

 /// not_none + undef => not_none
 ///          V1 + V2 => nullptr
 std::optional<Value *>
 combineOptionalValuesInAAValueLatice(const std::optional<Value *> &A,
                                      const std::optional<Value *> &B, Type *Ty);
 
 /// Helper to represent an access offset and size, with logic to deal with
 /// uncertainty and check for overlapping accesses.
-struct OffsetAndSize {
+struct RangeTy {
   int64_t Offset = Unassigned;
   int64_t Size = Unassigned;
 
-  OffsetAndSize(int64_t Offset, int64_t Size) : Offset(Offset), Size(Size) {}
-  OffsetAndSize() = default;
-  static OffsetAndSize getUnknown() { return OffsetAndSize{Unknown, Unknown}; }
+  RangeTy(int64_t Offset, int64_t Size) : Offset(Offset), Size(Size) {}
+  RangeTy() = default;
+  static RangeTy getUnknown() { return RangeTy{Unknown, Unknown}; }
 
   /// Return true if offset or size are unknown.
   bool offsetOrSizeAreUnknown() const {
-    return Offset == OffsetAndSize::Unknown || Size == OffsetAndSize::Unknown;
+    return Offset == RangeTy::Unknown || Size == RangeTy::Unknown;
   }
 
   /// Return true if offset and size are unknown, thus this is the default
   /// unknown object.
   bool offsetAndSizeAreUnknown() const {
-    return Offset == OffsetAndSize::Unknown && Size == OffsetAndSize::Unknown;
+    return Offset == RangeTy::Unknown && Size == RangeTy::Unknown;
   }
 
   /// Return true if the offset and size are unassigned.
   bool isUnassigned() const {
-    assert((Offset == OffsetAndSize::Unassigned) ==
-               (Size == OffsetAndSize::Unassigned) &&
+    assert((Offset == RangeTy::Unassigned) == (Size == RangeTy::Unassigned) &&
            "Inconsistent state!");
-    return Offset == OffsetAndSize::Unassigned;
+    return Offset == RangeTy::Unassigned;
   }
 
   /// Return true if this offset and size pair might describe an address that
-  /// overlaps with \p OAS.
-  bool mayOverlap(const OffsetAndSize &OAS) const {
+  /// overlaps with \p Range.
+  bool mayOverlap(const RangeTy &Range) const {
     // Any unknown value and we are giving up -> overlap.
-    if (offsetOrSizeAreUnknown() || OAS.offsetOrSizeAreUnknown())
+    if (offsetOrSizeAreUnknown() || Range.offsetOrSizeAreUnknown())
       return true;
 
     // Check if one offset point is in the other interval [offset,
     // offset+size].
-    return OAS.Offset + OAS.Size > Offset && OAS.Offset < Offset + Size;
+    return Range.Offset + Range.Size > Offset && Range.Offset < Offset + Size;
   }
 
-  OffsetAndSize &operator&=(const OffsetAndSize &R) {
+  RangeTy &operator&=(const RangeTy &R) {
     if (Offset == Unassigned)
       Offset = R.Offset;
     else if (R.Offset != Unassigned && R.Offset != Offset)
       Offset = Unknown;
 
     if (Size == Unassigned)
       Size = R.Size;
     else if (Size == Unknown || R.Size == Unknown)
       Size = Unknown;
     else if (R.Size != Unassigned)
       Size = std::max(Size, R.Size);
 
     return *this;
   }
 
   /// Constants used to represent special offsets or sizes.
   /// - This assumes that Offset and Size are non-negative.
   /// - The constants should not clash with DenseMapInfo, such as EmptyKey
   ///   (INT64_MAX) and TombstoneKey (INT64_MIN).
   static constexpr int64_t Unassigned = -1;
   static constexpr int64_t Unknown = -2;
 };
 
-inline bool operator==(const OffsetAndSize &A, const OffsetAndSize &B) {
+inline bool operator==(const RangeTy &A, const RangeTy &B) {
   return A.Offset == B.Offset && A.Size == B.Size;
 }
 
-inline bool operator!=(const OffsetAndSize &A, const OffsetAndSize &B) {
-  return !(A == B);
-}
+inline bool operator!=(const RangeTy &A, const RangeTy &B) { return !(A == B); }
 
 /// Return the initial value of \p Obj with type \p Ty if that is a constant.
 Constant *getInitialValueForObj(Value &Obj, Type &Ty,
                                 const TargetLibraryInfo *TLI,
                                 const DataLayout &DL,
-                                OffsetAndSize *OASPtr = nullptr);
+                                RangeTy *RangePtr = nullptr);
 
 /// Collect all potential underlying objects of \p Ptr at position \p CtxI in
 /// \p Objects. Assumed information is used and dependences onto \p QueryingAA
 /// are added appropriately.
 ///
 /// \returns True if \p Objects contains all assumed underlying objects, and
 ///          false if something went wrong and the objects could not be
 ///          determined.
enum AccessKind {
     AK_MUST_WRITE = AK_MUST | AK_W,
     AK_MUST_READ_WRITE = AK_MUST | AK_R | AK_W,
   };
 
   /// An access description.
   struct Access {
     Access(Instruction *I, int64_t Offset, int64_t Size,
            std::optional<Value *> Content, AccessKind Kind, Type *Ty)
-        : LocalI(I), RemoteI(I), Content(Content), OAS(Offset, Size),
+        : LocalI(I), RemoteI(I), Content(Content), Range(Offset, Size),
           Kind(Kind), Ty(Ty) {
       verify();
     }
     Access(Instruction *LocalI, Instruction *RemoteI, int64_t Offset,
            int64_t Size, std::optional<Value *> Content, AccessKind Kind,
            Type *Ty)
-        : LocalI(LocalI), RemoteI(RemoteI), Content(Content), OAS(Offset, Size),
-          Kind(Kind), Ty(Ty) {
+        : LocalI(LocalI), RemoteI(RemoteI), Content(Content),
+          Range(Offset, Size), Kind(Kind), Ty(Ty) {
       verify();
     }
     Access(const Access &Other) = default;
     Access(const Access &&Other)
         : LocalI(Other.LocalI), RemoteI(Other.RemoteI), Content(Other.Content),
-          OAS(Other.OAS), Kind(Other.Kind), Ty(Other.Ty) {}
+          Range(Other.Range), Kind(Other.Kind), Ty(Other.Ty) {}
 
     Access &operator=(const Access &Other) = default;
     bool operator==(const Access &R) const {
-      return LocalI == R.LocalI && RemoteI == R.RemoteI && OAS == R.OAS &&
+      return LocalI == R.LocalI && RemoteI == R.RemoteI && Range == R.Range &&
              Content == R.Content && Kind == R.Kind;
     }
     bool operator!=(const Access &R) const { return !(*this == R); }
 
     Access &operator&=(const Access &R) {
       assert(RemoteI == R.RemoteI && "Expected same instruction!");
       assert(LocalI == R.LocalI && "Expected same instruction!");
       Kind = AccessKind(Kind | R.Kind);
-      auto Before = OAS;
-      OAS &= R.OAS;
-      if (Before.isUnassigned() || Before == OAS) {
+      auto Before = Range;
+      Range &= R.Range;
+      if (Before.isUnassigned() || Before == Range) {
         Content =
             AA::combineOptionalValuesInAAValueLatice(Content, R.Content, Ty);
       } else {
-        // Since the OAS information changed, set a conservative state -- drop
+        // Since the Range information changed, set a conservative state -- drop
         // the contents, and assume MayAccess rather than MustAccess.
         setWrittenValueUnknown();
         Kind = AccessKind(Kind | AK_MAY);
         Kind = AccessKind(Kind & ~AK_MUST);
       }
       verify();
       return *this;
     }
Value *getWrittenValue() const {
       return *Content;
     }
 
     /// Return the written value which can be `llvm::null` if it is not yet
     /// determined.
     std::optional<Value *> getContent() const { return Content; }
 
     /// Return the offset for this access.
-    int64_t getOffset() const { return OAS.Offset; }
+    int64_t getOffset() const { return Range.Offset; }
 
     /// Return the size for this access.
-    int64_t getSize() const { return OAS.Size; }
+    int64_t getSize() const { return Range.Size; }
 
   private:
     /// The instruction responsible for the access with respect to the local
     /// scope of the associated attribute.
     Instruction *LocalI;
 
     /// The instruction responsible for the access.
     Instruction *RemoteI;
 
     /// The value written, if any. `llvm::none` means "not known yet", `nullptr`
     /// cannot be determined.
     std::optional<Value *> Content;
 
     /// The object accessed, in terms of an offset and size in bytes.
-    AA::OffsetAndSize OAS;
+    AA::RangeTy Range;
 
     /// The access kind, e.g., READ, as bitset (could be more than one).
     AccessKind Kind;
 
     /// The type of the content, thus the type read/written, can be null if not
     /// available.
     Type *Ty;
   };
 
   /// Create an abstract attribute view for the position \p IRP.
   static AAPointerInfo &createForPosition(const IRPosition &IRP, Attributor &A);
 
   /// See AbstractAttribute::getName()
   const std::string getName() const override { return "AAPointerInfo"; }
 
   /// See AbstractAttribute::getIdAddr()
   const char *getIdAddr() const override { return &ID; }
 
-  /// Call \p CB on all accesses that might interfere with \p OAS and return
+  /// 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
   /// all of them, false otherwise. An access interferes with an offset-size
   /// pair if it might read or write that memory region.
   virtual bool forallInterferingAccesses(
-      AA::OffsetAndSize OAS,
-      function_ref<bool(const Access &, bool)> CB) const = 0;
+      AA::RangeTy Range, function_ref<bool(const Access &, bool)> CB) const = 0;
 
   /// Call \p CB on all accesses that might interfere with \p I and
   /// return true if all such accesses were known and the callback returned true
   /// for all of them, false otherwise. In contrast to forallInterferingAccesses
   /// this function will perform reasoning to exclude write accesses that cannot
   /// affect the load even if they on the surface look as if they would. The
   /// flag \p HasBeenWrittenTo will be set to true if we know that \p I does not
   /// read the intial value of the underlying memory.
   virtual bool forallInterferingAccesses(
       Attributor &A, const AbstractAttribute &QueryingAA, Instruction &I,
       function_ref<bool(const Access &, bool)> CB, bool &HasBeenWrittenTo,
-      AA::OffsetAndSize &OAS) const = 0;
+      AA::RangeTy &Range) const = 0;
 
   /// This function should return true if the type of the \p AA is AAPointerInfo
   static bool classof(const AbstractAttribute *AA) {
     return (AA->getIdAddr() == &ID);
   }
 
   /// Unique ID (due to the unique address)
   static const char ID;

llvm/lib/Target/AMDGPU/AMDGPUAttributor.cpp

for (BasicBlock &BB : *F) {
       }
     }
 
     return false;
   }
 
   bool funcRetrievesMultigridSyncArg(Attributor &A) {
     auto Pos = llvm::AMDGPU::getMultigridSyncArgImplicitArgPosition();
-    AA::OffsetAndSize OAS(Pos, 8);
-    return funcRetrievesImplicitKernelArg(A, OAS);
+    AA::RangeTy Range(Pos, 8);
+    return funcRetrievesImplicitKernelArg(A, Range);
   }
 
   bool funcRetrievesHostcallPtr(Attributor &A) {
     auto Pos = llvm::AMDGPU::getHostcallImplicitArgPosition();
-    AA::OffsetAndSize OAS(Pos, 8);
-    return funcRetrievesImplicitKernelArg(A, OAS);
+    AA::RangeTy Range(Pos, 8);
+    return funcRetrievesImplicitKernelArg(A, Range);
   }
 
   bool funcRetrievesHeapPtr(Attributor &A) {
     if (AMDGPU::getAmdhsaCodeObjectVersion() != 5)
       return false;
-    AA::OffsetAndSize OAS(AMDGPU::ImplicitArg::HEAP_PTR_OFFSET, 8);
-    return funcRetrievesImplicitKernelArg(A, OAS);
+    AA::RangeTy Range(AMDGPU::ImplicitArg::HEAP_PTR_OFFSET, 8);
+    return funcRetrievesImplicitKernelArg(A, Range);
   }
 
   bool funcRetrievesQueuePtr(Attributor &A) {
     if (AMDGPU::getAmdhsaCodeObjectVersion() != 5)
       return false;
-    AA::OffsetAndSize OAS(AMDGPU::ImplicitArg::QUEUE_PTR_OFFSET, 8);
-    return funcRetrievesImplicitKernelArg(A, OAS);
+    AA::RangeTy Range(AMDGPU::ImplicitArg::QUEUE_PTR_OFFSET, 8);
+    return funcRetrievesImplicitKernelArg(A, Range);
   }
 
-  bool funcRetrievesImplicitKernelArg(Attributor &A,
-                                      AA::OffsetAndSize OAS) {
+  bool funcRetrievesImplicitKernelArg(Attributor &A, AA::RangeTy Range) {
     // Check if this is a call to the implicitarg_ptr builtin and it
     // is used to retrieve the hostcall pointer. The implicit arg for
     // hostcall is not used only if every use of the implicitarg_ptr
     // is a load that clearly does not retrieve any byte of the
     // hostcall pointer. We check this by tracing all the uses of the
     // initial call to the implicitarg_ptr intrinsic.
     auto DoesNotLeadToKernelArgLoc = [&](Instruction &I) {
       auto &Call = cast<CallBase>(I);
       if (Call.getIntrinsicID() != Intrinsic::amdgcn_implicitarg_ptr)
         return true;
 
       const auto &PointerInfoAA = A.getAAFor<AAPointerInfo>(
           *this, IRPosition::callsite_returned(Call), DepClassTy::REQUIRED);
 
       return PointerInfoAA.forallInterferingAccesses(
-          OAS, [](const AAPointerInfo::Access &Acc, bool IsExact) {
+          Range, [](const AAPointerInfo::Access &Acc, bool IsExact) {
             return Acc.getRemoteInst()->isDroppable();
           });
     };
 
     bool UsedAssumedInformation = false;
     return !A.checkForAllCallLikeInstructions(DoesNotLeadToKernelArgLoc, *this,
                                               UsedAssumedInformation);
   }

llvm/lib/Transforms/IPO/Attributor.cpp

bool AA::isDynamicallyUnique(Attributor &A, const AbstractAttribute &QueryingAA,
   auto &InstanceInfoAA = A.getAAFor<AAInstanceInfo>(
       QueryingAA, IRPosition::value(V), DepClassTy::OPTIONAL);
   return InstanceInfoAA.isAssumedUniqueForAnalysis();
 }
 
 Constant *AA::getInitialValueForObj(Value &Obj, Type &Ty,
                                     const TargetLibraryInfo *TLI,
                                     const DataLayout &DL,
-                                    AA::OffsetAndSize *OASPtr) {
+                                    AA::RangeTy *RangePtr) {
   if (isa<AllocaInst>(Obj))
     return UndefValue::get(&Ty);
   if (Constant *Init = getInitialValueOfAllocation(&Obj, TLI, &Ty))
     return Init;
   auto *GV = dyn_cast<GlobalVariable>(&Obj);
   if (!GV)
     return nullptr;
   if (!GV->hasLocalLinkage() && !(GV->isConstant() && GV->hasInitializer()))
     return nullptr;
   if (!GV->hasInitializer())
     return UndefValue::get(&Ty);
 
-  if (OASPtr && !OASPtr->offsetOrSizeAreUnknown()) {
-    APInt Offset = APInt(64, OASPtr->Offset);
+  if (RangePtr && !RangePtr->offsetOrSizeAreUnknown()) {
+    APInt Offset = APInt(64, RangePtr->Offset);
     return ConstantFoldLoadFromConst(GV->getInitializer(), &Ty, Offset, DL);
   }
 
   return ConstantFoldLoadFromUniformValue(GV->getInitializer(), &Ty);
 }
 
 bool AA::isValidInScope(const Value &V, const Function *Scope) {
   if (isa<Constant>(V))
auto CheckAccess = [&](const AAPointerInfo::Access &Acc, bool IsExact) {
       }
       return true;
     };
 
     // If the value has been written to we don't need the initial value of the
     // object.
     bool HasBeenWrittenTo = false;
 
-    AA::OffsetAndSize OAS;
+    AA::RangeTy Range;
     auto &PI = A.getAAFor<AAPointerInfo>(QueryingAA, IRPosition::value(*Obj),
                                          DepClassTy::NONE);
     if (!PI.forallInterferingAccesses(A, QueryingAA, I, CheckAccess,
-                                      HasBeenWrittenTo, OAS)) {
+                                      HasBeenWrittenTo, Range)) {
       LLVM_DEBUG(
           dbgs()
           << "Failed to verify all interfering accesses for underlying object: "
           << *Obj << "\n");
       return false;
     }
 
-    if (IsLoad && !HasBeenWrittenTo && !OAS.isUnassigned()) {
+    if (IsLoad && !HasBeenWrittenTo && !Range.isUnassigned()) {
       const DataLayout &DL = A.getDataLayout();
       Value *InitialValue =
-          AA::getInitialValueForObj(*Obj, *I.getType(), TLI, DL, &OAS);
+          AA::getInitialValueForObj(*Obj, *I.getType(), TLI, DL, &Range);
       if (!InitialValue) {
         LLVM_DEBUG(dbgs() << "Could not determine required initial value of "
                              "underlying object, abort!\n");
         return false;
       }
       CheckForNullOnlyAndUndef(InitialValue, /* IsExact */ true);
       if (NullRequired && !NullOnly) {
         LLVM_DEBUG(dbgs() << "Non exact access but initial value that is not "

llvm/lib/Transforms/IPO/AttributorAttributes.cpp

 struct DenseMapInfo<AAPointerInfo::Access> : DenseMapInfo<Instruction *> {
   using Access = AAPointerInfo::Access;
   static inline Access getEmptyKey();
   static inline Access getTombstoneKey();
   static unsigned getHashValue(const Access &A);
   static bool isEqual(const Access &LHS, const Access &RHS);
 };
 
-/// Helper that allows OffsetAndSize as a key in a DenseMap.
-template <> struct DenseMapInfo<AA::OffsetAndSize> {
-  static inline AA::OffsetAndSize getEmptyKey() {
+/// Helper that allows RangeTy as a key in a DenseMap.
+template <> struct DenseMapInfo<AA::RangeTy> {
+  static inline AA::RangeTy getEmptyKey() {
     auto EmptyKey = DenseMapInfo<int64_t>::getEmptyKey();
-    return AA::OffsetAndSize{EmptyKey, EmptyKey};
+    return AA::RangeTy{EmptyKey, EmptyKey};
   }
 
-  static inline AA::OffsetAndSize getTombstoneKey() {
+  static inline AA::RangeTy getTombstoneKey() {
     auto TombstoneKey = DenseMapInfo<int64_t>::getTombstoneKey();
-    return AA::OffsetAndSize{TombstoneKey, TombstoneKey};
+    return AA::RangeTy{TombstoneKey, TombstoneKey};
   }
 
-  static unsigned getHashValue(const AA::OffsetAndSize &OAS) {
+  static unsigned getHashValue(const AA::RangeTy &Range) {
     return detail::combineHashValue(
-        DenseMapInfo<int64_t>::getHashValue(OAS.Offset),
-        DenseMapInfo<int64_t>::getHashValue(OAS.Size));
+        DenseMapInfo<int64_t>::getHashValue(Range.Offset),
+        DenseMapInfo<int64_t>::getHashValue(Range.Size));
   }
 
-  static bool isEqual(const AA::OffsetAndSize &A, const AA::OffsetAndSize B) {
+  static bool isEqual(const AA::RangeTy &A, const AA::RangeTy B) {
     return A == B;
   }
 };
 
 /// Helper for AA::PointerInfo::Access DenseMap/Set usage ignoring everythign
 /// but the instruction
 struct AccessAsInstructionInfo : DenseMapInfo<Instruction *> {
   using Base = DenseMapInfo<Instruction *>;
struct AA::PointerInfo::State : public AbstractState {
   /// OffsetBin to the bin for its new offset.
   ///
   /// \Returns CHANGED, if the state changed, UNCHANGED otherwise.
   ChangeStatus addAccess(Attributor &A, int64_t Offset, int64_t Size,
                          Instruction &I, std::optional<Value *> Content,
                          AAPointerInfo::AccessKind Kind, Type *Ty,
                          Instruction *RemoteI = nullptr);
 
-  using OffsetBinsTy = DenseMap<OffsetAndSize, SmallSet<unsigned, 4>>;
+  using OffsetBinsTy = DenseMap<RangeTy, SmallSet<unsigned, 4>>;
 
   using const_bin_iterator = OffsetBinsTy::const_iterator;
   const_bin_iterator begin() const { return OffsetBins.begin(); }
   const_bin_iterator end() const { return OffsetBins.end(); }
 
   const AAPointerInfo::Access &getAccess(unsigned Index) const {
     return AccessList[Index];
   }
 
 protected:
   // Every memory instruction results in an Access object. We maintain a list of
   // all Access objects that we own, along with the following maps:
   //
-  // - OffsetBins: OffsetAndSize -> { Access }
+  // - OffsetBins: RangeTy -> { Access }
   // - RemoteIMap: RemoteI x LocalI -> Access
   //
   // A RemoteI is any instruction that accesses memory. RemoteI is different
   // from LocalI if and only if LocalI is a call; then RemoteI is some
   // instruction in the callgraph starting from LocalI. Multiple paths in the
   // callgraph from LocalI to RemoteI may produce multiple accesses, but these
   // are all combined into a single Access object. This may result in loss of
-  // information in OffsetAndSize in the Access object.
+  // information in RangeTy in the Access object.
   SmallVector<AAPointerInfo::Access> AccessList;
   OffsetBinsTy OffsetBins;
   DenseMap<const Instruction *, SmallVector<unsigned>> RemoteIMap;
 
   /// See AAPointerInfo::forallInterferingAccesses.
   bool forallInterferingAccesses(
-      AA::OffsetAndSize OAS,
+      AA::RangeTy Range,
       function_ref<bool(const AAPointerInfo::Access &, bool)> CB) const {
     if (!isValidState())
       return false;
 
     for (const auto &It : OffsetBins) {
-      AA::OffsetAndSize ItOAS = It.getFirst();
-      if (!OAS.mayOverlap(ItOAS))
+      AA::RangeTy ItRange = It.getFirst();
+      if (!Range.mayOverlap(ItRange))
         continue;
-      bool IsExact = OAS == ItOAS && !OAS.offsetOrSizeAreUnknown();
+      bool IsExact = Range == ItRange && !Range.offsetOrSizeAreUnknown();
       for (auto Index : It.getSecond()) {
         auto &Access = AccessList[Index];
         if (!CB(Access, IsExact))
           return false;
       }
     }
     return true;
   }
 
   /// See AAPointerInfo::forallInterferingAccesses.
   bool forallInterferingAccesses(
       Instruction &I,
       function_ref<bool(const AAPointerInfo::Access &, bool)> CB,
-      AA::OffsetAndSize &OAS) const {
+      AA::RangeTy &Range) const {
     if (!isValidState())
       return false;
 
     auto LocalList = RemoteIMap.find(&I);
     if (LocalList == RemoteIMap.end()) {
       return true;
     }
 
     for (auto LI : LocalList->getSecond()) {
       auto &Access = AccessList[LI];
-      OAS &= {Access.getOffset(), Access.getSize()};
+      Range &= {Access.getOffset(), Access.getSize()};
     }
-    return forallInterferingAccesses(OAS, CB);
+    return forallInterferingAccesses(Range, CB);
   }
 
 private:
   /// State to track fixpoint and validity.
   BooleanState BS;
 };
 
 ChangeStatus AA::PointerInfo::State::addAccess(Attributor &A, int64_t Offset,
if (!AccExists) {
     // The new one will be combined with the existing one.
     auto &Current = AccessList[AccIndex];
     auto Before = Current;
     Current &= Acc;
     if (Current == Before)
       return ChangeStatus::UNCHANGED;
 
     Acc = Current;
-    AA::OffsetAndSize Key{Before.getOffset(), Before.getSize()};
+    AA::RangeTy Key{Before.getOffset(), Before.getSize()};
     assert(OffsetBins.count(Key) && "Existing Access must be in some bin.");
     auto &Bin = OffsetBins[Key];
     assert(Bin.count(AccIndex) &&
            "Expected bin to actually contain the Access.");
     LLVM_DEBUG(dbgs() << "[AAPointerInfo] Removing Access "
                       << AccessList[AccIndex] << " with key {" << Key.Offset
                       << ',' << Key.Size << "}\n");
     Bin.erase(AccIndex);
   }
 
-  AA::OffsetAndSize Key{Acc.getOffset(), Acc.getSize()};
+  AA::RangeTy Key{Acc.getOffset(), Acc.getSize()};
   LLVM_DEBUG(dbgs() << "[AAPointerInfo] Inserting Access " << Acc
                     << " with key {" << Key.Offset << ',' << Key.Size << "}\n");
   OffsetBins[Key].insert(AccIndex);
   return ChangeStatus::CHANGED;
 }
 
 namespace {
 struct AAPointerInfoImpl
struct AAPointerInfoImpl
   }
 
   /// See AbstractAttribute::manifest(...).
   ChangeStatus manifest(Attributor &A) override {
     return AAPointerInfo::manifest(A);
   }
 
   bool forallInterferingAccesses(
-      AA::OffsetAndSize OAS,
+      AA::RangeTy Range,
       function_ref<bool(const AAPointerInfo::Access &, bool)> CB)
       const override {
-    return State::forallInterferingAccesses(OAS, CB);
+    return State::forallInterferingAccesses(Range, CB);
   }
 
   bool forallInterferingAccesses(
       Attributor &A, const AbstractAttribute &QueryingAA, Instruction &I,
       function_ref<bool(const Access &, bool)> UserCB, bool &HasBeenWrittenTo,
-      AA::OffsetAndSize &OAS) const override {
+      AA::RangeTy &Range) const override {
     HasBeenWrittenTo = false;
 
     SmallPtrSet<const Access *, 8> DominatingWrites;
     SmallVector<std::pair<const Access *, bool>, 8> InterferingAccesses;
 
     Function &Scope = *I.getFunction();
     const auto &NoSyncAA = A.getAAFor<AANoSync>(
         QueryingAA, IRPosition::function(Scope), DepClassTy::OPTIONAL);
auto AccessCB = [&](const Access &Acc, bool Exact) {
       // work yet if we have threading effects, or the access is complicated.
       if (CanUseCFGResoning && Dominates && UseDominanceReasoning &&
           IsSameThreadAsLoad(Acc))
         DominatingWrites.insert(&Acc);
 
       InterferingAccesses.push_back({&Acc, Exact});
       return true;
     };
-    if (!State::forallInterferingAccesses(I, AccessCB, OAS))
+    if (!State::forallInterferingAccesses(I, AccessCB, Range))
       return false;
 
     if (HasBeenWrittenTo) {
       const Function *ScopePtr = &Scope;
       IsLiveInCalleeCB = [ScopePtr](const Function &Fn) {
         return ScopePtr != &Fn;
       };
     }
ChangeStatus translateAndAddState(Attributor &A, const AAPointerInfo &OtherAA,
     const auto &OtherAAImpl = static_cast<const AAPointerInfoImpl &>(OtherAA);
     bool IsByval =
         FromCallee && OtherAAImpl.getAssociatedArgument()->hasByValAttr();
 
     // Combine the accesses bin by bin.
     ChangeStatus Changed = ChangeStatus::UNCHANGED;
     const auto &State = OtherAAImpl.getState();
     for (const auto &It : State) {
-      AA::OffsetAndSize OAS = AA::OffsetAndSize::getUnknown();
-      if (Offset != AA::OffsetAndSize::Unknown &&
+      AA::RangeTy Range = AA::RangeTy::getUnknown();
+      if (Offset != AA::RangeTy::Unknown &&
           !It.first.offsetOrSizeAreUnknown()) {
-        OAS = AA::OffsetAndSize(It.first.Offset + Offset, It.first.Size);
+        Range = AA::RangeTy(It.first.Offset + Offset, It.first.Size);
       }
       for (auto Index : It.getSecond()) {
         const auto &RAcc = State.getAccess(Index);
         if (IsByval && !RAcc.isRead())
           continue;
         bool UsedAssumedInformation = false;
         AccessKind AK = RAcc.getKind();
         std::optional<Value *> Content = RAcc.getContent();
         if (FromCallee) {
           Content = A.translateArgumentToCallSiteContent(
               RAcc.getContent(), CB, *this, UsedAssumedInformation);
           AK =
               AccessKind(AK & (IsByval ? AccessKind::AK_R : AccessKind::AK_RW));
           AK = AccessKind(AK | (RAcc.isMayAccess() ? AK_MAY : AK_MUST));
         }
-        Changed = Changed | addAccess(A, OAS.Offset, OAS.Size, CB, Content, AK,
-                                      RAcc.getType(), RAcc.getRemoteInst());
+        Changed = Changed | addAccess(A, Range.Offset, Range.Size, CB, Content,
+                                      AK, RAcc.getType(), RAcc.getRemoteInst());
       }
     }
     return Changed;
   }
 
   /// Statistic tracking for all AAPointerInfo implementations.
   /// See AbstractAttribute::trackStatistics().
   void trackPointerInfoStatistics(const IRPosition &IRP) const {}
struct AAPointerInfoFloating : public AAPointerInfoImpl {
   using AccessKind = AAPointerInfo::AccessKind;
   AAPointerInfoFloating(const IRPosition &IRP, Attributor &A)
       : AAPointerInfoImpl(IRP, A) {}
 
   /// Deal with an access and signal if it was handled successfully.
   bool handleAccess(Attributor &A, Instruction &I, Value &Ptr,
                     std::optional<Value *> Content, AccessKind Kind,
                     int64_t Offset, ChangeStatus &Changed, Type *Ty,
-                    int64_t Size = AA::OffsetAndSize::Unknown) {
+                    int64_t Size = AA::RangeTy::Unknown) {
     using namespace AA::PointerInfo;
     // No need to find a size if one is given.
-    if (Size == AA::OffsetAndSize::Unknown && Ty) {
+    if (Size == AA::RangeTy::Unknown && Ty) {
       const DataLayout &DL = A.getDataLayout();
       TypeSize AccessSize = DL.getTypeStoreSize(Ty);
       if (!AccessSize.isScalable())
         Size = AccessSize.getFixedSize();
     }
     Changed = Changed | addAccess(A, Offset, Size, I, Content, Kind, Ty);
     return true;
   };
 
   /// Helper struct, will support ranges eventually.
+  ///
+  /// FIXME: Tracks a single Offset until we have proper support for a list of
+  /// RangeTy objects.
   struct OffsetInfo {
-    int64_t Offset = AA::OffsetAndSize::Unassigned;
+    int64_t Offset = AA::RangeTy::Unassigned;
 
     bool operator==(const OffsetInfo &OI) const { return Offset == OI.Offset; }
   };
 
   /// See AbstractAttribute::updateImpl(...).
   ChangeStatus updateImpl(Attributor &A) override {
     using namespace AA::PointerInfo;
     ChangeStatus Changed = ChangeStatus::UNCHANGED;
     Value &AssociatedValue = getAssociatedValue();
 
     const DataLayout &DL = A.getDataLayout();
     DenseMap<Value *, OffsetInfo> OffsetInfoMap;
     OffsetInfoMap[&AssociatedValue] = OffsetInfo{0};
 
     auto HandlePassthroughUser = [&](Value *Usr, OffsetInfo PtrOI,
                                      bool &Follow) {
-      assert(PtrOI.Offset != AA::OffsetAndSize::Unassigned &&
+      assert(PtrOI.Offset != AA::RangeTy::Unassigned &&
              "Cannot pass through if the input Ptr was not visited!");
       OffsetInfo &UsrOI = OffsetInfoMap[Usr];
       UsrOI = PtrOI;
       Follow = true;
       return true;
     };
 
     const auto *TLI = getAnchorScope()
auto UsePred = [&](const Use &U, bool &Follow) -> bool {
         // Note the order here, the Usr access might change the map, CurPtr is
         // already in it though.
         OffsetInfo &UsrOI = OffsetInfoMap[Usr];
         OffsetInfo &PtrOI = OffsetInfoMap[CurPtr];
         UsrOI = PtrOI;
 
         // TODO: Use range information.
         APInt GEPOffset(DL.getIndexTypeSizeInBits(GEP->getType()), 0);
-        if (PtrOI.Offset == AA::OffsetAndSize::Unknown ||
+        if (PtrOI.Offset == AA::RangeTy::Unknown ||
             !GEP->accumulateConstantOffset(DL, GEPOffset)) {
           LLVM_DEBUG(dbgs() << "[AAPointerInfo] GEP offset not constant "
                             << *GEP << "\n");
-          UsrOI.Offset = AA::OffsetAndSize::Unknown;
+          UsrOI.Offset = AA::RangeTy::Unknown;
           Follow = true;
           return true;
         }
 
         LLVM_DEBUG(dbgs() << "[AAPointerInfo] GEP offset is constant " << *GEP
                           << "\n");
         UsrOI.Offset = PtrOI.Offset + GEPOffset.getZExtValue();
         Follow = true;
auto UsePred = [&](const Use &U, bool &Follow) -> bool {
         // Note the order here, the Usr access might change the map, CurPtr is
         // already in it though.
         bool IsFirstPHIUser = !OffsetInfoMap.count(Usr);
         OffsetInfo &UsrOI = OffsetInfoMap[Usr];
         OffsetInfo &PtrOI = OffsetInfoMap[CurPtr];
 
         // Check if the PHI operand has already an unknown offset as we can't
         // improve on that anymore.
-        if (PtrOI.Offset == AA::OffsetAndSize::Unknown) {
+        if (PtrOI.Offset == AA::RangeTy::Unknown) {
           LLVM_DEBUG(dbgs() << "[AAPointerInfo] PHI operand offset unknown "
                             << *CurPtr << " in " << *Usr << "\n");
-          Follow = UsrOI.Offset != AA::OffsetAndSize::Unknown;
+          Follow = UsrOI.Offset != AA::RangeTy::Unknown;
           UsrOI = PtrOI;
           return true;
         }
 
         // Check if the PHI is invariant (so far).
         if (UsrOI == PtrOI) {
-          assert(PtrOI.Offset != AA::OffsetAndSize::Unassigned &&
+          assert(PtrOI.Offset != AA::RangeTy::Unassigned &&
                  "Cannot assign if the current Ptr was not visited!");
           LLVM_DEBUG(dbgs() << "[AAPointerInfo] PHI is invariant (so far)");
           return true;
         }
 
         // Check if the PHI operand is not dependent on the PHI itself.
         APInt Offset(
             DL.getIndexSizeInBits(CurPtr->getType()->getPointerAddressSpace()),
auto UsePred = [&](const Use &U, bool &Follow) -> bool {
                      << *CurPtr << " in " << *Usr << "\n");
         } else {
           LLVM_DEBUG(dbgs() << "[AAPointerInfo] PHI operand is too complex "
                             << *CurPtr << " in " << *Usr << "\n");
         }
 
         // TODO: Approximate in case we know the direction of the recurrence.
         UsrOI = PtrOI;
-        UsrOI.Offset = AA::OffsetAndSize::Unknown;
+        UsrOI.Offset = AA::RangeTy::Unknown;
         Follow = true;
         return true;
       }
 
       if (auto *LoadI = dyn_cast<LoadInst>(Usr)) {
         // If the access is to a pointer that may or may not be the associated
         // value, e.g. due to a PHI, we cannot assume it will be read.
         AccessKind AK = AccessKind::AK_R;
struct AAPointerInfoCallSiteArgument final : AAPointerInfoFloating {
   /// See AbstractAttribute::updateImpl(...).
   ChangeStatus updateImpl(Attributor &A) override {
     using namespace AA::PointerInfo;
     // We handle memory intrinsics explicitly, at least the first (=
     // destination) and second (=source) arguments as we know how they are
     // accessed.
     if (auto *MI = dyn_cast_or_null<MemIntrinsic>(getCtxI())) {
       ConstantInt *Length = dyn_cast<ConstantInt>(MI->getLength());
-      int64_t LengthVal = AA::OffsetAndSize::Unknown;
+      int64_t LengthVal = AA::RangeTy::Unknown;
       if (Length)
         LengthVal = Length->getSExtValue();
       Value &Ptr = getAssociatedValue();
       unsigned ArgNo = getIRPosition().getCallSiteArgNo();
       ChangeStatus Changed = ChangeStatus::UNCHANGED;
       if (ArgNo == 0) {
         handleAccess(A, *MI, Ptr, nullptr, AccessKind::AK_MUST_WRITE, 0,
                      Changed, nullptr, LengthVal);
ChangeStatus updateImpl(Attributor &A) override {
     if (AA::isAssumedReadNone(A, getIRPosition(), *this, IsKnown))
       return ChangeStatus::UNCHANGED;
     bool ReadOnly = AA::isAssumedReadOnly(A, getIRPosition(), *this, IsKnown);
 
     ChangeStatus Changed = ChangeStatus::UNCHANGED;
     handleAccess(A, *getCtxI(), getAssociatedValue(), nullptr,
                  ReadOnly ? AccessKind::AK_MAY_READ
                           : AccessKind::AK_MAY_READ_WRITE,
-                 AA::OffsetAndSize::Unknown, Changed, nullptr,
-                 AA::OffsetAndSize::Unknown);
+                 AA::RangeTy::Unknown, Changed, nullptr, AA::RangeTy::Unknown);
     return Changed;
   }
 
   /// See AbstractAttribute::trackStatistics()
   void trackStatistics() const override {
     AAPointerInfoImpl::trackPointerInfoStatistics(getIRPosition());
   }
 };