[Attributor] Add AAAddressSpace to deduce address spaces

[tianshilei1992]

Summary

This patch adds initial support for the AAAddressSpace abstract
attributor interface to deduce and query address space information for a
pointer. We simply query the underlying objects that a pointer can point
to and find a common address space if they exist. This is the minimal
support for the interface, we currently manifest changes on loads and
stores. Additionally we should use the target transform information to
deduce if an address space transformation is a no-op for the target
machine when calculating compatibility.

[jdoerfert]

llvm/lib/Transforms/IPO/AttributorAttributes.cpp

11738

hasXXX sounds like a boolean return, this would be getAS

11745

don't make it required, make the dependence type NONE

11752

Check the return type of this function.

11759

That doesn't work. We cannot ignore things with the "wrong type".
V should never be null, undef can be ignored, a "zero" too if nullptr is not valid, everything else not I think.
See some other uses of getAssumedUnderlyingObjects.

11766

break

11785

before, not after.

11810

We should reuse the rewrite capabilities of the existing pass, or at least clone loads/stores properly so we don't loose metadata and such.

llvm/test/Transforms/Attributor/IPConstantProp/2009-09-24-byval-ptr.ll

233 ↗

(On Diff #411499)

This indicates a problem, though, not necessarily in your code.

[jhuber6]

Addressing some comments.

[jdoerfert]

We can get this in such that we only modify accesses first. However, we need to rewrite other pointers (arguments, phi's, geps, ...) in a follow up as that can save registers.

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

1798

This is not a good idea.

5951

I don't think we want an inc state. It is really just <no-AS/dead, AS-X, unknown>

llvm/lib/Transforms/IPO/AttributorAttributes.cpp

11751

This is now AAUnderlyingValues

11793–11811

We can just replace all uses with the casted pointer, no need for pretty much all of this.

[tianshilei1992]

rebase and fix tests

[tianshilei1992]

llvm/lib/Transforms/IPO/AttributorAttributes.cpp

12224

We probably want an assertion here. Returning 0 is not necessarily correct for the case where the AS associated with the value is non-zero but somehow the state is invalid. Essentially we don't want users to call this method if the AA is invalid.

[jdoerfert]

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

6029

no null opt anymore

6047

docs

llvm/lib/Transforms/IPO/AttributorAttributes.cpp

12236–12244

All of this happens implicitly. No need for you to check it. It would also not be required.

12248–12250

Check out other uses of AAUnderlyingObjects. Instead of requiring it, you can just look at the associated value in case the forallUnderlyingObjects call fails.

12258

Vector is overkill. You can return false as soon as we know we have more than one value. You can directly work on the AssumedAddressSpace.

12285

No need for the vector, change the uses in the first loop.

12291–12294

No need. Just let the attributor change all uses.

[jdoerfert]

llvm/lib/Transforms/IPO/AttributorAttributes.cpp

12320

add a statistic counter please

llvm/test/Transforms/Attributor/address_space_info.ll

3

remove the max iterations flag

5

transform this to opaque ptr please.

18

What are we testing here?

33

What are we testing here?

197

Make a test where the value and pointer operand are the same and can be casted to an AS.

[arsenm]

llvm/lib/Transforms/IPO/AttributorAttributes.cpp

12303–12305

Doesn't consider vector of pointers

12315

Stick to IR addrspace name?

llvm/test/Transforms/Attributor/address_space_info.ll

289

test intrinsics. memcpy, memmove, memset and some target ones. Also the predicates, like llvm.amdgcn.is.shared/is.private

[tianshilei1992]

address some comments

[tianshilei1992]

I'll rewrite the test.

llvm/lib/Transforms/IPO/AttributorAttributes.cpp

12285

I think it looks more clean if we first collect all uses to be changed and then create the cast instruction as we only consider two cases here after all.

llvm/test/Transforms/Attributor/address_space_info.ll

289

We only look into two kinds of interactions here. We will not need them *for now*. For sure the following patch(es) can cover cases like the runtime check of AS since we might eliminate them if feasible.

[tschuett]

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

6029

Could you instead return an optional to handle invalid and unknown states?

[jdoerfert]

llvm/lib/Transforms/IPO/AttributorAttributes.cpp

12285

It's more complex. More complex is bad.

[tianshilei1992]

rebase and fix tests

[tianshilei1992]

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

6029

I could do it but we can also assume this function should not be called if the AA is invalid, which is what is being used right now. I suppose users have to check the state of the AA before query the AS.

llvm/test/Transforms/Attributor/address_space_info.ll

89

This looks so twisted. Have to fix it.

[jdoerfert]

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

6025

Checkout isValidIRPositionForInit in upstream attributes. Use it to restrict this one.

llvm/lib/Transforms/IPO/AttributorAttributes.cpp

12232

No need for AAIsDead.

12238–12241

No need. Most attributes behave correct w/o state check. This one does too.

12249–12255

Do all of this is takeAS, no need to have the logic split. It should return true if we are still "valid", and false otherwise. You can just do return takeAS(AS)

12271

Technically, you can replace the value with poison if you have NoAS at the end.

12280–12281

Why check this? What can check is if the pointer is actually an AS cast we can just "undo".

12361

or put this into the initialize of all the ones we do not actually support.

[arsenm]

llvm/lib/Transforms/IPO/AttributorAttributes.cpp

12310

address spaces only use 24 bits so there's no overflow concern with just u32

[tianshilei1992]

rebase, fix comments, fix tests

there should be one test left

llvm/lib/Transforms/IPO/AttributorAttributes.cpp

12280–12281

Because the doc of the function checkForAllUses says:

Check \p Pred on all (transitive) uses of \p V.

We only want direct uses of the value here, so we check if the use is the value itself. Did I get it wrong?

12303–12305

Hmm, vector of pointers or pointer of vector?

[tianshilei1992]

remove unnecessary changes

[jdoerfert]

I think this is basically done for a first version. I left last comments. We can improve on this in a follow up

llvm/lib/Transforms/IPO/AttributorAttributes.cpp

12274

For stores you need to check it's the pointer operand, assuming it would be invalid IR to change the value operand with one of a different type. You should make a test and verify if it's ok or not. If it's OK, this is OK.

12280–12281

We only want direct uses of the value here, so we check if the use is the value itself. Did I get it wrong?

We are generally happy modifying any use, I'd say. Should not matter much right now anyway.

12301

Why do we cast this? Keep one type consistently.

[tianshilei1992]

rebase, fix tests, and rename to AAAddressSpace

[tianshilei1992]

llvm/lib/Transforms/IPO/AttributorAttributes.cpp

12301

getPointerAddressSpace() returns uint32_t but AssumedAddressSpace is int32_t since AssumedAddressSpace can be -1. There must be a cast.

[tianshilei1992]

llvm/test/Transforms/Attributor/address_space_info.ll

25

This is supposed to be replaced with an addrspacecast.

llvm/test/Transforms/Attributor/value-simplify.ll

804

This should be replaced by @ConstAS3Ptr directly.

[jdoerfert]

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

1129

remove unrelated changes please.

[tianshilei1992]

rebase to remove unrelated changes

[jdoerfert]

llvm/lib/Transforms/IPO/AttributorAttributes.cpp

12237

12268–12269

Hoist this.

12295–12296

This doesn't actually help as it does not filter store ptr %p, ptr %p. Again, if we can just change both uses, then let's do so. If the verifier is unhappy, check that the use U is the pointer operand.

12324–12325

llvm/test/Transforms/Attributor/address_space_info.ll

10

remove the compiler used part

109

llvm/test/Transforms/Attributor/value-simplify.ll

804

Did you update the test, above it seems to work.

[tianshilei1992]

rebase, fix comments, fix tests

the patch is in a good shape now

llvm/lib/Transforms/IPO/AttributorAttributes.cpp

12295–12296

Why does the AS of value operand matter here?

llvm/test/Transforms/Attributor/value-simplify.ll

804

I expect it to be store i32 0, ptr addrspace(3) @ConstAS3Ptr, align 4 directly but actually here it is more complicated than I thought.

[jdoerfert]

LG, assuming the stuff below works out.

llvm/lib/Transforms/IPO/AttributorAttributes.cpp

12272

early exit.

12295–12296

because the verifier might not like us replacing the value ptr %p with ptr addrspace(3) %q. Make a test with that patter, if it passes, we are A-OK.

llvm/test/Transforms/Attributor/value-simplify.ll

18

Can you undo this for now.

804

Oh, right. Because it is simplified. Leave it for now like this.

[tianshilei1992]

rebase and fix comments

llvm/lib/Transforms/IPO/AttributorAttributes.cpp

12295–12296

I tested the following case and it works:

define internal void @_Z13unknown_writePi(ptr addrspace(1) noundef %p) #0 {
entry:
  store ptr addrspace(1) %p, ptr addrspace(1) %p, align 4
  ret void
}

[jdoerfert]

llvm/test/Transforms/Attributor/address_space_info.ll

6

28

Now we can see if it works.

[tianshilei1992]

rebase and fix comments

[arsenm]

llvm/test/Transforms/Attributor/address_space_info.ll

3

How is this doing anything without a target?

74

Use named values

[tianshilei1992]

llvm/test/Transforms/Attributor/address_space_info.ll

3

We have many IR tests w/o a target.

74

K, to avoid potential false alarm in the test? I can do it in a following patch.

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

struct AnalysisGetter {
   // updated. Only those new analyses that the client cares about in the old
   // pass manager need to expose a LegacyWrapper type, and that wrapper should
   // support a getResult() method that matches the new Analysis.
   //
   // We need SFINAE to check for the LegacyWrapper, but function templates don't
   // allow partial specialization, which is needed in this case. So instead, we
   // use a constexpr bool to perform the SFINAE, and then use this information
   // inside the function template.
-  template <typename, typename = void> static constexpr bool HasLegacyWrapper = false;
+  template <typename, typename = void>
+  static constexpr bool HasLegacyWrapper = false;
 
   template <typename Analysis>
   typename Analysis::Result *getAnalysis(const Function &F,
                                          bool RequestCachedOnly = false) {
     if (!LegacyPass && !FAM)
       return nullptr;
     if (FAM) {
       if (CachedOnly || RequestCachedOnly)
private:
 
   /// If \p CachedOnly is true, no pass is created, just existing results are
   /// used. Also available per request.
   bool CachedOnly = false;
 };
 
 template <typename Analysis>
 constexpr bool AnalysisGetter::HasLegacyWrapper<
-      Analysis, std::void_t<typename Analysis::LegacyWrapper>> = true;
 
 /// Data structure to hold cached (LLVM-IR) information.
 ///
 /// All attributes are given an InformationCache object at creation time to
 /// avoid inspection of the IR by all of them individually. This default
 /// InformationCache will hold information required by 'default' attributes,
 /// thus the ones deduced when Attributor::identifyDefaultAbstractAttributes(..)
 /// is called.
if (V && (V->stripPointerCasts() == NV.stripPointerCasts() ||
       return false;
     assert((!V || V == &NV || isa<UndefValue>(NV)) &&
            "Use was registered twice for replacement with different values!");
     V = &NV;
     return true;
   }
 
   /// Helper function to replace all uses associated with \p IRP with \p NV.
   /// Return true if there is any change. The flag \p ChangeDroppable indicates
   /// if dropppable uses should be changed too.
   bool changeAfterManifest(const IRPosition IRP, Value &NV,
                            bool ChangeDroppable = true) {
     if (IRP.getPositionKind() == IRPosition::IRP_CALL_SITE_ARGUMENT) {
       auto *CB = cast<CallBase>(IRP.getCtxI());
       return changeUseAfterManifest(
           CB->getArgOperandUse(IRP.getCallSiteArgNo()), NV);
     }

 /// An abstract Attribute for determining the necessity of the convergent
 /// attribute.
 struct AANonConvergent : public StateWrapper<BooleanState, AbstractAttribute> {
   using Base = StateWrapper<BooleanState, AbstractAttribute>;
 
   AANonConvergent(const IRPosition &IRP, Attributor &A) : Base(IRP) {}
 
   /// Create an abstract attribute view for the position \p IRP.
-  static AANonConvergent &createForPosition(const IRPosition &IRP, Attributor &A);
+  static AANonConvergent &createForPosition(const IRPosition &IRP,
+                                            Attributor &A);
 
   /// Return true if "non-convergent" is assumed.
   bool isAssumedNotConvergent() const { return getAssumed(); }
 
   /// Return true if "non-convergent" is known.
   bool isKnownNotConvergent() const { return getKnown(); }
 
   /// See AbstractAttribute::getName()
   const std::string getName() const override { return "AANonConvergent"; }
 
   /// See AbstractAttribute::getIdAddr()
   const char *getIdAddr() const override { return &ID; }
 
-  /// This function should return true if the type of the \p AA is AANonConvergent.
+  /// This function should return true if the type of the \p AA is
+  /// AANonConvergent.
   static bool classof(const AbstractAttribute *AA) {
     return (AA->getIdAddr() == &ID);
   }
 
   /// Unique ID (due to the unique address)
   static const char ID;
 };
 
struct AAPointerInfo : public AbstractAttribute {
   /// Unique ID (due to the unique address)
   static const char ID;
 };
 
 /// An abstract attribute for getting assumption information.
 struct AAAssumptionInfo
     : public StateWrapper<SetState<StringRef>, AbstractAttribute,
                           DenseSet<StringRef>> {
   using Base =
       StateWrapper<SetState<StringRef>, AbstractAttribute, DenseSet<StringRef>>;
 
   AAAssumptionInfo(const IRPosition &IRP, Attributor &A,
                    const DenseSet<StringRef> &Known)
       : Base(IRP, Known) {}
 
   /// Returns true if the assumption set contains the assumption \p Assumption.
   virtual bool hasAssumption(const StringRef Assumption) const = 0;
struct AAUnderlyingObjects : AbstractAttribute {
   ///
   /// This method will evaluate \p Pred on all underlying objects in \p Scope
   /// collected so far and return true if \p Pred holds on all of them.
   virtual bool
   forallUnderlyingObjects(function_ref<bool(Value &)> Pred,
                           AA::ValueScope Scope = AA::Interprocedural) const = 0;
 };
 
+/// An abstract interface for address space information.
+struct AAAddressSpace : public StateWrapper<BooleanState, AbstractAttribute> {
+  AAAddressSpace(const IRPosition &IRP, Attributor &A)
+      : StateWrapper<BooleanState, AbstractAttribute>(IRP) {}
+
+  /// See AbstractAttribute::isValidIRPositionForInit
+  static bool isValidIRPositionForInit(Attributor &A, const IRPosition &IRP) {
+    if (!IRP.getAssociatedType()->isPtrOrPtrVectorTy())
+      return false;
+    return AbstractAttribute::isValidIRPositionForInit(A, IRP);
+  }
+
+  /// Return the address space of the associated value. \p NoAddressSpace is
+  /// returned if the associated value is dead. This functions is not supposed
+  /// to be called if the AA is invalid.
+  virtual int32_t getAddressSpace() const = 0;
+
+  /// Create an abstract attribute view for the position \p IRP.
+  static AAAddressSpace &createForPosition(const IRPosition &IRP,
+                                           Attributor &A);
+
+  /// See AbstractAttribute::getName()
+  const std::string getName() const override { return "AAAddressSpace"; }
+
+  /// See AbstractAttribute::getIdAddr()
+  const char *getIdAddr() const override { return &ID; }
+
+  /// This function should return true if the type of the \p AA is
+  /// AAAssumptionInfo
+  static bool classof(const AbstractAttribute *AA) {
+    return (AA->getIdAddr() == &ID);
+  }
+
+  // No address space which indicates the associated value is dead.
+  static const int32_t NoAddressSpace = -1;
+
+  /// Unique ID (due to the unique address)
+  static const char ID;
+};
+
 raw_ostream &operator<<(raw_ostream &, const AAPointerInfo::Access &);
 
 /// Run options, used by the pass manager.
 enum AttributorRunOption {
   NONE = 0,
   MODULE = 1 << 0,
   CGSCC = 1 << 1,
   ALL = MODULE | CGSCC

llvm/lib/Transforms/IPO/Attributor.cpp

Success = checkForAllInstructionsImpl(
       nullptr, OpcodeInstMap, CallSitePred, nullptr, nullptr,
       {(unsigned)Instruction::Invoke, (unsigned)Instruction::CallBr,
        (unsigned)Instruction::Call},
       UsedAssumedInformation);
   (void)Success;
   assert(Success && "Expected the check call to be successful!");
 
   auto LoadStorePred = [&](Instruction &I) -> bool {
-    if (isa<LoadInst>(I)) {
-      getOrCreateAAFor<AAAlign>(
-          IRPosition::value(*cast<LoadInst>(I).getPointerOperand()));
+    if (auto *LI = dyn_cast<LoadInst>(&I)) {
+      getOrCreateAAFor<AAAlign>(IRPosition::value(*LI->getPointerOperand()));
       if (SimplifyAllLoads)
         getAssumedSimplified(IRPosition::value(I), nullptr,
                              UsedAssumedInformation, AA::Intraprocedural);
+      getOrCreateAAFor<AAAddressSpace>(
+          IRPosition::value(*LI->getPointerOperand()));
     } else {
       auto &SI = cast<StoreInst>(I);
       getOrCreateAAFor<AAIsDead>(IRPosition::inst(I));
       getAssumedSimplified(IRPosition::value(*SI.getValueOperand()), nullptr,
                            UsedAssumedInformation, AA::Intraprocedural);
       getOrCreateAAFor<AAAlign>(IRPosition::value(*SI.getPointerOperand()));
+      getOrCreateAAFor<AAAddressSpace>(
+          IRPosition::value(*SI.getPointerOperand()));
     }
     return true;
   };
   Success = checkForAllInstructionsImpl(
       nullptr, OpcodeInstMap, LoadStorePred, nullptr, nullptr,
       {(unsigned)Instruction::Load, (unsigned)Instruction::Store},
       UsedAssumedInformation);
   (void)Success;

llvm/lib/Transforms/IPO/AttributorAttributes.cpp

 PIPE_OPERATOR(AAPotentialValues)
 PIPE_OPERATOR(AANoUndef)
 PIPE_OPERATOR(AANoFPClass)
 PIPE_OPERATOR(AACallEdges)
 PIPE_OPERATOR(AAInterFnReachability)
 PIPE_OPERATOR(AAPointerInfo)
 PIPE_OPERATOR(AAAssumptionInfo)
 PIPE_OPERATOR(AAUnderlyingObjects)
+PIPE_OPERATOR(AAAddressSpace)
 
 #undef PIPE_OPERATOR
 
 template <>
 ChangeStatus clampStateAndIndicateChange<DerefState>(DerefState &S,
                                                      const DerefState &R) {
   ChangeStatus CS0 =
       clampStateAndIndicateChange(S.DerefBytesState, R.DerefBytesState);
for (auto Index : LocalList) {
     if (A.getLocalInst() == &I) {
       AccExists = true;
       AccIndex = Index;
       break;
     }
   }
 
   auto AddToBins = [&](const AAPointerInfo::RangeList &ToAdd) {
-    LLVM_DEBUG(
-      if (ToAdd.size())
-        dbgs() << "[AAPointerInfo] Inserting access in new offset bins\n";
-    );
+    LLVM_DEBUG(if (ToAdd.size()) dbgs()
+                   << "[AAPointerInfo] Inserting access in new offset bins\n";);
 
     for (auto Key : ToAdd) {
       LLVM_DEBUG(dbgs() << "    key " << Key << "\n");
       OffsetBins[Key].insert(AccIndex);
     }
   };
 
   if (!AccExists) {
ChangeStatus AA::PointerInfo::State::addAccess(
 
   auto &ExistingRanges = Before.getRanges();
   auto &NewRanges = Current.getRanges();
 
   // Ranges that are in the old access but not the new access need to be removed
   // from the offset bins.
   AAPointerInfo::RangeList ToRemove;
   AAPointerInfo::RangeList::set_difference(ExistingRanges, NewRanges, ToRemove);
-  LLVM_DEBUG(
-    if (ToRemove.size())
-      dbgs() << "[AAPointerInfo] Removing access from old offset bins\n";
-  );
+  LLVM_DEBUG(if (ToRemove.size()) dbgs()
+                 << "[AAPointerInfo] Removing access from old offset bins\n";);
 
   for (auto Key : ToRemove) {
     LLVM_DEBUG(dbgs() << "    key " << Key << "\n");
     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.");
     Bin.erase(AccIndex);

 };
 
 struct AANonConvergentFunction final : AANonConvergentImpl {
   AANonConvergentFunction(const IRPosition &IRP, Attributor &A)
       : AANonConvergentImpl(IRP, A) {}
 
   /// See AbstractAttribute::updateImpl(...).
   ChangeStatus updateImpl(Attributor &A) override {
-    // If all function calls are known to not be convergent, we are not convergent.
+    // If all function calls are known to not be convergent, we are not
+    // convergent.
     auto CalleeIsNotConvergent = [&](Instruction &Inst) {
       CallBase &CB = cast<CallBase>(Inst);
       auto *Callee = dyn_cast_if_present<Function>(CB.getCalledOperand());
       if (!Callee || Callee->isIntrinsic()) {
         return false;
       }
       if (Callee->isDeclaration()) {
         return !Callee->hasFnAttribute(Attribute::Convergent);
bool rememberResult(Attributor &A, typename RQITy::Reachable Result,
                       RQITy &RQI, bool UsedExclusionSet) {
     RQI.Result = Result;
 
     // Remove the temporary RQI from the cache.
     if (!InUpdate)
       QueryCache.erase(&RQI);
 
     // Insert a plain RQI (w/o exclusion set) if that makes sense. Two options:
-    // 1) If it is reachable, it doesn't matter if we have an exclusion set for this query.
-    // 2) We did not use the exclusion set, potentially because there is none.
+    // 1) If it is reachable, it doesn't matter if we have an exclusion set for
+    // this query. 2) We did not use the exclusion set, potentially because
+    // there is none.
     if (Result == RQITy::Reachable::Yes || !UsedExclusionSet) {
       RQITy PlainRQI(RQI.From, RQI.To);
       if (!QueryCache.count(&PlainRQI)) {
         RQITy *RQIPtr = new (A.Allocator) RQITy(RQI.From, RQI.To);
         RQIPtr->Result = Result;
         QueryVector.push_back(RQIPtr);
         QueryCache.insert(RQIPtr);
       }
ChangeStatus manifest(Attributor &A) override {
     if (isAssumedReadNone())
       ME = MemoryEffects::none();
     else if (isAssumedReadOnly())
       ME = MemoryEffects::readOnly();
     else if (isAssumedWriteOnly())
       ME = MemoryEffects::writeOnly();
 
     A.removeAttrs(getIRPosition(), AttrKinds);
-    return A.manifestAttrs(getIRPosition(),
-                           Attribute::getWithMemoryEffects(CB.getContext(), ME));
+    return A.manifestAttrs(
+        getIRPosition(), Attribute::getWithMemoryEffects(CB.getContext(), ME));
   }
 
   /// See AbstractAttribute::trackStatistics()
   void trackStatistics() const override {
     if (isAssumedReadNone())
       STATS_DECLTRACK_CS_ATTR(readnone)
     else if (isAssumedReadOnly())
       STATS_DECLTRACK_CS_ATTR(readonly)
ChangeStatus manifest(Attributor &A) override {
     const IRPosition &IRP = getIRPosition();
 
     SmallVector<Attribute, 1> DeducedAttrs;
     getDeducedAttributes(A, IRP.getAnchorValue().getContext(), DeducedAttrs);
     if (DeducedAttrs.size() != 1)
       return ChangeStatus::UNCHANGED;
     MemoryEffects ME = DeducedAttrs[0].getMemoryEffects();
 
-    return A.manifestAttrs(
-        IRP,
-        Attribute::getWithMemoryEffects(IRP.getAnchorValue().getContext(), ME));
+    return A.manifestAttrs(IRP, Attribute::getWithMemoryEffects(
+                                    IRP.getAnchorValue().getContext(), ME));
   }
 
   /// See AAMemoryLocation::checkForAllAccessesToMemoryKind(...).
   bool checkForAllAccessesToMemoryKind(
       function_ref<bool(const Instruction *, const Value *, AccessKind,
                         MemoryLocationsKind)>
           Pred,
       MemoryLocationsKind RequestedMLK) const override {

 namespace {
 struct AAAssumptionInfoImpl : public AAAssumptionInfo {
   AAAssumptionInfoImpl(const IRPosition &IRP, Attributor &A,
                        const DenseSet<StringRef> &Known)
       : AAAssumptionInfo(IRP, A, Known) {}
 
   /// See AbstractAttribute::manifest(...).
   ChangeStatus manifest(Attributor &A) override {
     // Don't manifest a universal set if it somehow made it here.
     if (getKnown().isUniversal())
       return ChangeStatus::UNCHANGED;
 
     const IRPosition &IRP = getIRPosition();
     return A.manifestAttrs(
         IRP,
         Attribute::get(IRP.getAnchorValue().getContext(), AssumptionAttrKey,
                        llvm::join(getAssumed().getSet(), ",")),
         /* ForceReplace */ true);
   }
 
   bool hasAssumption(const StringRef Assumption) const override {
     return isValidState() && setContains(Assumption);
   }
 
   /// See AbstractAttribute::getAsStr()
   const std::string getAsStr(Attributor *A) const override {
     const SetContents &Known = getKnown();
     const SetContents &Assumed = getAssumed();
 
     const std::string KnownStr =
         llvm::join(Known.getSet().begin(), Known.getSet().end(), ",");
     const std::string AssumedStr =
         (Assumed.isUniversal())
             ? "Universal"
             : llvm::join(Assumed.getSet().begin(), Assumed.getSet().end(), ",");
 
     return "Known [" + KnownStr + "]," + " Assumed [" + AssumedStr + "]";
   }
 };
 
 /// Propagates assumption information from parent functions to all of their
 /// successors. An assumption can be propagated if the containing function
 /// dominates the called function.
 ///
 /// We start with a "known" set of assumptions already valid for the associated
 /// function and an "assumed" set that initially contains all possible
 /// assumptions. The assumed set is inter-procedurally updated by narrowing its
 /// contents as concrete values are known. The concrete values are seeded by the
 /// first nodes that are either entries into the call graph, or contains no
 /// assumptions. Each node is updated as the intersection of the assumed state
 /// with all of its predecessors.
 struct AAAssumptionInfoFunction final : AAAssumptionInfoImpl {
   AAAssumptionInfoFunction(const IRPosition &IRP, Attributor &A)
       : AAAssumptionInfoImpl(IRP, A,
                              getAssumptions(*IRP.getAssociatedFunction())) {}
 
   /// See AbstractAttribute::updateImpl(...).
   ChangeStatus updateImpl(Attributor &A) override {
     bool Changed = false;
 
     auto CallSitePred = [&](AbstractCallSite ACS) {
       const auto *AssumptionAA = A.getAAFor<AAAssumptionInfo>(
           *this, IRPosition::callsite_function(*ACS.getInstruction()),
           DepClassTy::REQUIRED);
       if (!AssumptionAA)
         return false;
       // Get the set of assumptions shared by all of this function's callers.
       Changed |= getIntersection(AssumptionAA->getAssumed());
       return !getAssumed().empty() || !getKnown().empty();
     };
 
     bool UsedAssumedInformation = false;
     // Get the intersection of all assumptions held by this node's predecessors.
     // If we don't know all the call sites then this is either an entry into the
     // call graph or an empty node. This node is known to only contain its own
     // assumptions and can be propagated to its successors.
     if (!A.checkForAllCallSites(CallSitePred, *this, true,
                                 UsedAssumedInformation))
       return indicatePessimisticFixpoint();
 
     return Changed ? ChangeStatus::CHANGED : ChangeStatus::UNCHANGED;
   }
 
   void trackStatistics() const override {}
 };
 
 /// Assumption Info defined for call sites.
 struct AAAssumptionInfoCallSite final : AAAssumptionInfoImpl {
 
   AAAssumptionInfoCallSite(const IRPosition &IRP, Attributor &A)
struct AAUnderlyingObjectsCallSiteReturned final : AAUnderlyingObjectsImpl {
   AAUnderlyingObjectsCallSiteReturned(const IRPosition &IRP, Attributor &A)
       : AAUnderlyingObjectsImpl(IRP, A) {}
 };
 
 struct AAUnderlyingObjectsFunction final : AAUnderlyingObjectsImpl {
   AAUnderlyingObjectsFunction(const IRPosition &IRP, Attributor &A)
       : AAUnderlyingObjectsImpl(IRP, A) {}
 };
+} // namespace
+
+/// ------------------------ Address Space Propagation -------------------------
+namespace {
+struct AAAddressSpaceImpl : public AAAddressSpace {
+  AAAddressSpaceImpl(const IRPosition &IRP, Attributor &A)
+      : AAAddressSpace(IRP, A) {}
+
+  int32_t getAddressSpace() const override {
+    assert(isValidState() && "the AA is invalid");
+    return AssumedAddressSpace;
+  }
+
+  /// See AbstractAttribute::initialize(...).
+  void initialize(Attributor &A) override {
+    assert(getAssociatedType()->isPtrOrPtrVectorTy() &&
+           "Associated value is not a pointer");
   }
 
+  ChangeStatus updateImpl(Attributor &A) override {
+    int32_t OldAddressSpace = AssumedAddressSpace;
+    auto *AUO = A.getOrCreateAAFor<AAUnderlyingObjects>(getIRPosition(), this,
+                                                        DepClassTy::OPTIONAL);
+    auto Pred = [&](Value &Obj) {
+      if (isa<UndefValue>(&Obj))
+        return true;
+      return takeAddressSpace(Obj.getType()->getPointerAddressSpace());
+    };
+
+    if (!AUO->forallUnderlyingObjects(Pred))
+      return indicatePessimisticFixpoint();
+
+    return OldAddressSpace == AssumedAddressSpace ? ChangeStatus::UNCHANGED
+                                                  : ChangeStatus::CHANGED;
+  }
+
+  /// See AbstractAttribute::manifest(...).
+  ChangeStatus manifest(Attributor &A) override {
+    Value *AssociatedValue = &getAssociatedValue();
+    Value *OriginalValue = peelAddrspacecast(AssociatedValue);
+    if (getAddressSpace() == NoAddressSpace ||
+        static_cast<uint32_t>(getAddressSpace()) ==
+            getAssociatedType()->getPointerAddressSpace())
+      return ChangeStatus::UNCHANGED;
+
+    Type *NewPtrTy = PointerType::getWithSamePointeeType(
+        cast<PointerType>(getAssociatedType()),
+        static_cast<uint32_t>(getAddressSpace()));
+
+    bool Changed = false;
+
+    auto MakeChange = [&](Instruction *I, Use &U) {
+      Value *NewV = nullptr;
+      if (OriginalValue->getType()->getPointerAddressSpace() ==
+          static_cast<uint32_t>(getAddressSpace())) {
+        NewV = OriginalValue;
+      } else {
+        Instruction *CastInst = new AddrSpaceCastInst(OriginalValue, NewPtrTy);
+        CastInst->insertBefore(cast<Instruction>(I));
+        NewV = CastInst;
+      }
+      A.changeUseAfterManifest(U, *NewV);
+      Changed = true;
+    };
+
+    auto Pred = [&](const Use &U, bool &) {
+      if (U.get() != AssociatedValue)
+        return true;
+      auto *Inst = dyn_cast<Instruction>(U.getUser());
+      if (!Inst)
+        return true;
+      // This is a WA to make sure we only change uses from the corresponding
+      // CGSCC if the AA is run on CGSCC instead of the entire module.
+      if (!A.isRunOn(Inst->getFunction()))
+        return true;
+      if (isa<LoadInst>(Inst)) {
+        MakeChange(Inst, const_cast<Use &>(U));
+        return true;
+      }
+      if (auto *SI = dyn_cast<StoreInst>(Inst))
+        if (SI->getPointerOperand() == AssociatedValue) {
+          MakeChange(Inst, const_cast<Use &>(U));
+          return true;
+        }
+      return true;
+    };
+
+    // It doesn't matter if we can't check all uses as we can simply
+    // conservatively ignore those that can not be visited.
+    (void)A.checkForAllUses(Pred, *this, getAssociatedValue(),
+                            /* CheckBBLivenessOnly */ true);
+
+    return Changed ? ChangeStatus::CHANGED : ChangeStatus::UNCHANGED;
+  }
+
+  /// See AbstractAttribute::getAsStr().
+  const std::string getAsStr(Attributor *A) const override {
+    if (!isValidState())
+      return "addrspace(<invalid>)";
+    return "addrspace(" +
+           (AssumedAddressSpace == NoAddressSpace
+                ? "none"
+                : std::to_string(AssumedAddressSpace)) +
+           ")";
+  }
+
+private:
+  int32_t AssumedAddressSpace = NoAddressSpace;
+
+  bool takeAddressSpace(uint32_t AS) {
+    int32_t Cast = static_cast<int32_t>(AS);
+    if (AssumedAddressSpace == NoAddressSpace) {
+      AssumedAddressSpace = Cast;
+      return true;
+    }
+    return AssumedAddressSpace == Cast;
+  }
+
+  static Value *peelAddrspacecast(Value *V) {
+    if (auto *I = dyn_cast<AddrSpaceCastInst>(V))
+      return peelAddrspacecast(I->getPointerOperand());
+    if (auto *C = dyn_cast<ConstantExpr>(V))
+      if (C->getOpcode() == Instruction::AddrSpaceCast)
+        return peelAddrspacecast(C->getOperand(0));
+    return V;
+  }
+};
+
+struct AAAddressSpaceFloating final : AAAddressSpaceImpl {
+  AAAddressSpaceFloating(const IRPosition &IRP, Attributor &A)
+      : AAAddressSpaceImpl(IRP, A) {}
+
+  void trackStatistics() const override {
+    STATS_DECLTRACK_FLOATING_ATTR(addrspace);
+  }
+};
+
+struct AAAddressSpaceReturned final : AAAddressSpaceImpl {
+  AAAddressSpaceReturned(const IRPosition &IRP, Attributor &A)
+      : AAAddressSpaceImpl(IRP, A) {}
+
+  /// See AbstractAttribute::initialize(...).
+  void initialize(Attributor &A) override {
+    // TODO: we don't rewrite function argument for now because it will need to
+    // rewrite the function signature and all call sites.
+    (void)indicatePessimisticFixpoint();
+  }
+
+  void trackStatistics() const override {
+    STATS_DECLTRACK_FNRET_ATTR(addrspace);
+  }
+};
+
+struct AAAddressSpaceCallSiteReturned final : AAAddressSpaceImpl {
+  AAAddressSpaceCallSiteReturned(const IRPosition &IRP, Attributor &A)
+      : AAAddressSpaceImpl(IRP, A) {}
+
+  void trackStatistics() const override {
+    STATS_DECLTRACK_CSRET_ATTR(addrspace);
+  }
+};
+
+struct AAAddressSpaceArgument final : AAAddressSpaceImpl {
+  AAAddressSpaceArgument(const IRPosition &IRP, Attributor &A)
+      : AAAddressSpaceImpl(IRP, A) {}
+
+  /// See AbstractAttribute::initialize(...).
+  void initialize(Attributor &A) override {
+    // TODO: we don't rewrite function argument for now because it will need to
+    // rewrite the function signature and all call sites.
+    (void)indicatePessimisticFixpoint();
+  }
+
+  void trackStatistics() const override { STATS_DECLTRACK_ARG_ATTR(addrspace); }
+};
+
+struct AAAddressSpaceCallSiteArgument final : AAAddressSpaceImpl {
+  AAAddressSpaceCallSiteArgument(const IRPosition &IRP, Attributor &A)
+      : AAAddressSpaceImpl(IRP, A) {}
+
+  /// See AbstractAttribute::initialize(...).
+  void initialize(Attributor &A) override {
+    // TODO: we don't rewrite call site argument for now because it will need to
+    // rewrite the function signature of the callee.
+    (void)indicatePessimisticFixpoint();
+  }
+
+  void trackStatistics() const override {
+    STATS_DECLTRACK_CSARG_ATTR(addrspace);
+  }
+};
+} // namespace
+
 const char AAReturnedValues::ID = 0;
 const char AANoUnwind::ID = 0;
 const char AANoSync::ID = 0;
 const char AANoFree::ID = 0;
 const char AANonNull::ID = 0;
 const char AAMustProgress::ID = 0;
 const char AANoRecurse::ID = 0;
 const char AANonConvergent::ID = 0;
 const char AAWillReturn::ID = 0;
 const char AAUndefinedBehavior::ID = 0;
 const char AANoAlias::ID = 0;
 const char AAIntraFnReachability::ID = 0;
 const char AANoReturn::ID = 0;
 const char AAIsDead::ID = 0;
 const char AADereferenceable::ID = 0;
 const char AAAlign::ID = 0;
 const char AAInstanceInfo::ID = 0;
 const char AANoCapture::ID = 0;
 const char AAValueSimplify::ID = 0;
 const char AAHeapToStack::ID = 0;
 const char AAPrivatizablePtr::ID = 0;
 const char AAMemoryBehavior::ID = 0;
 const char AAMemoryLocation::ID = 0;
 const char AAValueConstantRange::ID = 0;
 const char AAPotentialConstantValues::ID = 0;
 const char AAPotentialValues::ID = 0;
 const char AANoUndef::ID = 0;
 const char AANoFPClass::ID = 0;
 const char AACallEdges::ID = 0;
 const char AAInterFnReachability::ID = 0;
 const char AAPointerInfo::ID = 0;
 const char AAAssumptionInfo::ID = 0;
 const char AAUnderlyingObjects::ID = 0;
+const char AAAddressSpace::ID = 0;
 
 // Macro magic to create the static generator function for attributes that
 // follow the naming scheme.
 
 #define SWITCH_PK_INV(CLASS, PK, POS_NAME)                                     \
   case IRPosition::PK:                                                         \
     llvm_unreachable("Cannot create " #CLASS " for a " POS_NAME " position!");
 
 #define SWITCH_PK_CREATE(CLASS, IRP, PK, SUFFIX)                               \
   case IRPosition::PK:                                                         \
     AA = new (A.Allocator) CLASS##SUFFIX(IRP, A);                              \
     ++NumAAs;                                                                  \
     break;
 
 #define CREATE_FUNCTION_ABSTRACT_ATTRIBUTE_FOR_POSITION(CLASS)                 \
   CLASS &CLASS::createForPosition(const IRPosition &IRP, Attributor &A) {      \
     CLASS *AA = nullptr;                                                       \
     switch (IRP.getPositionKind()) {                                           \
       SWITCH_PK_INV(CLASS, IRP_INVALID, "invalid")                             \
       SWITCH_PK_INV(CLASS, IRP_FLOAT, "floating")                              \
       SWITCH_PK_INV(CLASS, IRP_ARGUMENT, "argument")                           \
       SWITCH_PK_INV(CLASS, IRP_RETURNED, "returned")                           \
       SWITCH_PK_INV(CLASS, IRP_CALL_SITE_RETURNED, "call site returned")       \
       SWITCH_PK_INV(CLASS, IRP_CALL_SITE_ARGUMENT, "call site argument")       \
       SWITCH_PK_CREATE(CLASS, IRP, IRP_FUNCTION, Function)                     \
       SWITCH_PK_CREATE(CLASS, IRP, IRP_CALL_SITE, CallSite)                    \
     }                                                                          \
     return *AA;                                                                \
   }
 
 #define CREATE_VALUE_ABSTRACT_ATTRIBUTE_FOR_POSITION(CLASS)                    \
   CLASS &CLASS::createForPosition(const IRPosition &IRP, Attributor &A) {      \
     CLASS *AA = nullptr;                                                       \
     switch (IRP.getPositionKind()) {                                           \
       SWITCH_PK_INV(CLASS, IRP_INVALID, "invalid")                             \
       SWITCH_PK_INV(CLASS, IRP_FUNCTION, "function")                           \
       SWITCH_PK_INV(CLASS, IRP_CALL_SITE, "call site")                         \
       SWITCH_PK_CREATE(CLASS, IRP, IRP_FLOAT, Floating)                        \
       SWITCH_PK_CREATE(CLASS, IRP, IRP_ARGUMENT, Argument)                     \
       SWITCH_PK_CREATE(CLASS, IRP, IRP_RETURNED, Returned)                     \
       SWITCH_PK_CREATE(CLASS, IRP, IRP_CALL_SITE_RETURNED, CallSiteReturned)   \
       SWITCH_PK_CREATE(CLASS, IRP, IRP_CALL_SITE_ARGUMENT, CallSiteArgument)   \
     }                                                                          \
     return *AA;                                                                \
   }
 
 #define CREATE_ALL_ABSTRACT_ATTRIBUTE_FOR_POSITION(CLASS)                      \
   CLASS &CLASS::createForPosition(const IRPosition &IRP, Attributor &A) {      \
     CLASS *AA = nullptr;                                                       \
     switch (IRP.getPositionKind()) {                                           \
       SWITCH_PK_INV(CLASS, IRP_INVALID, "invalid")                             \
       SWITCH_PK_CREATE(CLASS, IRP, IRP_FUNCTION, Function)                     \
       SWITCH_PK_CREATE(CLASS, IRP, IRP_CALL_SITE, CallSite)                    \
       SWITCH_PK_CREATE(CLASS, IRP, IRP_FLOAT, Floating)                        \
       SWITCH_PK_CREATE(CLASS, IRP, IRP_ARGUMENT, Argument)                     \
       SWITCH_PK_CREATE(CLASS, IRP, IRP_RETURNED, Returned)                     \
       SWITCH_PK_CREATE(CLASS, IRP, IRP_CALL_SITE_RETURNED, CallSiteReturned)   \
       SWITCH_PK_CREATE(CLASS, IRP, IRP_CALL_SITE_ARGUMENT, CallSiteArgument)   \
     }                                                                          \
     return *AA;                                                                \
   }
 
 #define CREATE_FUNCTION_ONLY_ABSTRACT_ATTRIBUTE_FOR_POSITION(CLASS)            \
   CLASS &CLASS::createForPosition(const IRPosition &IRP, Attributor &A) {      \
     CLASS *AA = nullptr;                                                       \
     switch (IRP.getPositionKind()) {                                           \
       SWITCH_PK_INV(CLASS, IRP_INVALID, "invalid")                             \
       SWITCH_PK_INV(CLASS, IRP_ARGUMENT, "argument")                           \
       SWITCH_PK_INV(CLASS, IRP_FLOAT, "floating")                              \
       SWITCH_PK_INV(CLASS, IRP_RETURNED, "returned")                           \
       SWITCH_PK_INV(CLASS, IRP_CALL_SITE_RETURNED, "call site returned")       \
       SWITCH_PK_INV(CLASS, IRP_CALL_SITE_ARGUMENT, "call site argument")       \
       SWITCH_PK_INV(CLASS, IRP_CALL_SITE, "call site")                         \
       SWITCH_PK_CREATE(CLASS, IRP, IRP_FUNCTION, Function)                     \
     }                                                                          \
     return *AA;                                                                \
   }
 
 #define CREATE_NON_RET_ABSTRACT_ATTRIBUTE_FOR_POSITION(CLASS)                  \
   CLASS &CLASS::createForPosition(const IRPosition &IRP, Attributor &A) {      \
     CLASS *AA = nullptr;                                                       \
     switch (IRP.getPositionKind()) {                                           \
       SWITCH_PK_INV(CLASS, IRP_INVALID, "invalid")                             \

 CREATE_FUNCTION_ABSTRACT_ATTRIBUTE_FOR_POSITION(AAAssumptionInfo)
 CREATE_FUNCTION_ABSTRACT_ATTRIBUTE_FOR_POSITION(AAMustProgress)
 
 CREATE_VALUE_ABSTRACT_ATTRIBUTE_FOR_POSITION(AANonNull)
 CREATE_VALUE_ABSTRACT_ATTRIBUTE_FOR_POSITION(AANoAlias)
 CREATE_VALUE_ABSTRACT_ATTRIBUTE_FOR_POSITION(AAPrivatizablePtr)
 CREATE_VALUE_ABSTRACT_ATTRIBUTE_FOR_POSITION(AADereferenceable)
 CREATE_VALUE_ABSTRACT_ATTRIBUTE_FOR_POSITION(AAAlign)
 CREATE_VALUE_ABSTRACT_ATTRIBUTE_FOR_POSITION(AAInstanceInfo)
 CREATE_VALUE_ABSTRACT_ATTRIBUTE_FOR_POSITION(AANoCapture)
 CREATE_VALUE_ABSTRACT_ATTRIBUTE_FOR_POSITION(AAValueConstantRange)
 CREATE_VALUE_ABSTRACT_ATTRIBUTE_FOR_POSITION(AAPotentialConstantValues)
 CREATE_VALUE_ABSTRACT_ATTRIBUTE_FOR_POSITION(AAPotentialValues)
 CREATE_VALUE_ABSTRACT_ATTRIBUTE_FOR_POSITION(AANoUndef)
 CREATE_VALUE_ABSTRACT_ATTRIBUTE_FOR_POSITION(AANoFPClass)
 CREATE_VALUE_ABSTRACT_ATTRIBUTE_FOR_POSITION(AAPointerInfo)
+CREATE_VALUE_ABSTRACT_ATTRIBUTE_FOR_POSITION(AAAddressSpace)
 
 CREATE_ALL_ABSTRACT_ATTRIBUTE_FOR_POSITION(AAValueSimplify)
 CREATE_ALL_ABSTRACT_ATTRIBUTE_FOR_POSITION(AAIsDead)
 CREATE_ALL_ABSTRACT_ATTRIBUTE_FOR_POSITION(AANoFree)
 CREATE_ALL_ABSTRACT_ATTRIBUTE_FOR_POSITION(AAUnderlyingObjects)
 
 CREATE_FUNCTION_ONLY_ABSTRACT_ATTRIBUTE_FOR_POSITION(AAHeapToStack)
 CREATE_FUNCTION_ONLY_ABSTRACT_ATTRIBUTE_FOR_POSITION(AAUndefinedBehavior)

llvm/test/Transforms/Attributor/address_space_info.ll

+; NOTE: Assertions have been autogenerated by utils/update_test_checks.py UTC_ARGS: --function-signature --check-attributes --check-globals --prefix-filecheck-ir-name true
+; RUN: opt -aa-pipeline=basic-aa -passes=attributor -attributor-manifest-internal -attributor-annotate-decl-cs -S < %s | FileCheck %s --check-prefixes=CHECK
+
+@dst = dso_local addrspace(1) externally_initialized global i32 0, align 4
+@g1 = dso_local addrspace(1) externally_initialized global i32 0, align 4
+@g2 = dso_local addrspace(1) externally_initialized global i32 0, align 4
+@s1 = dso_local addrspace(3) global i32 undef, align 4
+@s2 = dso_local addrspace(3) global i32 undef, align 4
[e-mail] = appending global [3 x ptr] [ptr addrspacecast (ptr addrspace(1) @dst to ptr), ptr addrspacecast (ptr addrspace(1) @g1 to ptr), ptr addrspacecast (ptr addrspace(1) @g2 to ptr)], section "llvm.metadata"
+
+; Function Attrs: convergent mustprogress noinline nounwind
+;.
+; CHECK: @dst = dso_local addrspace(1) externally_initialized global i32 0, align 4
+; CHECK: @g1 = dso_local addrspace(1) externally_initialized global i32 0, align 4
+; CHECK: @g2 = dso_local addrspace(1) externally_initialized global i32 0, align 4
+; CHECK: @s1 = dso_local addrspace(3) global i32 undef, align 4
+; CHECK: @s2 = dso_local addrspace(3) global i32 undef, align 4
+; CHECK: @llvm.compiler.used = appending global [3 x ptr] [ptr addrspacecast (ptr addrspace(1) @dst to ptr), ptr addrspacecast (ptr addrspace(1) @g1 to ptr), ptr addrspacecast (ptr addrspace(1) @g2 to ptr)], section "llvm.metadata"
+;.
+define internal void @_Z12global_writePi(ptr noundef %p) #0 {
+; CHECK: Function Attrs: mustprogress nofree noinline norecurse nosync nounwind willreturn memory(write)
+; CHECK-LABEL: define {{[^@]+}}@_Z12global_writePi
+; CHECK-SAME: (ptr nocapture nofree noundef nonnull writeonly align 4 dereferenceable(4) [[P:%.*]]) #[[ATTR0:[0-9]+]] {
+; CHECK-NEXT:  entry:
+; CHECK-NEXT:    store i32 1, ptr [[P]], align 4
+; CHECK-NEXT:    ret void
+;
+entry:
+  store i32 1, ptr %p, align 4
+  ret void
+}
+
+; Function Attrs: convergent mustprogress noinline nounwind
+define internal void @_Z13unknown_writePi(ptr noundef %p) #0 {
+; CHECK: Function Attrs: mustprogress nofree noinline norecurse nosync nounwind willreturn memory(write)
+; CHECK-LABEL: define {{[^@]+}}@_Z13unknown_writePi
+; CHECK-SAME: (ptr nocapture nofree noundef nonnull writeonly align 4 dereferenceable(4) [[P:%.*]]) #[[ATTR0]] {
+; CHECK-NEXT:  entry:
+; CHECK-NEXT:    store i32 2, ptr [[P]], align 4
+; CHECK-NEXT:    ret void
+;
+entry:
+  store i32 2, ptr %p, align 4
+  ret void
+}
+
+; Function Attrs: convergent mustprogress noinline nounwind
+define internal void @_Z12shared_writePi(ptr noundef %p) #0 {
+; CHECK: Function Attrs: mustprogress nofree noinline norecurse nosync nounwind willreturn memory(write)
+; CHECK-LABEL: define {{[^@]+}}@_Z12shared_writePi
+; CHECK-SAME: (ptr nocapture nofree noundef nonnull writeonly align 4 dereferenceable(4) [[P:%.*]]) #[[ATTR0]] {
+; CHECK-NEXT:  entry:
+; CHECK-NEXT:    store i32 3, ptr [[P]], align 4
+; CHECK-NEXT:    ret void
+;
+entry:
+  store i32 3, ptr %p, align 4
+  ret void
+}
+
+; Function Attrs: convergent mustprogress noinline nounwind
+define internal void @_Z11global_readPi(ptr noundef %p) #0 {
+; CHECK: Function Attrs: mustprogress nofree noinline norecurse nosync nounwind willreturn
+; CHECK-LABEL: define {{[^@]+}}@_Z11global_readPi
+; CHECK-SAME: (ptr nocapture nofree noundef nonnull readonly align 4 dereferenceable(4) [[P:%.*]]) #[[ATTR1:[0-9]+]] {
+; CHECK-NEXT:  entry:
+; CHECK-NEXT:    [[TMP0:%.*]] = load i32, ptr [[P]], align 4
+; CHECK-NEXT:    store i32 [[TMP0]], ptr addrspace(1) @dst, align 4
+; CHECK-NEXT:    ret void
+;
+entry:
+  %0 = load i32, ptr %p, align 4
+  store i32 %0, ptr addrspacecast (ptr addrspace(1) @dst to ptr), align 4
+  ret void
+}
+
+; Function Attrs: convergent mustprogress noinline nounwind
+define internal void @_Z12unknown_readPi(ptr noundef %p) #0 {
+; CHECK: Function Attrs: mustprogress nofree noinline norecurse nosync nounwind willreturn
+; CHECK-LABEL: define {{[^@]+}}@_Z12unknown_readPi
+; CHECK-SAME: (ptr nocapture nofree noundef nonnull readonly align 4 dereferenceable(4) [[P:%.*]]) #[[ATTR1]] {
+; CHECK-NEXT:  entry:
+; CHECK-NEXT:    [[TMP0:%.*]] = load i32, ptr [[P]], align 4
+; CHECK-NEXT:    store i32 [[TMP0]], ptr addrspace(1) @dst, align 4
+; CHECK-NEXT:    ret void
+;
+entry:
+  %0 = load i32, ptr %p, align 4
+  store i32 %0, ptr addrspacecast (ptr addrspace(1) @dst to ptr), align 4
+  ret void
+}
+
+; Function Attrs: convergent mustprogress noinline nounwind
+define internal void @_Z11shared_readPi(ptr noundef %p) #0 {
+; CHECK: Function Attrs: mustprogress nofree noinline norecurse nosync nounwind willreturn
+; CHECK-LABEL: define {{[^@]+}}@_Z11shared_readPi
+; CHECK-SAME: (ptr nocapture nofree noundef nonnull readonly align 4 dereferenceable(4) [[P:%.*]]) #[[ATTR1]] {
+; CHECK-NEXT:  entry:
+; CHECK-NEXT:    [[TMP0:%.*]] = load i32, ptr [[P]], align 4
+; CHECK-NEXT:    store i32 [[TMP0]], ptr addrspace(1) @dst, align 4
+; CHECK-NEXT:    ret void
+;
+entry:
+  %0 = load i32, ptr %p, align 4
+  store i32 %0, ptr addrspacecast (ptr addrspace(1) @dst to ptr), align 4
+  ret void
+}
+
+; Function Attrs: convergent mustprogress noinline nounwind
+define dso_local void @_Z3bazv() #0 {
+; CHECK: Function Attrs: mustprogress nofree noinline norecurse nosync nounwind willreturn
+; CHECK-LABEL: define {{[^@]+}}@_Z3bazv
+; CHECK-SAME: () #[[ATTR1]] {
+; CHECK-NEXT:  entry:
+; CHECK-NEXT:    call void @_Z12global_writePi(ptr nocapture nofree noundef nonnull writeonly align 4 dereferenceable(4) addrspacecast (ptr addrspace(1) @g1 to ptr)) #[[ATTR2:[0-9]+]]
+; CHECK-NEXT:    call void @_Z12global_writePi(ptr nocapture nofree noundef nonnull writeonly align 4 dereferenceable(4) addrspacecast (ptr addrspace(1) @g2 to ptr)) #[[ATTR2]]
+; CHECK-NEXT:    call void @_Z13unknown_writePi(ptr nocapture nofree noundef nonnull writeonly align 4 dereferenceable(4) addrspacecast (ptr addrspace(1) @g1 to ptr)) #[[ATTR2]]
+; CHECK-NEXT:    call void @_Z13unknown_writePi(ptr nocapture nofree noundef nonnull writeonly align 4 dereferenceable(4) addrspacecast (ptr addrspace(3) @s1 to ptr)) #[[ATTR2]]
+; CHECK-NEXT:    call void @_Z12shared_writePi(ptr nocapture nofree noundef nonnull writeonly align 4 dereferenceable(4) addrspacecast (ptr addrspace(3) @s1 to ptr)) #[[ATTR2]]
+; CHECK-NEXT:    call void @_Z12shared_writePi(ptr nocapture nofree noundef nonnull writeonly align 4 dereferenceable(4) addrspacecast (ptr addrspace(3) @s2 to ptr)) #[[ATTR2]]
+; CHECK-NEXT:    call void @_Z11global_readPi(ptr nocapture nofree noundef nonnull readonly align 4 dereferenceable(4) addrspacecast (ptr addrspace(1) @g1 to ptr)) #[[ATTR3:[0-9]+]]
+; CHECK-NEXT:    call void @_Z11global_readPi(ptr nocapture nofree noundef nonnull readonly align 4 dereferenceable(4) addrspacecast (ptr addrspace(1) @g2 to ptr)) #[[ATTR3]]
+; CHECK-NEXT:    call void @_Z12unknown_readPi(ptr nocapture nofree noundef nonnull readonly align 4 dereferenceable(4) addrspacecast (ptr addrspace(1) @g1 to ptr)) #[[ATTR3]]
+; CHECK-NEXT:    call void @_Z12unknown_readPi(ptr nocapture nofree noundef nonnull readonly align 4 dereferenceable(4) addrspacecast (ptr addrspace(3) @s1 to ptr)) #[[ATTR3]]
+; CHECK-NEXT:    call void @_Z11shared_readPi(ptr nocapture nofree noundef nonnull readonly align 4 dereferenceable(4) addrspacecast (ptr addrspace(3) @s1 to ptr)) #[[ATTR3]]
+; CHECK-NEXT:    call void @_Z11shared_readPi(ptr nocapture nofree noundef nonnull readonly align 4 dereferenceable(4) addrspacecast (ptr addrspace(3) @s2 to ptr)) #[[ATTR3]]
+; CHECK-NEXT:    ret void
+;
+entry:
+  call void @_Z12global_writePi(ptr noundef addrspacecast (ptr addrspace(1) @g1 to ptr)) #1
+  call void @_Z12global_writePi(ptr noundef addrspacecast (ptr addrspace(1) @g2 to ptr)) #1
+  call void @_Z13unknown_writePi(ptr noundef addrspacecast (ptr addrspace(1) @g1 to ptr)) #1
+  call void @_Z13unknown_writePi(ptr noundef addrspacecast (ptr addrspace(3) @s1 to ptr)) #1
+  call void @_Z12shared_writePi(ptr noundef addrspacecast (ptr addrspace(3) @s1 to ptr)) #1
+  call void @_Z12shared_writePi(ptr noundef addrspacecast (ptr addrspace(3) @s2 to ptr)) #1
+  call void @_Z11global_readPi(ptr noundef addrspacecast (ptr addrspace(1) @g1 to ptr)) #1
+  call void @_Z11global_readPi(ptr noundef addrspacecast (ptr addrspace(1) @g2 to ptr)) #1
+  call void @_Z12unknown_readPi(ptr noundef addrspacecast (ptr addrspace(1) @g1 to ptr)) #1
+  call void @_Z12unknown_readPi(ptr noundef addrspacecast (ptr addrspace(3) @s1 to ptr)) #1
+  call void @_Z11shared_readPi(ptr noundef addrspacecast (ptr addrspace(3) @s1 to ptr)) #1
+  call void @_Z11shared_readPi(ptr noundef addrspacecast (ptr addrspace(3) @s2 to ptr)) #1
+  ret void
+}
+
+attributes #0 = { convergent mustprogress noinline nounwind }
+attributes #1 = { convergent nounwind }
+;.
+; CHECK: attributes #[[ATTR0]] = { mustprogress nofree noinline norecurse nosync nounwind willreturn memory(write) }
+; CHECK: attributes #[[ATTR1]] = { mustprogress nofree noinline norecurse nosync nounwind willreturn }
+; CHECK: attributes #[[ATTR2]] = { convergent nofree nosync nounwind willreturn memory(write) }
+; CHECK: attributes #[[ATTR3]] = { convergent nofree nosync nounwind willreturn }
+;.

llvm/test/Transforms/Attributor/depgraph.ll

 ; GRAPH-NEXT: [AAAssumptionInfo] for CtxI '  %6 = call ptr @checkAndAdvance(ptr %5)' at position {cs: [@-1]} with state Known [], Assumed []
 ; GRAPH-EMPTY:
 ; GRAPH-NEXT: [AANoAlias] for CtxI '  %6 = call ptr @checkAndAdvance(ptr %5)' at position {cs_arg: [@0]} with state may-alias
 ; GRAPH-EMPTY:
 ; GRAPH-NEXT: [AANoAlias] for CtxI '  %5 = getelementptr inbounds i32, ptr %0, i64 4' at position {flt: [@-1]} with state may-alias
 ; GRAPH-EMPTY:
 ; GRAPH-NEXT: [AANoFree] for CtxI '  %6 = call ptr @checkAndAdvance(ptr %5)' at position {cs_arg: [@0]} with state nofree
 ; GRAPH-EMPTY:
+; GRAPH-NEXT: [AAAddressSpace] for CtxI '  %2 = load i32, ptr %0, align 4' at position {arg: [@0]} with state addrspace(<invalid>)
+; GRAPH-EMPTY:
 ; GRAPH-NEXT: [AADereferenceable] for CtxI '  %5 = getelementptr inbounds i32, ptr %0, i64 4' at position {flt: [@-1]} with state unknown-dereferenceable
 
 ; GRAPH-NOT: update
 
 ;
 ; Check for .dot file
 ;
 ; DOT-DAG: Node[[Node0:0x[a-z0-9]+]] [shape=record,label="{[AAIsDead]

 ; DOT-DAG: Node[[Node66:0x[a-z0-9]+]] [shape=record,label="{[AAMemoryBehavior]
 ; DOT-DAG: Node[[Node67:0x[a-z0-9]+]] [shape=record,label="{[AAMemoryBehavior]
 ; DOT-DAG: Node[[Node68:0x[a-z0-9]+]] [shape=record,label="{[AANoFree]
 ; DOT-DAG: Node[[Node69:0x[a-z0-9]+]] [shape=record,label="{[AAPrivatizablePtr]
 ; DOT-DAG: Node[[Node70:0x[a-z0-9]+]] [shape=record,label="{[AAAssumptionInfo]
 ; DOT-DAG: Node[[Node71:0x[a-z0-9]+]] [shape=record,label="{[AANoAlias]
 ; DOT-DAG: Node[[Node72:0x[a-z0-9]+]] [shape=record,label="{[AANoAlias]
 ; DOT-DAG: Node[[Node73:0x[a-z0-9]+]] [shape=record,label="{[AANoFree]
+; DOT-DAG: Node[[Node75:0x[a-z0-9]+]] [shape=record,label="{[AAAddressSpace]
 ; DOT-DAG: Node[[Node74:0x[a-z0-9]+]] [shape=record,label="{[AADereferenceable]
 
 ; DOT-DAG: Node[[Node20]] -> Node[[Node19]];
 ; DOT-DAG: Node[[Node13]] -> Node[[Node12]];
 ; DOT-DAG: Node[[Node55]] -> Node[[Node56]];
 ; DOT-DAG: Node[[Node68]] -> Node[[Node73]];
 ; DOT-DAG: Node[[Node21]] -> Node[[Node20]];
 ; DOT-DAG: Node[[Node64]] -> Node[[Node61]];

llvm/test/Transforms/Attributor/memory_locations_gpu.ll

;
   %l1 = load i32, ptr addrspace(4) @G
   ret i32 %l1
 }
 ; Should be memory(none)
 define i32 @test_const_as_global2() {
 ; CHECK: Function Attrs: mustprogress nofree norecurse nosync nounwind willreturn memory(none)
 ; CHECK-LABEL: define {{[^@]+}}@test_const_as_global2
 ; CHECK-SAME: () #[[ATTR1]] {
-; CHECK-NEXT:    [[L2:%.*]] = load i32, ptr addrspacecast (ptr addrspace(4) @G to ptr), align 4
+; CHECK-NEXT:    [[L2:%.*]] = load i32, ptr addrspace(4) @G, align 4
 ; CHECK-NEXT:    ret i32 [[L2]]
 ;
   %l2 = load i32, ptr addrspacecast (ptr addrspace(4) @G to ptr)
   ret i32 %l2
 }
 ; Should be memory(none)
 define i32 @test_const_as_call1() {
 ; CHECK: Function Attrs: nosync memory(read)
 ; CHECK-LABEL: define {{[^@]+}}@test_const_as_call1
 ; CHECK-SAME: () #[[ATTR2:[0-9]+]] {
 ; CHECK-NEXT:    [[P1:%.*]] = call ptr addrspace(4) @ptr_to_const()
-; CHECK-NEXT:    [[C1:%.*]] = addrspacecast ptr addrspace(4) [[P1]] to ptr
-; CHECK-NEXT:    [[L1:%.*]] = load i32, ptr [[C1]], align 4
+; CHECK-NEXT:    [[L1:%.*]] = load i32, ptr addrspace(4) [[P1]], align 4
 ; CHECK-NEXT:    ret i32 [[L1]]
 ;
   %p1 = call ptr addrspace(4) @ptr_to_const()
   %c1 = addrspacecast ptr addrspace(4) %p1 to ptr
   %l1 = load i32, ptr %c1
   ret i32 %l1
 }
 ; Should be memory(none)
 define i32 @test_const_as_call2() {
 ; CHECK: Function Attrs: nosync memory(none)
 ; CHECK-LABEL: define {{[^@]+}}@test_const_as_call2
 ; CHECK-SAME: () #[[ATTR3:[0-9]+]] {
 ; CHECK-NEXT:    [[P2:%.*]] = call ptr @ptr()
-; CHECK-NEXT:    [[C2:%.*]] = addrspacecast ptr [[P2]] to ptr addrspace(4)
-; CHECK-NEXT:    [[L2:%.*]] = load i32, ptr addrspace(4) [[C2]], align 4
+; CHECK-NEXT:    [[L2:%.*]] = load i32, ptr [[P2]], align 4
 ; CHECK-NEXT:    ret i32 [[L2]]
 ;
   %p2 = call ptr @ptr()
   %c2 = addrspacecast ptr %p2 to ptr addrspace(4)
   %l2 = load i32, ptr addrspace(4) %c2
   ret i32 %l2
 }
 
 ; Should be memory(read)
 define i32 @test_shared_as_call1() {
 ; CHECK: Function Attrs: nosync memory(read)
 ; CHECK-LABEL: define {{[^@]+}}@test_shared_as_call1
 ; CHECK-SAME: () #[[ATTR2]] {
 ; CHECK-NEXT:    [[P1:%.*]] = call ptr addrspace(3) @ptr_to_shared()
-; CHECK-NEXT:    [[C1:%.*]] = addrspacecast ptr addrspace(3) [[P1]] to ptr
-; CHECK-NEXT:    [[L1:%.*]] = load i32, ptr [[C1]], align 4
+; CHECK-NEXT:    [[L1:%.*]] = load i32, ptr addrspace(3) [[P1]], align 4
 ; CHECK-NEXT:    ret i32 [[L1]]
 ;
   %p1 = call ptr addrspace(3) @ptr_to_shared()
   %c1 = addrspacecast ptr addrspace(3) %p1 to ptr
   %l1 = load i32, ptr %c1
   ret i32 %l1
 }
 ; Should be memory(read)
 define i32 @test_shared_as_call2() {
 ; CHECK: Function Attrs: nosync memory(read)
 ; CHECK-LABEL: define {{[^@]+}}@test_shared_as_call2
 ; CHECK-SAME: () #[[ATTR2]] {
 ; CHECK-NEXT:    [[P2:%.*]] = call ptr @ptr()
-; CHECK-NEXT:    [[C2:%.*]] = addrspacecast ptr [[P2]] to ptr addrspace(3)
-; CHECK-NEXT:    [[L2:%.*]] = load i32, ptr addrspace(3) [[C2]], align 4
+; CHECK-NEXT:    [[L2:%.*]] = load i32, ptr [[P2]], align 4
 ; CHECK-NEXT:    ret i32 [[L2]]
 ;
   %p2 = call ptr @ptr()
   %c2 = addrspacecast ptr %p2 to ptr addrspace(3)
   %l2 = load i32, ptr addrspace(3) %c2
   ret i32 %l2
 }
 ;.
 ; CHECK: attributes #[[ATTR0:[0-9]+]] = { memory(none) }
 ; CHECK: attributes #[[ATTR1]] = { mustprogress nofree norecurse nosync nounwind willreturn memory(none) }
 ; CHECK: attributes #[[ATTR2]] = { nosync memory(read) }
 ; CHECK: attributes #[[ATTR3]] = { nosync memory(none) }
 ;.
 ;; NOTE: These prefixes are unused and the list is autogenerated. Do not add tests below this line:
 ; CGSCC: {{.*}}
 ; TUNIT: {{.*}}

llvm/test/Transforms/Attributor/nocapture-1.ll

 ; TUNIT-NEXT:  e:
 ; TUNIT-NEXT:    br label [[L:%.*]]
 ; TUNIT:       l:
 ; TUNIT-NEXT:    [[X:%.*]] = phi ptr addrspace(1) [ [[P]], [[E:%.*]] ]
 ; TUNIT-NEXT:    [[Y:%.*]] = phi ptr [ [[Q]], [[E]] ]
 ; TUNIT-NEXT:    [[TMP:%.*]] = addrspacecast ptr addrspace(1) [[P]] to ptr
 ; TUNIT-NEXT:    [[TMP2:%.*]] = select i1 [[B]], ptr [[TMP]], ptr [[Q]]
 ; TUNIT-NEXT:    [[VAL:%.*]] = load i32, ptr [[TMP2]], align 4
-; TUNIT-NEXT:    store i32 0, ptr [[TMP]], align 4
+; TUNIT-NEXT:    store i32 0, ptr addrspace(1) [[P]], align 4
 ; TUNIT-NEXT:    store ptr [[Q]], ptr @g, align 8
 ; TUNIT-NEXT:    ret i32 [[VAL]]
 ;
 ; CGSCC: Function Attrs: mustprogress nofree norecurse nosync nounwind willreturn
 ; CGSCC-LABEL: define {{[^@]+}}@nc1_addrspace
 ; CGSCC-SAME: (ptr nofree [[Q:%.*]], ptr addrspace(1) nocapture nofree [[P:%.*]], i1 [[B:%.*]]) #[[ATTR6]] {
 ; CGSCC-NEXT:  e:
 ; CGSCC-NEXT:    br label [[L:%.*]]
 ; CGSCC:       l:
 ; CGSCC-NEXT:    [[X:%.*]] = phi ptr addrspace(1) [ [[P]], [[E:%.*]] ]
 ; CGSCC-NEXT:    [[Y:%.*]] = phi ptr [ [[Q]], [[E]] ]
 ; CGSCC-NEXT:    [[TMP:%.*]] = addrspacecast ptr addrspace(1) [[P]] to ptr
 ; CGSCC-NEXT:    [[TMP2:%.*]] = select i1 [[B]], ptr [[TMP]], ptr [[Q]]
 ; CGSCC-NEXT:    [[VAL:%.*]] = load i32, ptr [[TMP2]], align 4
-; CGSCC-NEXT:    store i32 0, ptr [[TMP]], align 4
+; CGSCC-NEXT:    store i32 0, ptr addrspace(1) [[P]], align 4
 ; CGSCC-NEXT:    store ptr [[Q]], ptr @g, align 8
 ; CGSCC-NEXT:    ret i32 [[VAL]]
 ;
 e:
   br label %l
 l:
   %x = phi ptr addrspace(1) [ %p, %e ]
   %y = phi ptr [ %q, %e ]

llvm/test/Transforms/Attributor/value-simplify-gpu.ll

 }
 
 define internal void @level2Kernelall_early() {
 ; CHECK: Function Attrs: mustprogress nofree norecurse nosync nounwind willreturn memory(write)
 ; CHECK-LABEL: define {{[^@]+}}@level2Kernelall_early
 ; CHECK-SAME: () #[[ATTR2:[0-9]+]] {
 ; CHECK-NEXT:  entry:
 ; CHECK-NEXT:    store i32 1, ptr @ReachableKernelAS0, align 4
-; CHECK-NEXT:    store i32 1, ptr addrspacecast (ptr addrspace(3) @ReachableKernel to ptr), align 4
+; CHECK-NEXT:    store i32 1, ptr addrspace(3) @ReachableKernel, align 4
 ; CHECK-NEXT:    ret void
 ;
 entry:
   store i32 1, ptr @ReachableKernelAS0, align 4
   store i32 1, ptr addrspacecast (ptr addrspace(3) @ReachableKernel to ptr), align 4
   ret void
 }
 
 define internal void @level2Kernela() {
 ; TUNIT: Function Attrs: norecurse nosync nounwind
 ; TUNIT-LABEL: define {{[^@]+}}@level2Kernela
 ; TUNIT-SAME: () #[[ATTR1]] {
 ; TUNIT-NEXT:  entry:
-; TUNIT-NEXT:    [[TMP0:%.*]] = load i32, ptr addrspacecast (ptr addrspace(3) @ReachableKernel to ptr), align 4
+; TUNIT-NEXT:    [[TMP0:%.*]] = load i32, ptr addrspace(3) @ReachableKernel, align 4
 ; TUNIT-NEXT:    [[TMP1:%.*]] = load i32, ptr @ReachableKernelAS0, align 4
-; TUNIT-NEXT:    [[TMP2:%.*]] = load i32, ptr addrspacecast (ptr addrspace(3) @UnreachableKernel to ptr), align 4
+; TUNIT-NEXT:    [[TMP2:%.*]] = load i32, ptr addrspace(3) @UnreachableKernel, align 4
 ; TUNIT-NEXT:    call void @use(i32 noundef [[TMP0]], i32 noundef [[TMP1]], i32 noundef [[TMP2]]) #[[ATTR6:[0-9]+]]
 ; TUNIT-NEXT:    ret void
 ;
 ; CGSCC: Function Attrs: nosync nounwind
 ; CGSCC-LABEL: define {{[^@]+}}@level2Kernela
 ; CGSCC-SAME: () #[[ATTR3:[0-9]+]] {
 ; CGSCC-NEXT:  entry:
-; CGSCC-NEXT:    [[TMP0:%.*]] = load i32, ptr addrspacecast (ptr addrspace(3) @ReachableKernel to ptr), align 4
+; CGSCC-NEXT:    [[TMP0:%.*]] = load i32, ptr addrspace(3) @ReachableKernel, align 4
 ; CGSCC-NEXT:    [[TMP1:%.*]] = load i32, ptr @ReachableKernelAS0, align 4
-; CGSCC-NEXT:    [[TMP2:%.*]] = load i32, ptr addrspacecast (ptr addrspace(3) @UnreachableKernel to ptr), align 4
+; CGSCC-NEXT:    [[TMP2:%.*]] = load i32, ptr addrspace(3) @UnreachableKernel, align 4
 ; CGSCC-NEXT:    call void @use(i32 noundef [[TMP0]], i32 noundef [[TMP1]], i32 noundef [[TMP2]]) #[[ATTR4]]
 ; CGSCC-NEXT:    ret void
 ;
 entry:
   %0 = load i32, ptr addrspacecast (ptr addrspace(3) @ReachableKernel to ptr), align 4
   %1 = load i32, ptr @ReachableKernelAS0, align 4
   %2 = load i32, ptr addrspacecast (ptr addrspace(3) @UnreachableKernel to ptr), align 4
   call void @use(i32 %0, i32 %1, i32 %2)
   ret void
 }
 
 define internal void @level2Kernelb() {
 ; TUNIT: Function Attrs: norecurse nosync nounwind
 ; TUNIT-LABEL: define {{[^@]+}}@level2Kernelb
 ; TUNIT-SAME: () #[[ATTR1]] {
 ; TUNIT-NEXT:  entry:
-; TUNIT-NEXT:    [[TMP0:%.*]] = load i32, ptr addrspacecast (ptr addrspace(3) @ReachableKernel to ptr), align 4
+; TUNIT-NEXT:    [[TMP0:%.*]] = load i32, ptr addrspace(3) @ReachableKernel, align 4
 ; TUNIT-NEXT:    [[TMP1:%.*]] = load i32, ptr @ReachableKernelAS0, align 4
-; TUNIT-NEXT:    [[TMP2:%.*]] = load i32, ptr addrspacecast (ptr addrspace(3) @UnreachableKernel to ptr), align 4
+; TUNIT-NEXT:    [[TMP2:%.*]] = load i32, ptr addrspace(3) @UnreachableKernel, align 4
 ; TUNIT-NEXT:    call void @use(i32 noundef [[TMP0]], i32 noundef [[TMP1]], i32 noundef [[TMP2]]) #[[ATTR6]]
 ; TUNIT-NEXT:    ret void
 ;
 ; CGSCC: Function Attrs: nosync nounwind
 ; CGSCC-LABEL: define {{[^@]+}}@level2Kernelb
 ; CGSCC-SAME: () #[[ATTR3]] {
 ; CGSCC-NEXT:  entry:
-; CGSCC-NEXT:    [[TMP0:%.*]] = load i32, ptr addrspacecast (ptr addrspace(3) @ReachableKernel to ptr), align 4
+; CGSCC-NEXT:    [[TMP0:%.*]] = load i32, ptr addrspace(3) @ReachableKernel, align 4
 ; CGSCC-NEXT:    [[TMP1:%.*]] = load i32, ptr @ReachableKernelAS0, align 4
-; CGSCC-NEXT:    [[TMP2:%.*]] = load i32, ptr addrspacecast (ptr addrspace(3) @UnreachableKernel to ptr), align 4
+; CGSCC-NEXT:    [[TMP2:%.*]] = load i32, ptr addrspace(3) @UnreachableKernel, align 4
 ; CGSCC-NEXT:    call void @use(i32 noundef [[TMP0]], i32 noundef [[TMP1]], i32 noundef [[TMP2]]) #[[ATTR4]]
 ; CGSCC-NEXT:    ret void
 ;
 entry:
   %0 = load i32, ptr addrspacecast (ptr addrspace(3) @ReachableKernel to ptr), align 4
   %1 = load i32, ptr @ReachableKernelAS0, align 4
   %2 = load i32, ptr addrspacecast (ptr addrspace(3) @UnreachableKernel to ptr), align 4
   call void @use(i32 %0, i32 %1, i32 %2)
   ret void
 }
 
 define internal void @level2Kernelall_late() {
 ; CHECK: Function Attrs: mustprogress nofree norecurse nosync nounwind willreturn memory(write)
 ; CHECK-LABEL: define {{[^@]+}}@level2Kernelall_late
 ; CHECK-SAME: () #[[ATTR2]] {
 ; CHECK-NEXT:  entry:
-; CHECK-NEXT:    store i32 1, ptr addrspacecast (ptr addrspace(3) @UnreachableKernel to ptr), align 4
+; CHECK-NEXT:    store i32 1, ptr addrspace(3) @UnreachableKernel, align 4
 ; CHECK-NEXT:    ret void
 ;
 entry:
   store i32 1, ptr addrspacecast (ptr addrspace(3) @UnreachableKernel to ptr), align 4
   ret void
 }
 
 @ReachableNonKernel = internal addrspace(3) global i32 0, align 4
if.end:                                           ; preds = %if.else, %if.then
   ret void
 }
 
 define internal void @level2all_early(ptr %addr) {
 ; TUNIT: Function Attrs: mustprogress nofree norecurse nosync nounwind willreturn memory(write)
 ; TUNIT-LABEL: define {{[^@]+}}@level2all_early
 ; TUNIT-SAME: (ptr noalias nocapture nofree noundef nonnull writeonly align 4 dereferenceable(4) [[ADDR:%.*]]) #[[ATTR2]] {
 ; TUNIT-NEXT:  entry:
-; TUNIT-NEXT:    store i32 1, ptr addrspacecast (ptr addrspace(3) @ReachableNonKernel to ptr), align 4
+; TUNIT-NEXT:    store i32 1, ptr addrspace(3) @ReachableNonKernel, align 4
 ; TUNIT-NEXT:    ret void
 ;
 ; CGSCC: Function Attrs: mustprogress nofree norecurse nosync nounwind willreturn memory(write)
 ; CGSCC-LABEL: define {{[^@]+}}@level2all_early
 ; CGSCC-SAME: (ptr nocapture nofree noundef nonnull writeonly align 4 dereferenceable(4) [[ADDR:%.*]]) #[[ATTR2]] {
 ; CGSCC-NEXT:  entry:
-; CGSCC-NEXT:    store i32 1, ptr addrspacecast (ptr addrspace(3) @ReachableNonKernel to ptr), align 4
+; CGSCC-NEXT:    store i32 1, ptr addrspace(3) @ReachableNonKernel, align 4
 ; CGSCC-NEXT:    store i32 17, ptr [[ADDR]], align 4
 ; CGSCC-NEXT:    ret void
 ;
 entry:
   store i32 1, ptr addrspacecast (ptr addrspace(3) @ReachableNonKernel to ptr), align 4
   store i32 17, ptr %addr, align 4
   ret void
 }
 
 define internal void @level2a(ptr %addr) {
 ; TUNIT: Function Attrs: norecurse nosync nounwind
 ; TUNIT-LABEL: define {{[^@]+}}@level2a
 ; TUNIT-SAME: () #[[ATTR1]] {
 ; TUNIT-NEXT:  entry:
-; TUNIT-NEXT:    [[TMP0:%.*]] = load i32, ptr addrspacecast (ptr addrspace(3) @ReachableNonKernel to ptr), align 4
-; TUNIT-NEXT:    [[TMP1:%.*]] = load i32, ptr addrspacecast (ptr addrspace(3) @UnreachableNonKernel to ptr), align 4
+; TUNIT-NEXT:    [[TMP0:%.*]] = load i32, ptr addrspace(3) @ReachableNonKernel, align 4
+; TUNIT-NEXT:    [[TMP1:%.*]] = load i32, ptr addrspace(3) @UnreachableNonKernel, align 4
 ; TUNIT-NEXT:    call void @use(i32 noundef [[TMP0]], i32 noundef [[TMP1]], i32 17) #[[ATTR6]]
 ; TUNIT-NEXT:    ret void
 ;
 ; CGSCC: Function Attrs: nosync nounwind
 ; CGSCC-LABEL: define {{[^@]+}}@level2a
 ; CGSCC-SAME: (ptr nocapture nofree noundef nonnull readonly align 4 dereferenceable(4) [[ADDR:%.*]]) #[[ATTR3]] {
 ; CGSCC-NEXT:  entry:
-; CGSCC-NEXT:    [[TMP0:%.*]] = load i32, ptr addrspacecast (ptr addrspace(3) @ReachableNonKernel to ptr), align 4
-; CGSCC-NEXT:    [[TMP1:%.*]] = load i32, ptr addrspacecast (ptr addrspace(3) @UnreachableNonKernel to ptr), align 4
+; CGSCC-NEXT:    [[TMP0:%.*]] = load i32, ptr addrspace(3) @ReachableNonKernel, align 4
+; CGSCC-NEXT:    [[TMP1:%.*]] = load i32, ptr addrspace(3) @UnreachableNonKernel, align 4
 ; CGSCC-NEXT:    [[QQQQ2:%.*]] = load i32, ptr [[ADDR]], align 4
 ; CGSCC-NEXT:    call void @use(i32 noundef [[TMP0]], i32 noundef [[TMP1]], i32 [[QQQQ2]]) #[[ATTR4]]
 ; CGSCC-NEXT:    ret void
 ;
 entry:
   %0 = load i32, ptr addrspacecast (ptr addrspace(3) @ReachableNonKernel to ptr), align 4
   %1 = load i32, ptr addrspacecast (ptr addrspace(3) @UnreachableNonKernel to ptr), align 4
   %qqqq2 = load i32, ptr %addr
   call void @use(i32 %0, i32 %1, i32 %qqqq2)
   ret void
 }
 
 define internal void @level2b(ptr %addr) {
 ; TUNIT: Function Attrs: norecurse nosync nounwind
 ; TUNIT-LABEL: define {{[^@]+}}@level2b
 ; TUNIT-SAME: () #[[ATTR1]] {
 ; TUNIT-NEXT:  entry:
-; TUNIT-NEXT:    [[TMP0:%.*]] = load i32, ptr addrspacecast (ptr addrspace(3) @ReachableNonKernel to ptr), align 4
-; TUNIT-NEXT:    [[TMP1:%.*]] = load i32, ptr addrspacecast (ptr addrspace(3) @UnreachableNonKernel to ptr), align 4
+; TUNIT-NEXT:    [[TMP0:%.*]] = load i32, ptr addrspace(3) @ReachableNonKernel, align 4
+; TUNIT-NEXT:    [[TMP1:%.*]] = load i32, ptr addrspace(3) @UnreachableNonKernel, align 4
 ; TUNIT-NEXT:    call void @use(i32 noundef [[TMP0]], i32 noundef [[TMP1]], i32 17) #[[ATTR6]]
 ; TUNIT-NEXT:    ret void
 ;
 ; CGSCC: Function Attrs: nosync nounwind
 ; CGSCC-LABEL: define {{[^@]+}}@level2b
 ; CGSCC-SAME: (ptr nocapture nofree noundef nonnull readonly align 4 dereferenceable(4) [[ADDR:%.*]]) #[[ATTR3]] {
 ; CGSCC-NEXT:  entry:
-; CGSCC-NEXT:    [[TMP0:%.*]] = load i32, ptr addrspacecast (ptr addrspace(3) @ReachableNonKernel to ptr), align 4
-; CGSCC-NEXT:    [[TMP1:%.*]] = load i32, ptr addrspacecast (ptr addrspace(3) @UnreachableNonKernel to ptr), align 4
+; CGSCC-NEXT:    [[TMP0:%.*]] = load i32, ptr addrspace(3) @ReachableNonKernel, align 4
+; CGSCC-NEXT:    [[TMP1:%.*]] = load i32, ptr addrspace(3) @UnreachableNonKernel, align 4
 ; CGSCC-NEXT:    [[TMP2:%.*]] = load i32, ptr [[ADDR]], align 4
 ; CGSCC-NEXT:    call void @use(i32 noundef [[TMP0]], i32 noundef [[TMP1]], i32 [[TMP2]]) #[[ATTR4]]
 ; CGSCC-NEXT:    ret void
 ;
 entry:
   %0 = load i32, ptr addrspacecast (ptr addrspace(3) @ReachableNonKernel to ptr), align 4
   %1 = load i32, ptr addrspacecast (ptr addrspace(3) @UnreachableNonKernel to ptr), align 4
   %2 = load i32, ptr %addr
   call void @use(i32 %0, i32 %1, i32 %2)
   ret void
 }
 
 define internal void @level2all_late(ptr %addr) {
 ; TUNIT: Function Attrs: mustprogress nofree norecurse nosync nounwind willreturn memory(write)
 ; TUNIT-LABEL: define {{[^@]+}}@level2all_late
 ; TUNIT-SAME: (ptr noalias nocapture nofree noundef nonnull writeonly align 4 dereferenceable(4) [[ADDR:%.*]]) #[[ATTR2]] {
 ; TUNIT-NEXT:  entry:
-; TUNIT-NEXT:    store i32 1, ptr addrspacecast (ptr addrspace(3) @UnreachableNonKernel to ptr), align 4
+; TUNIT-NEXT:    store i32 1, ptr addrspace(3) @UnreachableNonKernel, align 4
 ; TUNIT-NEXT:    ret void
 ;
 ; CGSCC: Function Attrs: mustprogress nofree norecurse nosync nounwind willreturn memory(write)
 ; CGSCC-LABEL: define {{[^@]+}}@level2all_late
 ; CGSCC-SAME: (ptr noalias nocapture nofree noundef nonnull writeonly align 4 dereferenceable(4) [[ADDR:%.*]]) #[[ATTR2]] {
 ; CGSCC-NEXT:  entry:
-; CGSCC-NEXT:    store i32 1, ptr addrspacecast (ptr addrspace(3) @UnreachableNonKernel to ptr), align 4
+; CGSCC-NEXT:    store i32 1, ptr addrspace(3) @UnreachableNonKernel, align 4
 ; CGSCC-NEXT:    store i32 5, ptr [[ADDR]], align 4
 ; CGSCC-NEXT:    ret void
 ;
 entry:
   store i32 1, ptr addrspacecast (ptr addrspace(3) @UnreachableNonKernel to ptr), align 4
   store i32 5, ptr %addr, align 4
   ret void
 }

llvm/test/Transforms/Attributor/value-simplify.ll

 @str = private unnamed_addr addrspace(4) constant [1 x i8] c"\00", align 1
 @ConstAS3Ptr = addrspace(3) global i32 0, align 4
 
 ;.
 ; CHECK: @[[STR:[a-zA-Z0-9_$"\\.-]+]] = private unnamed_addr addrspace(4) constant [1 x i8] zeroinitializer, align 1
 ; CHECK: @[[CONSTAS3PTR:[a-zA-Z0-9_$"\\.-]+]] = addrspace(3) global i32 0, align 4
 ; CHECK: @[[S:[a-zA-Z0-9_$"\\.-]+]] = external global [[STRUCT_X:%.*]]
 ; CHECK: @[[G:[a-zA-Z0-9_$"\\.-]+]] = internal constant { [2 x ptr] } { [2 x ptr] [ptr @f1, ptr @f2] }
 ; CHECK: @[[X:[a-zA-Z0-9_$"\\.-]+]] = external global i32
 ;.
 define internal ptr addrspace(3) @const_ptr_return_as3() {
 ; CGSCC: Function Attrs: mustprogress nofree norecurse nosync nounwind willreturn memory(none)
 ; CGSCC-LABEL: define {{[^@]+}}@const_ptr_return_as3
 ; CGSCC-SAME: () #[[ATTR1:[0-9]+]] {
 ; CGSCC-NEXT:    ret ptr addrspace(3) @ConstAS3Ptr
 ;
   ret ptr addrspace(3) @ConstAS3Ptr
;
   %call = call fastcc ptr addrspace(3) @const_ptr_return_as3()
   store i32 0, ptr addrspace(3) %call
   ret void
 }
 define void @user() {
 ; TUNIT: Function Attrs: mustprogress nofree norecurse nosync nounwind willreturn memory(write)
 ; TUNIT-LABEL: define {{[^@]+}}@user
 ; TUNIT-SAME: () #[[ATTR4]] {
-; TUNIT-NEXT:    store i32 0, ptr addrspacecast (ptr addrspace(3) @ConstAS3Ptr to ptr), align 4
+; TUNIT-NEXT:    [[TMP1:%.*]] = addrspacecast ptr addrspacecast (ptr addrspace(3) @ConstAS3Ptr to ptr) to ptr addrspace(3)
+; TUNIT-NEXT:    store i32 0, ptr addrspace(3) [[TMP1]], align 4
 ; TUNIT-NEXT:    ret void
 ;
 ; CGSCC: Function Attrs: mustprogress nofree nosync nounwind willreturn memory(write)
 ; CGSCC-LABEL: define {{[^@]+}}@user
 ; CGSCC-SAME: () #[[ATTR6]] {
 ; CGSCC-NEXT:    [[CALL:%.*]] = call fastcc align 4 ptr @const_ptr_return() #[[ATTR12]]
 ; CGSCC-NEXT:    store i32 0, ptr [[CALL]], align 4
 ; CGSCC-NEXT:    ret void