diff --git a/llvm/lib/Transforms/IPO/Attributor.cpp b/llvm/lib/Transforms/IPO/Attributor.cpp
--- a/llvm/lib/Transforms/IPO/Attributor.cpp
+++ b/llvm/lib/Transforms/IPO/Attributor.cpp
@@ -2543,7 +2543,7 @@
 
     // Try to rule it out at the call site.
     bool IsAliasing = !AAR || !AAR->isNoAlias(&getAssociatedValue(), ArgOp);
-    LLVM_DEBUG(dbgs() << "[NoAliasCSArg] Check alias between "
+    LLVM_DEBUG(dbgs() << "[AANoAlias] Check alias between "
                          "callsite arguments: "
                       << getAssociatedValue() << " " << *ArgOp << " => "
                       << (IsAliasing ? "" : "no-") << "alias \n");
@@ -2596,6 +2596,142 @@
     return true;
   }
 
+  bool isKnownNoAliasAtCallSiteDueToAccesses(
+      Attributor &A, AAResults *&AAR, const AAMemoryBehavior &MemBehaviorAA,
+      const AANoAlias &NoAliasAA, const AAMemoryLocation &MemLocationAA) {
+    // 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.
+
+    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();
+    Argument *AssociatedArg = getAssociatedArgument();
+    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) {
+      assert(Ptr && "Checkable memory locations should come with a pointer!");
+      LLVM_DEBUG(dbgs() << "[AANoAlias] Check access by " << I << " to " << *Ptr
+                        << " ["
+                        << AAMemoryLocation::getMemoryLocationsAsStr(MLK)
+                        << "]\n");
+      if (Kind == AAMemoryLocation::READ && IsReadOnly) {
+        A.recordDependence(MemBehaviorAA, *this, DepClassTy::OPTIONAL);
+        return true;
+      }
+      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;
+  }
+
+  bool
+  isKnownNoAliasAtCalleeDueToAccesses(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 " << I << " to " << Ptr << " ["
+                 << AAMemoryLocation::getMemoryLocationsAsStr(MLK) << "]\n");
+      if (Kind == AAMemoryLocation::READ && IsReadOnly) {
+        A.recordDependence(MemBehaviorAA, *this, DepClassTy::OPTIONAL);
+        return true;
+      }
+      if (!Ptr)
+        return false;
+      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 and globals for aliasing.
+    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
@@ -2620,6 +2756,22 @@
       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 (isKnownNoAliasAtCalleeDueToAccesses(A, MemBehaviorAA, MemLocationAA)) {
+      LLVM_DEBUG(
+          dbgs() << "[AANoAlias] No-Alias deduced via callee accesses\n");
+      return ChangeStatus::UNCHANGED;
+    }
+
     return indicatePessimisticFixpoint();
   }
 
diff --git a/llvm/test/Transforms/Attributor/ArgumentPromotion/attrs.ll b/llvm/test/Transforms/Attributor/ArgumentPromotion/attrs.ll
--- a/llvm/test/Transforms/Attributor/ArgumentPromotion/attrs.ll
+++ b/llvm/test/Transforms/Attributor/ArgumentPromotion/attrs.ll
@@ -36,7 +36,7 @@
 ; CHECK-NEXT:    store i32 1, i32* [[TMP1]], align 8
 ; CHECK-NEXT:    [[TMP4:%.*]] = getelementptr [[STRUCT_SS]], %struct.ss* [[S]], i32 0, i32 1
 ; CHECK-NEXT:    store i64 2, i64* [[TMP4]], align 4
-; CHECK-NEXT:    call void @f(%struct.ss* noalias nocapture nofree nonnull readonly byval align 8 dereferenceable(12) [[S]], i32* nocapture nofree readonly byval [[X]], i32 zeroext 0)
+; CHECK-NEXT:    call void @f(%struct.ss* noalias nocapture nofree nonnull readonly byval align 8 dereferenceable(12) [[S]], i32* noalias nocapture nofree readonly byval [[X]], i32 zeroext 0)
 ; CHECK-NEXT:    ret i32 0
 ;
 entry:
diff --git a/llvm/test/Transforms/Attributor/ArgumentPromotion/byval-2.ll b/llvm/test/Transforms/Attributor/ArgumentPromotion/byval-2.ll
--- a/llvm/test/Transforms/Attributor/ArgumentPromotion/byval-2.ll
+++ b/llvm/test/Transforms/Attributor/ArgumentPromotion/byval-2.ll
@@ -33,7 +33,7 @@
 ; CHECK-NEXT:    store i32 1, i32* [[TMP1]], align 8
 ; CHECK-NEXT:    [[TMP4:%.*]] = getelementptr [[STRUCT_SS]], %struct.ss* [[S]], i32 0, i32 1
 ; CHECK-NEXT:    store i64 2, i64* [[TMP4]], align 4
-; CHECK-NEXT:    call void @f(%struct.ss* noalias nocapture nofree nonnull readonly byval align 8 dereferenceable(12) [[S]], i32* nocapture nofree readonly byval [[X]])
+; CHECK-NEXT:    call void @f(%struct.ss* noalias nocapture nofree nonnull readonly byval align 8 dereferenceable(12) [[S]], i32* noalias nocapture nofree readonly byval [[X]])
 ; CHECK-NEXT:    ret i32 0
 ;
 entry:
diff --git a/llvm/test/Transforms/Attributor/ArgumentPromotion/chained.ll b/llvm/test/Transforms/Attributor/ArgumentPromotion/chained.ll
--- a/llvm/test/Transforms/Attributor/ArgumentPromotion/chained.ll
+++ b/llvm/test/Transforms/Attributor/ArgumentPromotion/chained.ll
@@ -6,7 +6,7 @@
 
 define internal i32 @test(i32** %x) {
 ; CHECK-LABEL: define {{[^@]+}}@test
-; CHECK-SAME: (i32** nocapture nofree nonnull readonly align 8 dereferenceable(8) [[X:%.*]])
+; CHECK-SAME: (i32** noalias nocapture nofree nonnull readonly align 8 dereferenceable(8) [[X:%.*]])
 ; CHECK-NEXT:  entry:
 ; CHECK-NEXT:    [[Y:%.*]] = load i32*, i32** @G2, align 8
 ; CHECK-NEXT:    [[Z:%.*]] = load i32, i32* [[Y]]
@@ -21,7 +21,7 @@
 define i32 @caller() {
 ; CHECK-LABEL: define {{[^@]+}}@caller()
 ; CHECK-NEXT:  entry:
-; CHECK-NEXT:    [[X:%.*]] = call i32 @test(i32** nofree nonnull readonly align 8 dereferenceable(8) @G2)
+; CHECK-NEXT:    [[X:%.*]] = call i32 @test(i32** noalias nofree nonnull readonly align 8 dereferenceable(8) @G2)
 ; CHECK-NEXT:    ret i32 [[X]]
 ;
 entry:
diff --git a/llvm/test/Transforms/Attributor/ArgumentPromotion/control-flow.ll b/llvm/test/Transforms/Attributor/ArgumentPromotion/control-flow.ll
--- a/llvm/test/Transforms/Attributor/ArgumentPromotion/control-flow.ll
+++ b/llvm/test/Transforms/Attributor/ArgumentPromotion/control-flow.ll
@@ -4,7 +4,7 @@
 ; 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:
@@ -28,7 +28,7 @@
 ; 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:
diff --git a/llvm/test/Transforms/Attributor/ArgumentPromotion/musttail.ll b/llvm/test/Transforms/Attributor/ArgumentPromotion/musttail.ll
--- a/llvm/test/Transforms/Attributor/ArgumentPromotion/musttail.ll
+++ b/llvm/test/Transforms/Attributor/ArgumentPromotion/musttail.ll
@@ -8,7 +8,7 @@
 
 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]]
@@ -27,7 +27,7 @@
 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)
@@ -46,7 +46,7 @@
 
 define internal i32 @test2(%T* %p, i32 %p2) {
 ; CHECK-LABEL: define {{[^@]+}}@test2
-; CHECK-SAME: (%T* nocapture nofree readonly [[P:%.*]], i32 [[P2:%.*]])
+; CHECK-SAME: (%T* noalias nocapture nofree readonly [[P:%.*]], i32 [[P2:%.*]])
 ; CHECK-NEXT:    [[CA:%.*]] = musttail call i32 @foo(%T* undef, i32 undef)
 ; CHECK-NEXT:    ret i32 [[CA]]
 ;
@@ -62,7 +62,7 @@
 define i32 @caller2(%T* %g) {
 ; CHECK-LABEL: define {{[^@]+}}@caller2
 ; CHECK-SAME: (%T* nocapture nofree readonly [[G:%.*]])
-; CHECK-NEXT:    [[V:%.*]] = call i32 @test2(%T* nocapture nofree readonly undef, i32 undef)
+; CHECK-NEXT:    [[V:%.*]] = call i32 @test2(%T* noalias nocapture nofree readonly undef, i32 undef)
 ; CHECK-NEXT:    ret i32 0
 ;
   %v = call i32 @test2(%T* %g, i32 0)
diff --git a/llvm/test/Transforms/Attributor/ArgumentPromotion/reserve-tbaa.ll b/llvm/test/Transforms/Attributor/ArgumentPromotion/reserve-tbaa.ll
--- a/llvm/test/Transforms/Attributor/ArgumentPromotion/reserve-tbaa.ll
+++ b/llvm/test/Transforms/Attributor/ArgumentPromotion/reserve-tbaa.ll
@@ -15,7 +15,7 @@
 
 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 i64, i64* undef, align 8, !tbaa !0
 ; CHECK-NEXT:    [[CONV:%.*]] = trunc i64 [[TMP0]] to i32
@@ -40,7 +40,7 @@
 ; CHECK-NEXT:    store i32* @g, i32** [[TMP0]], align 8, !tbaa !7
 ; CHECK-NEXT:    [[TMP1:%.*]] = load i32*, i32** @a, align 8, !tbaa !7
 ; CHECK-NEXT:    store i32 1, i32* [[TMP1]], align 4, !tbaa !4
-; 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:
diff --git a/llvm/test/Transforms/Attributor/ArgumentPromotion/variadic.ll b/llvm/test/Transforms/Attributor/ArgumentPromotion/variadic.ll
--- a/llvm/test/Transforms/Attributor/ArgumentPromotion/variadic.ll
+++ b/llvm/test/Transforms/Attributor/ArgumentPromotion/variadic.ll
@@ -18,7 +18,7 @@
 ; CHECK-LABEL: define {{[^@]+}}@main
 ; CHECK-SAME: (i32 [[ARGC:%.*]], i8** nocapture nofree readnone [[ARGV:%.*]])
 ; CHECK-NEXT:  entry:
-; CHECK-NEXT:    tail call void (i8*, i8*, i8*, i8*, i8*, ...) @callee_t0f(i8* undef, i8* undef, i8* undef, i8* undef, i8* undef, %struct.tt0* nonnull byval align 8 dereferenceable(16) @t45)
+; CHECK-NEXT:    tail call void (i8*, i8*, i8*, i8*, i8*, ...) @callee_t0f(i8* undef, i8* undef, i8* undef, i8* undef, i8* undef, %struct.tt0* noalias nonnull byval align 8 dereferenceable(16) @t45)
 ; CHECK-NEXT:    ret i32 0
 ;
 entry:
@@ -29,7 +29,7 @@
 ; Function Attrs: nounwind uwtable
 define internal void @callee_t0f(i8* nocapture readnone %tp13, i8* nocapture readnone %tp14, i8* nocapture readnone %tp15, i8* nocapture readnone %tp16, i8* nocapture readnone %tp17, ...) {
 ; CHECK-LABEL: define {{[^@]+}}@callee_t0f
-; CHECK-SAME: (i8* nocapture nofree nonnull readnone [[TP13:%.*]], i8* nocapture nofree nonnull readnone [[TP14:%.*]], i8* nocapture nofree nonnull readnone [[TP15:%.*]], i8* nocapture nofree nonnull readnone [[TP16:%.*]], i8* nocapture nofree nonnull readnone [[TP17:%.*]], ...)
+; CHECK-SAME: (i8* noalias nocapture nofree nonnull readnone [[TP13:%.*]], i8* noalias nocapture nofree nonnull readnone [[TP14:%.*]], i8* noalias nocapture nofree nonnull readnone [[TP15:%.*]], i8* noalias nocapture nofree nonnull readnone [[TP16:%.*]], i8* noalias nocapture nofree nonnull readnone [[TP17:%.*]], ...)
 ; CHECK-NEXT:  entry:
 ; CHECK-NEXT:    ret void
 ;
diff --git a/llvm/test/Transforms/Attributor/IPConstantProp/2009-09-24-byval-ptr.ll b/llvm/test/Transforms/Attributor/IPConstantProp/2009-09-24-byval-ptr.ll
--- a/llvm/test/Transforms/Attributor/IPConstantProp/2009-09-24-byval-ptr.ll
+++ b/llvm/test/Transforms/Attributor/IPConstantProp/2009-09-24-byval-ptr.ll
@@ -52,8 +52,8 @@
 define i32 @unions() nounwind {
 ; CHECK-LABEL: define {{[^@]+}}@unions()
 ; CHECK-NEXT:  entry:
-; CHECK-NEXT:    call void @vfu1(%struct.MYstr* nofree nonnull readonly byval align 8 dereferenceable(8) @mystr)
-; CHECK-NEXT:    [[RESULT:%.*]] = call i32 @vfu2(%struct.MYstr* nofree nonnull readonly byval align 8 dereferenceable(8) @mystr)
+; CHECK-NEXT:    call void @vfu1(%struct.MYstr* noalias nofree nonnull readonly byval align 8 dereferenceable(8) @mystr)
+; CHECK-NEXT:    [[RESULT:%.*]] = call i32 @vfu2(%struct.MYstr* noalias nofree nonnull readonly byval align 8 dereferenceable(8) @mystr)
 ; CHECK-NEXT:    ret i32 [[RESULT]]
 ;
 entry:
@@ -91,8 +91,8 @@
 define i32 @unions_v2() nounwind {
 ; CHECK-LABEL: define {{[^@]+}}@unions_v2()
 ; CHECK-NEXT:  entry:
-; CHECK-NEXT:    call void @vfu1(%struct.MYstr* nofree nonnull readonly byval align 8 dereferenceable(8) @mystr)
-; CHECK-NEXT:    [[RESULT:%.*]] = call i32 @vfu2_v2(%struct.MYstr* nofree nonnull readonly byval align 8 dereferenceable(8) @mystr)
+; CHECK-NEXT:    call void @vfu1(%struct.MYstr* noalias nofree nonnull readonly byval align 8 dereferenceable(8) @mystr)
+; CHECK-NEXT:    [[RESULT:%.*]] = call i32 @vfu2_v2(%struct.MYstr* noalias nofree nonnull readonly byval align 8 dereferenceable(8) @mystr)
 ; CHECK-NEXT:    ret i32 [[RESULT]]
 ;
 entry:
diff --git a/llvm/test/Transforms/Attributor/IPConstantProp/PR16052.ll b/llvm/test/Transforms/Attributor/IPConstantProp/PR16052.ll
--- a/llvm/test/Transforms/Attributor/IPConstantProp/PR16052.ll
+++ b/llvm/test/Transforms/Attributor/IPConstantProp/PR16052.ll
@@ -9,7 +9,7 @@
 ; CHECK-NEXT:  entry:
 ; CHECK-NEXT:    [[CONV:%.*]] = sext i32 undef to i64
 ; CHECK-NEXT:    [[DIV:%.*]] = sdiv i64 8, [[CONV]]
-; CHECK-NEXT:    [[CALL2:%.*]] = call i64 @fn1(i64 [[DIV]])
+; CHECK-NEXT:    [[CALL2:%.*]] = call i64 @fn1(i64 [[DIV]]) #0, !range !0
 ; CHECK-NEXT:    ret i64 [[CALL2]]
 ;
 entry:
diff --git a/llvm/test/Transforms/Attributor/IPConstantProp/pthreads.ll b/llvm/test/Transforms/Attributor/IPConstantProp/pthreads.ll
--- a/llvm/test/Transforms/Attributor/IPConstantProp/pthreads.ll
+++ b/llvm/test/Transforms/Attributor/IPConstantProp/pthreads.ll
@@ -34,9 +34,9 @@
 ; CHECK-NEXT:    [[ALLOC2:%.*]] = alloca i8, align 8
 ; CHECK-NEXT:    [[THREAD:%.*]] = alloca i64, align 8
 ; CHECK-NEXT:    [[CALL:%.*]] = call i32 @pthread_create(i64* nonnull align 8 dereferenceable(8) [[THREAD]], %union.pthread_attr_t* noalias align 536870912 null, i8* (i8*)* nonnull @foo, i8* noalias nofree readnone align 536870912 null)
-; CHECK-NEXT:    [[CALL1:%.*]] = call i32 @pthread_create(i64* nonnull align 8 dereferenceable(8) [[THREAD]], %union.pthread_attr_t* noalias align 536870912 null, i8* (i8*)* nonnull @bar, i8* nofree nonnull readnone align 8 dereferenceable(8) bitcast (i8** @GlobalVPtr to i8*))
+; CHECK-NEXT:    [[CALL1:%.*]] = call i32 @pthread_create(i64* nonnull align 8 dereferenceable(8) [[THREAD]], %union.pthread_attr_t* noalias align 536870912 null, i8* (i8*)* nonnull @bar, i8* noalias nofree nonnull readnone align 8 dereferenceable(8) bitcast (i8** @GlobalVPtr to i8*))
 ; CHECK-NEXT:    [[CALL2:%.*]] = call i32 @pthread_create(i64* nonnull align 8 dereferenceable(8) [[THREAD]], %union.pthread_attr_t* noalias align 536870912 null, i8* (i8*)* nonnull @baz, i8* noalias nocapture nofree nonnull readnone align 8 dereferenceable(1) [[ALLOC1]])
-; CHECK-NEXT:    [[CALL3:%.*]] = call i32 @pthread_create(i64* nonnull align 8 dereferenceable(8) [[THREAD]], %union.pthread_attr_t* noalias align 536870912 null, i8* (i8*)* nonnull @buz, i8* nofree nonnull readnone align 8 dereferenceable(1) [[ALLOC2]])
+; CHECK-NEXT:    [[CALL3:%.*]] = call i32 @pthread_create(i64* nonnull align 8 dereferenceable(8) [[THREAD]], %union.pthread_attr_t* noalias align 536870912 null, i8* (i8*)* nonnull @buz, i8* noalias nofree nonnull readnone align 8 dereferenceable(1) [[ALLOC2]])
 ; CHECK-NEXT:    ret i32 0
 ;
 entry:
@@ -64,7 +64,7 @@
 
 define internal i8* @bar(i8* %arg) {
 ; CHECK-LABEL: define {{[^@]+}}@bar
-; CHECK-SAME: (i8* nofree nonnull readnone returned align 8 dereferenceable(8) [[ARG:%.*]])
+; CHECK-SAME: (i8* noalias nofree nonnull readnone returned align 8 dereferenceable(8) [[ARG:%.*]])
 ; CHECK-NEXT:  entry:
 ; CHECK-NEXT:    ret i8* bitcast (i8** @GlobalVPtr to i8*)
 ;
@@ -84,7 +84,7 @@
 
 define internal i8* @buz(i8* %arg) {
 ; CHECK-LABEL: define {{[^@]+}}@buz
-; CHECK-SAME: (i8* nofree nonnull readnone returned align 8 dereferenceable(1) [[ARG:%.*]])
+; CHECK-SAME: (i8* noalias nofree nonnull readnone returned align 8 dereferenceable(1) [[ARG:%.*]])
 ; CHECK-NEXT:  entry:
 ; CHECK-NEXT:    ret i8* [[ARG]]
 ;
diff --git a/llvm/test/Transforms/Attributor/align.ll b/llvm/test/Transforms/Attributor/align.ll
--- a/llvm/test/Transforms/Attributor/align.ll
+++ b/llvm/test/Transforms/Attributor/align.ll
@@ -147,11 +147,11 @@
 ; Function Attrs: nounwind readnone ssp uwtable
 define internal i8* @f1b(i8* readnone %0) local_unnamed_addr #0 {
 ; ATTRIBUTOR-LABEL: define {{[^@]+}}@f1b
-; ATTRIBUTOR-SAME: (i8* nofree nonnull readnone align 8 dereferenceable(1) "no-capture-maybe-returned" [[TMP0:%.*]]) local_unnamed_addr
+; ATTRIBUTOR-SAME: (i8* noalias nofree nonnull readnone align 8 dereferenceable(1) "no-capture-maybe-returned" [[TMP0:%.*]]) local_unnamed_addr
 ; ATTRIBUTOR-NEXT:    [[TMP2:%.*]] = icmp eq i8* [[TMP0]], null
 ; ATTRIBUTOR-NEXT:    br i1 [[TMP2]], label [[TMP3:%.*]], label [[TMP5:%.*]]
 ; ATTRIBUTOR:       3:
-; ATTRIBUTOR-NEXT:    [[TMP4:%.*]] = tail call align 8 i8* @f2b(i8* nofree nonnull readnone align 8 dereferenceable(1) @a1)
+; ATTRIBUTOR-NEXT:    [[TMP4:%.*]] = tail call align 8 i8* @f2b(i8* noalias nofree nonnull readnone align 8 dereferenceable(1) @a1)
 ; ATTRIBUTOR-NEXT:    [[L:%.*]] = load i8, i8* [[TMP4]], align 8
 ; ATTRIBUTOR-NEXT:    store i8 [[L]], i8* @a1, align 8
 ; ATTRIBUTOR-NEXT:    br label [[TMP5]]
@@ -177,14 +177,14 @@
 define internal i8* @f2b(i8* readnone %0) local_unnamed_addr #0 {
 ;
 ; ATTRIBUTOR-LABEL: define {{[^@]+}}@f2b
-; ATTRIBUTOR-SAME: (i8* nofree nonnull readnone align 8 dereferenceable(1) "no-capture-maybe-returned" [[TMP0:%.*]]) local_unnamed_addr
+; ATTRIBUTOR-SAME: (i8* noalias nofree nonnull readnone align 8 dereferenceable(1) "no-capture-maybe-returned" [[TMP0:%.*]]) local_unnamed_addr
 ; ATTRIBUTOR-NEXT:    [[TMP2:%.*]] = icmp eq i8* @a1, null
 ; ATTRIBUTOR-NEXT:    br i1 [[TMP2]], label [[TMP5:%.*]], label [[TMP3:%.*]]
 ; ATTRIBUTOR:       3:
-; ATTRIBUTOR-NEXT:    [[TMP4:%.*]] = tail call i8* @f1b(i8* nofree nonnull readnone align 8 dereferenceable(1) "no-capture-maybe-returned" @a1)
+; ATTRIBUTOR-NEXT:    [[TMP4:%.*]] = tail call i8* @f1b(i8* noalias nofree nonnull readnone align 8 dereferenceable(1) "no-capture-maybe-returned" @a1)
 ; ATTRIBUTOR-NEXT:    br label [[TMP7:%.*]]
 ; ATTRIBUTOR:       5:
-; ATTRIBUTOR-NEXT:    [[TMP6:%.*]] = tail call i8* @f3b(i8* nofree nonnull readnone align 16 dereferenceable(1) @a2)
+; ATTRIBUTOR-NEXT:    [[TMP6:%.*]] = tail call i8* @f3b(i8* noalias nofree nonnull readnone align 16 dereferenceable(1) @a2)
 ; ATTRIBUTOR-NEXT:    br label [[TMP7]]
 ; ATTRIBUTOR:       7:
 ; ATTRIBUTOR-NEXT:    [[TMP8:%.*]] = phi i8* [ [[TMP4]], [[TMP3]] ], [ [[TMP6]], [[TMP5]] ]
@@ -211,11 +211,11 @@
 define internal i8* @f3b(i8* readnone %0) local_unnamed_addr #0 {
 ;
 ; ATTRIBUTOR-LABEL: define {{[^@]+}}@f3b
-; ATTRIBUTOR-SAME: (i8* nocapture nofree nonnull readnone align 16 dereferenceable(1) [[TMP0:%.*]]) local_unnamed_addr
+; ATTRIBUTOR-SAME: (i8* noalias nocapture nofree nonnull readnone align 16 dereferenceable(1) [[TMP0:%.*]]) local_unnamed_addr
 ; ATTRIBUTOR-NEXT:    [[TMP2:%.*]] = icmp eq i8* @a2, null
 ; ATTRIBUTOR-NEXT:    br i1 [[TMP2]], label [[TMP3:%.*]], label [[TMP5:%.*]]
 ; ATTRIBUTOR:       3:
-; ATTRIBUTOR-NEXT:    [[TMP4:%.*]] = tail call i8* @f1b(i8* nofree nonnull readnone align 16 dereferenceable(1) @a2)
+; ATTRIBUTOR-NEXT:    [[TMP4:%.*]] = tail call i8* @f1b(i8* noalias nofree nonnull readnone align 16 dereferenceable(1) @a2)
 ; ATTRIBUTOR-NEXT:    br label [[TMP5]]
 ; ATTRIBUTOR:       5:
 ; ATTRIBUTOR-NEXT:    [[TMP6:%.*]] = phi i8* [ [[TMP4]], [[TMP3]] ], [ @a1, [[TMP1:%.*]] ]
@@ -236,7 +236,7 @@
 define align 4 i32* @test7b(i32* align 32 %p) #0 {
 ; ATTRIBUTOR-LABEL: define {{[^@]+}}@test7b
 ; ATTRIBUTOR-SAME: (i32* nofree readnone returned align 32 "no-capture-maybe-returned" [[P:%.*]])
-; ATTRIBUTOR-NEXT:    [[TMP1:%.*]] = tail call i8* @f1b(i8* nofree nonnull readnone align 8 dereferenceable(1) @a1)
+; ATTRIBUTOR-NEXT:    [[TMP1:%.*]] = tail call i8* @f1b(i8* noalias nofree nonnull readnone align 8 dereferenceable(1) @a1)
 ; ATTRIBUTOR-NEXT:    ret i32* [[P]]
 ;
   tail call i8* @f1b(i8* align 8 dereferenceable(1) @a1)
@@ -252,17 +252,17 @@
   %ptr2 = tail call align 8 i32* @unknown()
 
   tail call void @test8(i32* %ptr1, i32* %ptr1, i32* %ptr0)
-; ATTRIBUTOR: tail call void @test8(i32* readnone align 4 %ptr1, i32* readnone align 4 %ptr1, i32* readnone %ptr0)
+; ATTRIBUTOR: tail call void @test8(i32* noalias readnone align 4 %ptr1, i32* noalias readnone align 4 %ptr1, i32* noalias readnone %ptr0)
   tail call void @test8(i32* %ptr2, i32* %ptr1, i32* %ptr1)
-; ATTRIBUTOR: tail call void @test8(i32* readnone align 8 %ptr2, i32* readnone align 4 %ptr1, i32* readnone align 4 %ptr1)
+; ATTRIBUTOR: tail call void @test8(i32* noalias readnone align 8 %ptr2, i32* noalias readnone align 4 %ptr1, i32* noalias readnone align 4 %ptr1)
   tail call void @test8(i32* %ptr2, i32* %ptr1, i32* %ptr1)
-; ATTRIBUTOR: tail call void @test8(i32* readnone align 8 %ptr2, i32* readnone align 4 %ptr1, i32* readnone align 4 %ptr1)
+; ATTRIBUTOR: tail call void @test8(i32* noalias readnone align 8 %ptr2, i32* noalias readnone align 4 %ptr1, i32* noalias readnone align 4 %ptr1)
   ret void
 }
 
 declare void @user_i32_ptr(i32*) readnone nounwind
 define internal void @test8(i32* %a, i32* %b, i32* %c) {
-; ATTRIBUTOR: define internal void @test8(i32* nocapture readnone align 4 %a, i32* nocapture readnone align 4 %b, i32* nocapture readnone %c)
+; ATTRIBUTOR: define internal void @test8(i32* noalias nocapture readnone align 4 %a, i32* noalias nocapture readnone align 4 %b, i32* noalias nocapture readnone %c)
   call void @user_i32_ptr(i32* %a)
   call void @user_i32_ptr(i32* %b)
   call void @user_i32_ptr(i32* %c)
diff --git a/llvm/test/Transforms/Attributor/dereferenceable-1.ll b/llvm/test/Transforms/Attributor/dereferenceable-1.ll
--- a/llvm/test/Transforms/Attributor/dereferenceable-1.ll
+++ b/llvm/test/Transforms/Attributor/dereferenceable-1.ll
@@ -226,7 +226,7 @@
 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:%.*]]
@@ -260,7 +260,7 @@
 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:%.*]]
@@ -297,8 +297,8 @@
 ; 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:
diff --git a/llvm/test/Transforms/Attributor/internal-noalias.ll b/llvm/test/Transforms/Attributor/internal-noalias.ll
--- a/llvm/test/Transforms/Attributor/internal-noalias.ll
+++ b/llvm/test/Transforms/Attributor/internal-noalias.ll
@@ -8,7 +8,7 @@
   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:
@@ -21,9 +21,7 @@
 }
 
 
-; FIXME: Should be something like this.
-; define internal i32 @noalias_args_argmem(i32* noalias nocapture readonly %A, i32* noalias nocapture readonly %B)
-; CHECK: define internal i32 @noalias_args_argmem(i32* nocapture nofree nonnull readonly align 4 dereferenceable(4) %A, i32* 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 {
diff --git a/llvm/test/Transforms/Attributor/misc.ll b/llvm/test/Transforms/Attributor/misc.ll
--- a/llvm/test/Transforms/Attributor/misc.ll
+++ b/llvm/test/Transforms/Attributor/misc.ll
@@ -10,7 +10,7 @@
 ; CHECK-NEXT:  entry:
 ; CHECK-NEXT:    [[A:%.*]] = alloca i32, align 4
 ; CHECK-NEXT:    [[TMP:%.*]] = bitcast i32* [[A]] to i8*
-; CHECK-NEXT:    call void @foo(i32* nocapture nofree nonnull readnone align 4 dereferenceable(4) undef)
+; CHECK-NEXT:    call void @foo(i32* noalias nofree nonnull readnone align 4 dereferenceable(4) undef)
 ; 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*)*))
@@ -24,7 +24,7 @@
 ; DECL_CS-NEXT:  entry:
 ; DECL_CS-NEXT:    [[A:%.*]] = alloca i32, align 4
 ; DECL_CS-NEXT:    [[TMP:%.*]] = bitcast i32* [[A]] to i8*
-; DECL_CS-NEXT:    call void @foo(i32* nocapture nofree nonnull readnone align 4 dereferenceable(4) undef)
+; DECL_CS-NEXT:    call void @foo(i32* noalias nofree nonnull readnone align 4 dereferenceable(4) undef)
 ; 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*)*))
@@ -52,7 +52,7 @@
 ; CHECK-NEXT:  entry:
 ; CHECK-NEXT:    [[A:%.*]] = alloca i32, align 4
 ; CHECK-NEXT:    [[TMP:%.*]] = bitcast i32* [[A]] to i8*
-; CHECK-NEXT:    call void @foo(i32* nocapture nofree nonnull readnone align 4 dereferenceable(4) undef)
+; CHECK-NEXT:    call void @foo(i32* noalias nofree nonnull readnone align 4 dereferenceable(4) undef)
 ; 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]])
@@ -67,7 +67,7 @@
 ; DECL_CS-NEXT:  entry:
 ; DECL_CS-NEXT:    [[A:%.*]] = alloca i32, align 4
 ; DECL_CS-NEXT:    [[TMP:%.*]] = bitcast i32* [[A]] to i8*
-; DECL_CS-NEXT:    call void @foo(i32* nocapture nofree nonnull readnone align 4 dereferenceable(4) undef)
+; DECL_CS-NEXT:    call void @foo(i32* noalias nofree nonnull readnone align 4 dereferenceable(4) undef)
 ; 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]])
diff --git a/llvm/test/Transforms/Attributor/noalias.ll b/llvm/test/Transforms/Attributor/noalias.ll
--- a/llvm/test/Transforms/Attributor/noalias.ll
+++ b/llvm/test/Transforms/Attributor/noalias.ll
@@ -1,4 +1,4 @@
-; RUN: opt -S -passes=attributor -aa-pipeline='basic-aa' -attributor-disable=false -attributor-max-iterations-verify -attributor-annotate-decl-cs -attributor-max-iterations=3 < %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=4 < %s | FileCheck %s
 
 ; TEST 1 - negative.
 
@@ -152,27 +152,39 @@
 
 ; TEST 9
 ; Simple Argument Test
-declare void @use_i8(i8* nocapture) readnone
+declare void @use_i8(i8* nocapture)
 define internal void @test9a(i8* %a, i8* %b) {
 ; CHECK: define internal void @test9a()
   ret void
 }
 define internal void @test9b(i8* %a, i8* %b) {
-; CHECK: define internal void @test9b(i8* noalias nocapture readnone %a, i8* nocapture readnone %b)
+; FIXME: %b should be noalias
+; CHECK: define internal void @test9b(i8* noalias nocapture %a, i8* nocapture %b)
   call void @use_i8(i8* %a)
   call void @use_i8(i8* %b)
   ret void
 }
+define internal void @test9c(i8* %a, i8* %b, i8* %c) {
+; CHECK: define internal void @test9c(i8* noalias nocapture %a, i8* nocapture %b, i8* nocapture %c)
+  call void @use_i8(i8* %a)
+  call void @use_i8(i8* %b)
+  call void @use_i8(i8* %c)
+  ret void
+}
 define void @test9_helper(i8* %a, i8* %b) {
-; CHECK: define void @test9_helper(i8* nocapture readnone %a, i8* nocapture readnone %b)
+; CHECK: define void @test9_helper(i8* nocapture %a, i8* nocapture %b)
 ; CHECK:  tail call void @test9a()
 ; CHECK:  tail call void @test9a()
-; CHECK:  tail call void @test9b(i8* noalias nocapture readnone %a, i8* nocapture readnone %b)
-; CHECK:  tail call void @test9b(i8* noalias nocapture readnone %b, i8* noalias nocapture readnone %a)
+; CHECK:  tail call void @test9b(i8* noalias nocapture %a, i8* nocapture %b)
+; CHECK:  tail call void @test9b(i8* noalias nocapture %b, i8* noalias nocapture %a)
+; CHECK:  tail call void @test9c(i8* noalias nocapture %a, i8* nocapture %b, i8* nocapture %b)
+; CHECK:  tail call void @test9c(i8* noalias nocapture %b, i8* noalias nocapture %a, i8* noalias nocapture %a)
   tail call void @test9a(i8* noalias %a, i8* %b)
   tail call void @test9a(i8* noalias %b, i8* noalias %a)
   tail call void @test9b(i8* noalias %a, i8* %b)
   tail call void @test9b(i8* noalias %b, i8* noalias %a)
+  tail call void @test9c(i8* noalias %a, i8* %b, i8* %b)
+  tail call void @test9c(i8* noalias %b, i8* noalias %a, i8* noalias %a)
   ret void
 }
 
diff --git a/llvm/test/Transforms/Attributor/nonnull.ll b/llvm/test/Transforms/Attributor/nonnull.ll
--- a/llvm/test/Transforms/Attributor/nonnull.ll
+++ b/llvm/test/Transforms/Attributor/nonnull.ll
@@ -167,7 +167,7 @@
 }
 declare void @use_i8_ptr(i8* nofree) readnone nounwind
 define internal void @test13(i8* %a, i8* %b, i8* %c) {
-; ATTRIBUTOR: define internal void @test13(i8* nocapture nofree nonnull readnone %a, i8* nocapture nofree readnone %b, i8* nocapture nofree readnone %c)
+; ATTRIBUTOR: define internal void @test13(i8* noalias nocapture nofree nonnull readnone %a, i8* noalias nocapture nofree readnone %b, i8* noalias nocapture nofree readnone %c)
   call void @use_i8_ptr(i8* %a)
   call void @use_i8_ptr(i8* %b)
   call void @use_i8_ptr(i8* %c)
@@ -190,7 +190,7 @@
 
 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
@@ -203,14 +203,14 @@
 
 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
 
@@ -221,21 +221,22 @@
 
 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
 }
@@ -536,7 +537,7 @@
 }
 
 declare void @use_i32_ptr(i32*) readnone nounwind
-; ATTRIBUTOR: define internal void @called_by_weak(i32* nocapture nonnull readnone %a)
+; ATTRIBUTOR: define internal void @called_by_weak(i32* noalias nocapture nonnull readnone %a)
 define internal void @called_by_weak(i32* %a) {
   call void @use_i32_ptr(i32* %a)
   ret void
@@ -550,7 +551,7 @@
 }
 
 ; Expect nonnull
-; ATTRIBUTOR: define internal void @control(i32* nocapture nonnull readnone align 16 dereferenceable(8) %a)
+; ATTRIBUTOR: define internal void @control(i32* noalias nocapture nonnull readnone align 16 dereferenceable(8) %a)
 define internal void @control(i32* dereferenceable(4) %a) {
   call void @use_i32_ptr(i32* %a)
   ret void
diff --git a/llvm/test/Transforms/Attributor/range.ll b/llvm/test/Transforms/Attributor/range.ll
--- a/llvm/test/Transforms/Attributor/range.ll
+++ b/llvm/test/Transforms/Attributor/range.ll
@@ -14,7 +14,7 @@
 define i32 @test0-range-check(i32* %p) {
 ; CHECK-LABEL: define {{[^@]+}}@test0-range-check
 ; CHECK-SAME: (i32* nocapture nofree readonly [[P:%.*]])
-; CHECK-NEXT:    [[A:%.*]] = tail call i32 @test0(i32* nocapture nofree readonly [[P]])
+; CHECK-NEXT:    [[A:%.*]] = tail call i32 @test0(i32* noalias nocapture nofree readonly [[P]])
 ; CHECK-SAME: !range !0
 ; CHECK-NEXT:    ret i32 [[A]]
 ;
@@ -37,7 +37,7 @@
 define void @test0-icmp-check(i32* %p){
 ; CHECK-LABEL: define {{[^@]+}}@test0-icmp-check
 ; CHECK-SAME: (i32* nocapture nofree readonly [[P:%.*]])
-; CHECK-NEXT:    [[RET:%.*]] = tail call i32 @test0(i32* nocapture nofree readonly [[P]])
+; CHECK-NEXT:    [[RET:%.*]] = tail call i32 @test0(i32* noalias nocapture nofree readonly [[P]])
 ; CHECK-SAME: !range !0
 ; CHECK-NEXT:    [[CMP_EQ_2:%.*]] = icmp eq i32 [[RET]], 9
 ; CHECK-NEXT:    [[CMP_EQ_3:%.*]] = icmp eq i32 [[RET]], 8
@@ -185,7 +185,7 @@
 define i1 @test1-check(i32* %p) {
 ; CHECK-LABEL: define {{[^@]+}}@test1-check
 ; CHECK-SAME: (i32* nocapture nofree readonly [[P:%.*]])
-; CHECK-NEXT:    [[RES:%.*]] = tail call i32 @test1(i32* nocapture nofree readonly [[P]])
+; CHECK-NEXT:    [[RES:%.*]] = tail call i32 @test1(i32* noalias nocapture nofree readonly [[P]])
 ; CHECK-SANME: !range !2
 ; CHECK-NEXT:    [[CMP:%.*]] = icmp eq i32 [[RES]], 500
 ; CHECK-NEXT:    ret i1 [[CMP]]
diff --git a/llvm/test/Transforms/Attributor/value-simplify.ll b/llvm/test/Transforms/Attributor/value-simplify.ll
--- a/llvm/test/Transforms/Attributor/value-simplify.ll
+++ b/llvm/test/Transforms/Attributor/value-simplify.ll
@@ -210,7 +210,7 @@
 
 define internal void @test_sret(%struct.X* sret %a, %struct.X** %b) {
 ; CHECK-LABEL: define {{[^@]+}}@test_sret
-; CHECK-SAME: (%struct.X* 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
 ;
@@ -220,7 +220,7 @@
 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* 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)
@@ -257,7 +257,7 @@
 }
 define void @complicated_args_byval() {
 ; CHECK-LABEL: define {{[^@]+}}@complicated_args_byval()
-; CHECK-NEXT:    call void @test_byval(%struct.X* nofree nonnull readonly align 8 dereferenceable(8) @S)
+; CHECK-NEXT:    call void @test_byval(%struct.X* noalias nofree nonnull readonly align 8 dereferenceable(8) @S)
 ; CHECK-NEXT:    ret void
 ;
   call void @test_byval(%struct.X* @S)