[Attributor] Improve `noalias` deduction based on memory information

[jdoerfert]

Summary

We now use memory behavior and memory location information to deduce

`noalias` for (call site) arguments. The key idea is that `noalias`
does not prevent aliases but accesses that would cause a race if
executed concurrently.

We do this in two ways:

[(1) At the call site] If the callee will not access "unknown" memory
locations we can look at the global and argument locations that are
accessed and determine if the call site operand aliases with the globals
or the call site operands associated with the arguments. If not,
`noalias` can be deduced.

[(2) In the callee] No matter what accesses the callee contains, if we
know the ones that happen for a given call site do not alias with an
argument the associated call site operand is `noalias`.

[merge_guards_bot]

Unit tests: unknown.

clang-tidy: unknown.

clang-format: unknown.

Build artifacts: diff.json, console-log.txt

Pre-merge checks is in beta. Report issue. Please join beta or enable it for your project.

[xbolva00]

llvm/test/Transforms/Attributor/ArgumentPromotion/2008-02-01-ReturnAttrs.ll

22 ↗

(On Diff #240424)

What happens here? We lost nocapture.

[jdoerfert]

llvm/test/Transforms/Attributor/ArgumentPromotion/2008-02-01-ReturnAttrs.ll

22 ↗

(On Diff #240424)

We did not lose information ;)

On call sites we do not automatically derive every attribute, it is generally not needed. Before, we needed to know if the attribute was nocapture so we derived it for the call site as well. Now, we can get the noalias on %x in @deref without the nocapture so it is not manifested here. If you query it via the llvm API you would get it anyway because we marked the argument in @deref.

[xbolva00]

llvm/test/Transforms/Attributor/ArgumentPromotion/2008-02-01-ReturnAttrs.ll

22 ↗

(On Diff #240424)

Ah, true. Thanks!

[jdoerfert]

Second try, cleaner approach and more powerful

[jdoerfert]

Update the tests as well

[merge_guards_bot]

Unit tests: unknown.

clang-tidy: unknown.

clang-format: unknown.

Build artifacts: diff.json, console-log.txt

Pre-merge checks is in beta. Report issue. Please join beta or enable it for your project.

[merge_guards_bot]

Unit tests: unknown.

clang-tidy: unknown.

clang-format: unknown.

Build artifacts: diff.json, console-log.txt

Pre-merge checks is in beta. Report issue. Please join beta or enable it for your project.

[jdoerfert]

rebase

[jdoerfert]

ping :)

[baziotis]

llvm/lib/Transforms/IPO/Attributor.cpp

2838–2840

Why do we know that?

2858

Maybe doc here (?) It looks similar to the above but some things I think would be good to be mentioned like why do we test for globals here.

2871

Maybe you want *Ptr here. Also maybe conditioned on Ptr (like above).

[jdoerfert]

llvm/lib/Transforms/IPO/Attributor.cpp

2838–2840

If we have already noalias (or an alloca) we know we do not alias any access in the scope not derived from this pointer. Since globals cannot be derived from a noalias pointer (in a way that would be problematic here) or in any way from an alloca, we know the global does not alias the pointer.

2858

Will write a doc :)

2871

Will do that.

[jdoerfert]

Addressed comments

[uenoku]

llvm/lib/Transforms/IPO/Attributor.cpp

2769

Don't we need to look at constant memories?

2830–2837

Please make a helper for

if(!AAR) AAR = ..
bool IsAliasing = !AAR | !AAR->isNoAlias(..);

2924

How about NO_MALLOCED_MEM?

[baziotis]

llvm/lib/Transforms/IPO/Attributor.cpp

2838–2840

Thanks for the explanation! The parts "a scope is derived from a pointer" (e.g. in the scope not derived from this pointer) are still unclear to me. What do I miss? Is there a specific part of code / doc I can read?

2858

Thanks!

2871

Ty!

[baziotis]

llvm/lib/Transforms/IPO/Attributor.cpp

2769

So, no malloced memory?

2924

Why not check for malloced memory? Although I think this goes along with your comment about constant memories.

[uenoku]

And I have a question.

define i32 @f1(i32* %p, i32* %q){
entry:
  %0 = load i32, i32* %q
  %1 = load i32, i32* %p
  %add = add nsw i32 %1, %0
  ret i32 %add
}

define i32 @f2(i32* nocapture readonly %p) {
entry:
  %call = tail call i32 @f1(i32* %p, i32* %p)
  ret i32 %call
}

In this case, %call = tail call i32 @f1(i32* noalias %p, i32* noalias %p) is deduced because they have only "read-read" dependencies.
I agree that this is a sound deduction since there is no write. (I know Rust compiler is doing similar things)

However, looking back to the definition of noalias in LangRef, I think this annotation violates the definition. Is it allowed conventionally?

[uenoku]

llvm/lib/Transforms/IPO/Attributor.cpp

2769

I think malloced memory cannot be seen from the caller so we don't have to care about here.

2924

I think malloced mem cannot be accessed from the caller but constant memory can be accessed.

[jdoerfert]

In D73428#1878746, @uenoku wrote:

And I have a question.

define i32 @f1(i32* %p, i32* %q){
entry:
  %0 = load i32, i32* %q
  %1 = load i32, i32* %p
  %add = add nsw i32 %1, %0
  ret i32 %add
}

define i32 @f2(i32* nocapture readonly %p) {
entry:
  %call = tail call i32 @f1(i32* %p, i32* %p)
  ret i32 %call
}

In this case, %call = tail call i32 @f1(i32* noalias %p, i32* noalias %p) is deduced because they have only "read-read" dependencies.
I agree that this is a sound deduction since there is no write. (I know Rust compiler is doing similar things)

However, looking back to the definition of noalias in LangRef, I think this annotation violates the definition. Is it allowed conventionally?

If this would violate the LangRef we would have a problem. I don't think it does but I think we need to make that explicit. I'll talk to @hfinkel and come back with lang ref patch or a revised version of this ;)

llvm/lib/Transforms/IPO/Attributor.cpp

2769

Correct. Constant memory does not change, so it's the read only argument again. Malloced memory, local memory, inaccessible memory, cannot "alias" with the arguments we pass at the call site by design.

2838–2840

I think the actually relevant documentation is https://en.cppreference.com/w/c/language/restrict

2924

Constant memory is read only, read-read argument. Malloced memory is memory that was returned by a noalias function. It does not alias anything not derived from that pointer. If the call was made in this function (the callee wrt AANoAliasCallSiteArgument) then it cannot alias an argument of this function since they were around before the call was made :)

[hfinkel]

In D73428#1879059, @jdoerfert wrote:

In D73428#1878746, @uenoku wrote:

And I have a question.

define i32 @f1(i32* %p, i32* %q){
entry:
  %0 = load i32, i32* %q
  %1 = load i32, i32* %p
  %add = add nsw i32 %1, %0
  ret i32 %add
}

define i32 @f2(i32* nocapture readonly %p) {
entry:
  %call = tail call i32 @f1(i32* %p, i32* %p)
  ret i32 %call
}

In this case, %call = tail call i32 @f1(i32* noalias %p, i32* noalias %p) is deduced because they have only "read-read" dependencies.
I agree that this is a sound deduction since there is no write. (I know Rust compiler is doing similar things)

However, looking back to the definition of noalias in LangRef, I think this annotation violates the definition. Is it allowed conventionally?

If this would violate the LangRef we would have a problem. I don't think it does but I think we need to make that explicit. I'll talk to @hfinkel and come back with lang ref patch or a revised version of this ;)

I think that this is probably a good idea, but I think that we need a short RFC on this. We should have some visibility on this issue before we update the LangRef in this regard.

[baziotis]

llvm/lib/Transforms/IPO/Attributor.cpp

2838–2840

Thanks, I hadn't seen that comment.

[jdoerfert]

The lang ref patch landed. I need to rebase this but I was hoping someone could take another look now.

llvm/lib/Transforms/IPO/Attributor.cpp

isKnownNoAliasDueToNoAliasPreservation(Attributor &A, AAResults *&AAR,
     for (unsigned OtherArgNo = 0; OtherArgNo < ICS.getNumArgOperands();
          OtherArgNo++)
       if (mayAliasWithArgument(A, AAR, MemBehaviorAA, ICS, OtherArgNo))
         return false;
 
     return true;
   }
 
+  /// Perform the alias check at the call site. We can allow all but accesses to
+  /// unknown memory as long as we check accesses to arguments and globals for
+  /// potential aliases to the underlying call site argument. That is, if the
+  /// call site argument does not alias any argument or global which is accessed
+  /// by the callee it can be marked noalias.
+  bool isKnownNoAliasAtCallSiteDueToAccesses(
+      Attributor &A, AAResults *&AAR, const AAMemoryBehavior &MemBehaviorAA,
+      const AANoAlias &NoAliasAA, const AAMemoryLocation &MemLocationAA) {
+
+    AAMemoryLocation::MemoryLocationsKind AllowedAccessLocs =
+        AAMemoryLocation::NO_UNKOWN_MEM;
+
+    bool OnlyKnownLocationsAccessed =
+        MemLocationAA.isAssumedSpecifiedMemOnly(AllowedAccessLocs);
+    LLVM_DEBUG(
+        dbgs() << "[AANoAlias] Only known locations "
+                  "accessed by callee: "
+               << OnlyKnownLocationsAccessed << " ["
+               << AAMemoryLocation::getMemoryLocationsAsStr(AllowedAccessLocs)
+               << " vs "
+               << AAMemoryLocation::getMemoryLocationsAsStr(
+                      MemLocationAA.getAssumedNotAccessedLocation())
+               << "]\n");
+
+    if (!OnlyKnownLocationsAccessed)
+      return false;
+
+    bool IsReadOnly = MemBehaviorAA.isAssumedReadOnly();
+    ImmutableCallSite ICS(&getAnchorValue());
+
+    // Helper to determine if noalias is prevented by the memory access
+    // instruction I which accesses Ptr of memory kind MLK.
+    auto AccessPred = [&](const Instruction *I, const Value *Ptr,
+                          AAMemoryLocation::AccessKind Kind,
+                          AAMemoryLocation::MemoryLocationsKind MLK) {
+      LLVM_DEBUG({
+        dbgs() << "[AANoAlias] Check access by ";
+        if (I)
+          dbgs() << *I << " to ";
+        else
+          dbgs() << "<unknown inst> to ";
+        if (Ptr)
+          dbgs() << *Ptr << " ["
+                 << AAMemoryLocation::getMemoryLocationsAsStr(MLK) << "]\n";
+        else
+          dbgs() << "<unknown ptr> ["
+                 << AAMemoryLocation::getMemoryLocationsAsStr(MLK) << "]\n";
+      });
+
+      // Ignore "read-read" "dependences".
+      if (Kind == AAMemoryLocation::READ && IsReadOnly) {
+        A.recordDependence(MemBehaviorAA, *this, DepClassTy::OPTIONAL);
+        return true;
+      }
+      if (!Ptr)
+        return false;
+      if (auto *PtrArg = dyn_cast<Argument>(Ptr))
+        return !mayAliasWithArgument(A, AAR, MemBehaviorAA, ICS,
+                                     PtrArg->getArgNo());
+
+      if (!AAR)
+        AAR = A.getInfoCache().getAAResultsForFunction(*getAnchorScope());
+
+      assert(isa<GlobalValue>(Ptr) && "Expected global value.");
+      bool IsAliasing = !AAR || !AAR->isNoAlias(&getAssociatedValue(), Ptr);
+      LLVM_DEBUG(dbgs() << "[AANoAlias] Check alias at "
+                           "callsite: "
+                        << getAssociatedValue() << " | " << *Ptr << " => "
+                        << (IsAliasing ? "" : "no-") << "alias \n");
+
+      return !IsAliasing;
+    };
+
+    // We can and want to check arguments and globals for aliasing.
+    AAMemoryLocation::MemoryLocationsKind LocationsNotToCheck =
+        AAMemoryLocation::NO_ARGUMENT_MEM;
+
+    // If the definition is not `noalias` we need to check globals in addition
+    // to arguments. If the definition is `noalias` we cannot alias globals to
+    // begin with.
+    bool AssociatedValueIsNoAliasAtDef = NoAliasAA.isAssumedNoAlias();
+    if (!AssociatedValueIsNoAliasAtDef)
+      LocationsNotToCheck |= AAMemoryLocation::NO_GLOBAL_MEM;
+    else
+      A.recordDependence(NoAliasAA, *this, DepClassTy::OPTIONAL);
+
+    AAMemoryLocation::MemoryLocationsKind LocationsToCheck =
+        AAMemoryLocation::inverseLocation(LocationsNotToCheck, false, false);
+    if (!MemLocationAA.checkForAllAccessesToMemoryKind(AccessPred,
+                                                       LocationsToCheck))
+      return false;
+
+    A.recordDependence(MemLocationAA, *this, DepClassTy::OPTIONAL);
+    return true;
+  }
+
+  /// Perform the alias check in the callee. We basically check if all
+  /// accesses in the callee do not violate the `noalias` property for the
+  /// underlying call site argument. A violation would be an access that may not
+  /// be derived from the argument but which aliases it. Note that this allows
+  /// accesses to unknown memory as long as AliasAnalysis knows it will not
+  /// alias with the associated argument.
+  bool
+  isKnownNoAliasInCalleeDueToAccesses(Attributor &A,
+                                      const AAMemoryBehavior &MemBehaviorAA,
+                                      const AAMemoryLocation &MemLocationAA) {
+    bool IsReadOnly = MemBehaviorAA.isAssumedReadOnly();
+    Argument *AssociatedArg = getAssociatedArgument();
+    AAResults *AAR = nullptr;
+
+    // Helper to determine if noalias is prevented by the memory access
+    // instruction I which accesses Ptr of memory kind MLK.
+    auto AccessPred = [&](const Instruction *I, const Value *Ptr,
+                          AAMemoryLocation::AccessKind Kind,
+                          AAMemoryLocation::MemoryLocationsKind MLK) {
+      LLVM_DEBUG({
+        dbgs() << "[AANoAlias] Check access by ";
+        if (I)
+          dbgs() << *I << " to ";
+        else
+          dbgs() << "<unknown inst> to ";
+        if (Ptr)
+          dbgs() << *Ptr << " ["
+                 << AAMemoryLocation::getMemoryLocationsAsStr(MLK) << "]\n";
+        else
+          dbgs() << "<unknown ptr> ["
+                 << AAMemoryLocation::getMemoryLocationsAsStr(MLK) << "]\n";
+      });
+
+      // Ignore "read-read" "dependences".
+      if (Kind == AAMemoryLocation::READ && IsReadOnly) {
+        A.recordDependence(MemBehaviorAA, *this, DepClassTy::OPTIONAL);
+        return true;
+      }
+      if (!Ptr)
+        return false;
+
+      // Ignore accesses derived from this argument.
+      if (auto *PtrArg = dyn_cast<Argument>(Ptr))
+        if (AssociatedArg == PtrArg)
+          return true;
+
+      if (!AAR)
+        AAR = A.getInfoCache().getAAResultsForFunction(
+            *AssociatedArg->getParent());
+
+      bool IsAliasing = !AAR || !AAR->isNoAlias(AssociatedArg, Ptr);
+      LLVM_DEBUG(dbgs() << "[AANoAlias] Check alias in callee: "
+                        << *AssociatedArg << " : " << *Ptr << " => "
+                        << (IsAliasing ? "" : "no-") << "alias \n");
+
+      return !IsAliasing;
+    };
+
+    // We can and want to check arguments against all but local and inaccesible
+    // memory. Arguments are by definition not aliasing either of those.
+    AAMemoryLocation::MemoryLocationsKind LocationsToCheck =
+        AAMemoryLocation::ALL_LOCATIONS | AAMemoryLocation::NO_LOCAL_MEM |
+        AAMemoryLocation::NO_INACCESSIBLE_MEM;
+
+    if (!MemLocationAA.checkForAllAccessesToMemoryKind(AccessPred,
+                                                       LocationsToCheck))
+      return false;
+
+    A.recordDependence(MemLocationAA, *this, DepClassTy::OPTIONAL);
+    return true;
+  }
+
   /// See AbstractAttribute::updateImpl(...).
   ChangeStatus updateImpl(Attributor &A) override {
     // If the argument is readnone we are done as there are no accesses via the
     // argument.
     auto &MemBehaviorAA =
         A.getAAFor<AAMemoryBehavior>(*this, getIRPosition(),
                                      /* TrackDependence */ false);
     if (MemBehaviorAA.isAssumedReadNone()) {
       A.recordDependence(MemBehaviorAA, *this, DepClassTy::OPTIONAL);
       return ChangeStatus::UNCHANGED;
     }
 
     const IRPosition &VIRP = IRPosition::value(getAssociatedValue());
     const auto &NoAliasAA = A.getAAFor<AANoAlias>(*this, VIRP,
                                                   /* TrackDependence */ false);
 
     AAResults *AAR = nullptr;
     if (isKnownNoAliasDueToNoAliasPreservation(A, AAR, MemBehaviorAA,
                                                NoAliasAA)) {
       LLVM_DEBUG(
           dbgs() << "[AANoAlias] No-Alias deduced via no-alias preservation\n");
       return ChangeStatus::UNCHANGED;
     }
 
+    auto &MemLocationAA = A.getAAFor<AAMemoryLocation>(
+        *this, IRPosition::function_scope(getIRPosition()),
+        /* TrackDependence */ false);
+    if (isKnownNoAliasAtCallSiteDueToAccesses(A, AAR, MemBehaviorAA, NoAliasAA,
+                                              MemLocationAA)) {
+      LLVM_DEBUG(
+          dbgs() << "[AANoAlias] No-Alias deduced via call site accesses\n");
+      return ChangeStatus::UNCHANGED;
+    }
+
+    if (isKnownNoAliasInCalleeDueToAccesses(A, MemBehaviorAA, MemLocationAA)) {
+      LLVM_DEBUG(
+          dbgs() << "[AANoAlias] No-Alias deduced via callee accesses\n");
+      return ChangeStatus::UNCHANGED;
+    }
+
     return indicatePessimisticFixpoint();
   }
 
   /// See AbstractAttribute::trackStatistics()
   void trackStatistics() const override { STATS_DECLTRACK_CSARG_ATTR(noalias) }
 };
 
 /// NoAlias attribute for function return value.

llvm/test/Transforms/Attributor/ArgumentPromotion/control-flow.ll

 ; NOTE: Assertions have been autogenerated by utils/update_test_checks.py UTC_ARGS: --function-signature --scrub-attributes
 ; RUN: opt -S -passes='attributor' -aa-pipeline='basic-aa' -attributor-disable=false -attributor-max-iterations-verify -attributor-max-iterations=2 < %s | FileCheck %s
 
 ; Don't promote around control flow.
 define internal i32 @callee(i1 %C, i32* %P) {
 ; CHECK-LABEL: define {{[^@]+}}@callee
-; CHECK-SAME: (i1 [[C:%.*]], i32* nocapture nofree readonly [[P:%.*]])
+; CHECK-SAME: (i1 [[C:%.*]], i32* noalias nocapture nofree readonly [[P:%.*]])
 ; CHECK-NEXT:  entry:
 ; CHECK-NEXT:    br i1 [[C]], label [[T:%.*]], label [[F:%.*]]
 ; CHECK:       T:
 ; CHECK-NEXT:    ret i32 17
 ; CHECK:       F:
 ; CHECK-NEXT:    [[X:%.*]] = load i32, i32* [[P]]
 ; CHECK-NEXT:    ret i32 [[X]]
 ;
 entry:
   br i1 %C, label %T, label %F
 
 T:
   ret i32 17
 
 F:
   %X = load i32, i32* %P
   ret i32 %X
 }
 
 define i32 @foo(i1 %C, i32* %P) {
 ; CHECK-LABEL: define {{[^@]+}}@foo
 ; CHECK-SAME: (i1 [[C:%.*]], i32* nocapture nofree readonly [[P:%.*]])
 ; CHECK-NEXT:  entry:
-; CHECK-NEXT:    [[X:%.*]] = call i32 @callee(i1 [[C]], i32* nocapture nofree readonly [[P]])
+; CHECK-NEXT:    [[X:%.*]] = call i32 @callee(i1 [[C]], i32* noalias nocapture nofree readonly [[P]])
 ; CHECK-NEXT:    ret i32 [[X]]
 ;
 entry:
   %X = call i32 @callee(i1 %C, i32* %P)
   ret i32 %X
 }
 

llvm/test/Transforms/Attributor/ArgumentPromotion/live_called_from_dead_2.ll

 ; OLDPM_MODULE-NEXT:    br i1 true, label [[LIVE:%.*]], label [[DEAD:%.*]]
 ; OLDPM_MODULE:       live:
 ; OLDPM_MODULE-NEXT:    store i32 0, i32* [[X]], align 4
 ; OLDPM_MODULE-NEXT:    ret i32 undef
 ; OLDPM_MODULE:       dead:
 ; OLDPM_MODULE-NEXT:    unreachable
 ;
 ; OLDPM_CGSCC-LABEL: define {{[^@]+}}@test
-; OLDPM_CGSCC-SAME: (i32* nocapture nofree writeonly [[X:%.*]])
+; OLDPM_CGSCC-SAME: (i32* noalias nocapture nofree writeonly [[X:%.*]])
 ; OLDPM_CGSCC-NEXT:    br i1 true, label [[LIVE:%.*]], label [[DEAD:%.*]]
 ; OLDPM_CGSCC:       live:
 ; OLDPM_CGSCC-NEXT:    store i32 0, i32* [[X]]
 ; OLDPM_CGSCC-NEXT:    ret i32 undef
 ; OLDPM_CGSCC:       dead:
 ; OLDPM_CGSCC-NEXT:    unreachable
 ;
 ; NEWPM_MODULE-LABEL: define {{[^@]+}}@test
 ; NEWPM_MODULE-SAME: (i32* noalias nocapture nofree writeonly align 4 [[X:%.*]])
 ; NEWPM_MODULE-NEXT:    br i1 true, label [[LIVE:%.*]], label [[DEAD:%.*]]
 ; NEWPM_MODULE:       live:
 ; NEWPM_MODULE-NEXT:    store i32 0, i32* [[X]], align 4
 ; NEWPM_MODULE-NEXT:    ret i32 undef
 ; NEWPM_MODULE:       dead:
 ; NEWPM_MODULE-NEXT:    unreachable
 ;
 ; NEWPM_CGSCC-LABEL: define {{[^@]+}}@test
-; NEWPM_CGSCC-SAME: (i32* nocapture nofree writeonly [[X:%.*]])
+; NEWPM_CGSCC-SAME: (i32* noalias nocapture nofree writeonly [[X:%.*]])
 ; NEWPM_CGSCC-NEXT:    br i1 true, label [[LIVE:%.*]], label [[DEAD:%.*]]
 ; NEWPM_CGSCC:       live:
 ; NEWPM_CGSCC-NEXT:    store i32 0, i32* [[X]]
 ; NEWPM_CGSCC-NEXT:    ret i32 undef
 ; NEWPM_CGSCC:       dead:
 ; NEWPM_CGSCC-NEXT:    unreachable
 ;
   br i1 true, label %live, label %dead

 ; OLDPM_MODULE-NEXT:    store i32 1, i32* [[A]], align 4
 ; OLDPM_MODULE-NEXT:    [[C:%.*]] = call i32 @test(i32* noalias nocapture nofree nonnull writeonly align 4 dereferenceable(4) [[B]])
 ; OLDPM_MODULE-NEXT:    ret i32 undef
 ;
 ; OLDPM_CGSCC-LABEL: define {{[^@]+}}@caller
 ; OLDPM_CGSCC-SAME: (i32* nocapture nofree writeonly [[B:%.*]])
 ; OLDPM_CGSCC-NEXT:    [[A:%.*]] = alloca i32
 ; OLDPM_CGSCC-NEXT:    store i32 1, i32* [[A]], align 4
-; OLDPM_CGSCC-NEXT:    [[C:%.*]] = call i32 @test(i32* nocapture nofree writeonly [[B]])
+; OLDPM_CGSCC-NEXT:    [[C:%.*]] = call i32 @test(i32* noalias nocapture nofree writeonly [[B]])
 ; OLDPM_CGSCC-NEXT:    ret i32 0
 ;
 ; NEWPM_MODULE-LABEL: define {{[^@]+}}@caller
 ; NEWPM_MODULE-SAME: (i32* noalias nocapture nofree nonnull writeonly align 4 dereferenceable(4) [[B:%.*]])
 ; NEWPM_MODULE-NEXT:    [[A:%.*]] = alloca i32
 ; NEWPM_MODULE-NEXT:    store i32 1, i32* [[A]], align 4
 ; NEWPM_MODULE-NEXT:    [[C:%.*]] = call i32 @test(i32* noalias nocapture nofree nonnull writeonly align 4 dereferenceable(4) [[B]])
 ; NEWPM_MODULE-NEXT:    ret i32 undef
 ;
 ; NEWPM_CGSCC-LABEL: define {{[^@]+}}@caller
 ; NEWPM_CGSCC-SAME: (i32* nocapture nofree writeonly [[B:%.*]])
 ; NEWPM_CGSCC-NEXT:    [[A:%.*]] = alloca i32
 ; NEWPM_CGSCC-NEXT:    store i32 1, i32* [[A]], align 4
-; NEWPM_CGSCC-NEXT:    [[C:%.*]] = call i32 @test(i32* nocapture nofree writeonly [[B]])
+; NEWPM_CGSCC-NEXT:    [[C:%.*]] = call i32 @test(i32* noalias nocapture nofree writeonly [[B]])
 ; NEWPM_CGSCC-NEXT:    ret i32 undef
 ;
   %A = alloca i32
   store i32 1, i32* %A
   %C = call i32 @test(i32* %B, i32* %A)
   ret i32 %C
 }
 

llvm/test/Transforms/Attributor/ArgumentPromotion/musttail.ll

 ; NOTE: Assertions have been autogenerated by utils/update_test_checks.py UTC_ARGS: --function-signature --scrub-attributes
 ; RUN: opt -S -passes=attributor -aa-pipeline='basic-aa' -attributor-disable=false -attributor-max-iterations-verify -attributor-max-iterations=1 < %s | FileCheck %s
 ; PR36543
 
 ; Don't promote arguments of musttail callee
 
 %T = type { i32, i32, i32, i32 }
 
 define internal i32 @test(%T* %p) {
 ; CHECK-LABEL: define {{[^@]+}}@test
-; CHECK-SAME: (%T* nocapture nofree readonly [[P:%.*]])
+; CHECK-SAME: (%T* noalias nocapture nofree readonly [[P:%.*]])
 ; CHECK-NEXT:    [[A_GEP:%.*]] = getelementptr [[T:%.*]], %T* [[P]], i64 0, i32 3
 ; CHECK-NEXT:    [[B_GEP:%.*]] = getelementptr [[T]], %T* [[P]], i64 0, i32 2
 ; CHECK-NEXT:    [[A:%.*]] = load i32, i32* [[A_GEP]]
 ; CHECK-NEXT:    [[B:%.*]] = load i32, i32* [[B_GEP]]
 ; CHECK-NEXT:    [[V:%.*]] = add i32 [[A]], [[B]]
 ; CHECK-NEXT:    ret i32 [[V]]
 ;
   %a.gep = getelementptr %T, %T* %p, i64 0, i32 3
   %b.gep = getelementptr %T, %T* %p, i64 0, i32 2
   %a = load i32, i32* %a.gep
   %b = load i32, i32* %b.gep
   %v = add i32 %a, %b
   ret i32 %v
 }
 
 define i32 @caller(%T* %p) {
 ; CHECK-LABEL: define {{[^@]+}}@caller
 ; CHECK-SAME: (%T* nocapture nofree readonly [[P:%.*]])
-; CHECK-NEXT:    [[V:%.*]] = musttail call i32 @test(%T* nocapture nofree readonly [[P]])
+; CHECK-NEXT:    [[V:%.*]] = musttail call i32 @test(%T* noalias nocapture nofree readonly [[P]])
 ; CHECK-NEXT:    ret i32 [[V]]
 ;
   %v = musttail call i32 @test(%T* %p)
   ret i32 %v
 }
 
 ; Don't promote arguments of musttail caller
 

 ;
   %i32ptr = getelementptr %T, %T* %p, i64 0, i32 0
   store i32 %v, i32* %i32ptr
   ret i32 0
 }
 
 define internal i32 @test2b(%T* %p, i32 %p2) {
 ; CHECK-LABEL: define {{[^@]+}}@test2b
-; CHECK-SAME: (%T* nocapture nofree readonly [[P:%.*]], i32 [[P2:%.*]])
+; CHECK-SAME: (%T* noalias nocapture nofree readonly [[P:%.*]], i32 [[P2:%.*]])
 ; CHECK-NEXT:    [[A_GEP:%.*]] = getelementptr [[T:%.*]], %T* [[P]], i64 0, i32 3
 ; CHECK-NEXT:    [[B_GEP:%.*]] = getelementptr [[T]], %T* [[P]], i64 0, i32 2
 ; CHECK-NEXT:    [[A:%.*]] = load i32, i32* [[A_GEP]]
 ; CHECK-NEXT:    [[B:%.*]] = load i32, i32* [[B_GEP]]
 ; CHECK-NEXT:    [[V:%.*]] = add i32 [[A]], [[B]]
 ; CHECK-NEXT:    [[CA:%.*]] = musttail call i32 @bar(%T* undef, i32 [[V]])
 ; CHECK-NEXT:    ret i32 [[CA]]
 ;
   %a.gep = getelementptr %T, %T* %p, i64 0, i32 3
   %b.gep = getelementptr %T, %T* %p, i64 0, i32 2
   %a = load i32, i32* %a.gep
   %b = load i32, i32* %b.gep
   %v = add i32 %a, %b
   %ca = musttail call i32 @bar(%T* undef, i32 %v)
   ret i32 %ca
 }
 
 define i32 @caller2b(%T* %g) {
 ; CHECK-LABEL: define {{[^@]+}}@caller2b
 ; CHECK-SAME: (%T* nocapture nofree readonly [[G:%.*]])
-; CHECK-NEXT:    [[V:%.*]] = call i32 @test2b(%T* nocapture nofree readonly [[G]], i32 undef)
+; CHECK-NEXT:    [[V:%.*]] = call i32 @test2b(%T* noalias nocapture nofree readonly [[G]], i32 undef)
 ; CHECK-NEXT:    ret i32 0
 ;
   %v = call i32 @test2b(%T* %g, i32 0)
   ret i32 %v
 }

llvm/test/Transforms/Attributor/ArgumentPromotion/pr32917.ll

 ; NOTE: Assertions have been autogenerated by utils/update_test_checks.py UTC_ARGS: --function-signature --scrub-attributes
-; RUN: opt -S -passes=attributor -aa-pipeline='basic-aa' -attributor-disable=false -attributor-max-iterations-verify -attributor-max-iterations=3 < %s | FileCheck %s
+; RUN: opt -S -passes=attributor -aa-pipeline='basic-aa' -attributor-disable=false -attributor-max-iterations-verify -attributor-max-iterations=3 < %s | FileCheck %s --check-prefixes=CHECK,BASIC_AA
+; RUN: opt -S -passes='require<globals-aa>,attributor' -aa-pipeline='globals-aa,basic-aa' -attributor-disable=false -attributor-max-iterations-verify -attributor-max-iterations=3 < %s | FileCheck %s -check-prefixes=CHECK,GLOBALS_AA
 ; PR 32917
 
 @b = common local_unnamed_addr global i32 0, align 4
-@a = common local_unnamed_addr global i32 0, align 4
+@a = private local_unnamed_addr global i32 0, align 4
 
 define i32 @fn2() local_unnamed_addr {
-; CHECK-LABEL: define {{[^@]+}}@fn2() local_unnamed_addr
-; CHECK-NEXT:    [[TMP1:%.*]] = load i32, i32* @b, align 4
-; CHECK-NEXT:    [[TMP2:%.*]] = sext i32 [[TMP1]] to i64
-; CHECK-NEXT:    [[TMP3:%.*]] = inttoptr i64 [[TMP2]] to i32*
-; CHECK-NEXT:    call fastcc void @fn1(i32* nofree readonly align 4 [[TMP3]])
-; CHECK-NEXT:    ret i32 undef
+; BASIC_AA-LABEL: define {{[^@]+}}@fn2() local_unnamed_addr
+; BASIC_AA-NEXT:    [[TMP1:%.*]] = load i32, i32* @b, align 4
+; BASIC_AA-NEXT:    [[TMP2:%.*]] = sext i32 [[TMP1]] to i64
+; BASIC_AA-NEXT:    [[TMP3:%.*]] = inttoptr i64 [[TMP2]] to i32*
+; BASIC_AA-NEXT:    call fastcc void @fn1(i32* nofree readonly align 4 [[TMP3]])
+; BASIC_AA-NEXT:    ret i32 undef
+;
+; GLOBALS_AA-LABEL: define {{[^@]+}}@fn2() local_unnamed_addr
+; GLOBALS_AA-NEXT:    [[TMP1:%.*]] = load i32, i32* @b, align 4
+; GLOBALS_AA-NEXT:    [[TMP2:%.*]] = sext i32 [[TMP1]] to i64
+; GLOBALS_AA-NEXT:    [[TMP3:%.*]] = inttoptr i64 [[TMP2]] to i32*
+; GLOBALS_AA-NEXT:    call fastcc void @fn1(i32* noalias nofree readonly align 4 [[TMP3]])
+; GLOBALS_AA-NEXT:    ret i32 undef
 ;
   %1 = load i32, i32* @b, align 4
   %2 = sext i32 %1 to i64
   %3 = inttoptr i64 %2 to i32*
   call fastcc void @fn1(i32* %3)
   ret i32 undef
 }
 
 define internal fastcc void @fn1(i32* nocapture readonly) unnamed_addr {
-; CHECK-LABEL: define {{[^@]+}}@fn1
-; CHECK-SAME: (i32* nocapture nofree nonnull readonly align 4 [[TMP0:%.*]]) unnamed_addr
-; CHECK-NEXT:    [[TMP2:%.*]] = getelementptr inbounds i32, i32* [[TMP0]], i64 -1
-; CHECK-NEXT:    [[TMP3:%.*]] = load i32, i32* [[TMP2]], align 4
-; CHECK-NEXT:    store i32 [[TMP3]], i32* @a, align 4
-; CHECK-NEXT:    ret void
+; BASIC_AA-LABEL: define {{[^@]+}}@fn1
+; BASIC_AA-SAME: (i32* nocapture nofree nonnull readonly align 4 [[TMP0:%.*]]) unnamed_addr
+; BASIC_AA-NEXT:    [[TMP2:%.*]] = getelementptr inbounds i32, i32* [[TMP0]], i64 -1
+; BASIC_AA-NEXT:    [[TMP3:%.*]] = load i32, i32* [[TMP2]], align 4
+; BASIC_AA-NEXT:    store i32 [[TMP3]], i32* @a, align 4
+; BASIC_AA-NEXT:    ret void
+;
+; GLOBALS_AA-LABEL: define {{[^@]+}}@fn1
+; GLOBALS_AA-SAME: (i32* noalias nocapture nofree nonnull readonly align 4 [[TMP0:%.*]]) unnamed_addr
+; GLOBALS_AA-NEXT:    [[TMP2:%.*]] = getelementptr inbounds i32, i32* [[TMP0]], i64 -1
+; GLOBALS_AA-NEXT:    [[TMP3:%.*]] = load i32, i32* [[TMP2]], align 4
+; GLOBALS_AA-NEXT:    store i32 [[TMP3]], i32* @a, align 4
+; GLOBALS_AA-NEXT:    ret void
 ;
   %2 = getelementptr inbounds i32, i32* %0, i64 -1
   %3 = load i32, i32* %2, align 4
   store i32 %3, i32* @a, align 4
   ret void
 }

llvm/test/Transforms/Attributor/ArgumentPromotion/reserve-tbaa.ll

 @a = global i32* null, align 8
 @e = global i32** @a, align 8
 @g = global i32 0, align 4
 @c = global i64 0, align 8
 @d = global i8 0, align 1
 
 define internal fastcc void @fn(i32* nocapture readonly %p1, i64* nocapture readonly %p2) {
 ; CHECK-LABEL: define {{[^@]+}}@fn
-; CHECK-SAME: (i32* nocapture nofree nonnull readonly align 4 dereferenceable(4) [[P1:%.*]])
+; CHECK-SAME: (i32* noalias nocapture nofree nonnull readonly align 4 dereferenceable(4) [[P1:%.*]])
 ; CHECK-NEXT:  entry:
 ; CHECK-NEXT:    [[TMP0:%.*]] = load i32, i32* @g, align 4, !tbaa !0
 ; CHECK-NEXT:    [[CONV1:%.*]] = trunc i32 [[TMP0]] to i8
 ; CHECK-NEXT:    store i8 [[CONV1]], i8* @d, align 1, !tbaa !4
 ; CHECK-NEXT:    ret void
 ;
 entry:
   %0 = load i64, i64* %p2, align 8, !tbaa !1
   %conv = trunc i64 %0 to i32
   %1 = load i32, i32* %p1, align 4, !tbaa !5
   %conv1 = trunc i32 %1 to i8
   store i8 %conv1, i8* @d, align 1, !tbaa !7
   ret void
 }
 
 define i32 @main() {
 ; CHECK-LABEL: define {{[^@]+}}@main()
 ; CHECK-NEXT:  entry:
 ; CHECK-NEXT:    [[TMP0:%.*]] = load i32**, i32*** @e, align 8, !tbaa !5
 ; CHECK-NEXT:    store i32* @g, i32** [[TMP0]], align 8, !tbaa !5
 ; CHECK-NEXT:    [[TMP1:%.*]] = load i32*, i32** @a, align 8, !tbaa !5
 ; CHECK-NEXT:    store i32 1, i32* [[TMP1]], align 4, !tbaa !0
-; CHECK-NEXT:    call fastcc void @fn(i32* nofree nonnull readonly align 4 dereferenceable(4) @g)
+; CHECK-NEXT:    call fastcc void @fn(i32* noalias nofree nonnull readonly align 4 dereferenceable(4) @g)
 ; CHECK-NEXT:    ret i32 0
 ;
 entry:
   %0 = load i32**, i32*** @e, align 8, !tbaa !8
   store i32* @g, i32** %0, align 8, !tbaa !8
   %1 = load i32*, i32** @a, align 8, !tbaa !8
   store i32 1, i32* %1, align 4, !tbaa !5
   call fastcc void @fn(i32* @g, i64* @c)

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

 ;     // If p[i] is inbounds, p is dereferenceable(40) at least.
 ;     p[i] = i;
 ;   }
 ; }
 
 define internal void @fill_range_not_inbounds(i32* %p, i64 %start){
 ; ATTRIBUTOR-LABEL: define {{[^@]+}}@fill_range_not_inbounds
 ; NOTE: %p should not be dereferenceable
-; ATTRIBUTOR-SAME: (i32* nocapture nofree writeonly [[P:%.*]], i64 [[START:%.*]])
+; ATTRIBUTOR-SAME: (i32* noalias nocapture nofree writeonly [[P:%.*]], i64 [[START:%.*]])
 ; ATTRIBUTOR-NEXT:  entry:
 ; ATTRIBUTOR-NEXT:    [[TMP0:%.*]] = add nsw i64 [[START:%.*]], 9
 ; ATTRIBUTOR-NEXT:    br label [[FOR_BODY:%.*]]
 ; ATTRIBUTOR:       for.cond.cleanup:
 ; ATTRIBUTOR-NEXT:    ret void
 ; ATTRIBUTOR:       for.body:
 ; ATTRIBUTOR-NEXT:    [[I_06:%.*]] = phi i64 [ [[START]], [[ENTRY:%.*]] ], [ [[INC:%.*]], [[FOR_BODY]] ]
 ; ATTRIBUTOR-NEXT:    [[CONV:%.*]] = trunc i64 [[I_06]] to i32
for.body:                                         ; preds = %entry, %for.body
   store i32 %conv, i32* %arrayidx, align 4
   %inc = add nsw i64 %i.06, 1
   %cmp = icmp slt i64 %i.06, %0
   br i1 %cmp, label %for.body, label %for.cond.cleanup
 }
 define internal void @fill_range_inbounds(i32* %p, i64 %start){
 ; ATTRIBUTOR-LABEL: define {{[^@]+}}@fill_range_inbounds
 ; FIXME: %p should be dereferenceable(40)
-; ATTRIBUTOR-SAME: (i32* nocapture nofree writeonly [[P:%.*]], i64 [[START:%.*]])
+; ATTRIBUTOR-SAME: (i32* noalias nocapture nofree writeonly [[P:%.*]], i64 [[START:%.*]])
 ; ATTRIBUTOR-NEXT:  entry:
 ; ATTRIBUTOR-NEXT:    [[TMP0:%.*]] = add nsw i64 [[START:%.*]], 9
 ; ATTRIBUTOR-NEXT:    br label [[FOR_BODY:%.*]]
 ; ATTRIBUTOR:       for.cond.cleanup:
 ; ATTRIBUTOR-NEXT:    ret void
 ; ATTRIBUTOR:       for.body:
 ; ATTRIBUTOR-NEXT:    [[I_06:%.*]] = phi i64 [ [[START]], [[ENTRY:%.*]] ], [ [[INC:%.*]], [[FOR_BODY]] ]
 ; ATTRIBUTOR-NEXT:    [[CONV:%.*]] = trunc i64 [[I_06]] to i32
for.body:                                         ; preds = %entry, %for.body
   br i1 %cmp, label %for.body, label %for.cond.cleanup
 }
 
 define void @call_fill_range(i32* nocapture %p, i64* nocapture readonly %range) {
 ; ATTRIBUTOR-LABEL: define {{[^@]+}}@call_fill_range
 ; ATTRIBUTOR-SAME: (i32* nocapture nofree writeonly [[P:%.*]], i64* nocapture nofree nonnull readonly align 8 dereferenceable(8) [[RANGE:%.*]])
 ; ATTRIBUTOR-NEXT:  entry:
 ; ATTRIBUTOR-NEXT:    [[TMP0:%.*]] = load i64, i64* [[RANGE:%.*]], align 8, !range !0
-; ATTRIBUTOR-NEXT:    tail call void @fill_range_inbounds(i32* nocapture nofree writeonly [[P:%.*]], i64 [[TMP0]])
-; ATTRIBUTOR-NEXT:    tail call void @fill_range_not_inbounds(i32* nocapture nofree writeonly [[P]], i64 [[TMP0]])
+; ATTRIBUTOR-NEXT:    tail call void @fill_range_inbounds(i32* noalias nocapture nofree writeonly [[P:%.*]], i64 [[TMP0]])
+; ATTRIBUTOR-NEXT:    tail call void @fill_range_not_inbounds(i32* noalias nocapture nofree writeonly [[P]], i64 [[TMP0]])
 ; ATTRIBUTOR-NEXT:    ret void
 ;
 entry:
   %0 = load i64, i64* %range, align 8, !range !0
   tail call void @fill_range_inbounds(i32* %p, i64 %0)
   tail call void @fill_range_not_inbounds(i32* %p, i64 %0)
   ret void
 }
 
 !0 = !{i64 10, i64 100}
 

llvm/test/Transforms/Attributor/internal-noalias.ll

 ; RUN: opt -S -passes=attributor -aa-pipeline='basic-aa' -attributor-disable=false -attributor-max-iterations-verify -attributor-annotate-decl-cs -attributor-max-iterations=6 < %s | FileCheck %s
 
 define dso_local i32 @visible(i32* noalias %A, i32* noalias %B) #0 {
 entry:
   %call1 = call i32 @noalias_args(i32* %A, i32* %B)
   %call2 = call i32 @noalias_args_argmem(i32* %A, i32* %B)
   %add = add nsw i32 %call1, %call2
   ret i32 %add
 }
 
-; CHECK: define private i32 @noalias_args(i32* nocapture nofree nonnull readonly align 4 dereferenceable(4) %A, i32* noalias nocapture nofree nonnull readonly align 4 dereferenceable(4) %B)
+; CHECK: define private i32 @noalias_args(i32* noalias nocapture nofree nonnull readonly align 4 dereferenceable(4) %A, i32* noalias nocapture nofree nonnull readonly align 4 dereferenceable(4) %B)
 
 define private i32 @noalias_args(i32* %A, i32* %B) #0 {
 entry:
   %0 = load i32, i32* %A, align 4
   %1 = load i32, i32* %B, align 4
   %add = add nsw i32 %0, %1
   %call = call i32 @noalias_args_argmem(i32* %A, i32* %B)
   %add2 = add nsw i32 %add, %call
   ret i32 %add2
 }
 
 
-; CHECK: define internal i32 @noalias_args_argmem(i32* nocapture nofree nonnull readonly align 4 dereferenceable(4) %A, i32* noalias nocapture nofree nonnull readonly align 4 dereferenceable(4) %B)
+; CHECK: define internal i32 @noalias_args_argmem(i32* noalias nocapture nofree nonnull readonly align 4 dereferenceable(4) %A, i32* noalias nocapture nofree nonnull readonly align 4 dereferenceable(4) %B)
 define internal i32 @noalias_args_argmem(i32* %A, i32* %B) #1 {
 entry:
   %0 = load i32, i32* %A, align 4
   %1 = load i32, i32* %B, align 4
   %add = add nsw i32 %0, %1
   ret i32 %add
 }
 

llvm/test/Transforms/Attributor/memory_locations.ll

entry:
   ret i8* %call
 }
 
 define dso_local i8* @internal_argmem_only_rec(i32* %arg) {
 ; CHECK: Function Attrs: inaccessiblemem_or_argmemonly
 ; MODULE-LABEL: define {{[^@]+}}@internal_argmem_only_rec
 ; MODULE-SAME: (i32* nocapture align 4 [[ARG:%.*]])
 ; MODULE-NEXT:  entry:
-; MODULE-NEXT:    [[CALL:%.*]] = call noalias i8* @internal_argmem_only_rec_1(i32* nocapture align 4 [[ARG]])
+; MODULE-NEXT:    [[CALL:%.*]] = call noalias i8* @internal_argmem_only_rec_1(i32* noalias nocapture align 4 [[ARG]])
 ; MODULE-NEXT:    ret i8* [[CALL]]
 ;
 ; CGSCC-LABEL: define {{[^@]+}}@internal_argmem_only_rec
 ; CGSCC-SAME: (i32* nocapture nonnull align 4 dereferenceable(4) [[ARG:%.*]])
 ; CGSCC-NEXT:  entry:
 ; CGSCC-NEXT:    [[CALL:%.*]] = call noalias i8* @internal_argmem_only_rec_1(i32* nocapture nonnull align 4 dereferenceable(4) [[ARG]])
 ; CGSCC-NEXT:    ret i8* [[CALL]]
 ;
 entry:
   %call = call i8* @internal_argmem_only_rec_1(i32* %arg)
   ret i8* %call
 }
 
 define internal i8* @internal_argmem_only_rec_1(i32* %arg) {
 ; CHECK: Function Attrs: inaccessiblemem_or_argmemonly
-; CHECK-LABEL: define {{[^@]+}}@internal_argmem_only_rec_1
-; CHECK-SAME: (i32* nocapture nonnull align 4 dereferenceable(4) [[ARG:%.*]])
-; CHECK-NEXT:  entry:
-; CHECK-NEXT:    [[TMP:%.*]] = load i32, i32* [[ARG]], align 4
-; CHECK-NEXT:    [[CMP:%.*]] = icmp eq i32 [[TMP]], 0
-; CHECK-NEXT:    br i1 [[CMP]], label [[IF_THEN:%.*]], label [[IF_END:%.*]]
-; CHECK:       if.then:
-; CHECK-NEXT:    br label [[RETURN:%.*]]
-; CHECK:       if.end:
-; CHECK-NEXT:    [[TMP1:%.*]] = load i32, i32* [[ARG]], align 4
-; CHECK-NEXT:    [[CMP1:%.*]] = icmp eq i32 [[TMP1]], 1
-; CHECK-NEXT:    br i1 [[CMP1]], label [[IF_THEN2:%.*]], label [[IF_END3:%.*]]
-; CHECK:       if.then2:
-; CHECK-NEXT:    [[ADD_PTR:%.*]] = getelementptr inbounds i32, i32* [[ARG]], i64 -1
-; CHECK-NEXT:    [[CALL:%.*]] = call noalias i8* @internal_argmem_only_rec_2(i32* nocapture nonnull align 4 dereferenceable(4) [[ADD_PTR]])
-; CHECK-NEXT:    br label [[RETURN]]
-; CHECK:       if.end3:
-; CHECK-NEXT:    [[TMP2:%.*]] = load i32, i32* [[ARG]], align 4
-; CHECK-NEXT:    [[CONV:%.*]] = sext i32 [[TMP2]] to i64
-; CHECK-NEXT:    [[CALL4:%.*]] = call noalias i8* @malloc(i64 [[CONV]])
-; CHECK-NEXT:    br label [[RETURN]]
-; CHECK:       return:
-; CHECK-NEXT:    [[RETVAL_0:%.*]] = phi i8* [ null, [[IF_THEN]] ], [ [[CALL]], [[IF_THEN2]] ], [ [[CALL4]], [[IF_END3]] ]
-; CHECK-NEXT:    ret i8* [[RETVAL_0]]
+; MODULE-LABEL: define {{[^@]+}}@internal_argmem_only_rec_1
+; MODULE-SAME: (i32* noalias nocapture nonnull align 4 dereferenceable(4) [[ARG:%.*]])
+; MODULE-NEXT:  entry:
+; MODULE-NEXT:    [[TMP:%.*]] = load i32, i32* [[ARG]], align 4
+; MODULE-NEXT:    [[CMP:%.*]] = icmp eq i32 [[TMP]], 0
+; MODULE-NEXT:    br i1 [[CMP]], label [[IF_THEN:%.*]], label [[IF_END:%.*]]
+; MODULE:       if.then:
+; MODULE-NEXT:    br label [[RETURN:%.*]]
+; MODULE:       if.end:
+; MODULE-NEXT:    [[TMP1:%.*]] = load i32, i32* [[ARG]], align 4
+; MODULE-NEXT:    [[CMP1:%.*]] = icmp eq i32 [[TMP1]], 1
+; MODULE-NEXT:    br i1 [[CMP1]], label [[IF_THEN2:%.*]], label [[IF_END3:%.*]]
+; MODULE:       if.then2:
+; MODULE-NEXT:    [[ADD_PTR:%.*]] = getelementptr inbounds i32, i32* [[ARG]], i64 -1
+; MODULE-NEXT:    [[CALL:%.*]] = call noalias i8* @internal_argmem_only_rec_2(i32* noalias nocapture nonnull align 4 dereferenceable(4) [[ADD_PTR]])
+; MODULE-NEXT:    br label [[RETURN]]
+; MODULE:       if.end3:
+; MODULE-NEXT:    [[TMP2:%.*]] = load i32, i32* [[ARG]], align 4
+; MODULE-NEXT:    [[CONV:%.*]] = sext i32 [[TMP2]] to i64
+; MODULE-NEXT:    [[CALL4:%.*]] = call noalias i8* @malloc(i64 [[CONV]])
+; MODULE-NEXT:    br label [[RETURN]]
+; MODULE:       return:
+; MODULE-NEXT:    [[RETVAL_0:%.*]] = phi i8* [ null, [[IF_THEN]] ], [ [[CALL]], [[IF_THEN2]] ], [ [[CALL4]], [[IF_END3]] ]
+; MODULE-NEXT:    ret i8* [[RETVAL_0]]
+;
+; CGSCC-LABEL: define {{[^@]+}}@internal_argmem_only_rec_1
+; CGSCC-SAME: (i32* nocapture nonnull align 4 dereferenceable(4) [[ARG:%.*]])
+; CGSCC-NEXT:  entry:
+; CGSCC-NEXT:    [[TMP:%.*]] = load i32, i32* [[ARG]], align 4
+; CGSCC-NEXT:    [[CMP:%.*]] = icmp eq i32 [[TMP]], 0
+; CGSCC-NEXT:    br i1 [[CMP]], label [[IF_THEN:%.*]], label [[IF_END:%.*]]
+; CGSCC:       if.then:
+; CGSCC-NEXT:    br label [[RETURN:%.*]]
+; CGSCC:       if.end:
+; CGSCC-NEXT:    [[TMP1:%.*]] = load i32, i32* [[ARG]], align 4
+; CGSCC-NEXT:    [[CMP1:%.*]] = icmp eq i32 [[TMP1]], 1
+; CGSCC-NEXT:    br i1 [[CMP1]], label [[IF_THEN2:%.*]], label [[IF_END3:%.*]]
+; CGSCC:       if.then2:
+; CGSCC-NEXT:    [[ADD_PTR:%.*]] = getelementptr inbounds i32, i32* [[ARG]], i64 -1
+; CGSCC-NEXT:    [[CALL:%.*]] = call noalias i8* @internal_argmem_only_rec_2(i32* noalias nocapture nonnull align 4 dereferenceable(4) [[ADD_PTR]])
+; CGSCC-NEXT:    br label [[RETURN]]
+; CGSCC:       if.end3:
+; CGSCC-NEXT:    [[TMP2:%.*]] = load i32, i32* [[ARG]], align 4
+; CGSCC-NEXT:    [[CONV:%.*]] = sext i32 [[TMP2]] to i64
+; CGSCC-NEXT:    [[CALL4:%.*]] = call noalias i8* @malloc(i64 [[CONV]])
+; CGSCC-NEXT:    br label [[RETURN]]
+; CGSCC:       return:
+; CGSCC-NEXT:    [[RETVAL_0:%.*]] = phi i8* [ null, [[IF_THEN]] ], [ [[CALL]], [[IF_THEN2]] ], [ [[CALL4]], [[IF_END3]] ]
+; CGSCC-NEXT:    ret i8* [[RETVAL_0]]
 ;
 entry:
   %tmp = load i32, i32* %arg, align 4
   %cmp = icmp eq i32 %tmp, 0
   br i1 %cmp, label %if.then, label %if.end
 
 if.then:                                          ; preds = %entry
   br label %return

 return:                                           ; preds = %if.end3, %if.then2, %if.then
   %retval.0 = phi i8* [ null, %if.then ], [ %call, %if.then2 ], [ %call4, %if.end3 ]
   ret i8* %retval.0
 }
 
 define internal i8* @internal_argmem_only_rec_2(i32* %arg) {
 ; CHECK: Function Attrs: inaccessiblemem_or_argmemonly
 ; CHECK-LABEL: define {{[^@]+}}@internal_argmem_only_rec_2
-; CHECK-SAME: (i32* nocapture nonnull align 4 dereferenceable(4) [[ARG:%.*]])
+; CHECK-SAME: (i32* noalias nocapture nonnull align 4 dereferenceable(4) [[ARG:%.*]])
 ; CHECK-NEXT:  entry:
 ; CHECK-NEXT:    store i32 0, i32* [[ARG]], align 4
 ; CHECK-NEXT:    [[ADD_PTR:%.*]] = getelementptr inbounds i32, i32* [[ARG]], i64 -1
-; CHECK-NEXT:    [[CALL:%.*]] = call noalias i8* @internal_argmem_only_rec_1(i32* nocapture nonnull align 4 dereferenceable(4) [[ADD_PTR]])
+; CHECK-NEXT:    [[CALL:%.*]] = call noalias i8* @internal_argmem_only_rec_1(i32* noalias nocapture nonnull align 4 dereferenceable(4) [[ADD_PTR]])
 ; CHECK-NEXT:    ret i8* [[CALL]]
 ;
 entry:
   store i32 0, i32* %arg, align 4
   %add.ptr = getelementptr inbounds i32, i32* %arg, i64 -1
   %call = call i8* @internal_argmem_only_rec_1(i32* nonnull %add.ptr)
   ret i8* %call
 }

llvm/test/Transforms/Attributor/misc.ll

 ; NOTE: Assertions have been autogenerated by utils/update_test_checks.py UTC_ARGS: --function-signature --scrub-attributes
 ; RUN: opt -S -attributor -attributor-disable=false < %s | FileCheck %s --check-prefixes=ALL,CHECK
 ; RUN: opt -S -aa-pipeline='basic-aa' -passes=attributor -attributor-disable=false -attributor-annotate-decl-cs < %s | FileCheck %s --check-prefixes=ALL,DECL_CS
 ;
 ; Mostly check we do not crash on these uses
 
 define internal void @internal(void (i8*)* %fp) {
 ; CHECK-LABEL: define {{[^@]+}}@internal
 ; CHECK-SAME: (void (i8*)* [[FP:%.*]])
 ; CHECK-NEXT:  entry:
 ; CHECK-NEXT:    [[A:%.*]] = alloca i32, align 4
-; CHECK-NEXT:    call void @foo(i32* nocapture nofree nonnull writeonly align 4 dereferenceable(4) [[A]])
+; CHECK-NEXT:    call void @foo(i32* noalias nocapture nofree nonnull writeonly align 4 dereferenceable(4) [[A]])
 ; CHECK-NEXT:    call void [[FP]](i8* bitcast (void (i32*)* @foo to i8*))
 ; CHECK-NEXT:    call void @callback1(void (i32*)* nonnull @foo)
 ; CHECK-NEXT:    call void @callback2(void (i8*)* bitcast (void (i32*)* @foo to void (i8*)*))
 ; CHECK-NEXT:    call void @callback2(void (i8*)* [[FP]])
 ; CHECK-NEXT:    [[TMP1:%.*]] = bitcast i32* [[A]] to i8*
 ; CHECK-NEXT:    call void [[FP]](i8* [[TMP1]])
 ; CHECK-NEXT:    ret void
 ;
 ; DECL_CS-LABEL: define {{[^@]+}}@internal
 ; DECL_CS-SAME: (void (i8*)* [[FP:%.*]])
 ; DECL_CS-NEXT:  entry:
 ; DECL_CS-NEXT:    [[A:%.*]] = alloca i32, align 4
-; DECL_CS-NEXT:    call void @foo(i32* nocapture nofree nonnull writeonly align 4 dereferenceable(4) [[A]])
+; DECL_CS-NEXT:    call void @foo(i32* noalias nocapture nofree nonnull writeonly align 4 dereferenceable(4) [[A]])
 ; DECL_CS-NEXT:    call void [[FP]](i8* bitcast (void (i32*)* @foo to i8*))
 ; DECL_CS-NEXT:    call void @callback1(void (i32*)* nonnull @foo)
 ; DECL_CS-NEXT:    call void @callback2(void (i8*)* nonnull bitcast (void (i32*)* @foo to void (i8*)*))
 ; DECL_CS-NEXT:    call void @callback2(void (i8*)* [[FP]])
 ; DECL_CS-NEXT:    [[TMP1:%.*]] = bitcast i32* [[A]] to i8*
 ; DECL_CS-NEXT:    call void [[FP]](i8* [[TMP1]])
 ; DECL_CS-NEXT:    ret void
 ;
entry:
   ret void
 }
 
 define void @external(void (i8*)* %fp) {
 ; CHECK-LABEL: define {{[^@]+}}@external
 ; CHECK-SAME: (void (i8*)* [[FP:%.*]])
 ; CHECK-NEXT:  entry:
 ; CHECK-NEXT:    [[A:%.*]] = alloca i32, align 4
-; CHECK-NEXT:    call void @foo(i32* nocapture nofree nonnull writeonly align 4 dereferenceable(4) [[A]])
+; CHECK-NEXT:    call void @foo(i32* noalias nocapture nofree nonnull writeonly align 4 dereferenceable(4) [[A]])
 ; CHECK-NEXT:    call void @callback1(void (i32*)* nonnull @foo)
 ; CHECK-NEXT:    call void @callback2(void (i8*)* bitcast (void (i32*)* @foo to void (i8*)*))
 ; CHECK-NEXT:    call void @callback2(void (i8*)* [[FP]])
 ; CHECK-NEXT:    call void [[FP]](i8* bitcast (void (i32*)* @foo to i8*))
 ; CHECK-NEXT:    [[TMP1:%.*]] = bitcast i32* [[A]] to i8*
 ; CHECK-NEXT:    call void [[FP]](i8* [[TMP1]])
 ; CHECK-NEXT:    call void @internal(void (i8*)* [[FP]])
 ; CHECK-NEXT:    ret void
 ;
 ; DECL_CS-LABEL: define {{[^@]+}}@external
 ; DECL_CS-SAME: (void (i8*)* [[FP:%.*]])
 ; DECL_CS-NEXT:  entry:
 ; DECL_CS-NEXT:    [[A:%.*]] = alloca i32, align 4
-; DECL_CS-NEXT:    call void @foo(i32* nocapture nofree nonnull writeonly align 4 dereferenceable(4) [[A]])
+; DECL_CS-NEXT:    call void @foo(i32* noalias nocapture nofree nonnull writeonly align 4 dereferenceable(4) [[A]])
 ; DECL_CS-NEXT:    call void @callback1(void (i32*)* nonnull @foo)
 ; DECL_CS-NEXT:    call void @callback2(void (i8*)* nonnull bitcast (void (i32*)* @foo to void (i8*)*))
 ; DECL_CS-NEXT:    call void @callback2(void (i8*)* [[FP]])
 ; DECL_CS-NEXT:    call void [[FP]](i8* bitcast (void (i32*)* @foo to i8*))
 ; DECL_CS-NEXT:    [[TMP1:%.*]] = bitcast i32* [[A]] to i8*
 ; DECL_CS-NEXT:    call void [[FP]](i8* [[TMP1]])
 ; DECL_CS-NEXT:    call void @internal(void (i8*)* [[FP]])
 ; DECL_CS-NEXT:    ret void

llvm/test/Transforms/Attributor/noalias.ll

-; RUN: opt -S -passes=attributor -aa-pipeline='basic-aa' -attributor-disable=false -attributor-max-iterations-verify -attributor-annotate-decl-cs -attributor-max-iterations=7 < %s | FileCheck %s
+; RUN: opt -S -passes=attributor -aa-pipeline='basic-aa' -attributor-disable=false -attributor-max-iterations-verify -attributor-annotate-decl-cs -attributor-max-iterations=6 < %s | FileCheck %s
 
 ; TEST 1 - negative.
 
 ; void *G;
 ; void *foo(){
 ;   void *V = malloc(4);
 ;   G = V;
 ;   return V;

llvm/test/Transforms/Attributor/nonnull.ll

 ; 2. Because f2 is internal function, f2(i32* %arg) -> @f2(i32* nonnull %arg)
 ; 3. In f1:bb4 %tmp5 is nonnull and f3 is internal function.
 ;    Then, f3(i32* %arg) -> @f3(i32* nonnull %arg)
 ; 4. We get nonnull in whole f1 call sites so f1(i32* %arg) -> @f1(i32* nonnull %arg)
 
 
 define internal i32* @f1(i32* %arg) {
 ; FIXME: missing nonnull It should be nonnull @f1(i32* nonnull readonly %arg)
-; ATTRIBUTOR: define internal nonnull i32* @f1(i32* nofree readonly %arg)
+; ATTRIBUTOR: define internal nonnull i32* @f1(i32* noalias nofree readonly %arg)
 
 bb:
   %tmp = icmp eq i32* %arg, null
   br i1 %tmp, label %bb9, label %bb1
 
 bb1:                                              ; preds = %bb
   %tmp2 = load i32, i32* %arg, align 4
   %tmp3 = icmp eq i32 %tmp2, 0
   br i1 %tmp3, label %bb6, label %bb4
 
 bb4:                                              ; preds = %bb1
   %tmp5 = getelementptr inbounds i32, i32* %arg, i64 1
-; ATTRIBUTOR: %tmp5b = tail call nonnull i32* @f3(i32* nofree nonnull readonly %tmp5)
+; ATTRIBUTOR: %tmp5b = tail call nonnull i32* @f3(i32* noalias nofree nonnull readonly %tmp5)
   %tmp5b = tail call i32* @f3(i32* %tmp5)
   %tmp5c = getelementptr inbounds i32, i32* %tmp5b, i64 -1
   br label %bb9
 
 bb6:                                              ; preds = %bb1
 ; FIXME: missing nonnull. It should be @f2(i32* nonnull %arg)
-; ATTRIBUTOR: %tmp7 = tail call nonnull i32* @f2(i32* nofree readonly %arg)
+; ATTRIBUTOR: %tmp7 = tail call nonnull i32* @f2(i32* noalias nofree readonly %arg)
   %tmp7 = tail call i32* @f2(i32* %arg)
   ret i32* %tmp7
 
 bb9:                                              ; preds = %bb4, %bb
   %tmp10 = phi i32* [ %tmp5c, %bb4 ], [ inttoptr (i64 4 to i32*), %bb ]
   ret i32* %tmp10
 }
 
 define internal i32* @f2(i32* %arg) {
 ; FIXME: missing nonnull. It should be nonnull @f2(i32* nonnull %arg)
-; ATTRIBUTOR: define internal nonnull i32* @f2(i32* nofree readonly %arg)
+; ATTRIBUTOR: define internal nonnull i32* @f2(i32* noalias nofree readonly %arg)
 bb:
 
 ; FIXME: missing nonnull. It should be @f1(i32* nonnull readonly %arg)
-; ATTRIBUTOR:   %tmp = tail call nonnull i32* @f1(i32* nofree readonly %arg)
+; ATTRIBUTOR:   %tmp = tail call nonnull i32* @f1(i32* noalias nofree readonly %arg)
   %tmp = tail call i32* @f1(i32* %arg)
   ret i32* %tmp
 }
 
 define dso_local noalias i32* @f3(i32* %arg) {
+; FIXME: %arg can be noalias as well
 ; FIXME: missing nonnull. It should be nonnull @f3(i32* nonnull readonly %arg)
 ; ATTRIBUTOR: define dso_local noalias nonnull i32* @f3(i32* nofree readonly %arg)
 bb:
 ; FIXME: missing nonnull. It should be @f1(i32* nonnull readonly %arg)
-; ATTRIBUTOR:   %tmp = call nonnull i32* @f1(i32* nofree readonly %arg)
+; ATTRIBUTOR:   %tmp = call nonnull i32* @f1(i32* noalias nofree readonly %arg)
   %tmp = call i32* @f1(i32* %arg)
   ret i32* %tmp
 }
 
 ; TEST 15
 define void @f15(i8* %arg) {
 ; ATTRIBUTOR:   tail call void @use1(i8* nonnull dereferenceable(4) %arg)
 

llvm/test/Transforms/Attributor/range.ll

;
   %a = load i32, i32* %p, !range !0
   ret i32 %a
 }
 
 define i32 @test0-range-check(i32* %p) {
 ;
 ; OLD_PM-LABEL: define {{[^@]+}}@test0-range-check
 ; OLD_PM-SAME: (i32* nocapture nofree readonly [[P:%.*]])
-; OLD_PM-NEXT:    [[A:%.*]] = tail call i32 @test0(i32* nocapture nofree readonly [[P]]) #{{[0-9]+}}, !range !0
+; OLD_PM-NEXT:    [[A:%.*]] = tail call i32 @test0(i32* noalias nocapture nofree readonly [[P]]) #{{[0-9]+}}, !range !0
 ; OLD_PM-NEXT:    ret i32 [[A]]
 ;
 ; NEW_PM-LABEL: define {{[^@]+}}@test0-range-check
 ; NEW_PM-SAME: (i32* nocapture nofree readonly [[P:%.*]])
-; NEW_PM-NEXT:    [[A:%.*]] = tail call i32 @test0(i32* nocapture nofree readonly [[P]]) #{{[0-9]+}}, !range !0
+; NEW_PM-NEXT:    [[A:%.*]] = tail call i32 @test0(i32* noalias nocapture nofree readonly [[P]]) #{{[0-9]+}}, !range !0
 ; NEW_PM-NEXT:    ret i32 [[A]]
 ;
 ; CGSCC_OLD_PM-LABEL: define {{[^@]+}}@test0-range-check
 ; CGSCC_OLD_PM-SAME: (i32* nocapture nofree nonnull readonly dereferenceable(4) [[P:%.*]])
 ; CGSCC_OLD_PM-NEXT:    [[A:%.*]] = tail call i32 @test0(i32* nocapture nofree nonnull readonly dereferenceable(4) [[P]])
 ; CGSCC_OLD_PM-NEXT:    ret i32 [[A]]
 ;
 ; CGSCC_NEW_PM-LABEL: define {{[^@]+}}@test0-range-check
 ; CGSCC_NEW_PM-SAME: (i32* nocapture nofree nonnull readonly dereferenceable(4) [[P:%.*]])
 ; CGSCC_NEW_PM-NEXT:    [[A:%.*]] = tail call i32 @test0(i32* nocapture nofree nonnull readonly dereferenceable(4) [[P]])
 ; CGSCC_NEW_PM-NEXT:    ret i32 [[A]]
 ;
 ; MODULE-LABEL: define {{[^@]+}}@test0-range-check
 ; MODULE-SAME: (i32* nocapture nofree readonly [[P:%.*]])
-; MODULE-NEXT:    [[A:%.*]] = tail call i32 @test0(i32* nocapture nofree readonly [[P]]) #{{[0-9]+}}, !range !0
+; MODULE-NEXT:    [[A:%.*]] = tail call i32 @test0(i32* noalias nocapture nofree readonly [[P]]) #{{[0-9]+}}, !range !0
 ; MODULE-NEXT:    ret i32 [[A]]
 ; CGSCC-LABEL: define {{[^@]+}}@test0-range-check
 ; CGSCC-SAME: (i32* nocapture nofree nonnull readonly dereferenceable(4) [[P:%.*]])
 ; CGSCC-NEXT:    [[A:%.*]] = tail call i32 @test0(i32* nocapture nofree nonnull readonly dereferenceable(4) [[P]])
 ; CGSCC-NEXT:    ret i32 [[A]]
   %a = tail call i32 @test0(i32* %p)
   ret i32 %a
 }
 
 declare void @use3-dummy(i1, i1, i1)
 define void @use3(i1, i1, i1) {
 ; CHECK-LABEL: define {{[^@]+}}@use3
 ; CHECK-SAME: (i1 [[TMP0:%.*]], i1 [[TMP1:%.*]], i1 [[TMP2:%.*]])
 ; CHECK-NEXT:    tail call void @use3-dummy(i1 [[TMP0]], i1 [[TMP1]], i1 [[TMP2]])
 ; CHECK-NEXT:    ret void
 ;
   tail call void @use3-dummy(i1 %0, i1 %1, i1 %2)
   ret void
 }
 
 ; TEST0 icmp test
 define void @test0-icmp-check(i32* %p){
 ; OLD_PM-LABEL: define {{[^@]+}}@test0-icmp-check
 ; OLD_PM-SAME: (i32* nocapture nofree readonly [[P:%.*]])
-; OLD_PM-NEXT:    [[RET:%.*]] = tail call i32 @test0(i32* nocapture nofree readonly [[P]]) #{{[0-9]+}}, !range !0
+; OLD_PM-NEXT:    [[RET:%.*]] = tail call i32 @test0(i32* noalias nocapture nofree readonly [[P]]) #{{[0-9]+}}, !range !0
 ; OLD_PM-NEXT:    [[CMP_EQ_2:%.*]] = icmp eq i32 [[RET]], 9
 ; OLD_PM-NEXT:    [[CMP_EQ_3:%.*]] = icmp eq i32 [[RET]], 8
 ; OLD_PM-NEXT:    [[CMP_EQ_4:%.*]] = icmp eq i32 [[RET]], 1
 ; OLD_PM-NEXT:    [[CMP_EQ_5:%.*]] = icmp eq i32 [[RET]], 0
 ; OLD_PM-NEXT:    tail call void @use3(i1 false, i1 [[CMP_EQ_2]], i1 [[CMP_EQ_3]])
 ; OLD_PM-NEXT:    tail call void @use3(i1 [[CMP_EQ_4]], i1 [[CMP_EQ_5]], i1 false)
 ; OLD_PM-NEXT:    [[CMP_NE_2:%.*]] = icmp ne i32 [[RET]], 9
 ; OLD_PM-NEXT:    [[CMP_NE_3:%.*]] = icmp ne i32 [[RET]], 8

 ; OLD_PM-NEXT:    [[CMP_LTE_4:%.*]] = icmp sle i32 [[RET]], 1
 ; OLD_PM-NEXT:    [[CMP_LTE_5:%.*]] = icmp sle i32 [[RET]], 0
 ; OLD_PM-NEXT:    tail call void @use3(i1 true, i1 true, i1 [[CMP_LTE_3]])
 ; OLD_PM-NEXT:    tail call void @use3(i1 [[CMP_LTE_4]], i1 [[CMP_LTE_5]], i1 false)
 ; OLD_PM-NEXT:    ret void
 ;
 ; NEW_PM-LABEL: define {{[^@]+}}@test0-icmp-check
 ; NEW_PM-SAME: (i32* nocapture nofree readonly [[P:%.*]])
-; NEW_PM-NEXT:    [[RET:%.*]] = tail call i32 @test0(i32* nocapture nofree readonly [[P]]) #{{[0-9]+}}, !range !0
+; NEW_PM-NEXT:    [[RET:%.*]] = tail call i32 @test0(i32* noalias nocapture nofree readonly [[P]]) #{{[0-9]+}}, !range !0
 ; NEW_PM-NEXT:    [[CMP_EQ_2:%.*]] = icmp eq i32 [[RET]], 9
 ; NEW_PM-NEXT:    [[CMP_EQ_3:%.*]] = icmp eq i32 [[RET]], 8
 ; NEW_PM-NEXT:    [[CMP_EQ_4:%.*]] = icmp eq i32 [[RET]], 1
 ; NEW_PM-NEXT:    [[CMP_EQ_5:%.*]] = icmp eq i32 [[RET]], 0
 ; NEW_PM-NEXT:    tail call void @use3(i1 false, i1 [[CMP_EQ_2]], i1 [[CMP_EQ_3]])
 ; NEW_PM-NEXT:    tail call void @use3(i1 [[CMP_EQ_4]], i1 [[CMP_EQ_5]], i1 false)
 ; NEW_PM-NEXT:    [[CMP_NE_2:%.*]] = icmp ne i32 [[RET]], 9
 ; NEW_PM-NEXT:    [[CMP_NE_3:%.*]] = icmp ne i32 [[RET]], 8

 ; CGSCC_NEW_PM-NEXT:    [[CMP_LTE_5:%.*]] = icmp sle i32 [[RET]], 0
 ; CGSCC_NEW_PM-NEXT:    [[CMP_LTE_6:%.*]] = icmp sle i32 [[RET]], -1
 ; CGSCC_NEW_PM-NEXT:    tail call void @use3(i1 [[CMP_LTE_1]], i1 [[CMP_LTE_2]], i1 [[CMP_LTE_3]])
 ; CGSCC_NEW_PM-NEXT:    tail call void @use3(i1 [[CMP_LTE_4]], i1 [[CMP_LTE_5]], i1 [[CMP_LTE_6]])
 ; CGSCC_NEW_PM-NEXT:    ret void
 ;
 ; MODULE-LABEL: define {{[^@]+}}@test0-icmp-check
 ; MODULE-SAME: (i32* nocapture nofree readonly [[P:%.*]])
-; MODULE-NEXT:    [[RET:%.*]] = tail call i32 @test0(i32* nocapture nofree readonly [[P]]) #{{[0-9]+}}, !range !0
+; MODULE-NEXT:    [[RET:%.*]] = tail call i32 @test0(i32* noalias nocapture nofree readonly [[P]]) #{{[0-9]+}}, !range !0
 ; MODULE-NEXT:    [[CMP_EQ_2:%.*]] = icmp eq i32 [[RET]], 9
 ; MODULE-NEXT:    [[CMP_EQ_3:%.*]] = icmp eq i32 [[RET]], 8
 ; MODULE-NEXT:    [[CMP_EQ_4:%.*]] = icmp eq i32 [[RET]], 1
 ; MODULE-NEXT:    [[CMP_EQ_5:%.*]] = icmp eq i32 [[RET]], 0
 ; MODULE-NEXT:    tail call void @use3(i1 false, i1 [[CMP_EQ_2]], i1 [[CMP_EQ_3]])
 ; MODULE-NEXT:    tail call void @use3(i1 [[CMP_EQ_4]], i1 [[CMP_EQ_5]], i1 false)
 ; MODULE-NEXT:    [[CMP_NE_2:%.*]] = icmp ne i32 [[RET]], 9
 ; MODULE-NEXT:    [[CMP_NE_3:%.*]] = icmp ne i32 [[RET]], 8
;
   %add-10-then-20-110 = add i32 %load-10-100, 10
   %mul-10-then-200-1091 = mul i32 %add-10-then-20-110, 10
   ret i32 %mul-10-then-200-1091
 }
 
 define i1 @test1-check(i32* %p) {
 ; OLD_PM-LABEL: define {{[^@]+}}@test1-check
 ; OLD_PM-SAME: (i32* nocapture nofree readonly [[P:%.*]])
-; OLD_PM-NEXT:    [[RES:%.*]] = tail call i32 @test1(i32* nocapture nofree readonly [[P]]) #{{[0-9]+}}, !range !2
+; OLD_PM-NEXT:    [[RES:%.*]] = tail call i32 @test1(i32* noalias nocapture nofree readonly [[P]]) #{{[0-9]+}}, !range !2
 ; OLD_PM-NEXT:    [[CMP:%.*]] = icmp eq i32 [[RES]], 500
 ; OLD_PM-NEXT:    ret i1 [[CMP]]
 ;
 ; NEW_PM-LABEL: define {{[^@]+}}@test1-check
 ; NEW_PM-SAME: (i32* nocapture nofree readonly [[P:%.*]])
-; NEW_PM-NEXT:    [[RES:%.*]] = tail call i32 @test1(i32* nocapture nofree readonly [[P]]) #{{[0-9]+}}, !range !2
+; NEW_PM-NEXT:    [[RES:%.*]] = tail call i32 @test1(i32* noalias nocapture nofree readonly [[P]]) #{{[0-9]+}}, !range !2
 ; NEW_PM-NEXT:    [[CMP:%.*]] = icmp eq i32 [[RES]], 500
 ; NEW_PM-NEXT:    ret i1 [[CMP]]
 ;
 ; CGSCC_OLD_PM-LABEL: define {{[^@]+}}@test1-check
 ; CGSCC_OLD_PM-SAME: (i32* nocapture nofree nonnull readonly dereferenceable(4) [[P:%.*]])
 ; CGSCC_OLD_PM-NEXT:    [[RES:%.*]] = tail call i32 @test1(i32* nocapture nofree nonnull readonly dereferenceable(4) [[P]])
 ; CGSCC_OLD_PM-NEXT:    [[CMP:%.*]] = icmp eq i32 [[RES]], 500
 ; CGSCC_OLD_PM-NEXT:    ret i1 [[CMP]]
 ;
 ; CGSCC_NEW_PM-LABEL: define {{[^@]+}}@test1-check
 ; CGSCC_NEW_PM-SAME: (i32* nocapture nofree nonnull readonly dereferenceable(4) [[P:%.*]])
 ; CGSCC_NEW_PM-NEXT:    [[RES:%.*]] = tail call i32 @test1(i32* nocapture nofree nonnull readonly dereferenceable(4) [[P]])
 ; CGSCC_NEW_PM-NEXT:    [[CMP:%.*]] = icmp eq i32 [[RES]], 500
 ; CGSCC_NEW_PM-NEXT:    ret i1 [[CMP]]
 ;
 ; MODULE-LABEL: define {{[^@]+}}@test1-check
 ; MODULE-SAME: (i32* nocapture nofree readonly [[P:%.*]])
-; MODULE-NEXT:    [[RES:%.*]] = tail call i32 @test1(i32* nocapture nofree readonly [[P]]) #{{[0-9]+}}, !range !2
+; MODULE-NEXT:    [[RES:%.*]] = tail call i32 @test1(i32* noalias nocapture nofree readonly [[P]]) #{{[0-9]+}}, !range !2
 ; MODULE-NEXT:    [[CMP:%.*]] = icmp eq i32 [[RES]], 500
 ; MODULE-NEXT:    ret i1 [[CMP]]
 ; CGSCC-LABEL: define {{[^@]+}}@test1-check
 ; CGSCC-SAME: (i32* nocapture nofree nonnull readonly dereferenceable(4) [[P:%.*]])
 ; CGSCC-NEXT:    [[RES:%.*]] = tail call i32 @test1(i32* nocapture nofree nonnull readonly dereferenceable(4) [[P]])
 ; CGSCC-NEXT:    [[CMP:%.*]] = icmp eq i32 [[RES]], 500
 ; CGSCC-NEXT:    ret i1 [[CMP]]
   %res = tail call i32 @test1(i32* %p)

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

 ; CHECK-NEXT:    ret i32* [[CALL]]
 ;
   %call = call i32* @test_inalloca(i32* null)
   ret i32* %call
 }
 
 define internal void @test_sret(%struct.X* sret %a, %struct.X** %b) {
 ; CHECK-LABEL: define {{[^@]+}}@test_sret
-; CHECK-SAME: (%struct.X* noalias nofree sret writeonly align 536870912 [[A:%.*]], %struct.X** nocapture nofree nonnull writeonly dereferenceable(8) [[B:%.*]])
+; CHECK-SAME: (%struct.X* noalias nofree sret writeonly align 536870912 [[A:%.*]], %struct.X** noalias nocapture nofree nonnull writeonly dereferenceable(8) [[B:%.*]])
 ; CHECK-NEXT:    store %struct.X* [[A]], %struct.X** [[B]]
 ; CHECK-NEXT:    ret void
 ;
   store %struct.X* %a, %struct.X** %b
   ret void
 }
 define void @complicated_args_sret(%struct.X** %b) {
 ; CHECK-LABEL: define {{[^@]+}}@complicated_args_sret
 ; CHECK-SAME: (%struct.X** nocapture nofree writeonly [[B:%.*]])
-; CHECK-NEXT:    call void @test_sret(%struct.X* noalias nofree writeonly align 536870912 null, %struct.X** nocapture nofree writeonly [[B]])
+; CHECK-NEXT:    call void @test_sret(%struct.X* noalias nofree writeonly align 536870912 null, %struct.X** noalias nocapture nofree writeonly [[B]])
 ; CHECK-NEXT:    ret void
 ;
   call void @test_sret(%struct.X* null, %struct.X** %b)
   ret void
 }
 
 define internal %struct.X* @test_nest(%struct.X* nest %a) {
 ; CHECK-LABEL: define {{[^@]+}}@test_nest