[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

9910

hasXXX sounds like a boolean return, this would be getAS

9917

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

9924

Check the return type of this function.

9931

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.

9938

break

9957

before, not after.

9982

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

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

1514

This is not a good idea.

4870

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

9923

This is now AAUnderlyingValues

9965–9983

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

10180

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

4937

no null opt anymore

4955

docs

llvm/lib/Transforms/IPO/AttributorAttributes.cpp

10192–10200

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

10204–10206

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

10214

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.

10241

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

10247–10250

No need. Just let the attributor change all uses.

[jdoerfert]

llvm/lib/Transforms/IPO/AttributorAttributes.cpp

10276

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

10259–10261

Doesn't consider vector of pointers

10271

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

10241

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

4937

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

[jdoerfert]

llvm/lib/Transforms/IPO/AttributorAttributes.cpp

10241

It's more complex. More complex is bad.

[tianshilei1992]

rebase and fix tests

[tianshilei1992]

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

4937

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

4933

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

llvm/lib/Transforms/IPO/AttributorAttributes.cpp

10188

No need for AAIsDead.

10194–10197

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

10205–10211

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)

10227

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

10236–10237

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

10317

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

[arsenm]

llvm/lib/Transforms/IPO/AttributorAttributes.cpp

10266

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

10236–10237

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?

10259–10261

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

10230

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.

10236–10237

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.

10257

Why do we cast this? Keep one type consistently.

[tianshilei1992]

rebase, fix tests, and rename to AAAddressSpace

[tianshilei1992]

llvm/lib/Transforms/IPO/AttributorAttributes.cpp

10257

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

26

This is supposed to be replaced with an addrspacecast.

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

788

This should be replaced by @ConstAS3Ptr directly.

[jdoerfert]

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

883

remove unrelated changes please.

[tianshilei1992]

rebase to remove unrelated changes

[jdoerfert]

llvm/lib/Transforms/IPO/AttributorAttributes.cpp

10193

10224–10225

Hoist this.

10251–10252

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.

10280–10281

llvm/test/Transforms/Attributor/address_space_info.ll

10

remove the compiler used part

109

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

788

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

10251–10252

Why does the AS of value operand matter here?

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

788

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

10228

early exit.

10251–10252

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

17

Can you undo this for now.

788

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

[tianshilei1992]

rebase and fix comments

llvm/lib/Transforms/IPO/AttributorAttributes.cpp

10251–10252

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

 public:
   SubsumingPositionIterator(const IRPosition &IRP);
   iterator begin() { return IRPositions.begin(); }
   iterator end() { return IRPositions.end(); }
 };
 
 /// Wrapper for FunctoinAnalysisManager.
 struct AnalysisGetter {
   template <typename Analysis>
   typename Analysis::Result *getAnalysis(const Function &F) {
     if (!FAM || !F.getParent())
       return nullptr;
     return &FAM->getResult<Analysis>(const_cast<Function &>(F));
   }
 
   AnalysisGetter(FunctionAnalysisManager &FAM) : FAM(&FAM) {}
   AnalysisGetter() = default;
bool changeUseAfterManifest(Use &U, Value &NV) {
     V = &NV;
     return true;
   }
 
   /// Helper function to replace all uses of \p V with \p NV. Return true if
   /// there is any change. The flag \p ChangeDroppable indicates if dropppable
   /// uses should be changed too.
   bool changeValueAfterManifest(Value &V, Value &NV,
-                                bool ChangeDroppable = true) {
+                                bool ChangeDroppable = true,
+                                bool AllowDuplicates = false) {
     auto &Entry = ToBeChangedValues[&V];
     Value *&CurNV = Entry.first;
     if (CurNV && (CurNV->stripPointerCasts() == NV.stripPointerCasts() ||
                   isa<UndefValue>(CurNV)))
       return false;
-    assert((!CurNV || CurNV == &NV || isa<UndefValue>(NV)) &&
+    assert((AllowDuplicates || !CurNV || CurNV == &NV || isa<UndefValue>(NV)) &&
            "Value replacement was registered twice with different values!");
     CurNV = &NV;
     Entry.second = ChangeDroppable;
     return true;
   }
 
   /// Record that \p I is to be replaced with `unreachable` after information
   /// was manifested.
struct AAPointerInfo : public AbstractAttribute {
   static bool classof(const AbstractAttribute *AA) {
     return (AA->getIdAddr() == &ID);
   }
 
   /// Unique ID (due to the unique address)
   static const char ID;
 };
 
+/// An abstract interface for address space information.
+struct AAAddressSpaceInfo
+    : public StateWrapper<IncIntegerState<uint32_t>, AbstractAttribute> {
+  AAAddressSpaceInfo(const IRPosition &IRP, Attributor &A)
+      : StateWrapper<IncIntegerState<uint32_t>, AbstractAttribute>(IRP) {}
+
+  virtual uint32_t getAddressSpace() const = 0;
+
+  /// Create an abstract attribute view for the position \p IRP.
+  static AAAddressSpaceInfo &createForPosition(const IRPosition &IRP,
+                                               Attributor &A);
+
+  /// See AbstractAttribute::getName()
+  const std::string getName() const override { return "AAAddressSpaceInfo"; }
+
+  /// 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);
+  }
+
+  /// 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,
struct AAAssumptionInfo
   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
 };
 
 } // end namespace llvm
 
 #endif // LLVM_TRANSFORMS_IPO_ATTRIBUTOR_H

llvm/lib/Transforms/IPO/Attributor.cpp

Success = checkForAllInstructionsImpl(
       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()));
+      getOrCreateAAFor<AAAddressSpaceInfo>(
+          IRPosition::value(*cast<LoadInst>(I).getPointerOperand()));
       if (SimplifyAllLoads)
         getOrCreateAAFor<AAValueSimplify>(IRPosition::value(I));
-    } else
+    } else {
       getOrCreateAAFor<AAAlign>(
           IRPosition::value(*cast<StoreInst>(I).getPointerOperand()));
+      getOrCreateAAFor<AAAddressSpaceInfo>(
+          IRPosition::value(*cast<StoreInst>(I).getPointerOperand()));
+    }
     return true;
   };
   Success = checkForAllInstructionsImpl(
       nullptr, OpcodeInstMap, LoadStorePred, nullptr, nullptr,
       {(unsigned)Instruction::Load, (unsigned)Instruction::Store},
       UsedAssumedInformation);
   (void)Success;
   assert(Success && "Expected the check call to be successful!");

llvm/lib/Transforms/IPO/AttributorAttributes.cpp

 PIPE_OPERATOR(AAPrivatizablePtr)
 PIPE_OPERATOR(AAUndefinedBehavior)
 PIPE_OPERATOR(AAPotentialValues)
 PIPE_OPERATOR(AANoUndef)
 PIPE_OPERATOR(AACallEdges)
 PIPE_OPERATOR(AAFunctionReachability)
 PIPE_OPERATOR(AAPointerInfo)
 PIPE_OPERATOR(AAAssumptionInfo)
+PIPE_OPERATOR(AAAddressSpaceInfo)
 
 #undef PIPE_OPERATOR
 
 template <>
 ChangeStatus clampStateAndIndicateChange<DerefState>(DerefState &S,
                                                      const DerefState &R) {
   ChangeStatus CS0 =
       clampStateAndIndicateChange(S.DerefBytesState, R.DerefBytesState);
private:
   /// Used to answer if a call base inside this function can reach a specific
   /// function.
   DenseMap<const CallBase *, QueryResolver> CBQueries;
 
   /// This is for instruction queries than scan "forward".
   DenseMap<const Instruction *, QueryResolver> InstQueries;
 };
 
+/// ------------------------ Address Space Propagation -------------------------
+struct AAAddressSpaceInfoImpl : public AAAddressSpaceInfo {
+  AAAddressSpaceInfoImpl(const IRPosition &IRP, Attributor &A)
+      : AAAddressSpaceInfo(IRP, A) {}
+
+  uint32_t getAddressSpace() const override {
+    if (!isValidState())
+      return getWorstState();
+    return getAssumed();
+  }
+
+  /// See AbstractAttribute::initialize(...).
+  void initialize(Attributor &A) override {
+    assert(getAssociatedType()->isPointerTy() &&
+           "Cannot deduce address space of value that is not a pointer");
+
+    A.getAAFor<AAIsDead>(*this, getIRPosition(), DepClassTy::NONE);
+  }
+
+  ChangeStatus updateImpl(Attributor &A) override {
+    SmallVector<Value *, 16> Objects;
+    bool UsedAssumedInformation = false;
+    if (!AA::getAssumedUnderlyingObjects(A, getAssociatedValue(), Objects, *this,
+                                    getCtxI(), UsedAssumedInformation))
+      return indicatePessimisticFixpoint();
+
+    // We can infer the address space if each underlying object has the same
+    // address space or at least one that is the same on the target.
+    uint32_t AddressSpace = getAssumed();
+    for (Value *Obj : Objects) {
+      if (isa<UndefValue>(Obj))
+        continue;
+
+      uint32_t NewAddressSpace = Obj->getType()->getPointerAddressSpace();
+
+      if (AddressSpace == getBestState()) {
+        AddressSpace = NewAddressSpace;
+      } else if (AddressSpace != NewAddressSpace) {
+        AddressSpace = getWorstState();
+        break;
+      }
+    }
+
+    return takeAssumedMinimum(AddressSpace).getAssumed() == AddressSpace
+               ? ChangeStatus::UNCHANGED
+               : ChangeStatus::CHANGED;
+  };
+
+  /// See AbstractAttribute::manifest(...).
+  ChangeStatus manifest(Attributor &A) override {
+    Instruction *CtxI = getCtxI();
+    Value *AssociatedValue = &getAssociatedValue();
+    if (!CtxI || getKnown() == getBestState() ||
+        getKnown() == getAssociatedType()->getPointerAddressSpace())
+      return ChangeStatus::UNCHANGED;
+
+    Type *NewPtrTy = PointerType::getWithSamePointeeType(
+        cast<PointerType>(AssociatedValue->getType()), getKnown());
+    Instruction *Cast = new AddrSpaceCastInst(AssociatedValue, NewPtrTy);
+    Cast->insertAfter(CtxI);
+
+    // Cast the pointer to the inferred address space and replace the uses with
+    // it. If the pointer is considered dead don't bother removing it.
+    for (User *U : AssociatedValue->users()) {
+      const IRPosition &InstPos = IRPosition::inst(*cast<Instruction>(U));
+      bool UsedAssumedInformation = false;
+      auto &LivenessAA =
+          A.getAAFor<AAIsDead>(*this, InstPos, DepClassTy::REQUIRED);
+      if (A.isAssumedDead(InstPos, this, &LivenessAA, UsedAssumedInformation))
+        continue;
+
+      if (auto *LI = dyn_cast<LoadInst>(U)) {
+        Value *NewV = new LoadInst(LI->getType(), Cast, "",
+                                   LI->isVolatile(), LI->getAlign(),
+                                   LI->getOrdering(), LI->getSyncScopeID(), LI);
+        A.changeValueAfterManifest(*LI, *NewV, true, true);
+        A.deleteAfterManifest(*LI);
+      } else if (auto *SI = dyn_cast<StoreInst>(U)) {
+        Value *NewV = new StoreInst(
+            SI->getValueOperand(), Cast, SI->isVolatile(), SI->getAlign(),
+            SI->getOrdering(), SI->getSyncScopeID(), SI);
+        A.changeValueAfterManifest(*SI, *NewV, true, true);
+        A.deleteAfterManifest(*SI);
+      }
+    }
+
+    return ChangeStatus::CHANGED;
+  }
+
+  /// See AbstractAttribute::getAsStr().
+  const std::string getAsStr() const override {
+    return "Address Space: " + std::to_string(getAssumed());
+  }
+};
+
+struct AAAddressSpaceInfoFloating final : AAAddressSpaceInfoImpl {
+  AAAddressSpaceInfoFloating(const IRPosition &IRP, Attributor &A)
+      : AAAddressSpaceInfoImpl(IRP, A) {}
+
+  void trackStatistics() const override {}
+};
+struct AAAddressSpaceInfoReturned final : AAAddressSpaceInfoImpl {
+  AAAddressSpaceInfoReturned(const IRPosition &IRP, Attributor &A)
+      : AAAddressSpaceInfoImpl(IRP, A) {}
+
+  void trackStatistics() const override {}
+};
+struct AAAddressSpaceInfoCallSiteReturned final : AAAddressSpaceInfoImpl {
+  AAAddressSpaceInfoCallSiteReturned(const IRPosition &IRP, Attributor &A)
+      : AAAddressSpaceInfoImpl(IRP, A) {}
+
+  void trackStatistics() const override {}
+};
+struct AAAddressSpaceInfoArgument final : AAAddressSpaceInfoImpl {
+  AAAddressSpaceInfoArgument(const IRPosition &IRP, Attributor &A)
+      : AAAddressSpaceInfoImpl(IRP, A) {}
+
+  void trackStatistics() const override {}
+};
+struct AAAddressSpaceInfoCallSiteArgument final : AAAddressSpaceInfoImpl {
+  AAAddressSpaceInfoCallSiteArgument(const IRPosition &IRP, Attributor &A)
+      : AAAddressSpaceInfoImpl(IRP, A) {}
+
+  ChangeStatus updateImpl(Attributor &A) override {
+    return ChangeStatus::UNCHANGED;
+  };
+
+  void trackStatistics() const override {}
+};
+
 /// ---------------------- Assumption Propagation ------------------------------
 struct AAAssumptionInfoImpl : public AAAssumptionInfo {
   AAAssumptionInfoImpl(const IRPosition &IRP, Attributor &A,
                        const DenseSet<StringRef> &Known)
       : AAAssumptionInfo(IRP, A, Known) {}
 
   bool hasAssumption(const StringRef Assumption) const override {
     return isValidState() && setContains(Assumption);

 
 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 AANoRecurse::ID = 0;
 const char AAWillReturn::ID = 0;
 const char AAUndefinedBehavior::ID = 0;
 const char AANoAlias::ID = 0;
 const char AAReachability::ID = 0;
 const char AANoReturn::ID = 0;
 const char AAIsDead::ID = 0;
 const char AADereferenceable::ID = 0;
 const char AAAlign::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 AAPotentialValues::ID = 0;
 const char AANoUndef::ID = 0;
 const char AACallEdges::ID = 0;
 const char AAFunctionReachability::ID = 0;
 const char AAPointerInfo::ID = 0;
 const char AAAssumptionInfo::ID = 0;
+const char AAAddressSpaceInfo::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")                             \
       SWITCH_PK_INV(CLASS, IRP_RETURNED, "returned")                           \
       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_CALL_SITE_RETURNED, CallSiteReturned)   \

 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(AANoCapture)
 CREATE_VALUE_ABSTRACT_ATTRIBUTE_FOR_POSITION(AAValueConstantRange)
 CREATE_VALUE_ABSTRACT_ATTRIBUTE_FOR_POSITION(AAPotentialValues)
 CREATE_VALUE_ABSTRACT_ATTRIBUTE_FOR_POSITION(AANoUndef)
 CREATE_VALUE_ABSTRACT_ATTRIBUTE_FOR_POSITION(AAPointerInfo)
+CREATE_VALUE_ABSTRACT_ATTRIBUTE_FOR_POSITION(AAAddressSpaceInfo)
 
 CREATE_ALL_ABSTRACT_ATTRIBUTE_FOR_POSITION(AAValueSimplify)
 CREATE_ALL_ABSTRACT_ATTRIBUTE_FOR_POSITION(AAIsDead)
 CREATE_ALL_ABSTRACT_ATTRIBUTE_FOR_POSITION(AANoFree)
 
 CREATE_FUNCTION_ONLY_ABSTRACT_ATTRIBUTE_FOR_POSITION(AAHeapToStack)
 CREATE_FUNCTION_ONLY_ABSTRACT_ATTRIBUTE_FOR_POSITION(AAReachability)
 CREATE_FUNCTION_ONLY_ABSTRACT_ATTRIBUTE_FOR_POSITION(AAUndefinedBehavior)
 CREATE_FUNCTION_ONLY_ABSTRACT_ATTRIBUTE_FOR_POSITION(AAFunctionReachability)
 

llvm/test/Transforms/Attributor/ArgumentPromotion/alloca-as.ll

 ; IS__TUNIT_NPM-NEXT:    ret i32 [[L]]
 ;
 ; IS__CGSCC_NPM-LABEL: define {{[^@]+}}@foo
 ; IS__CGSCC_NPM-SAME: (i32 returned [[TMP0:%.*]]) {
 ; IS__CGSCC_NPM-NEXT:  entry:
 ; IS__CGSCC_NPM-NEXT:    [[ARG_PRIV:%.*]] = alloca i32, align 4, addrspace(7)
 ; IS__CGSCC_NPM-NEXT:    store i32 [[TMP0]], i32 addrspace(7)* [[ARG_PRIV]], align 4
 ; IS__CGSCC_NPM-NEXT:    [[TMP1:%.*]] = addrspacecast i32 addrspace(7)* [[ARG_PRIV]] to i32*
+; IS__CGSCC_NPM-NEXT:    [[TMP2:%.*]] = addrspacecast i32* [[TMP1]] to i32 addrspace(7)*
+; IS__CGSCC_NPM-NEXT:    [[L1:%.*]] = load i32, i32 addrspace(7)* [[TMP2]], align 4
 ; IS__CGSCC_NPM-NEXT:    [[L:%.*]] = load i32, i32* [[TMP1]], align 4
 ; IS__CGSCC_NPM-NEXT:    call void @use(i32 [[TMP0]])
 ; IS__CGSCC_NPM-NEXT:    ret i32 [[TMP0]]
 ;
 entry:
   %l = load i32, i32* %arg
   call void @use(i32 %l)
   ret i32 %l
 }
 
 declare void @use(i32)

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

 ; IS__TUNIT_OPM-NEXT:    call void @vfu1(%struct.MYstr* nocapture nofree noundef nonnull readonly byval([[STRUCT_MYSTR:%.*]]) align 8 dereferenceable(8) @mystr) #[[ATTR0]]
 ; IS__TUNIT_OPM-NEXT:    [[RESULT:%.*]] = call i32 @vfu2(%struct.MYstr* nocapture nofree noundef nonnull readonly byval([[STRUCT_MYSTR]]) align 8 dereferenceable(8) @mystr) #[[ATTR2:[0-9]+]]
 ; IS__TUNIT_OPM-NEXT:    ret i32 [[RESULT]]
 ;
 ; IS__TUNIT_NPM: Function Attrs: nounwind
 ; IS__TUNIT_NPM-LABEL: define {{[^@]+}}@unions
 ; IS__TUNIT_NPM-SAME: () #[[ATTR0]] {
 ; IS__TUNIT_NPM-NEXT:  entry:
-; IS__TUNIT_NPM-NEXT:    [[MYSTR_CAST1:%.*]] = bitcast %struct.MYstr* @mystr to i8*
-; IS__TUNIT_NPM-NEXT:    [[TMP0:%.*]] = load i8, i8* [[MYSTR_CAST1]], align 8
-; IS__TUNIT_NPM-NEXT:    [[MYSTR_0_12:%.*]] = getelementptr [[STRUCT_MYSTR:%.*]], %struct.MYstr* @mystr, i64 0, i32 1
-; IS__TUNIT_NPM-NEXT:    [[TMP1:%.*]] = load i32, i32* [[MYSTR_0_12]], align 8
-; IS__TUNIT_NPM-NEXT:    call void @vfu1(i8 [[TMP0]], i32 [[TMP1]]) #[[ATTR0]]
 ; IS__TUNIT_NPM-NEXT:    [[MYSTR_CAST:%.*]] = bitcast %struct.MYstr* @mystr to i8*
-; IS__TUNIT_NPM-NEXT:    [[TMP2:%.*]] = load i8, i8* [[MYSTR_CAST]], align 8
-; IS__TUNIT_NPM-NEXT:    [[MYSTR_0_1:%.*]] = getelementptr [[STRUCT_MYSTR]], %struct.MYstr* @mystr, i64 0, i32 1
-; IS__TUNIT_NPM-NEXT:    [[TMP3:%.*]] = load i32, i32* [[MYSTR_0_1]], align 8
+; IS__TUNIT_NPM-NEXT:    [[TMP0:%.*]] = load i8, i8* [[MYSTR_CAST]], align 8
+; IS__TUNIT_NPM-NEXT:    [[MYSTR_0_1:%.*]] = getelementptr [[STRUCT_MYSTR:%.*]], %struct.MYstr* @mystr, i64 0, i32 1
+; IS__TUNIT_NPM-NEXT:    [[TMP1:%.*]] = load i32, i32* [[MYSTR_0_1]], align 8
+; IS__TUNIT_NPM-NEXT:    call void @vfu1(i8 [[TMP0]], i32 [[TMP1]]) #[[ATTR0]]
+; IS__TUNIT_NPM-NEXT:    [[MYSTR_CAST1:%.*]] = bitcast %struct.MYstr* @mystr to i8*
+; IS__TUNIT_NPM-NEXT:    [[TMP2:%.*]] = load i8, i8* [[MYSTR_CAST1]], align 8
+; IS__TUNIT_NPM-NEXT:    [[MYSTR_0_12:%.*]] = getelementptr [[STRUCT_MYSTR]], %struct.MYstr* @mystr, i64 0, i32 1
+; IS__TUNIT_NPM-NEXT:    [[TMP3:%.*]] = load i32, i32* [[MYSTR_0_12]], align 8
 ; IS__TUNIT_NPM-NEXT:    [[RESULT:%.*]] = call i32 @vfu2(i8 [[TMP2]], i32 [[TMP3]]) #[[ATTR2:[0-9]+]]
 ; IS__TUNIT_NPM-NEXT:    ret i32 [[RESULT]]
 ;
 ; IS__CGSCC_OPM: Function Attrs: nounwind
 ; IS__CGSCC_OPM-LABEL: define {{[^@]+}}@unions
 ; IS__CGSCC_OPM-SAME: () #[[ATTR0]] {
 ; IS__CGSCC_OPM-NEXT:  entry:
 ; IS__CGSCC_OPM-NEXT:    call void @vfu1(%struct.MYstr* noalias nocapture nofree noundef nonnull readonly byval([[STRUCT_MYSTR:%.*]]) align 8 dereferenceable(8) @mystr) #[[ATTR0]]

 ; IS__CGSCC_NPM-LABEL: define {{[^@]+}}@vfu2_v2
 ; IS__CGSCC_NPM-SAME: (i8 [[TMP0:%.*]], i32 [[TMP1:%.*]]) #[[ATTR1]] {
 ; IS__CGSCC_NPM-NEXT:  entry:
 ; IS__CGSCC_NPM-NEXT:    [[U_PRIV:%.*]] = alloca [[STRUCT_MYSTR:%.*]], align 8
 ; IS__CGSCC_NPM-NEXT:    [[U_PRIV_CAST:%.*]] = bitcast %struct.MYstr* [[U_PRIV]] to i8*
 ; IS__CGSCC_NPM-NEXT:    [[U_PRIV_0_1:%.*]] = getelementptr [[STRUCT_MYSTR]], %struct.MYstr* [[U_PRIV]], i64 0, i32 1
 ; IS__CGSCC_NPM-NEXT:    [[Z:%.*]] = getelementptr [[STRUCT_MYSTR]], %struct.MYstr* [[U_PRIV]], i32 0, i32 1
 ; IS__CGSCC_NPM-NEXT:    [[TMP2:%.*]] = getelementptr [[STRUCT_MYSTR]], %struct.MYstr* [[U_PRIV]], i32 0, i32 1
-; IS__CGSCC_NPM-NEXT:    [[TMP3:%.*]] = load i32, i32* [[TMP2]], align 4
+; IS__CGSCC_NPM-NEXT:    [[TMP3:%.*]] = load i32, i32* undef, align 4
 ; IS__CGSCC_NPM-NEXT:    [[TMP4:%.*]] = getelementptr [[STRUCT_MYSTR]], %struct.MYstr* [[U_PRIV]], i32 0, i32 0
-; IS__CGSCC_NPM-NEXT:    [[TMP5:%.*]] = load i8, i8* [[TMP4]], align 8
+; IS__CGSCC_NPM-NEXT:    [[TMP5:%.*]] = load i8, i8* undef, align 8
 ; IS__CGSCC_NPM-NEXT:    [[TMP6:%.*]] = zext i8 0 to i32
 ; IS__CGSCC_NPM-NEXT:    [[TMP7:%.*]] = add i32 0, 99
 ; IS__CGSCC_NPM-NEXT:    ret i32 undef
 ;
 entry:
   %z = getelementptr %struct.MYstr, %struct.MYstr* %u, i32 0, i32 1
   store i32 99, i32* %z, align 4
   %0 = getelementptr %struct.MYstr, %struct.MYstr* %u, i32 0, i32 1 ; <i32*> [#uses=1]

 ; IS__TUNIT_OPM-NEXT:    call void @vfu1(%struct.MYstr* nocapture nofree noundef nonnull readonly byval([[STRUCT_MYSTR:%.*]]) align 8 dereferenceable(8) @mystr) #[[ATTR0]]
 ; IS__TUNIT_OPM-NEXT:    [[RESULT:%.*]] = call i32 @vfu2_v2(%struct.MYstr* nocapture nofree noundef nonnull readonly byval([[STRUCT_MYSTR]]) align 8 dereferenceable(8) @mystr) #[[ATTR2]]
 ; IS__TUNIT_OPM-NEXT:    ret i32 [[RESULT]]
 ;
 ; IS__TUNIT_NPM: Function Attrs: nounwind
 ; IS__TUNIT_NPM-LABEL: define {{[^@]+}}@unions_v2
 ; IS__TUNIT_NPM-SAME: () #[[ATTR0]] {
 ; IS__TUNIT_NPM-NEXT:  entry:
-; IS__TUNIT_NPM-NEXT:    [[MYSTR_CAST1:%.*]] = bitcast %struct.MYstr* @mystr to i8*
-; IS__TUNIT_NPM-NEXT:    [[TMP0:%.*]] = load i8, i8* [[MYSTR_CAST1]], align 8
-; IS__TUNIT_NPM-NEXT:    [[MYSTR_0_12:%.*]] = getelementptr [[STRUCT_MYSTR:%.*]], %struct.MYstr* @mystr, i64 0, i32 1
-; IS__TUNIT_NPM-NEXT:    [[TMP1:%.*]] = load i32, i32* [[MYSTR_0_12]], align 8
-; IS__TUNIT_NPM-NEXT:    call void @vfu1(i8 [[TMP0]], i32 [[TMP1]]) #[[ATTR0]]
 ; IS__TUNIT_NPM-NEXT:    [[MYSTR_CAST:%.*]] = bitcast %struct.MYstr* @mystr to i8*
-; IS__TUNIT_NPM-NEXT:    [[TMP2:%.*]] = load i8, i8* [[MYSTR_CAST]], align 8
-; IS__TUNIT_NPM-NEXT:    [[MYSTR_0_1:%.*]] = getelementptr [[STRUCT_MYSTR]], %struct.MYstr* @mystr, i64 0, i32 1
-; IS__TUNIT_NPM-NEXT:    [[TMP3:%.*]] = load i32, i32* [[MYSTR_0_1]], align 8
+; IS__TUNIT_NPM-NEXT:    [[TMP0:%.*]] = load i8, i8* [[MYSTR_CAST]], align 8
+; IS__TUNIT_NPM-NEXT:    [[MYSTR_0_1:%.*]] = getelementptr [[STRUCT_MYSTR:%.*]], %struct.MYstr* @mystr, i64 0, i32 1
+; IS__TUNIT_NPM-NEXT:    [[TMP1:%.*]] = load i32, i32* [[MYSTR_0_1]], align 8
+; IS__TUNIT_NPM-NEXT:    call void @vfu1(i8 [[TMP0]], i32 [[TMP1]]) #[[ATTR0]]
+; IS__TUNIT_NPM-NEXT:    [[MYSTR_CAST1:%.*]] = bitcast %struct.MYstr* @mystr to i8*
+; IS__TUNIT_NPM-NEXT:    [[TMP2:%.*]] = load i8, i8* [[MYSTR_CAST1]], align 8
+; IS__TUNIT_NPM-NEXT:    [[MYSTR_0_12:%.*]] = getelementptr [[STRUCT_MYSTR]], %struct.MYstr* @mystr, i64 0, i32 1
+; IS__TUNIT_NPM-NEXT:    [[TMP3:%.*]] = load i32, i32* [[MYSTR_0_12]], align 8
 ; IS__TUNIT_NPM-NEXT:    [[RESULT:%.*]] = call i32 @vfu2_v2(i8 [[TMP2]], i32 [[TMP3]]) #[[ATTR2]]
 ; IS__TUNIT_NPM-NEXT:    ret i32 [[RESULT]]
 ;
 ; IS__CGSCC_OPM: Function Attrs: nounwind
 ; IS__CGSCC_OPM-LABEL: define {{[^@]+}}@unions_v2
 ; IS__CGSCC_OPM-SAME: () #[[ATTR0]] {
 ; IS__CGSCC_OPM-NEXT:  entry:
 ; IS__CGSCC_OPM-NEXT:    call void @vfu1(%struct.MYstr* noalias nocapture nofree noundef nonnull readonly byval([[STRUCT_MYSTR:%.*]]) align 8 dereferenceable(8) @mystr) #[[ATTR0]]

llvm/test/Transforms/Attributor/IPConstantProp/PR26044.ll

 ; IS__TUNIT_OPM: Function Attrs: nofree norecurse nosync nounwind null_pointer_is_valid
 ; IS__TUNIT_OPM-LABEL: define {{[^@]+}}@fn_no_null_opt
 ; IS__TUNIT_OPM-SAME: (i32* nocapture nofree writeonly [[P:%.*]], i1 [[C:%.*]]) #[[ATTR2:[0-9]+]] {
 ; IS__TUNIT_OPM-NEXT:  entry:
 ; IS__TUNIT_OPM-NEXT:    br label [[IF_END:%.*]]
 ; IS__TUNIT_OPM:       for.cond1:
 ; IS__TUNIT_OPM-NEXT:    br i1 [[C]], label [[IF_END]], label [[EXIT:%.*]]
 ; IS__TUNIT_OPM:       if.end:
-; IS__TUNIT_OPM-NEXT:    [[E_2:%.*]] = phi i32* [ undef, [[ENTRY:%.*]] ], [ null, [[FOR_COND1:%.*]] ]
 ; IS__TUNIT_OPM-NEXT:    [[TMP0:%.*]] = load i32, i32* null, align 4
 ; IS__TUNIT_OPM-NEXT:    [[CALL:%.*]] = call i32 @fn0(i32 [[TMP0]]) #[[ATTR3]]
 ; IS__TUNIT_OPM-NEXT:    store i32 [[CALL]], i32* [[P]], align 4
-; IS__TUNIT_OPM-NEXT:    br label [[FOR_COND1]]
+; IS__TUNIT_OPM-NEXT:    br label [[FOR_COND1:%.*]]
 ; IS__TUNIT_OPM:       exit:
 ; IS__TUNIT_OPM-NEXT:    ret void
 ;
 ; IS__TUNIT_NPM: Function Attrs: nofree norecurse nosync nounwind null_pointer_is_valid
 ; IS__TUNIT_NPM-LABEL: define {{[^@]+}}@fn_no_null_opt
 ; IS__TUNIT_NPM-SAME: (i32* nocapture nofree writeonly [[P:%.*]], i1 [[C:%.*]]) #[[ATTR1:[0-9]+]] {
 ; IS__TUNIT_NPM-NEXT:  entry:
 ; IS__TUNIT_NPM-NEXT:    br label [[IF_END:%.*]]
 ; IS__TUNIT_NPM:       for.cond1:
 ; IS__TUNIT_NPM-NEXT:    br i1 [[C]], label [[IF_END]], label [[EXIT:%.*]]
 ; IS__TUNIT_NPM:       if.end:
-; IS__TUNIT_NPM-NEXT:    [[E_2:%.*]] = phi i32* [ undef, [[ENTRY:%.*]] ], [ null, [[FOR_COND1:%.*]] ]
 ; IS__TUNIT_NPM-NEXT:    [[TMP0:%.*]] = load i32, i32* null, align 4
 ; IS__TUNIT_NPM-NEXT:    store i32 [[TMP0]], i32* [[P]], align 4
-; IS__TUNIT_NPM-NEXT:    br label [[FOR_COND1]]
+; IS__TUNIT_NPM-NEXT:    br label [[FOR_COND1:%.*]]
 ; IS__TUNIT_NPM:       exit:
 ; IS__TUNIT_NPM-NEXT:    ret void
 ;
 ; IS__CGSCC_OPM: Function Attrs: nofree norecurse nosync nounwind null_pointer_is_valid
 ; IS__CGSCC_OPM-LABEL: define {{[^@]+}}@fn_no_null_opt
 ; IS__CGSCC_OPM-SAME: (i32* nocapture nofree writeonly align 4 dereferenceable_or_null(4) [[P:%.*]], i1 [[C:%.*]]) #[[ATTR2:[0-9]+]] {
 ; IS__CGSCC_OPM-NEXT:  entry:
 ; IS__CGSCC_OPM-NEXT:    br label [[IF_END:%.*]]

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 -attributor -enable-new-pm=0 -attributor-manifest-internal  -attributor-max-iterations-verify -attributor-annotate-decl-cs -attributor-max-iterations=2 -S < %s | FileCheck %s --check-prefixes=CHECK,NOT_CGSCC_NPM,NOT_CGSCC_OPM,NOT_TUNIT_NPM,IS__TUNIT____,IS________OPM,IS__TUNIT_OPM
+; RUN: opt -aa-pipeline=basic-aa -passes=attributor -attributor-manifest-internal  -attributor-max-iterations-verify -attributor-annotate-decl-cs -attributor-max-iterations=2 -S < %s | FileCheck %s --check-prefixes=CHECK,NOT_CGSCC_OPM,NOT_CGSCC_NPM,NOT_TUNIT_OPM,IS__TUNIT____,IS________NPM,IS__TUNIT_NPM
+; RUN: opt -attributor-cgscc -enable-new-pm=0 -attributor-manifest-internal  -attributor-annotate-decl-cs -S < %s | FileCheck %s --check-prefixes=CHECK,NOT_TUNIT_NPM,NOT_TUNIT_OPM,NOT_CGSCC_NPM,IS__CGSCC____,IS________OPM,IS__CGSCC_OPM
+; RUN: opt -aa-pipeline=basic-aa -passes=attributor-cgscc -attributor-manifest-internal  -attributor-annotate-decl-cs -S < %s | FileCheck %s --check-prefixes=CHECK,NOT_TUNIT_NPM,NOT_TUNIT_OPM,NOT_CGSCC_OPM,IS__CGSCC____,IS________NPM,IS__CGSCC_NPM
+
+define float @load_global_from_flat(float* %generic_scalar) #0 {
+;
+; CHECK: Function Attrs: argmemonly nofree norecurse nosync nounwind readonly willreturn
+; CHECK-LABEL: define {{[^@]+}}@load_global_from_flat
+; CHECK-SAME: (float* nocapture nofree readonly align 4 dereferenceable_or_null(4) [[GENERIC_SCALAR:%.*]]) #[[ATTR0:[0-9]+]] {
+; CHECK-NEXT:    [[TRUETMP0:%.*]] = addrspacecast float* [[GENERIC_SCALAR]] to float addrspace(1)*
+; CHECK-NEXT:    [[TRUETMP1:%.*]] = load float, float addrspace(1)* [[TRUETMP0]], align 4
+; CHECK-NEXT:    ret float [[TRUETMP1]]
+;
+  %tmp0 = addrspacecast float* %generic_scalar to float addrspace(1)*
+  %tmp1 = load float, float addrspace(1)* %tmp0
+  ret float %tmp1
+}
+
+define float @load_constant_from_flat(float* %generic_scalar) #0 {
+;
+;
+; CHECK: Function Attrs: argmemonly nofree norecurse nosync nounwind readonly willreturn
+; CHECK-LABEL: define {{[^@]+}}@load_constant_from_flat
+; CHECK-SAME: (float* nocapture nofree readonly align 4 dereferenceable_or_null(4) [[GENERIC_SCALAR:%.*]]) #[[ATTR0]] {
+; CHECK-NEXT:    [[TRUETMP0:%.*]] = addrspacecast float* [[GENERIC_SCALAR]] to float addrspace(4)*
+; CHECK-NEXT:    [[TRUETMP1:%.*]] = load float, float addrspace(4)* [[TRUETMP0]], align 4
+; CHECK-NEXT:    ret float [[TRUETMP1]]
+;
+  %tmp0 = addrspacecast float* %generic_scalar to float addrspace(4)*
+  %tmp1 = load float, float addrspace(4)* %tmp0
+  ret float %tmp1
+}
+
+define float @load_group_from_flat(float* %generic_scalar) #0 {
+;
+;
+; CHECK: Function Attrs: argmemonly nofree norecurse nosync nounwind readonly willreturn
+; CHECK-LABEL: define {{[^@]+}}@load_group_from_flat
+; CHECK-SAME: (float* nocapture nofree readonly align 4 dereferenceable_or_null(4) [[GENERIC_SCALAR:%.*]]) #[[ATTR0]] {
+; CHECK-NEXT:    [[TRUETMP0:%.*]] = addrspacecast float* [[GENERIC_SCALAR]] to float addrspace(3)*
+; CHECK-NEXT:    [[TRUETMP1:%.*]] = load float, float addrspace(3)* [[TRUETMP0]], align 4
+; CHECK-NEXT:    ret float [[TRUETMP1]]
+;
+  %tmp0 = addrspacecast float* %generic_scalar to float addrspace(3)*
+  %tmp1 = load float, float addrspace(3)* %tmp0
+  ret float %tmp1
+}
+
+define float @load_private_from_flat(float* %generic_scalar) #0 {
+;
+; CHECK: Function Attrs: argmemonly nofree norecurse nosync nounwind readonly willreturn
+; CHECK-LABEL: define {{[^@]+}}@load_private_from_flat
+; CHECK-SAME: (float* nocapture nofree readonly align 4 dereferenceable_or_null(4) [[GENERIC_SCALAR:%.*]]) #[[ATTR0]] {
+; CHECK-NEXT:    [[TRUETMP0:%.*]] = addrspacecast float* [[GENERIC_SCALAR]] to float addrspace(5)*
+; CHECK-NEXT:    [[TRUETMP1:%.*]] = load float, float addrspace(5)* [[TRUETMP0]], align 4
+; CHECK-NEXT:    ret float [[TRUETMP1]]
+;
+  %tmp0 = addrspacecast float* %generic_scalar to float addrspace(5)*
+  %tmp1 = load float, float addrspace(5)* %tmp0
+  ret float %tmp1
+}
+
+define void @store_global_from_flat(float* %generic_scalar) #0 {
+;
+;
+; CHECK: Function Attrs: argmemonly nofree norecurse nosync nounwind willreturn writeonly
+; CHECK-LABEL: define {{[^@]+}}@store_global_from_flat
+; CHECK-SAME: (float* nocapture nofree writeonly align 4 dereferenceable_or_null(4) [[GENERIC_SCALAR:%.*]]) #[[ATTR1:[0-9]+]] {
+; CHECK-NEXT:    [[TRUETMP0:%.*]] = addrspacecast float* [[GENERIC_SCALAR]] to float addrspace(1)*
+; CHECK-NEXT:    store float 0.000000e+00, float addrspace(1)* [[TRUETMP0]], align 4
+; CHECK-NEXT:    ret void
+;
+  %tmp0 = addrspacecast float* %generic_scalar to float addrspace(1)*
+  store float 0.0, float addrspace(1)* %tmp0
+  ret void
+}
+
+define void @store_group_from_flat(float* %generic_scalar) #0 {
+;
+;
+; CHECK: Function Attrs: argmemonly nofree norecurse nosync nounwind willreturn writeonly
+; CHECK-LABEL: define {{[^@]+}}@store_group_from_flat
+; CHECK-SAME: (float* nocapture nofree writeonly align 4 dereferenceable_or_null(4) [[GENERIC_SCALAR:%.*]]) #[[ATTR1]] {
+; CHECK-NEXT:    [[TRUETMP0:%.*]] = addrspacecast float* [[GENERIC_SCALAR]] to float addrspace(3)*
+; CHECK-NEXT:    store float 0.000000e+00, float addrspace(3)* [[TRUETMP0]], align 4
+; CHECK-NEXT:    ret void
+;
+  %tmp0 = addrspacecast float* %generic_scalar to float addrspace(3)*
+  store float 0.0, float addrspace(3)* %tmp0
+  ret void
+}
+
+define void @store_private_from_flat(float* %generic_scalar) #0 {
+;
+;
+; CHECK: Function Attrs: argmemonly nofree norecurse nosync nounwind willreturn writeonly
+; CHECK-LABEL: define {{[^@]+}}@store_private_from_flat
+; CHECK-SAME: (float* nocapture nofree writeonly align 4 dereferenceable_or_null(4) [[GENERIC_SCALAR:%.*]]) #[[ATTR1]] {
+; CHECK-NEXT:    [[TRUETMP0:%.*]] = addrspacecast float* [[GENERIC_SCALAR]] to float addrspace(5)*
+; CHECK-NEXT:    store float 0.000000e+00, float addrspace(5)* [[TRUETMP0]], align 4
+; CHECK-NEXT:    ret void
+;
+  %tmp0 = addrspacecast float* %generic_scalar to float addrspace(5)*
+  store float 0.0, float addrspace(5)* %tmp0
+  ret void
+}
+
+; optimized to global load/store.
+
+define void @load_store_global(i32 addrspace(1)* nocapture %input, i32 addrspace(1)* nocapture %output) #0 {
+;
+; CHECK: Function Attrs: argmemonly nofree norecurse nosync nounwind willreturn
+; CHECK-LABEL: define {{[^@]+}}@load_store_global
+; CHECK-SAME: (i32 addrspace(1)* nocapture nofree nonnull readonly align 4 dereferenceable(4) [[INPUT:%.*]], i32 addrspace(1)* nocapture nofree nonnull writeonly align 4 dereferenceable(4) [[OUTPUT:%.*]]) #[[ATTR2:[0-9]+]] {
+; CHECK-NEXT:    [[CAST0:%.*]] = addrspacecast i32 addrspace(1)* [[INPUT]] to i32*
+; CHECK-NEXT:    [[TMP1:%.*]] = addrspacecast i32* [[CAST0]] to i32 addrspace(1)*
+; CHECK-NEXT:    [[CAST1:%.*]] = addrspacecast i32 addrspace(1)* [[OUTPUT]] to i32*
+; CHECK-NEXT:    [[TMP2:%.*]] = addrspacecast i32* [[CAST1]] to i32 addrspace(1)*
+; CHECK-NEXT:    [[VAL1:%.*]] = load i32, i32 addrspace(1)* [[TMP1]], align 4
+; CHECK-NEXT:    store i32 [[VAL1]], i32 addrspace(1)* [[TMP2]], align 4
+; CHECK-NEXT:    ret void
+;
+  %cast0 = addrspacecast i32 addrspace(1)* %input to i32*
+  %cast1 = addrspacecast i32 addrspace(1)* %output to i32*
+  %val = load i32, i32* %cast0, align 4
+  store i32 %val, i32* %cast1, align 4
+  ret void
+}
+
+; Optimized to group load/store.
+
+define void @load_store_group(i32 addrspace(3)* nocapture %input, i32 addrspace(3)* nocapture %output) #0 {
+;
+; CHECK: Function Attrs: argmemonly nofree norecurse nosync nounwind willreturn
+; CHECK-LABEL: define {{[^@]+}}@load_store_group
+; CHECK-SAME: (i32 addrspace(3)* nocapture nofree nonnull readonly align 4 dereferenceable(4) [[INPUT:%.*]], i32 addrspace(3)* nocapture nofree nonnull writeonly align 4 dereferenceable(4) [[OUTPUT:%.*]]) #[[ATTR2]] {
+; CHECK-NEXT:    [[TRUETMP0:%.*]] = addrspacecast i32 addrspace(3)* [[INPUT]] to i32*
+; CHECK-NEXT:    [[TMP1:%.*]] = addrspacecast i32* [[TRUETMP0]] to i32 addrspace(3)*
+; CHECK-NEXT:    [[TRUETMP1:%.*]] = addrspacecast i32 addrspace(3)* [[OUTPUT]] to i32*
+; CHECK-NEXT:    [[TMP2:%.*]] = addrspacecast i32* [[TRUETMP1]] to i32 addrspace(3)*
+; CHECK-NEXT:    [[VAL1:%.*]] = load i32, i32 addrspace(3)* [[TMP1]], align 4
+; CHECK-NEXT:    store i32 [[VAL1]], i32 addrspace(3)* [[TMP2]], align 4
+; CHECK-NEXT:    ret void
+;
+  %tmp0 = addrspacecast i32 addrspace(3)* %input to i32*
+  %tmp1 = addrspacecast i32 addrspace(3)* %output to i32*
+  %val = load i32, i32* %tmp0, align 4
+  store i32 %val, i32* %tmp1, align 4
+  ret void
+}
+
+; Optimized to private load/store.
+
+define void @load_store_private(i32 addrspace(5)* nocapture %input, i32 addrspace(5)* nocapture %output) #0 {
+;
+; CHECK: Function Attrs: argmemonly nofree norecurse nosync nounwind willreturn
+; CHECK-LABEL: define {{[^@]+}}@load_store_private
+; CHECK-SAME: (i32 addrspace(5)* nocapture nofree nonnull readonly align 4 dereferenceable(4) [[INPUT:%.*]], i32 addrspace(5)* nocapture nofree nonnull writeonly align 4 dereferenceable(4) [[OUTPUT:%.*]]) #[[ATTR2]] {
+; CHECK-NEXT:    [[TRUETMP0:%.*]] = addrspacecast i32 addrspace(5)* [[INPUT]] to i32*
+; CHECK-NEXT:    [[TMP1:%.*]] = addrspacecast i32* [[TRUETMP0]] to i32 addrspace(5)*
+; CHECK-NEXT:    [[TRUETMP1:%.*]] = addrspacecast i32 addrspace(5)* [[OUTPUT]] to i32*
+; CHECK-NEXT:    [[TMP2:%.*]] = addrspacecast i32* [[TRUETMP1]] to i32 addrspace(5)*
+; CHECK-NEXT:    [[VAL1:%.*]] = load i32, i32 addrspace(5)* [[TMP1]], align 4
+; CHECK-NEXT:    store i32 [[VAL1]], i32 addrspace(5)* [[TMP2]], align 4
+; CHECK-NEXT:    ret void
+;
+  %tmp0 = addrspacecast i32 addrspace(5)* %input to i32*
+  %tmp1 = addrspacecast i32 addrspace(5)* %output to i32*
+  %val = load i32, i32* %tmp0, align 4
+  store i32 %val, i32* %tmp1, align 4
+  ret void
+}
+
+; No optimization. flat load/store.
+
+define void @load_store_flat(i32* nocapture %input, i32* nocapture %output) #0 {
+;
+; CHECK: Function Attrs: argmemonly nofree norecurse nosync nounwind willreturn
+; CHECK-LABEL: define {{[^@]+}}@load_store_flat
+; CHECK-SAME: (i32* nocapture nofree noundef nonnull readonly align 4 dereferenceable(4) [[INPUT:%.*]], i32* nocapture nofree noundef nonnull writeonly align 4 dereferenceable(4) [[OUTPUT:%.*]]) #[[ATTR2]] {
+; CHECK-NEXT:    [[VAL:%.*]] = load i32, i32* [[INPUT]], align 4
+; CHECK-NEXT:    store i32 [[VAL]], i32* [[OUTPUT]], align 4
+; CHECK-NEXT:    ret void
+;
+  %val = load i32, i32* %input, align 4
+  store i32 %val, i32* %output, align 4
+  ret void
+}
+
+define void @store_addrspacecast_ptr_value(i32 addrspace(1)* nocapture %input, i32* addrspace(1)* nocapture %output) #0 {
+;
+; CHECK: Function Attrs: argmemonly nofree norecurse nosync nounwind willreturn writeonly
+; CHECK-LABEL: define {{[^@]+}}@store_addrspacecast_ptr_value
+; CHECK-SAME: (i32 addrspace(1)* nocapture nofree writeonly [[INPUT:%.*]], i32* addrspace(1)* nocapture nofree noundef writeonly align 4 dereferenceable_or_null(8) [[OUTPUT:%.*]]) #[[ATTR1]] {
+; CHECK-NEXT:    [[CAST:%.*]] = addrspacecast i32 addrspace(1)* [[INPUT]] to i32*
+; CHECK-NEXT:    store i32* [[CAST]], i32* addrspace(1)* [[OUTPUT]], align 4
+; CHECK-NEXT:    ret void
+;
+  %cast = addrspacecast i32 addrspace(1)* %input to i32*
+  store i32* %cast, i32* addrspace(1)* %output, align 4
+  ret void
+}
+
+define i32 @atomicrmw_add_global_to_flat(i32 addrspace(1)* %global.ptr, i32 %y) #0 {
+;
+; CHECK: Function Attrs: argmemonly nofree norecurse nounwind willreturn
+; CHECK-LABEL: define {{[^@]+}}@atomicrmw_add_global_to_flat
+; CHECK-SAME: (i32 addrspace(1)* nocapture nofree nonnull dereferenceable(4) [[GLOBAL_PTR:%.*]], i32 [[Y:%.*]]) #[[ATTR3:[0-9]+]] {
+; CHECK-NEXT:    [[CAST:%.*]] = addrspacecast i32 addrspace(1)* [[GLOBAL_PTR]] to i32*
+; CHECK-NEXT:    [[RET:%.*]] = atomicrmw add i32* [[CAST]], i32 [[Y]] seq_cst, align 4
+; CHECK-NEXT:    ret i32 [[RET]]
+;
+  %cast = addrspacecast i32 addrspace(1)* %global.ptr to i32*
+  %ret = atomicrmw add i32* %cast, i32 %y seq_cst
+  ret i32 %ret
+}
+
+define i32 @atomicrmw_add_group_to_flat(i32 addrspace(3)* %group.ptr, i32 %y) #0 {
+;
+; CHECK: Function Attrs: argmemonly nofree norecurse nounwind willreturn
+; CHECK-LABEL: define {{[^@]+}}@atomicrmw_add_group_to_flat
+; CHECK-SAME: (i32 addrspace(3)* nocapture nofree nonnull dereferenceable(4) [[GROUP_PTR:%.*]], i32 [[Y:%.*]]) #[[ATTR3]] {
+; CHECK-NEXT:    [[CAST:%.*]] = addrspacecast i32 addrspace(3)* [[GROUP_PTR]] to i32*
+; CHECK-NEXT:    [[RET:%.*]] = atomicrmw add i32* [[CAST]], i32 [[Y]] seq_cst, align 4
+; CHECK-NEXT:    ret i32 [[RET]]
+;
+  %cast = addrspacecast i32 addrspace(3)* %group.ptr to i32*
+  %ret = atomicrmw add i32* %cast, i32 %y seq_cst
+  ret i32 %ret
+}
+
+define { i32, i1 } @cmpxchg_global_to_flat(i32 addrspace(1)* %global.ptr, i32 %cmp, i32 %val) #0 {
+;
+; CHECK: Function Attrs: argmemonly nofree norecurse nounwind willreturn
+; CHECK-LABEL: define {{[^@]+}}@cmpxchg_global_to_flat
+; CHECK-SAME: (i32 addrspace(1)* nocapture nofree nonnull dereferenceable(4) [[GLOBAL_PTR:%.*]], i32 [[CMP:%.*]], i32 [[VAL:%.*]]) #[[ATTR3]] {
+; CHECK-NEXT:    [[CAST:%.*]] = addrspacecast i32 addrspace(1)* [[GLOBAL_PTR]] to i32*
+; CHECK-NEXT:    [[RET:%.*]] = cmpxchg i32* [[CAST]], i32 [[CMP]], i32 [[VAL]] seq_cst monotonic, align 4
+; CHECK-NEXT:    ret { i32, i1 } [[RET]]
+;
+  %cast = addrspacecast i32 addrspace(1)* %global.ptr to i32*
+  %ret = cmpxchg i32* %cast, i32 %cmp, i32 %val seq_cst monotonic
+  ret { i32, i1 } %ret
+}
+
+define { i32, i1 } @cmpxchg_group_to_flat(i32 addrspace(3)* %group.ptr, i32 %cmp, i32 %val) #0 {
+;
+; CHECK: Function Attrs: argmemonly nofree norecurse nounwind willreturn
+; CHECK-LABEL: define {{[^@]+}}@cmpxchg_group_to_flat
+; CHECK-SAME: (i32 addrspace(3)* nocapture nofree nonnull dereferenceable(4) [[GROUP_PTR:%.*]], i32 [[CMP:%.*]], i32 [[VAL:%.*]]) #[[ATTR3]] {
+; CHECK-NEXT:    [[CAST:%.*]] = addrspacecast i32 addrspace(3)* [[GROUP_PTR]] to i32*
+; CHECK-NEXT:    [[RET:%.*]] = cmpxchg i32* [[CAST]], i32 [[CMP]], i32 [[VAL]] seq_cst monotonic, align 4
+; CHECK-NEXT:    ret { i32, i1 } [[RET]]
+;
+  %cast = addrspacecast i32 addrspace(3)* %group.ptr to i32*
+  %ret = cmpxchg i32* %cast, i32 %cmp, i32 %val seq_cst monotonic
+  ret { i32, i1 } %ret
+}
+
+; Not pointer operand
+define { i32*, i1 } @cmpxchg_group_to_flat_wrong_operand(i32* addrspace(3)* %cas.ptr, i32 addrspace(3)* %cmp.ptr, i32* %val) #0 {
+;
+; CHECK: Function Attrs: argmemonly nofree norecurse nounwind willreturn
+; CHECK-LABEL: define {{[^@]+}}@cmpxchg_group_to_flat_wrong_operand
+; CHECK-SAME: (i32* addrspace(3)* nocapture nofree noundef dereferenceable_or_null(8) [[CAS_PTR:%.*]], i32 addrspace(3)* nofree [[CMP_PTR:%.*]], i32* nofree [[VAL:%.*]]) #[[ATTR3]] {
+; CHECK-NEXT:    [[CAST_CMP:%.*]] = addrspacecast i32 addrspace(3)* [[CMP_PTR]] to i32*
+; CHECK-NEXT:    [[RET:%.*]] = cmpxchg i32* addrspace(3)* [[CAS_PTR]], i32* [[CAST_CMP]], i32* [[VAL]] seq_cst monotonic, align 8
+; CHECK-NEXT:    ret { i32*, i1 } [[RET]]
+;
+  %cast.cmp = addrspacecast i32 addrspace(3)* %cmp.ptr to i32*
+  %ret = cmpxchg i32* addrspace(3)* %cas.ptr, i32* %cast.cmp, i32* %val seq_cst monotonic
+  ret { i32*, i1 } %ret
+}
+
+; Null pointer in local addr space
+
+define void @local_nullptr(i32 addrspace(1)* nocapture %results, i8 addrspace(3)* %a) {
+;
+; CHECK: Function Attrs: argmemonly nofree norecurse nosync nounwind willreturn writeonly
+; CHECK-LABEL: define {{[^@]+}}@local_nullptr
+; CHECK-SAME: (i32 addrspace(1)* nocapture nofree noundef writeonly align 4 dereferenceable_or_null(4) [[RESULTS:%.*]], i8 addrspace(3)* nofree writeonly [[A:%.*]]) #[[ATTR1]] {
+; CHECK-NEXT:  entry:
+; CHECK-NEXT:    [[TOBOOL:%.*]] = icmp ne i8 addrspace(3)* [[A]], addrspacecast (i8 addrspace(5)* null to i8 addrspace(3)*)
+; CHECK-NEXT:    [[CONV:%.*]] = zext i1 [[TOBOOL]] to i32
+; CHECK-NEXT:    store i32 [[CONV]], i32 addrspace(1)* [[RESULTS]], align 4
+; CHECK-NEXT:    ret void
+;
+entry:
+  %tobool = icmp ne i8 addrspace(3)* %a, addrspacecast (i8 addrspace(5)* null to i8 addrspace(3)*)
+  %conv = zext i1 %tobool to i32
+  store i32 %conv, i32 addrspace(1)* %results, align 4
+  ret void
+}
+
+attributes #0 = { nounwind }
+
+
+
+
+;.
+; CHECK: attributes #[[ATTR0]] = { argmemonly nofree norecurse nosync nounwind readonly willreturn }
+; CHECK: attributes #[[ATTR1]] = { argmemonly nofree norecurse nosync nounwind willreturn writeonly }
+; CHECK: attributes #[[ATTR2]] = { argmemonly nofree norecurse nosync nounwind willreturn }
+; CHECK: attributes #[[ATTR3]] = { argmemonly nofree norecurse nounwind willreturn }
+;.

llvm/test/Transforms/Attributor/callbacks.ll

 
 define void @t0_caller(i32* %a) {
 ; IS__TUNIT_OPM-LABEL: define {{[^@]+}}@t0_caller
 ; IS__TUNIT_OPM-SAME: (i32* align 256 [[A:%.*]]) {
 ; IS__TUNIT_OPM-NEXT:  entry:
 ; IS__TUNIT_OPM-NEXT:    [[B:%.*]] = alloca i32, align 32
 ; IS__TUNIT_OPM-NEXT:    [[C:%.*]] = alloca i32*, align 64
 ; IS__TUNIT_OPM-NEXT:    [[PTR:%.*]] = alloca i32, align 128
-; IS__TUNIT_OPM-NEXT:    [[TMP0:%.*]] = bitcast i32* [[B]] to i8*
 ; IS__TUNIT_OPM-NEXT:    store i32 42, i32* [[B]], align 32
 ; IS__TUNIT_OPM-NEXT:    store i32* [[B]], i32** [[C]], align 64
 ; IS__TUNIT_OPM-NEXT:    call void (i32*, i32*, void (i32*, i32*, ...)*, ...) @t0_callback_broker(i32* noalias nocapture noundef align 4294967296 null, i32* noundef nonnull align 128 dereferenceable(4) [[PTR]], void (i32*, i32*, ...)* noundef bitcast (void (i32*, i32*, i32*, i64, i32**)* @t0_callback_callee to void (i32*, i32*, ...)*), i32* align 256 [[A]], i64 undef, i32** nocapture nofree noundef nonnull readonly align 64 dereferenceable(8) [[C]])
 ; IS__TUNIT_OPM-NEXT:    ret void
 ;
 ; IS__TUNIT_NPM-LABEL: define {{[^@]+}}@t0_caller
 ; IS__TUNIT_NPM-SAME: (i32* align 256 [[A:%.*]]) {
 ; IS__TUNIT_NPM-NEXT:  entry:
 ; IS__TUNIT_NPM-NEXT:    [[B:%.*]] = alloca i32, align 32
 ; IS__TUNIT_NPM-NEXT:    [[C:%.*]] = alloca i32*, align 64
 ; IS__TUNIT_NPM-NEXT:    [[PTR:%.*]] = alloca i32, align 128
-; IS__TUNIT_NPM-NEXT:    [[TMP0:%.*]] = bitcast i32* [[B]] to i8*
 ; IS__TUNIT_NPM-NEXT:    store i32 42, i32* [[B]], align 32
 ; IS__TUNIT_NPM-NEXT:    store i32* [[B]], i32** [[C]], align 64
 ; IS__TUNIT_NPM-NEXT:    call void (i32*, i32*, void (i32*, i32*, ...)*, ...) @t0_callback_broker(i32* noalias nocapture noundef align 4294967296 null, i32* noundef nonnull align 128 dereferenceable(4) [[PTR]], void (i32*, i32*, ...)* noundef bitcast (void (i32*, i32*, i32*, i64, i32**)* @t0_callback_callee to void (i32*, i32*, ...)*), i32* align 256 [[A]], i64 undef, i32** noalias nocapture nofree noundef nonnull readonly align 64 dereferenceable(8) [[C]])
 ; IS__TUNIT_NPM-NEXT:    ret void
 ;
 ; IS__CGSCC_OPM-LABEL: define {{[^@]+}}@t0_caller
 ; IS__CGSCC_OPM-SAME: (i32* align 256 [[A:%.*]]) {
 ; IS__CGSCC_OPM-NEXT:  entry:
 ; IS__CGSCC_OPM-NEXT:    [[B:%.*]] = alloca i32, align 32
 ; IS__CGSCC_OPM-NEXT:    [[C:%.*]] = alloca i32*, align 64
 ; IS__CGSCC_OPM-NEXT:    [[PTR:%.*]] = alloca i32, align 128
-; IS__CGSCC_OPM-NEXT:    [[TMP0:%.*]] = bitcast i32* [[B]] to i8*
 ; IS__CGSCC_OPM-NEXT:    store i32 42, i32* [[B]], align 32
 ; IS__CGSCC_OPM-NEXT:    store i32* [[B]], i32** [[C]], align 64
 ; IS__CGSCC_OPM-NEXT:    call void (i32*, i32*, void (i32*, i32*, ...)*, ...) @t0_callback_broker(i32* noalias nocapture noundef align 4294967296 null, i32* noundef nonnull align 128 dereferenceable(4) [[PTR]], void (i32*, i32*, ...)* noundef bitcast (void (i32*, i32*, i32*, i64, i32**)* @t0_callback_callee to void (i32*, i32*, ...)*), i32* align 256 [[A]], i64 noundef 99, i32** nocapture nofree noundef nonnull readonly align 64 dereferenceable(8) [[C]])
 ; IS__CGSCC_OPM-NEXT:    ret void
 ;
 ; IS__CGSCC_NPM-LABEL: define {{[^@]+}}@t0_caller
 ; IS__CGSCC_NPM-SAME: (i32* align 256 [[A:%.*]]) {
 ; IS__CGSCC_NPM-NEXT:  entry:
 ; IS__CGSCC_NPM-NEXT:    [[B:%.*]] = alloca i32, align 32
 ; IS__CGSCC_NPM-NEXT:    [[C:%.*]] = alloca i32*, align 64
 ; IS__CGSCC_NPM-NEXT:    [[PTR:%.*]] = alloca i32, align 128
-; IS__CGSCC_NPM-NEXT:    [[TMP0:%.*]] = bitcast i32* [[B]] to i8*
 ; IS__CGSCC_NPM-NEXT:    store i32 42, i32* [[B]], align 32
 ; IS__CGSCC_NPM-NEXT:    store i32* [[B]], i32** [[C]], align 64
 ; IS__CGSCC_NPM-NEXT:    call void (i32*, i32*, void (i32*, i32*, ...)*, ...) @t0_callback_broker(i32* noalias nocapture noundef align 4294967296 null, i32* noundef nonnull align 128 dereferenceable(4) [[PTR]], void (i32*, i32*, ...)* noundef bitcast (void (i32*, i32*, i32*, i64, i32**)* @t0_callback_callee to void (i32*, i32*, ...)*), i32* align 256 [[A]], i64 noundef 99, i32** noalias nocapture nofree noundef nonnull readonly align 64 dereferenceable(8) [[C]])
 ; IS__CGSCC_NPM-NEXT:    ret void
 ;
 entry:
   %b = alloca i32, align 32
   %c = alloca i32*, align 64

 define void @t1_caller(i32* noalias %a) {
 ;
 ; IS__TUNIT_OPM-LABEL: define {{[^@]+}}@t1_caller
 ; IS__TUNIT_OPM-SAME: (i32* noalias nocapture align 256 [[A:%.*]]) {
 ; IS__TUNIT_OPM-NEXT:  entry:
 ; IS__TUNIT_OPM-NEXT:    [[B:%.*]] = alloca i32, align 32
 ; IS__TUNIT_OPM-NEXT:    [[C:%.*]] = alloca i32*, align 64
 ; IS__TUNIT_OPM-NEXT:    [[PTR:%.*]] = alloca i32, align 128
-; IS__TUNIT_OPM-NEXT:    [[TMP0:%.*]] = bitcast i32* [[B]] to i8*
 ; IS__TUNIT_OPM-NEXT:    store i32 42, i32* [[B]], align 32
 ; IS__TUNIT_OPM-NEXT:    store i32* [[B]], i32** [[C]], align 64
 ; IS__TUNIT_OPM-NEXT:    call void (i32*, i32*, void (i32*, i32*, ...)*, ...) @t1_callback_broker(i32* noalias nocapture noundef align 4294967296 null, i32* nocapture noundef nonnull align 128 dereferenceable(4) [[PTR]], void (i32*, i32*, ...)* nocapture noundef bitcast (void (i32*, i32*, i32*, i64, i32**)* @t1_callback_callee to void (i32*, i32*, ...)*), i32* nocapture align 256 [[A]], i64 undef, i32** nocapture nofree noundef nonnull readonly align 64 dereferenceable(8) [[C]])
 ; IS__TUNIT_OPM-NEXT:    ret void
 ;
 ; IS__TUNIT_NPM-LABEL: define {{[^@]+}}@t1_caller
 ; IS__TUNIT_NPM-SAME: (i32* noalias nocapture align 256 [[A:%.*]]) {
 ; IS__TUNIT_NPM-NEXT:  entry:
 ; IS__TUNIT_NPM-NEXT:    [[B:%.*]] = alloca i32, align 32
 ; IS__TUNIT_NPM-NEXT:    [[C:%.*]] = alloca i32*, align 64
 ; IS__TUNIT_NPM-NEXT:    [[PTR:%.*]] = alloca i32, align 128
-; IS__TUNIT_NPM-NEXT:    [[TMP0:%.*]] = bitcast i32* [[B]] to i8*
 ; IS__TUNIT_NPM-NEXT:    store i32 42, i32* [[B]], align 32
 ; IS__TUNIT_NPM-NEXT:    store i32* [[B]], i32** [[C]], align 64
 ; IS__TUNIT_NPM-NEXT:    call void (i32*, i32*, void (i32*, i32*, ...)*, ...) @t1_callback_broker(i32* noalias nocapture noundef align 4294967296 null, i32* noalias nocapture noundef nonnull align 128 dereferenceable(4) [[PTR]], void (i32*, i32*, ...)* nocapture noundef bitcast (void (i32*, i32*, i32*, i64, i32**)* @t1_callback_callee to void (i32*, i32*, ...)*), i32* nocapture align 256 [[A]], i64 undef, i32** noalias nocapture nofree noundef nonnull readonly align 64 dereferenceable(8) [[C]])
 ; IS__TUNIT_NPM-NEXT:    ret void
 ;
 ; IS__CGSCC_OPM-LABEL: define {{[^@]+}}@t1_caller
 ; IS__CGSCC_OPM-SAME: (i32* noalias nocapture align 256 [[A:%.*]]) {
 ; IS__CGSCC_OPM-NEXT:  entry:
 ; IS__CGSCC_OPM-NEXT:    [[B:%.*]] = alloca i32, align 32
 ; IS__CGSCC_OPM-NEXT:    [[C:%.*]] = alloca i32*, align 64
 ; IS__CGSCC_OPM-NEXT:    [[PTR:%.*]] = alloca i32, align 128
-; IS__CGSCC_OPM-NEXT:    [[TMP0:%.*]] = bitcast i32* [[B]] to i8*
 ; IS__CGSCC_OPM-NEXT:    store i32 42, i32* [[B]], align 32
 ; IS__CGSCC_OPM-NEXT:    store i32* [[B]], i32** [[C]], align 64
 ; IS__CGSCC_OPM-NEXT:    call void (i32*, i32*, void (i32*, i32*, ...)*, ...) @t1_callback_broker(i32* noalias nocapture noundef align 4294967296 null, i32* nocapture noundef nonnull align 128 dereferenceable(4) [[PTR]], void (i32*, i32*, ...)* nocapture noundef bitcast (void (i32*, i32*, i32*, i64, i32**)* @t1_callback_callee to void (i32*, i32*, ...)*), i32* nocapture align 256 [[A]], i64 noundef 99, i32** nocapture nofree noundef nonnull readonly align 64 dereferenceable(8) [[C]])
 ; IS__CGSCC_OPM-NEXT:    ret void
 ;
 ; IS__CGSCC_NPM-LABEL: define {{[^@]+}}@t1_caller
 ; IS__CGSCC_NPM-SAME: (i32* noalias nocapture align 256 [[A:%.*]]) {
 ; IS__CGSCC_NPM-NEXT:  entry:
 ; IS__CGSCC_NPM-NEXT:    [[B:%.*]] = alloca i32, align 32
 ; IS__CGSCC_NPM-NEXT:    [[C:%.*]] = alloca i32*, align 64
 ; IS__CGSCC_NPM-NEXT:    [[PTR:%.*]] = alloca i32, align 128
-; IS__CGSCC_NPM-NEXT:    [[TMP0:%.*]] = bitcast i32* [[B]] to i8*
 ; IS__CGSCC_NPM-NEXT:    store i32 42, i32* [[B]], align 32
 ; IS__CGSCC_NPM-NEXT:    store i32* [[B]], i32** [[C]], align 64
 ; IS__CGSCC_NPM-NEXT:    call void (i32*, i32*, void (i32*, i32*, ...)*, ...) @t1_callback_broker(i32* noalias nocapture noundef align 4294967296 null, i32* noalias nocapture noundef nonnull align 128 dereferenceable(4) [[PTR]], void (i32*, i32*, ...)* nocapture noundef bitcast (void (i32*, i32*, i32*, i64, i32**)* @t1_callback_callee to void (i32*, i32*, ...)*), i32* nocapture align 256 [[A]], i64 noundef 99, i32** noalias nocapture nofree noundef nonnull readonly align 64 dereferenceable(8) [[C]])
 ; IS__CGSCC_NPM-NEXT:    ret void
 ;
 entry:
   %b = alloca i32, align 32
   %c = alloca i32*, align 64

 
 define void @t2_caller(i32* noalias %a) {
 ; IS__TUNIT_OPM-LABEL: define {{[^@]+}}@t2_caller
 ; IS__TUNIT_OPM-SAME: (i32* noalias nocapture align 256 [[A:%.*]]) {
 ; IS__TUNIT_OPM-NEXT:  entry:
 ; IS__TUNIT_OPM-NEXT:    [[B:%.*]] = alloca i32, align 32
 ; IS__TUNIT_OPM-NEXT:    [[C:%.*]] = alloca i32*, align 64
 ; IS__TUNIT_OPM-NEXT:    [[PTR:%.*]] = alloca i32, align 128
-; IS__TUNIT_OPM-NEXT:    [[TMP0:%.*]] = bitcast i32* [[B]] to i8*
 ; IS__TUNIT_OPM-NEXT:    store i32 42, i32* [[B]], align 32
 ; IS__TUNIT_OPM-NEXT:    store i32* [[B]], i32** [[C]], align 64
 ; IS__TUNIT_OPM-NEXT:    call void (i32*, i32*, void (i32*, i32*, ...)*, ...) @t2_callback_broker(i32* noalias nocapture noundef align 4294967296 null, i32* nocapture noundef nonnull align 128 dereferenceable(4) [[PTR]], void (i32*, i32*, ...)* nocapture noundef bitcast (void (i32*, i32*, i32*, i64, i32**)* @t2_callback_callee to void (i32*, i32*, ...)*), i32* nocapture align 256 [[A]], i64 undef, i32** nocapture nofree noundef nonnull readonly align 64 dereferenceable(8) [[C]])
 ; IS__TUNIT_OPM-NEXT:    ret void
 ;
 ; IS__TUNIT_NPM-LABEL: define {{[^@]+}}@t2_caller
 ; IS__TUNIT_NPM-SAME: (i32* noalias nocapture align 256 [[A:%.*]]) {
 ; IS__TUNIT_NPM-NEXT:  entry:
 ; IS__TUNIT_NPM-NEXT:    [[B:%.*]] = alloca i32, align 32
 ; IS__TUNIT_NPM-NEXT:    [[C:%.*]] = alloca i32*, align 64
 ; IS__TUNIT_NPM-NEXT:    [[PTR:%.*]] = alloca i32, align 128
-; IS__TUNIT_NPM-NEXT:    [[TMP0:%.*]] = bitcast i32* [[B]] to i8*
 ; IS__TUNIT_NPM-NEXT:    store i32 42, i32* [[B]], align 32
 ; IS__TUNIT_NPM-NEXT:    store i32* [[B]], i32** [[C]], align 64
 ; IS__TUNIT_NPM-NEXT:    call void (i32*, i32*, void (i32*, i32*, ...)*, ...) @t2_callback_broker(i32* noalias nocapture noundef align 4294967296 null, i32* noalias nocapture noundef nonnull align 128 dereferenceable(4) [[PTR]], void (i32*, i32*, ...)* nocapture noundef bitcast (void (i32*, i32*, i32*, i64, i32**)* @t2_callback_callee to void (i32*, i32*, ...)*), i32* nocapture align 256 [[A]], i64 undef, i32** noalias nocapture nofree noundef nonnull readonly align 64 dereferenceable(8) [[C]])
 ; IS__TUNIT_NPM-NEXT:    ret void
 ;
 ; IS__CGSCC_OPM-LABEL: define {{[^@]+}}@t2_caller
 ; IS__CGSCC_OPM-SAME: (i32* noalias nocapture align 256 [[A:%.*]]) {
 ; IS__CGSCC_OPM-NEXT:  entry:
 ; IS__CGSCC_OPM-NEXT:    [[B:%.*]] = alloca i32, align 32
 ; IS__CGSCC_OPM-NEXT:    [[C:%.*]] = alloca i32*, align 64
 ; IS__CGSCC_OPM-NEXT:    [[PTR:%.*]] = alloca i32, align 128
-; IS__CGSCC_OPM-NEXT:    [[TMP0:%.*]] = bitcast i32* [[B]] to i8*
 ; IS__CGSCC_OPM-NEXT:    store i32 42, i32* [[B]], align 32
 ; IS__CGSCC_OPM-NEXT:    store i32* [[B]], i32** [[C]], align 64
 ; IS__CGSCC_OPM-NEXT:    call void (i32*, i32*, void (i32*, i32*, ...)*, ...) @t2_callback_broker(i32* noalias nocapture noundef align 4294967296 null, i32* nocapture noundef nonnull align 128 dereferenceable(4) [[PTR]], void (i32*, i32*, ...)* nocapture noundef bitcast (void (i32*, i32*, i32*, i64, i32**)* @t2_callback_callee to void (i32*, i32*, ...)*), i32* nocapture align 256 [[A]], i64 noundef 99, i32** nocapture nofree noundef nonnull readonly align 64 dereferenceable(8) [[C]])
 ; IS__CGSCC_OPM-NEXT:    ret void
 ;
 ; IS__CGSCC_NPM-LABEL: define {{[^@]+}}@t2_caller
 ; IS__CGSCC_NPM-SAME: (i32* noalias nocapture align 256 [[A:%.*]]) {
 ; IS__CGSCC_NPM-NEXT:  entry:
 ; IS__CGSCC_NPM-NEXT:    [[B:%.*]] = alloca i32, align 32
 ; IS__CGSCC_NPM-NEXT:    [[C:%.*]] = alloca i32*, align 64
 ; IS__CGSCC_NPM-NEXT:    [[PTR:%.*]] = alloca i32, align 128
-; IS__CGSCC_NPM-NEXT:    [[TMP0:%.*]] = bitcast i32* [[B]] to i8*
 ; IS__CGSCC_NPM-NEXT:    store i32 42, i32* [[B]], align 32
 ; IS__CGSCC_NPM-NEXT:    store i32* [[B]], i32** [[C]], align 64
 ; IS__CGSCC_NPM-NEXT:    call void (i32*, i32*, void (i32*, i32*, ...)*, ...) @t2_callback_broker(i32* noalias nocapture noundef align 4294967296 null, i32* noalias nocapture noundef nonnull align 128 dereferenceable(4) [[PTR]], void (i32*, i32*, ...)* nocapture noundef bitcast (void (i32*, i32*, i32*, i64, i32**)* @t2_callback_callee to void (i32*, i32*, ...)*), i32* nocapture align 256 [[A]], i64 noundef 99, i32** noalias nocapture nofree noundef nonnull readonly align 64 dereferenceable(8) [[C]])
 ; IS__CGSCC_NPM-NEXT:    ret void
 ;
 entry:
   %b = alloca i32, align 32
   %c = alloca i32*, align 64

 
 define void @t3_caller(i32* noalias %a) {
 ; IS__TUNIT_OPM-LABEL: define {{[^@]+}}@t3_caller
 ; IS__TUNIT_OPM-SAME: (i32* noalias nocapture align 256 [[A:%.*]]) {
 ; IS__TUNIT_OPM-NEXT:  entry:
 ; IS__TUNIT_OPM-NEXT:    [[B:%.*]] = alloca i32, align 32
 ; IS__TUNIT_OPM-NEXT:    [[C:%.*]] = alloca i32*, align 64
 ; IS__TUNIT_OPM-NEXT:    [[PTR:%.*]] = alloca i32, align 128
-; IS__TUNIT_OPM-NEXT:    [[TMP0:%.*]] = bitcast i32* [[B]] to i8*
 ; IS__TUNIT_OPM-NEXT:    store i32 42, i32* [[B]], align 32
 ; IS__TUNIT_OPM-NEXT:    store i32* [[B]], i32** [[C]], align 64
 ; IS__TUNIT_OPM-NEXT:    call void (i32*, i32*, void (i32*, i32*, ...)*, ...) @t3_callback_broker(i32* noalias nocapture noundef align 4294967296 null, i32* nocapture noundef nonnull align 128 dereferenceable(4) [[PTR]], void (i32*, i32*, ...)* nocapture noundef bitcast (void (i32*, i32*, i32*, i64, i32**)* @t3_callback_callee to void (i32*, i32*, ...)*), i32* nocapture align 256 [[A]], i64 undef, i32** nocapture nofree noundef nonnull readonly align 64 dereferenceable(8) [[C]])
 ; IS__TUNIT_OPM-NEXT:    call void (i32*, i32*, void (i32*, i32*, ...)*, ...) @t3_callback_broker(i32* noalias nocapture noundef align 4294967296 null, i32* nocapture noundef nonnull align 128 dereferenceable(4) [[PTR]], void (i32*, i32*, ...)* nocapture noundef bitcast (void (i32*, i32*, i32*, i64, i32**)* @t3_callback_callee to void (i32*, i32*, ...)*), i32* nocapture align 256 [[A]], i64 undef, i32** nocapture nofree noundef nonnull readonly align 64 dereferenceable(8) [[C]])
 ; IS__TUNIT_OPM-NEXT:    ret void
 ;
 ; IS__TUNIT_NPM-LABEL: define {{[^@]+}}@t3_caller
 ; IS__TUNIT_NPM-SAME: (i32* noalias nocapture align 256 [[A:%.*]]) {
 ; IS__TUNIT_NPM-NEXT:  entry:
 ; IS__TUNIT_NPM-NEXT:    [[B:%.*]] = alloca i32, align 32
 ; IS__TUNIT_NPM-NEXT:    [[C:%.*]] = alloca i32*, align 64
 ; IS__TUNIT_NPM-NEXT:    [[PTR:%.*]] = alloca i32, align 128
-; IS__TUNIT_NPM-NEXT:    [[TMP0:%.*]] = bitcast i32* [[B]] to i8*
 ; IS__TUNIT_NPM-NEXT:    store i32 42, i32* [[B]], align 32
 ; IS__TUNIT_NPM-NEXT:    store i32* [[B]], i32** [[C]], align 64
 ; IS__TUNIT_NPM-NEXT:    call void (i32*, i32*, void (i32*, i32*, ...)*, ...) @t3_callback_broker(i32* noalias nocapture noundef align 4294967296 null, i32* noalias nocapture noundef nonnull align 128 dereferenceable(4) [[PTR]], void (i32*, i32*, ...)* nocapture noundef bitcast (void (i32*, i32*, i32*, i64, i32**)* @t3_callback_callee to void (i32*, i32*, ...)*), i32* nocapture align 256 [[A]], i64 undef, i32** noalias nocapture nofree noundef nonnull readonly align 64 dereferenceable(8) [[C]])
 ; IS__TUNIT_NPM-NEXT:    call void (i32*, i32*, void (i32*, i32*, ...)*, ...) @t3_callback_broker(i32* noalias nocapture noundef align 4294967296 null, i32* noalias nocapture noundef nonnull align 128 dereferenceable(4) [[PTR]], void (i32*, i32*, ...)* nocapture noundef bitcast (void (i32*, i32*, i32*, i64, i32**)* @t3_callback_callee to void (i32*, i32*, ...)*), i32* nocapture align 256 [[A]], i64 undef, i32** noalias nocapture nofree noundef nonnull readonly align 64 dereferenceable(8) [[C]])
 ; IS__TUNIT_NPM-NEXT:    ret void
 ;
 ; IS__CGSCC_OPM-LABEL: define {{[^@]+}}@t3_caller
 ; IS__CGSCC_OPM-SAME: (i32* noalias nocapture align 256 [[A:%.*]]) {
 ; IS__CGSCC_OPM-NEXT:  entry:
 ; IS__CGSCC_OPM-NEXT:    [[B:%.*]] = alloca i32, align 32
 ; IS__CGSCC_OPM-NEXT:    [[C:%.*]] = alloca i32*, align 64
 ; IS__CGSCC_OPM-NEXT:    [[PTR:%.*]] = alloca i32, align 128
-; IS__CGSCC_OPM-NEXT:    [[TMP0:%.*]] = bitcast i32* [[B]] to i8*
 ; IS__CGSCC_OPM-NEXT:    store i32 42, i32* [[B]], align 32
 ; IS__CGSCC_OPM-NEXT:    store i32* [[B]], i32** [[C]], align 64
 ; IS__CGSCC_OPM-NEXT:    call void (i32*, i32*, void (i32*, i32*, ...)*, ...) @t3_callback_broker(i32* noalias nocapture noundef align 4294967296 null, i32* nocapture noundef nonnull align 128 dereferenceable(4) [[PTR]], void (i32*, i32*, ...)* nocapture noundef bitcast (void (i32*, i32*, i32*, i64, i32**)* @t3_callback_callee to void (i32*, i32*, ...)*), i32* nocapture align 256 [[A]], i64 noundef 99, i32** nocapture nofree noundef nonnull readonly align 64 dereferenceable(8) [[C]])
 ; IS__CGSCC_OPM-NEXT:    call void (i32*, i32*, void (i32*, i32*, ...)*, ...) @t3_callback_broker(i32* noalias nocapture noundef align 4294967296 null, i32* nocapture noundef nonnull align 128 dereferenceable(4) [[PTR]], void (i32*, i32*, ...)* nocapture noundef bitcast (void (i32*, i32*, i32*, i64, i32**)* @t3_callback_callee to void (i32*, i32*, ...)*), i32* nocapture align 256 [[A]], i64 noundef 99, i32** nocapture nofree noundef nonnull readonly align 64 dereferenceable(8) [[C]])
 ; IS__CGSCC_OPM-NEXT:    ret void
 ;
 ; IS__CGSCC_NPM-LABEL: define {{[^@]+}}@t3_caller
 ; IS__CGSCC_NPM-SAME: (i32* noalias nocapture align 256 [[A:%.*]]) {
 ; IS__CGSCC_NPM-NEXT:  entry:
 ; IS__CGSCC_NPM-NEXT:    [[B:%.*]] = alloca i32, align 32
 ; IS__CGSCC_NPM-NEXT:    [[C:%.*]] = alloca i32*, align 64
 ; IS__CGSCC_NPM-NEXT:    [[PTR:%.*]] = alloca i32, align 128
-; IS__CGSCC_NPM-NEXT:    [[TMP0:%.*]] = bitcast i32* [[B]] to i8*
 ; IS__CGSCC_NPM-NEXT:    store i32 42, i32* [[B]], align 32
 ; IS__CGSCC_NPM-NEXT:    store i32* [[B]], i32** [[C]], align 64
 ; IS__CGSCC_NPM-NEXT:    call void (i32*, i32*, void (i32*, i32*, ...)*, ...) @t3_callback_broker(i32* noalias nocapture noundef align 4294967296 null, i32* noalias nocapture noundef nonnull align 128 dereferenceable(4) [[PTR]], void (i32*, i32*, ...)* nocapture noundef bitcast (void (i32*, i32*, i32*, i64, i32**)* @t3_callback_callee to void (i32*, i32*, ...)*), i32* nocapture align 256 [[A]], i64 noundef 99, i32** noalias nocapture nofree noundef nonnull readonly align 64 dereferenceable(8) [[C]])
 ; IS__CGSCC_NPM-NEXT:    call void (i32*, i32*, void (i32*, i32*, ...)*, ...) @t3_callback_broker(i32* noalias nocapture noundef align 4294967296 null, i32* noalias nocapture noundef nonnull align 128 dereferenceable(4) [[PTR]], void (i32*, i32*, ...)* nocapture noundef bitcast (void (i32*, i32*, i32*, i64, i32**)* @t3_callback_callee to void (i32*, i32*, ...)*), i32* nocapture align 256 [[A]], i64 noundef 99, i32** noalias nocapture nofree noundef nonnull readonly align 64 dereferenceable(8) [[C]])
 ; IS__CGSCC_NPM-NEXT:    ret void
 ;
 entry:
   %b = alloca i32, align 32

llvm/test/Transforms/Attributor/depgraph.ll

 ; GRAPH-NEXT: [AAAssumptionInfo] for CtxI ' %6 = call i32* @checkAndAdvance(i32* %5)' at position {cs: [@-1]} with state Known [], Assumed []
 ; GRAPH-EMPTY:
 ; GRAPH-NEXT: [AANoAlias] for CtxI '  %6 = call i32* @checkAndAdvance(i32* %5)' at position {cs_arg: [@0]} with state may-alias
 ; GRAPH-EMPTY:
 ; GRAPH-NEXT: [AANoAlias] for CtxI '  %5 = getelementptr inbounds i32, i32* %0, i64 4' at position {flt: [@-1]} with state may-alias
 ; GRAPH-EMPTY:
 ; GRAPH-NEXT: [AANoFree] for CtxI '  %6 = call i32* @checkAndAdvance(i32* %5)' at position {cs_arg: [@0]} with state nofree
 ; GRAPH-EMPTY:
+; GRAPH-NEXT: [AAAddressSpaceInfo] for CtxI ' %2 = load i32, i32* %0, align 4' at position {arg: [@0]} with state Address Space: 0
+; GRAPH-EMPTY:
 ; GRAPH-NEXT: [AADereferenceable] for CtxI ' %5 = getelementptr inbounds i32, i32* %0, i64 4' at position {flt: [@-1]} with state unknown-dereferenceable
 ; GRAPH-EMPTY:
 ; GRAPH-NEXT: [AAAlign] for CtxI '  %6 = call i32* @checkAndAdvance(i32* %5)' at position {cs_ret: [@-1]} with state align<1-16>
 ; GRAPH-NEXT:   updates [AAAlign] for CtxI '  %2 = load i32, i32* %0, align 4' at position {fn_ret:checkAndAdvance [checkAndAdvance@-1]} with state align<1-16>
 ; GRAPH-EMPTY:
 ; GRAPH-NEXT: [AANonNull] for CtxI '  %6 = call i32* @checkAndAdvance(i32* %5)' at position {cs_ret: [@-1]} with state nonnull
 ; GRAPH-NEXT:   updates [AANonNull] for CtxI '  %2 = load i32, i32* %0, align 4' at position {fn_ret:checkAndAdvance [checkAndAdvance@-1]} with state nonnull
 

llvm/test/Transforms/Attributor/heap_to_stack.ll

 ;
   %1 = tail call noalias i8* @aligned_alloc(i64 %alignment, i64 128)
   tail call void @free(i8* %1)
   ret void
 }
 
 ; leave alone a constant-but-invalid alignment
 define void @test3d(i8* %p) {
-; CHECK-LABEL: define {{[^@]+}}@test3d
-; CHECK-SAME; (i8* nocapture [[P:%.*]]) {
-; CHECK-NEXT:    [[TMP1:%.*]] = tail call noalias i8* @aligned_alloc(i64 noundef 33, i64 noundef 128)
-; CHECK:    tail call void @free(i8* noalias nocapture [[TMP1]])
-; CHECK-NEXT:    ret void
+; IS________OPM-LABEL: define {{[^@]+}}@test3d
+; IS________OPM-SAME: (i8* nocapture [[P:%.*]]) {
+; IS________OPM-NEXT:    [[TMP1:%.*]] = tail call noalias i8* @aligned_alloc(i64 noundef 33, i64 noundef 128)
+; IS________OPM-NEXT:    tail call void @nofree_arg_only(i8* nocapture nofree [[TMP1]], i8* nocapture [[P]])
+; IS________OPM-NEXT:    tail call void @free(i8* noalias nocapture [[TMP1]])
+; IS________OPM-NEXT:    ret void
 ;
+; IS________NPM-LABEL: define {{[^@]+}}@test3d
+; IS________NPM-SAME: (i8* nocapture [[P:%.*]]) {
+; IS________NPM-NEXT:    [[TMP1:%.*]] = tail call noalias i8* @aligned_alloc(i64 noundef 33, i64 noundef 128)
+; IS________NPM-NEXT:    tail call void @nofree_arg_only(i8* noalias nocapture nofree [[TMP1]], i8* nocapture [[P]])
+; IS________NPM-NEXT:    tail call void @free(i8* noalias nocapture [[TMP1]])
+; IS________NPM-NEXT:    ret void
+;
+; CHECK-SAME; (i8* nocapture [[P:%.*]]) {
   %1 = tail call noalias i8* @aligned_alloc(i64 33, i64 128)
   tail call void @nofree_arg_only(i8* %1, i8* %p)
   tail call void @free(i8* %1)
   ret void
 }
 
 declare noalias i8* @calloc(i64, i64)
 

 ; IS________OPM-NEXT:    [[TMP5:%.*]] = load i32, i32* [[TMP2]], align 4
 ; IS________OPM-NEXT:    [[TMP6:%.*]] = add nsw i32 [[TMP5]], -1
 ; IS________OPM-NEXT:    store i32 [[TMP6]], i32* [[TMP2]], align 4
 ; IS________OPM-NEXT:    [[TMP7:%.*]] = icmp sgt i32 [[TMP6]], 0
 ; IS________OPM-NEXT:    br i1 [[TMP7]], label [[TMP8:%.*]], label [[TMP11:%.*]]
 ; IS________OPM:       8:
 ; IS________OPM-NEXT:    [[TMP9:%.*]] = call noalias i8* @malloc(i64 noundef 4)
 ; IS________OPM-NEXT:    [[TMP10:%.*]] = bitcast i8* [[TMP9]] to i32*
-; IS________OPM-NEXT:    store i32 1, i32* [[TMP10]], align 8
 ; IS________OPM-NEXT:    br label [[TMP4]]
 ; IS________OPM:       11:
 ; IS________OPM-NEXT:    ret i32 5
 ;
 ; IS________NPM-LABEL: define {{[^@]+}}@malloc_in_loop
 ; IS________NPM-SAME: (i32 [[TMP0:%.*]]) {
 ; IS________NPM-NEXT:    [[TMP2:%.*]] = alloca i32, align 4
 ; IS________NPM-NEXT:    [[TMP3:%.*]] = alloca i32*, align 8

llvm/test/Transforms/Attributor/heap_to_stack_gpu.ll

 ; CHECK-NEXT:    [[TMP5:%.*]] = load i32, i32* [[TMP2]], align 4
 ; CHECK-NEXT:    [[TMP6:%.*]] = add nsw i32 [[TMP5]], -1
 ; CHECK-NEXT:    store i32 [[TMP6]], i32* [[TMP2]], align 4
 ; CHECK-NEXT:    [[TMP7:%.*]] = icmp sgt i32 [[TMP6]], 0
 ; CHECK-NEXT:    br i1 [[TMP7]], label [[TMP8:%.*]], label [[TMP11:%.*]]
 ; CHECK:       8:
 ; CHECK-NEXT:    [[TMP9:%.*]] = call noalias i8* @malloc(i64 noundef 4)
 ; CHECK-NEXT:    [[TMP10:%.*]] = bitcast i8* [[TMP9]] to i32*
-; CHECK-NEXT:    store i32 1, i32* [[TMP10]], align 8
 ; CHECK-NEXT:    br label [[TMP4]]
 ; CHECK:       11:
 ; CHECK-NEXT:    ret i32 5
 ;
   %2 = alloca i32, align 4
   %3 = alloca i32*, align 8
   store i32 %0, i32* %2, align 4
   br label %4

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

 ; CHECK-LABEL: define {{[^@]+}}@nc1_addrspace
 ; CHECK-SAME: (i32* nofree [[Q:%.*]], i32 addrspace(1)* nocapture nofree [[P:%.*]], i1 [[B:%.*]]) #[[ATTR5:[0-9]+]] {
 ; CHECK-NEXT:  e:
 ; CHECK-NEXT:    br label [[L:%.*]]
 ; CHECK:       l:
 ; CHECK-NEXT:    [[X:%.*]] = phi i32 addrspace(1)* [ [[P]], [[E:%.*]] ]
 ; CHECK-NEXT:    [[Y:%.*]] = phi i32* [ [[Q]], [[E]] ]
 ; CHECK-NEXT:    [[TMP:%.*]] = addrspacecast i32 addrspace(1)* [[X]] to i32*
+; CHECK-NEXT:    [[TMP0:%.*]] = addrspacecast i32* [[TMP]] to i32 addrspace(1)*
 ; CHECK-NEXT:    [[TMP2:%.*]] = select i1 [[B]], i32* [[TMP]], i32* [[Y]]
 ; CHECK-NEXT:    [[VAL:%.*]] = load i32, i32* [[TMP2]], align 4
-; CHECK-NEXT:    store i32 0, i32* [[TMP]], align 4
+; CHECK-NEXT:    store i32 0, i32 addrspace(1)* [[TMP0]], align 4
 ; CHECK-NEXT:    store i32* [[Y]], i32** @g, align 8
 ; CHECK-NEXT:    ret i32 [[VAL]]
 ;
 e:
   br label %l
 l:
   %x = phi i32 addrspace(1)* [ %p, %e ]
   %y = phi i32* [ %q, %e ]

llvm/test/Transforms/Attributor/nodelete.ll

entry:
   ret i64 undef
 }
 
 define internal void @f3(%"b"* %this) align 2 {
 ; IS__CGSCC____: Function Attrs: nofree norecurse nosync nounwind readnone willreturn
 ; IS__CGSCC____-LABEL: define {{[^@]+}}@f3
 ; IS__CGSCC____-SAME: () #[[ATTR0]] align 2 {
 ; IS__CGSCC____-NEXT:  entry:
-; IS__CGSCC____-NEXT:    [[THIS_ADDR:%.*]] = alloca %b*, align 8
-; IS__CGSCC____-NEXT:    [[THIS1:%.*]] = load %b*, %b** [[THIS_ADDR]], align 8
 ; IS__CGSCC____-NEXT:    ret void
 ;
 entry:
   %this.addr = alloca %"b"*, align 8
   store %"b"* %this, %"b"** %this.addr, align 8
   %this1 = load %"b"*, %"b"** %this.addr, align 8
   %call = call i1 @f4(%"b"* %this1)
   ret void
 }
 
 define internal i1 @f4(%"b"* %this) align 2 {
 ; IS__CGSCC____: Function Attrs: nofree norecurse nosync nounwind readnone willreturn
 ; IS__CGSCC____-LABEL: define {{[^@]+}}@f4
 ; IS__CGSCC____-SAME: () #[[ATTR0]] align 2 {
 ; IS__CGSCC____-NEXT:  entry:
-; IS__CGSCC____-NEXT:    [[THIS_ADDR:%.*]] = alloca %b*, align 8
-; IS__CGSCC____-NEXT:    [[THIS1:%.*]] = load %b*, %b** [[THIS_ADDR]], align 8
 ; IS__CGSCC____-NEXT:    ret i1 undef
 ;
 entry:
   %this.addr = alloca %"b"*, align 8
   store %"b"* %this, %"b"** %this.addr, align 8
   %this1 = load %"b"*, %"b"** %this.addr, align 8
   %call = call %"a"* @f5(%"b"* %this1)
   ret i1 undef

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

entry:
   %0 = load i32, i32* addrspacecast (i32 addrspace(3)* @ReachableNonKernel to i32*), align 4
   %1 = load i32, i32* addrspacecast (i32 addrspace(3)* @UnreachableNonKernel to i32*), align 4
   %2 = load i32, i32* %addr
   call void @use(i32 %0, i32 %1, i32 %2)
   ret void
 }
 
 define internal void @level2b(i32* %addr) {
-; IS__TUNIT____: Function Attrs: norecurse nosync nounwind
-; IS__TUNIT____-LABEL: define {{[^@]+}}@level2b
-; IS__TUNIT____-SAME: () #[[ATTR1]] {
-; IS__TUNIT____-NEXT:  entry:
-; IS__TUNIT____-NEXT:    [[TMP0:%.*]] = load i32, i32* addrspacecast (i32 addrspace(3)* @ReachableNonKernel to i32*), align 4
-; IS__TUNIT____-NEXT:    [[TMP1:%.*]] = load i32, i32* addrspacecast (i32 addrspace(3)* @UnreachableNonKernel to i32*), align 4
-; IS__TUNIT____-NEXT:    call void @use(i32 [[TMP0]], i32 [[TMP1]], i32 17) #[[ATTR6]]
-; IS__TUNIT____-NEXT:    ret void
+; IS__TUNIT_OPM: Function Attrs: norecurse nosync nounwind
+; IS__TUNIT_OPM-LABEL: define {{[^@]+}}@level2b
+; IS__TUNIT_OPM-SAME: () #[[ATTR1]] {
+; IS__TUNIT_OPM-NEXT:  entry:
+; IS__TUNIT_OPM-NEXT:    [[TMP0:%.*]] = load i32, i32* addrspacecast (i32 addrspace(3)* @ReachableNonKernel to i32*), align 4
+; IS__TUNIT_OPM-NEXT:    [[TMP1:%.*]] = load i32, i32* addrspacecast (i32 addrspace(3)* @UnreachableNonKernel to i32*), align 4
+; IS__TUNIT_OPM-NEXT:    call void @use(i32 [[TMP0]], i32 [[TMP1]], i32 noundef 17) #[[ATTR6]]
+; IS__TUNIT_OPM-NEXT:    ret void
+;
+; IS__TUNIT_NPM: Function Attrs: norecurse nosync nounwind
+; IS__TUNIT_NPM-LABEL: define {{[^@]+}}@level2b
+; IS__TUNIT_NPM-SAME: () #[[ATTR1]] {
+; IS__TUNIT_NPM-NEXT:  entry:
+; IS__TUNIT_NPM-NEXT:    [[TMP0:%.*]] = load i32, i32* addrspacecast (i32 addrspace(3)* @ReachableNonKernel to i32*), align 4
+; IS__TUNIT_NPM-NEXT:    [[TMP1:%.*]] = load i32, i32* addrspacecast (i32 addrspace(3)* @UnreachableNonKernel to i32*), align 4
+; IS__TUNIT_NPM-NEXT:    call void @use(i32 [[TMP0]], i32 [[TMP1]], i32 17) #[[ATTR6]]
+; IS__TUNIT_NPM-NEXT:    ret void
 ;
 ; IS__CGSCC_OPM: Function Attrs: norecurse nosync nounwind
 ; IS__CGSCC_OPM-LABEL: define {{[^@]+}}@level2b
 ; IS__CGSCC_OPM-SAME: (i32* noalias nocapture nofree nonnull readnone align 4 dereferenceable(4) [[ADDR:%.*]]) #[[ATTR1]] {
 ; IS__CGSCC_OPM-NEXT:  entry:
 ; IS__CGSCC_OPM-NEXT:    [[TMP0:%.*]] = load i32, i32* addrspacecast (i32 addrspace(3)* @ReachableNonKernel to i32*), align 4
 ; IS__CGSCC_OPM-NEXT:    [[TMP1:%.*]] = load i32, i32* addrspacecast (i32 addrspace(3)* @UnreachableNonKernel to i32*), align 4
 ; IS__CGSCC_OPM-NEXT:    [[TMP2:%.*]] = load i32, i32* undef, align 4

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

 define i32 @static_global_not_simplifiable_1(i32 %cnd) {
 ; CHECK-LABEL: define {{[^@]+}}@static_global_not_simplifiable_1
 ; CHECK-SAME: (i32 [[CND:%.*]]) {
 ; CHECK-NEXT:  entry:
 ; CHECK-NEXT:    call void @sync()
 ; CHECK-NEXT:    [[TOBOOL_NOT:%.*]] = icmp eq i32 [[CND]], 0
 ; CHECK-NEXT:    br i1 [[TOBOOL_NOT]], label [[IF_END:%.*]], label [[IF_THEN:%.*]]
 ; CHECK:       if.then:
-; CHECK-NEXT:    store i32 1, i32* @Flag1, align 4, !tbaa [[TBAA3]]
 ; CHECK-NEXT:    br label [[IF_END]]
 ; CHECK:       if.end:
 ; CHECK-NEXT:    ret i32 1
 ;
 entry:
   %i = load i32, i32* @Flag1, align 4, !tbaa !3
   call void @sync()
   %tobool.not = icmp eq i32 %cnd, 0

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

 ; NOTE: Assertions have been autogenerated by utils/update_test_checks.py UTC_ARGS: --function-signature --check-attributes --check-globals
 ; RUN: opt -attributor -enable-new-pm=0 -attributor-manifest-internal  -attributor-max-iterations-verify -attributor-annotate-decl-cs -attributor-max-iterations=16 -S < %s | FileCheck %s --check-prefixes=CHECK,NOT_CGSCC_NPM,NOT_CGSCC_OPM,NOT_TUNIT_NPM,IS__TUNIT____,IS________OPM,IS__TUNIT_OPM
 ; RUN: opt -aa-pipeline=basic-aa -passes=attributor -attributor-manifest-internal  -attributor-max-iterations-verify -attributor-annotate-decl-cs -attributor-max-iterations=16 -S < %s | FileCheck %s --check-prefixes=CHECK,NOT_CGSCC_OPM,NOT_CGSCC_NPM,NOT_TUNIT_OPM,IS__TUNIT____,IS________NPM,IS__TUNIT_NPM
 ; RUN: opt -attributor-cgscc -enable-new-pm=0 -attributor-manifest-internal  -attributor-annotate-decl-cs -S < %s | FileCheck %s --check-prefixes=CHECK,NOT_TUNIT_NPM,NOT_TUNIT_OPM,NOT_CGSCC_NPM,IS__CGSCC____,IS________OPM,IS__CGSCC_OPM
 ; RUN: opt -aa-pipeline=basic-aa -passes=attributor-cgscc -attributor-manifest-internal  -attributor-annotate-decl-cs -S < %s | FileCheck %s --check-prefixes=CHECK,NOT_TUNIT_NPM,NOT_TUNIT_OPM,NOT_CGSCC_OPM,IS__CGSCC____,IS________NPM,IS__CGSCC_NPM
 
 target datalayout = "e-m:o-i64:64-f80:128-n8:16:32:64-S128"
 declare void @f(i32)
 declare token @llvm.call.preallocated.setup(i32)
 declare i8* @llvm.call.preallocated.arg(token, i32)
 
 @ConstAS3Ptr = addrspace(3) global i32 0, align 4
 
 ;.
 ; 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 i8*] } { [2 x i8*] [i8* bitcast (void (i8***)* @f1 to i8*), i8* bitcast (void (i1 (i8*)*)* @f2 to i8*)] }
 ;.
 define internal i32 addrspace(3)* @const_ptr_return_as3() {
 ; IS__CGSCC____: Function Attrs: nofree norecurse nosync nounwind readnone willreturn
 ; IS__CGSCC____-LABEL: define {{[^@]+}}@const_ptr_return_as3
 ; IS__CGSCC____-SAME: () #[[ATTR1:[0-9]+]] {
 ; IS__CGSCC____-NEXT:    ret i32 addrspace(3)* undef
 ;
   ret i32 addrspace(3)* @ConstAS3Ptr

 ; IS__CGSCC_OPM-NEXT:    store i32 0, i32 addrspace(3)* @ConstAS3Ptr, align 4
 ; IS__CGSCC_OPM-NEXT:    ret void
 ;
   %call = call fastcc i32 addrspace(3)* @const_ptr_return_as3()
   store i32 0, i32 addrspace(3)* %call
   ret void
 }
 define void @user() {
-; NOT_CGSCC_OPM: Function Attrs: nofree norecurse nosync nounwind willreturn writeonly
-; NOT_CGSCC_OPM-LABEL: define {{[^@]+}}@user
-; NOT_CGSCC_OPM-SAME: () #[[ATTR3]] {
-; NOT_CGSCC_OPM-NEXT:    store i32 0, i32* addrspacecast (i32 addrspace(3)* @ConstAS3Ptr to i32*), align 4
-; NOT_CGSCC_OPM-NEXT:    ret void
+; IS__TUNIT____: Function Attrs: nofree norecurse nosync nounwind willreturn writeonly
+; IS__TUNIT____-LABEL: define {{[^@]+}}@user
+; IS__TUNIT____-SAME: () #[[ATTR3]] {
+; IS__TUNIT____-NEXT:    [[TMP1:%.*]] = addrspacecast i32* addrspacecast (i32 addrspace(3)* @ConstAS3Ptr to i32*) to i32 addrspace(3)*
+; IS__TUNIT____-NEXT:    store i32 0, i32 addrspace(3)* [[TMP1]], align 4
+; IS__TUNIT____-NEXT:    ret void
 ;
 ; IS__CGSCC_OPM: Function Attrs: nofree norecurse nosync nounwind willreturn writeonly
 ; IS__CGSCC_OPM-LABEL: define {{[^@]+}}@user
 ; IS__CGSCC_OPM-SAME: () #[[ATTR4]] {
 ; IS__CGSCC_OPM-NEXT:    store i32 0, i32* addrspacecast (i32 addrspace(3)* @ConstAS3Ptr to i32*), align 4
 ; IS__CGSCC_OPM-NEXT:    ret void
 ;
+; IS__CGSCC_NPM: Function Attrs: nofree norecurse nosync nounwind willreturn writeonly
+; IS__CGSCC_NPM-LABEL: define {{[^@]+}}@user
+; IS__CGSCC_NPM-SAME: () #[[ATTR3]] {
+; IS__CGSCC_NPM-NEXT:    store i32 0, i32* addrspacecast (i32 addrspace(3)* @ConstAS3Ptr to i32*), align 4
+; IS__CGSCC_NPM-NEXT:    ret void
+;
   %call = call fastcc i32* @const_ptr_return()
   store i32 0, i32* %call
   ret void
 }
 
 
 define i1 @test_merge_with_undef_values_ptr(i1 %c) {
 ; CHECK: Function Attrs: nofree norecurse nosync nounwind readnone willreturn
join:
   %phi = phi i32 [ %i, %then ], [ undef, %entry ]
   %ret = lshr i32 %phi, 1
   ret i32 %ret
 
   uselistorder label %join, { 1, 0 }
 }
 
 define i1 @test_liveness(i1 %c) {
+; IS__TUNIT_OPM: Function Attrs: nofree norecurse nosync nounwind readnone willreturn
+; IS__TUNIT_OPM-LABEL: define {{[^@]+}}@test_liveness
+; IS__TUNIT_OPM-SAME: (i1 [[C:%.*]]) #[[ATTR1]] {
+; IS__TUNIT_OPM-NEXT:  entry:
+; IS__TUNIT_OPM-NEXT:    br i1 [[C]], label [[T:%.*]], label [[F:%.*]]
+; IS__TUNIT_OPM:       t:
+; IS__TUNIT_OPM-NEXT:    br label [[F]]
+; IS__TUNIT_OPM:       f:
+; IS__TUNIT_OPM-NEXT:    [[P:%.*]] = phi i1 [ true, [[ENTRY:%.*]] ], [ false, [[T]] ]
+; IS__TUNIT_OPM-NEXT:    [[RC1:%.*]] = call noundef i1 @ret(i1 noundef [[P]]) #[[ATTR5]]
+; IS__TUNIT_OPM-NEXT:    ret i1 [[RC1]]
+;
+; IS__TUNIT_NPM: Function Attrs: nofree norecurse nosync nounwind readnone willreturn
+; IS__TUNIT_NPM-LABEL: define {{[^@]+}}@test_liveness
+; IS__TUNIT_NPM-SAME: (i1 [[C:%.*]]) #[[ATTR1]] {
+; IS__TUNIT_NPM-NEXT:  entry:
+; IS__TUNIT_NPM-NEXT:    br i1 [[C]], label [[T:%.*]], label [[F:%.*]]
+; IS__TUNIT_NPM:       t:
+; IS__TUNIT_NPM-NEXT:    br label [[F]]
+; IS__TUNIT_NPM:       f:
+; IS__TUNIT_NPM-NEXT:    [[P:%.*]] = phi i1 [ true, [[ENTRY:%.*]] ], [ false, [[T]] ]
+; IS__TUNIT_NPM-NEXT:    [[RC1:%.*]] = call noundef i1 @ret(i1 noundef [[P]]) #[[ATTR4]]
+; IS__TUNIT_NPM-NEXT:    ret i1 [[RC1]]
+;
+; IS__CGSCC_OPM: Function Attrs: nofree norecurse nosync nounwind readnone willreturn
+; IS__CGSCC_OPM-LABEL: define {{[^@]+}}@test_liveness
+; IS__CGSCC_OPM-SAME: (i1 [[C:%.*]]) #[[ATTR1]] {
+; IS__CGSCC_OPM-NEXT:  entry:
+; IS__CGSCC_OPM-NEXT:    br i1 [[C]], label [[T:%.*]], label [[F:%.*]]
+; IS__CGSCC_OPM:       t:
+; IS__CGSCC_OPM-NEXT:    br label [[F]]
+; IS__CGSCC_OPM:       f:
+; IS__CGSCC_OPM-NEXT:    [[P:%.*]] = phi i1 [ true, [[ENTRY:%.*]] ], [ false, [[T]] ]
+; IS__CGSCC_OPM-NEXT:    [[RC1:%.*]] = call noundef i1 @ret(i1 noundef [[P]]) #[[ATTR7:[0-9]+]]
+; IS__CGSCC_OPM-NEXT:    ret i1 [[RC1]]
+;
+; IS__CGSCC_NPM: Function Attrs: nofree norecurse nosync nounwind readnone willreturn
+; IS__CGSCC_NPM-LABEL: define {{[^@]+}}@test_liveness
+; IS__CGSCC_NPM-SAME: (i1 [[C:%.*]]) #[[ATTR1]] {
+; IS__CGSCC_NPM-NEXT:  entry:
+; IS__CGSCC_NPM-NEXT:    br i1 [[C]], label [[T:%.*]], label [[F:%.*]]
+; IS__CGSCC_NPM:       t:
+; IS__CGSCC_NPM-NEXT:    br label [[F]]
+; IS__CGSCC_NPM:       f:
+; IS__CGSCC_NPM-NEXT:    ret i1 false
+;
 entry:
-    br i1 %c, label %t, label %f
 t:
-    br label %f
 f:
-    %p = phi i1 [true, %entry], [false, %t]
-    %rc1 = call i1 @ret(i1 %p)
-    ret i1 %rc1
 }
 
 define internal i1 @ret(i1 %c) {
+; IS________OPM: Function Attrs: nofree norecurse nosync nounwind readnone willreturn
+; IS________OPM-LABEL: define {{[^@]+}}@ret
+; IS________OPM-SAME: (i1 noundef [[C:%.*]]) #[[ATTR1]] {
+; IS________OPM-NEXT:  entry:
+; IS________OPM-NEXT:    br i1 [[C]], label [[T:%.*]], label [[F:%.*]]
+; IS________OPM:       t:
+; IS________OPM-NEXT:    br label [[F]]
+; IS________OPM:       f:
+; IS________OPM-NEXT:    [[P:%.*]] = phi i1 [ [[C]], [[ENTRY:%.*]] ], [ false, [[T]] ]
+; IS________OPM-NEXT:    ret i1 [[P]]
+;
+; IS__TUNIT_NPM: Function Attrs: nofree norecurse nosync nounwind readnone willreturn
+; IS__TUNIT_NPM-LABEL: define {{[^@]+}}@ret
+; IS__TUNIT_NPM-SAME: (i1 noundef [[C:%.*]]) #[[ATTR1]] {
+; IS__TUNIT_NPM-NEXT:  entry:
+; IS__TUNIT_NPM-NEXT:    br i1 [[C]], label [[T:%.*]], label [[F:%.*]]
+; IS__TUNIT_NPM:       t:
+; IS__TUNIT_NPM-NEXT:    br label [[F]]
+; IS__TUNIT_NPM:       f:
+; IS__TUNIT_NPM-NEXT:    [[P:%.*]] = phi i1 [ [[C]], [[ENTRY:%.*]] ], [ false, [[T]] ]
+; IS__TUNIT_NPM-NEXT:    ret i1 false
+;
+; IS__CGSCC_NPM: Function Attrs: nofree norecurse nosync nounwind readnone willreturn
+; IS__CGSCC_NPM-LABEL: define {{[^@]+}}@ret
+; IS__CGSCC_NPM-SAME: (i1 noundef [[C:%.*]]) #[[ATTR1]] {
+; IS__CGSCC_NPM-NEXT:  entry:
+; IS__CGSCC_NPM-NEXT:    br i1 [[C]], label [[T:%.*]], label [[F:%.*]]
+; IS__CGSCC_NPM:       t:
+; IS__CGSCC_NPM-NEXT:    br label [[F]]
+; IS__CGSCC_NPM:       f:
+; IS__CGSCC_NPM-NEXT:    [[P:%.*]] = phi i1 [ [[C]], [[ENTRY:%.*]] ], [ false, [[T]] ]
+; IS__CGSCC_NPM-NEXT:    ret i1 undef
+;
 entry:
-    br i1 %c, label %t, label %f
 t:
-    br label %f
 f:
-    %p = phi i1 [%c, %entry], [false, %t]
-    ret i1 %p
 }
 
 ;.
 ; IS__TUNIT_OPM: attributes #[[ATTR0]] = { nofree nosync nounwind willreturn }
 ; IS__TUNIT_OPM: attributes #[[ATTR1]] = { nofree norecurse nosync nounwind readnone willreturn }
 ; IS__TUNIT_OPM: attributes #[[ATTR2]] = { argmemonly nofree norecurse nosync nounwind willreturn writeonly }
 ; IS__TUNIT_OPM: attributes #[[ATTR3]] = { nofree norecurse nosync nounwind willreturn writeonly }
 ; IS__TUNIT_OPM: attributes #[[ATTR4]] = { argmemonly nofree norecurse nosync nounwind writeonly }

 ;.
 ; IS__CGSCC_OPM: attributes #[[ATTR0]] = { nofree nosync nounwind willreturn }
 ; IS__CGSCC_OPM: attributes #[[ATTR1]] = { nofree norecurse nosync nounwind readnone willreturn }
 ; IS__CGSCC_OPM: attributes #[[ATTR2]] = { argmemonly nofree norecurse nosync nounwind willreturn writeonly }
 ; IS__CGSCC_OPM: attributes #[[ATTR3]] = { argmemonly nofree norecurse nosync nounwind writeonly }
 ; IS__CGSCC_OPM: attributes #[[ATTR4]] = { nofree norecurse nosync nounwind willreturn writeonly }
 ; IS__CGSCC_OPM: attributes #[[ATTR5]] = { willreturn }
 ; IS__CGSCC_OPM: attributes #[[ATTR6]] = { nounwind willreturn writeonly }
+; IS__CGSCC_OPM: attributes #[[ATTR7]] = { readnone willreturn }
 ;.
 ; IS__CGSCC_NPM: attributes #[[ATTR0]] = { nofree nosync nounwind willreturn }
 ; IS__CGSCC_NPM: attributes #[[ATTR1]] = { nofree norecurse nosync nounwind readnone willreturn }
 ; IS__CGSCC_NPM: attributes #[[ATTR2]] = { argmemonly nofree norecurse nosync nounwind willreturn writeonly }
 ; IS__CGSCC_NPM: attributes #[[ATTR3]] = { nofree norecurse nosync nounwind willreturn writeonly }
 ; IS__CGSCC_NPM: attributes #[[ATTR4]] = { willreturn }
 ;.
 ; CHECK: [[RNG0]] = !{i32 0, i32 -2147483648}
 ;.