[InlineFunction] Use llvm.experimental.noalias.scope.decl for noalias arguments.

[jeroen.dobbelaere]

Summary

Insert a llvm.experimental.noalias.scope.decl intrinsic that identifies where a noalias argument was inlined.

This patch includes some refactorings from D90104.

[jeroen.dobbelaere]

Rebased and adapted to changes to the intrinsic

[nikic]

llvm/include/llvm/IR/Metadata.h

1216 ↗

(On Diff #315132)

This should probably be part of D92887 rather than this one.

llvm/include/llvm/Transforms/Utils/Cloning.h

294 ↗

(On Diff #315132)

Is this needed? I originally introduced this class in order to reuse it between inlining and unrolling, but as far as I can tell, you do not make use of it later in the patch series (D92887 implements a separate set of helper functions). If that's right, then I would simply drop these changes and keep the original code.

[jeroen.dobbelaere]

llvm/include/llvm/Transforms/Utils/Cloning.h

294 ↗

(On Diff #315132)

I like the refactoring you did. It also makes it easier to put part of the mechanism early, which is needed (at least in the full restrict case, probably also here) when inlining recursive functions. In that case the caller and callee are the same and gathering things to clone before any change is done was necessary.

I'll move the infrastructure back to InlineFunction as it will indeed only be used there.

[jeroen.dobbelaere]

• Update according to comments
• Keep scope cloning refactoring local

[nikic]

llvm/lib/Transforms/Utils/InlineFunction.cpp

833

The mention of unrolling here no longer makes sense.

868

While this collects the metadata on the experimental.noalias.scope.decl, I'm not seeing any code that would actually update it on the cloned instructions. remap() only checks the noalias and alias.scope metadata, no?

Looking through the tests, I think we're missing a test case that inlines two levels, so that the first creates the intrinsic, and the second has to properly rename its operand.

llvm/test/Transforms/Coroutines/coro-retcon-resume-values.ll

3

You need to add -aa-pipeline=default to avoid the NPM regression.

[jeroen.dobbelaere]

Thanks for the review ! I'll try to come with an update later today.

llvm/lib/Transforms/Utils/InlineFunction.cpp

868

Good catch, it indeed seems that I missed the remapping of the 'llvm.experimental.noalias.scope.decl' argument in this version :(

More tests is always better. I'll add one for this, and also one for the caller == callee case.

llvm/test/Transforms/Coroutines/coro-retcon-resume-values.ll

3

That seems to do the trick.

[jeroen.dobbelaere]

When working on a test with recursion and inlining, I was thinking about the differences between duplicating scopes in the unrolling (D92887) and duplicating the scopes during the inlining. The refactored code for the inlining keeps the same behavior as before and does a 'deep clone': all the MDNodes and there dependencies are cloned. So the scopes themselves become unique, but also the (function) domains to which they belong are duplicated.

In the utilities added for unrolling (D92887), only the scopes are duplicated. Their domains are kept. And that makes sense as the domain represents the function to which the scope belongs.
The side effect of this, is that the scope layout can be different with different pass orders: loop-unroll after inlining or inlining after loop-unroll will make a difference on how the domains are represented.

IMHO, it would make sense to not do the deep copy for inlining. The scope domain of the inlined function can be kept and shared by multiple functions and multiple inlines, as long as the scopes themselves are unique.
On the other hand, a change in the domain handling can have an effect on the speed of analysis, as an initial filtering is done based on the domains. I don't think we should do this kind of change right now, but it is something we can keep in mind.

[jeroen.dobbelaere]

Adapted to comments.
Added new testcase for recursive inlining.

[nikic]

LGTM. I would simplify the MetadataAsValue cloning a bit, but it's not particularly important either.

llvm/lib/Transforms/Utils/InlineFunction.cpp

888

These can be dropped (inlining performs only one clone).

919

I don't think it makes sense to separately track MDV and MDVMap. I would create the new MetadataAsValue directly in remap:

if (auto *II = dyn_cast<IntrinsicInst>(I)) {
  if (II->getIntrinsicID() == Intrinsic::experimental_noalias_scope_decl) {
    auto *MV = cast<MetadataAsValue>(
        II->getOperand(Intrinsic::NoAliasScopeDeclScopeArg)));
    auto *NewMV = MetadataAsValue::get(
        I->getContext(), MDMap[cast<MDNode>(MV->getMetadata())]);
    II->setOperand(Intrinsic::NoAliasScopeDeclScopeArg, NewMV);
  }
}

Or so.

1809

The above part of the comment is repeated below. You might want to drop it in one place.

llvm/test/Transforms/Coroutines/coro-retcon-resume-values.ll

3

You can drop the --check-prefixes now.

[jeroen.dobbelaere]

Adapted to comments. Simplified the cloning of the MetadataAsValue.

Thanks @nikic for the fast and helpful reviews !

@jdoerfert, could you have an extra look at this one (and the follow ups) ? Thanks !

[nikic]

Ping @jdoerfert Do you want to check over this patch and the LoopUnroll/LoopRotate ones before they go in?

[asbirlea]

FWIW, this also lgtm.

[jeroen.dobbelaere]

I am going to commit this patch today, so that we have a view on possible fallout.

[xbolva00]

http://llvm-compile-time-tracker.com/compare.php?from=344afa853fcfcc085cb5c957b4a07c7ea013bb1b&to=2b9a834c43cb1f93d33958c14b695896bb4e9c1e&stat=size-text

Codesize regression 1% for tramp3d. Can you check it?

[jdoerfert]

In D93040#2517758, @xbolva00 wrote:

http://llvm-compile-time-tracker.com/compare.php?from=344afa853fcfcc085cb5c957b4a07c7ea013bb1b&to=2b9a834c43cb1f93d33958c14b695896bb4e9c1e&stat=size-text

Codesize regression 1% for tramp3d. Can you check it?

I assume this to be a secondary effect of having the instructions in the first place. Maybe some unroll or inline size threshold needs to be thought about them. At the end of the day, we might not be able to avoid something like this as we make !noalias correct, though, I imagine the threshold theory which can be resolved.

[jeroen.dobbelaere]

In D93040#2517769, @jdoerfert wrote:

In D93040#2517758, @xbolva00 wrote:

http://llvm-compile-time-tracker.com/compare.php?from=344afa853fcfcc085cb5c957b4a07c7ea013bb1b&to=2b9a834c43cb1f93d33958c14b695896bb4e9c1e&stat=size-text

Codesize regression 1% for tramp3d. Can you check it?

I assume this to be a secondary effect of having the instructions in the first place. Maybe some unroll or inline size threshold needs to be thought about them. At the end of the day, we might not be able to avoid something like this as we make !noalias correct, though, I imagine the threshold theory which can be resolved.

The loop unrolling/rotating and the cleanup patches are not yet committed. You can see the effect of those here:

http://llvm-compile-time-tracker.com/compare.php?from=344afa853fcfcc085cb5c957b4a07c7ea013bb1b&to=eaf871f4e7fde26cd755cc4c2d67f2c244c66f18&stat=size-text

Also see D95141 for links to more results.

[jeroen.dobbelaere]

llvm/lib/Transforms/Utils/InlineFunction.cpp

929

@nikic In the full restrict patches, we also check if the instruction was already handled. I was able to trigger this with an assertion and I have a more or less reduced testcase.

Either we keep a SmallPtrSet and check if the instruction was already handled (this is what the full restrict version does; See D68509 InlineFunction.cpp#969). Or we only replace the metadata if it is in the MDMap (by using MDMap.lookup(M).

Any preference ?

[nikic]

llvm/lib/Transforms/Utils/InlineFunction.cpp

929

I don't understand under what circumstances we'd handle an instruction twice.

clang/test/CodeGen/aarch64-ls64.c

 void *addr;
 uint64_t status;
 
 // CHECK-LABEL: @test_ld64b(
 // CHECK-NEXT:  entry:
 // CHECK-NEXT:    [[__ADDR_ADDR_I:%.*]] = alloca i8*, align 8
 // CHECK-NEXT:    [[REF_TMP:%.*]] = alloca [[STRUCT_DATA512_T:%.*]], align 8
 // CHECK-NEXT:    [[TMP0:%.*]] = load i8*, i8** @addr, align 8
+// CHECK-NEXT:    call void @llvm.experimental.noalias.scope.decl(metadata !6)
 // CHECK-NEXT:    store i8* [[TMP0]], i8** [[__ADDR_ADDR_I]], align 8, !noalias !6
 // CHECK-NEXT:    [[TMP1:%.*]] = load i8*, i8** [[__ADDR_ADDR_I]], align 8, !noalias !6
 // CHECK-NEXT:    [[VAL_I:%.*]] = getelementptr inbounds [[STRUCT_DATA512_T]], %struct.data512_t* [[REF_TMP]], i32 0, i32 0
 // CHECK-NEXT:    [[ARRAYDECAY_I:%.*]] = getelementptr inbounds [8 x i64], [8 x i64]* [[VAL_I]], i64 0, i64 0
 // CHECK-NEXT:    [[TMP2:%.*]] = call { i64, i64, i64, i64, i64, i64, i64, i64 } @llvm.aarch64.ld64b(i8* [[TMP1]]) [[ATTR2:#.*]], !noalias !6
 // CHECK-NEXT:    [[TMP3:%.*]] = extractvalue { i64, i64, i64, i64, i64, i64, i64, i64 } [[TMP2]], 0
 // CHECK-NEXT:    store i64 [[TMP3]], i64* [[ARRAYDECAY_I]], align 8, !alias.scope !6
 // CHECK-NEXT:    [[TMP4:%.*]] = getelementptr i64, i64* [[ARRAYDECAY_I]], i32 1

llvm/lib/Transforms/Utils/InlineFunction.cpp

 using namespace llvm;
 using ProfileCount = Function::ProfileCount;
 
 static cl::opt<bool>
 EnableNoAliasConversion("enable-noalias-to-md-conversion", cl::init(true),
   cl::Hidden,
   cl::desc("Convert noalias attributes to metadata during inlining."));
 
+static cl::opt<bool>
+    UseNoAliasIntrinsic("use-noalias-intrinsic-during-inlining", cl::Hidden,
+                        cl::ZeroOrMore, cl::init(true),
+                        cl::desc("Use the llvm.experimental.noalias.scope.decl "
+                                 "intrinsic during inlining."));
+
 // Disabled by default, because the added alignment assumptions may increase
 // compile-time and block optimizations. This option is not suitable for use
 // with frontends that emit comprehensive parameter alignment annotations.
 static cl::opt<bool>
 PreserveAlignmentAssumptions("preserve-alignment-assumptions-during-inlining",
   cl::init(false), cl::Hidden,
   cl::desc("Convert align attributes to assumptions during inlining."));
 
if (AliasScope)
           NI->getMetadata(LLVMContext::MD_alias_scope), AliasScope));
 
     if (NoAlias)
       NI->setMetadata(LLVMContext::MD_noalias, MDNode::concatenate(
           NI->getMetadata(LLVMContext::MD_noalias), NoAlias));
   }
 }
 
-/// When inlining a function that contains noalias scope metadata,
-/// this metadata needs to be cloned so that the inlined blocks
-/// have different "unique scopes" at every call site. Were this not done, then
-/// aliasing scopes from a function inlined into a caller multiple times could
-/// not be differentiated (and this would lead to miscompiles because the
-/// non-aliasing property communicated by the metadata could have
-/// call-site-specific control dependencies).
-static void CloneAliasScopeMetadata(CallBase &CB, ValueToValueMapTy &VMap) {
-  const Function *CalledFunc = CB.getCalledFunction();
+/// Utility for cloning !noalias and !alias.scope metadata. When a code region
+/// using scoped alias metadata is inlined, the aliasing relationships may not
+/// hold between the two version. It is necessary to create a deep clone of the
+/// metadata, putting the two versions in separate scope domains.
+class ScopedAliasMetadataDeepCloner {
+  using MetadataMap = DenseMap<const MDNode *, TrackingMDNodeRef>;
   SetVector<const MDNode *> MD;
+  MetadataMap MDMap;
+  void addRecursiveMetadataUses();
+
+public:
+  ScopedAliasMetadataDeepCloner(const Function *F);
+
+  /// Create a new clone of the scoped alias metadata, which will be used by
+  /// subsequent remap() calls.
+  void clone();
+
+  /// Remap instructions in the given VMap from the original to the cloned
+  /// metadata.
+  void remap(ValueToValueMapTy &VMap);
+};
 
-  // Note: We could only clone the metadata if it is already used in the
-  // caller. I'm omitting that check here because it might confuse
-  // inter-procedural alias analysis passes. We can revisit this if it becomes
-  // an efficiency or overhead problem.
-
-  for (const BasicBlock &I : *CalledFunc)
-    for (const Instruction &J : I) {
-      if (const MDNode *M = J.getMetadata(LLVMContext::MD_alias_scope))
+ScopedAliasMetadataDeepCloner::ScopedAliasMetadataDeepCloner(
+    const Function *F) {
+  for (const BasicBlock &BB : *F) {
+    for (const Instruction &I : BB) {
+      if (const MDNode *M = I.getMetadata(LLVMContext::MD_alias_scope))
         MD.insert(M);
-      if (const MDNode *M = J.getMetadata(LLVMContext::MD_noalias))
+      if (const MDNode *M = I.getMetadata(LLVMContext::MD_noalias))
         MD.insert(M);
-    }
 
-  if (MD.empty())
-    return;
+      // We also need to clone the metadata in noalias intrinsics.
+      if (const auto *II = dyn_cast<IntrinsicInst>(&I))
+        if (II->getIntrinsicID() == Intrinsic::experimental_noalias_scope_decl)
+          if (const auto *M = dyn_cast<MDNode>(
+                  cast<MetadataAsValue>(
+                      II->getOperand(Intrinsic::NoAliasScopeDeclScopeArg))
+                      ->getMetadata()))
+            MD.insert(M);
+    }
+  }
+  addRecursiveMetadataUses();
+}
 
-  // Walk the existing metadata, adding the complete (perhaps cyclic) chain to
-  // the set.
+void ScopedAliasMetadataDeepCloner::addRecursiveMetadataUses() {
   SmallVector<const Metadata *, 16> Queue(MD.begin(), MD.end());
   while (!Queue.empty()) {
     const MDNode *M = cast<MDNode>(Queue.pop_back_val());
-    for (unsigned i = 0, ie = M->getNumOperands(); i != ie; ++i)
-      if (const MDNode *M1 = dyn_cast<MDNode>(M->getOperand(i)))
-        if (MD.insert(M1))
-          Queue.push_back(M1);
-  }
+    for (const Metadata *Op : M->operands())
+      if (const MDNode *OpMD = dyn_cast<MDNode>(Op))
+        if (MD.insert(OpMD))
+          Queue.push_back(OpMD);
+  }
 
-  // Now we have a complete set of all metadata in the chains used to specify
-  // the noalias scopes and the lists of those scopes.
+void ScopedAliasMetadataDeepCloner::clone() {
+  assert(MDMap.empty() && "clone() already called ?");
+
   SmallVector<TempMDTuple, 16> DummyNodes;
-  DenseMap<const MDNode *, TrackingMDNodeRef> MDMap;
   for (const MDNode *I : MD) {
-    DummyNodes.push_back(MDTuple::getTemporary(CalledFunc->getContext(), None));
+    DummyNodes.push_back(MDTuple::getTemporary(I->getContext(), None));
     MDMap[I].reset(DummyNodes.back().get());
   }
 
   // Create new metadata nodes to replace the dummy nodes, replacing old
   // metadata references with either a dummy node or an already-created new
   // node.
-  for (const MDNode *I : MD) {
-    SmallVector<Metadata *, 4> NewOps;
-    for (unsigned i = 0, ie = I->getNumOperands(); i != ie; ++i) {
-      const Metadata *V = I->getOperand(i);
-      if (const MDNode *M = dyn_cast<MDNode>(V))
+  for (const MDNode *I : MD) {
+    for (const Metadata *Op : I->operands()) {
+      if (const MDNode *M = dyn_cast<MDNode>(Op))
         NewOps.push_back(MDMap[M]);
       else
-        NewOps.push_back(const_cast<Metadata *>(V));
+        NewOps.push_back(const_cast<Metadata *>(Op));
     }
 
-    MDNode *NewM = MDNode::get(CalledFunc->getContext(), NewOps);
+    MDNode *NewM = MDNode::get(I->getContext(), NewOps);
     MDTuple *TempM = cast<MDTuple>(MDMap[I]);
     assert(TempM->isTemporary() && "Expected temporary node");
 
     TempM->replaceAllUsesWith(NewM);
-  }
+    NewOps.clear();
+  }
 
-  // Now replace the metadata in the new inlined instructions with the
-  // repacements from the map.
-  for (ValueToValueMapTy::iterator VMI = VMap.begin(), VMIE = VMap.end();
-       VMI != VMIE; ++VMI) {
+void ScopedAliasMetadataDeepCloner::remap(ValueToValueMapTy &VMap) {
+  if (MDMap.empty())
+    return; // Nothing to do.
+
+  for (auto Entry : VMap) {
     // Check that key is an instruction, to skip the Argument mapping, which
     // points to an instruction in the original function, not the inlined one.
-    if (!VMI->second || !isa<Instruction>(VMI->first))
+    if (!Entry->second || !isa<Instruction>(Entry->first))
       continue;
 
-    Instruction *NI = dyn_cast<Instruction>(VMI->second);
-    if (!NI)
+    Instruction *I = dyn_cast<Instruction>(Entry->second);
+    if (!I)
       continue;
 
-    if (MDNode *M = NI->getMetadata(LLVMContext::MD_alias_scope))
-      NI->setMetadata(LLVMContext::MD_alias_scope, MDMap[M]);
+    if (MDNode *M = I->getMetadata(LLVMContext::MD_alias_scope))
+      I->setMetadata(LLVMContext::MD_alias_scope, MDMap[M]);
 
-    if (MDNode *M = NI->getMetadata(LLVMContext::MD_noalias))
-      NI->setMetadata(LLVMContext::MD_noalias, MDMap[M]);
+    if (MDNode *M = I->getMetadata(LLVMContext::MD_noalias))
+      I->setMetadata(LLVMContext::MD_noalias, MDMap[M]);
+
+    if (auto *II = dyn_cast<IntrinsicInst>(I))
+      if (II->getIntrinsicID() == Intrinsic::experimental_noalias_scope_decl) {
+        auto *MV = cast<MetadataAsValue>(
+            II->getOperand(Intrinsic::NoAliasScopeDeclScopeArg));
+        auto *NewMV = MetadataAsValue::get(
+            II->getContext(), MDMap[cast<MDNode>(MV->getMetadata())]);
+        II->setOperand(Intrinsic::NoAliasScopeDeclScopeArg, NewMV);
+      }
   }
 }
 
 /// If the inlined function has noalias arguments,
 /// then add new alias scopes for each noalias argument, tag the mapped noalias
 /// parameters with noalias metadata specifying the new scope, and tag all
 /// non-derived loads, stores and memory intrinsics with the new alias scopes.
 static void AddAliasScopeMetadata(CallBase &CB, ValueToValueMapTy &VMap,
if (A->hasName()) {
       Name += utostr(i);
     }
 
     // Note: We always create a new anonymous root here. This is true regardless
     // of the linkage of the callee because the aliasing "scope" is not just a
     // property of the callee, but also all control dependencies in the caller.
     MDNode *NewScope = MDB.createAnonymousAliasScope(NewDomain, Name);
     NewScopes.insert(std::make_pair(A, NewScope));
+
+    if (UseNoAliasIntrinsic) {
+      // Introduce a llvm.experimental.noalias.scope.decl for the noalias
+      // argument.
+      MDNode *AScopeList = MDNode::get(CalledFunc->getContext(), NewScope);
+      auto *NoAliasDecl =
+          IRBuilder<>(&CB).CreateNoAliasScopeDeclaration(AScopeList);
+      // Ignore the result for now. The result will be used when the
+      // llvm.noalias intrinsic is introduced.
+      (void)NoAliasDecl;
+    }
   }
 
   // Iterate over all new instructions in the map; for all memory-access
   // instructions, add the alias scope metadata.
   for (ValueToValueMapTy::iterator VMI = VMap.begin(), VMIE = VMap.end();
        VMI != VMIE; ++VMI) {
     if (const Instruction *I = dyn_cast<Instruction>(VMI->first)) {
       if (!VMI->second)
llvm::InlineResult llvm::InlineFunction(CallBase &CB, InlineFunctionInfo &IFI,
   ClonedCodeInfo InlinedFunctionInfo;
   Function::iterator FirstNewBlock;
 
   { // Scope to destroy VMap after cloning.
     ValueToValueMapTy VMap;
     // Keep a list of pair (dst, src) to emit byval initializations.
     SmallVector<std::pair<Value*, Value*>, 4> ByValInit;
 
+    // When inlining a function that contains noalias scope metadata,
+    // this metadata needs to be cloned so that the inlined blocks
+    // have different "unique scopes" at every call site.
+    // Track the metadata that must be cloned. Do this before other changes to
+    // the function, so that we do not get in trouble when inlining caller ==
+    // callee.
+    ScopedAliasMetadataDeepCloner SAMetadataCloner(CB.getCalledFunction());
+
     auto &DL = Caller->getParent()->getDataLayout();
 
     // Calculate the vector of arguments to pass into the function cloner, which
     // matches up the formal to the actual argument values.
     auto AI = CB.arg_begin();
     unsigned ArgNo = 0;
     for (Function::arg_iterator I = CalledFunc->arg_begin(),
          E = CalledFunc->arg_end(); I != E; ++I, ++AI, ++ArgNo) {
if (IFI.CG)
       UpdateCallGraphAfterInlining(CB, FirstNewBlock, VMap, IFI);
 
     // For 'nodebug' functions, the associated DISubprogram is always null.
     // Conservatively avoid propagating the callsite debug location to
     // instructions inlined from a function whose DISubprogram is not null.
     fixupLineNumbers(Caller, FirstNewBlock, &CB,
                      CalledFunc->getSubprogram() != nullptr);
 
-    // Clone existing noalias metadata if necessary.
-    CloneAliasScopeMetadata(CB, VMap);
+    // Now clone the inlined noalias scope metadata.
+    SAMetadataCloner.clone();
+    SAMetadataCloner.remap(VMap);
 
     // Add noalias metadata if necessary.
     AddAliasScopeMetadata(CB, VMap, DL, CalleeAAR);
 
     // Clone return attributes on the callsite into the calls within the inlined
     // function which feed into its return value.
     AddReturnAttributes(CB, VMap);
 

llvm/test/Transforms/Coroutines/ArgAddr.ll

 ; CHECK-NEXT: %dec1.spill.addr.i = getelementptr inbounds i8, i8* %call.i, i64 20
 ; CHECK-NEXT: bitcast i8* %dec1.spill.addr.i to i32*
 ; CHECK-NEXT: store i32 4
 ; CHECK-NEXT: call void @print(i32 4)
 ; CHECK-NEXT: %index.addr12.i = getelementptr inbounds i8, i8* %call.i, i64 24
 ; CHECK-NEXT: bitcast i8* %index.addr12.i to i1*
 ; CHECK-NEXT: store i1 false
 ; CHECK-NEXT: store i32 3
+; CHECK-NEXT: call void @llvm.experimental.noalias.scope.decl
 ; CHECK-NEXT: store i32 3
 ; CHECK-NEXT: call void @print(i32 3)
 ; CHECK-NEXT: store i1 false
 ; CHECK-NEXT: store i32 2
+; CHECK-NEXT: call void @llvm.experimental.noalias.scope.decl
 ; CHECK-NEXT: store i32 2
 ; CHECK-NEXT: call void @print(i32 2)
 ; CHECK:      ret i32 0
 }
 
 declare i8* @malloc(i32)
 declare void @free(i8*)
 declare void @print(i32)

llvm/test/Transforms/Coroutines/coro-retcon-resume-values.ll

 ; RUN: opt < %s -enable-coroutines -O2 -S | FileCheck %s
-; RUN: opt < %s -enable-coroutines -passes='default<O2>' -S | FileCheck %s
+; RUN: opt < %s -enable-coroutines -passes='default<O2>' -aa-pipeline=default -S | FileCheck %s
 
 define i8* @f(i8* %buffer, i32 %n) {
 entry:
   %id = call token @llvm.coro.id.retcon(i32 8, i32 4, i8* %buffer, i8* bitcast (i8* (i8*, i32, i1)* @prototype to i8*), i8* bitcast (i8* (i32)* @allocate to i8*), i8* bitcast (void (i8*)* @deallocate to i8*))
   %hdl = call i8* @llvm.coro.begin(token %id, i8* null)
   br label %loop
 
 loop:
   %n.val = phi i32 [ %n, %entry ], [ %sum, %resume ]

 }
 
 ;   Unfortunately, we don't seem to fully optimize this right now due
 ;   to some sort of phase-ordering thing.
 ; CHECK-LABEL: define i32 @main
 ; CHECK-NEXT:  entry:
 ; CHECK:         [[BUFFER:%.*]] = alloca [8 x i8], align 4
 ; CHECK:         [[SLOT:%.*]] = bitcast [8 x i8]* [[BUFFER]] to i32*
+; CHECK-NEXT:    call void @llvm.experimental.noalias.scope.decl
+; CHECK-NEXT:    call void @llvm.experimental.noalias.scope.decl
 ; CHECK-NEXT:    store i32 7, i32* [[SLOT]], align 4
+; CHECK-NEXT:    call void @llvm.experimental.noalias.scope.decl
 ; CHECK-NEXT:    call void @print(i32 7)
 ; CHECK-NEXT:    ret i32 0
 
 declare token @llvm.coro.id.retcon(i32, i32, i8*, i8*, i8*, i8*)
 declare i8* @llvm.coro.begin(token, i8*)
 declare { i32, i1 } @llvm.coro.suspend.retcon.sl_i32i1s(...)
 declare i1 @llvm.coro.end(i8*, i1)
 declare i8* @llvm.coro.prepare.retcon(i8*)
 
 declare i8* @prototype(i8*, i32, i1 zeroext)
 
 declare noalias i8* @allocate(i32 %size)
 declare void @deallocate(i8* %ptr)
 
 declare void @print(i32)
 

llvm/test/Transforms/Coroutines/coro-retcon-value.ll

 ;   Unfortunately, we don't seem to fully optimize this right now due
 ;   to some sort of phase-ordering thing.
 ; CHECK-LABEL: define i32 @main
 ; CHECK-NEXT:  entry:
 ; CHECK:         [[BUFFER:%.*]] = alloca [8 x i8], align 4
 ; CHECK:         [[SLOT:%.*]] = bitcast [8 x i8]* [[BUFFER]] to i32*
 ; CHECK-NEXT:    store i32 4, i32* [[SLOT]], align 4
 ; CHECK-NEXT:    call void @print(i32 4)
+; CHECK-NEXT:    call void @llvm.experimental.noalias.scope.decl
 ; CHECK-NEXT:    [[LOAD:%.*]] = load i32, i32* [[SLOT]], align 4
 ; CHECK-NEXT:    [[INC:%.*]] = add i32 [[LOAD]], 1
 ; CHECK-NEXT:    store i32 [[INC]], i32* [[SLOT]], align 4
 ; CHECK-NEXT:    call void @print(i32 [[INC]])
+; CHECK-NEXT:    call void @llvm.experimental.noalias.scope.decl
 ; CHECK-NEXT:    [[LOAD:%.*]] = load i32, i32* [[SLOT]], align 4
 ; CHECK-NEXT:    [[INC:%.*]] = add i32 [[LOAD]], 1
 ; CHECK-NEXT:    store i32 [[INC]], i32* [[SLOT]], align 4
 ; CHECK-NEXT:    call void @print(i32 [[INC]])
+; CHECK-NEXT:    call void @llvm.experimental.noalias.scope.decl
 ; CHECK-NEXT:    ret i32 0
 
 declare token @llvm.coro.id.retcon(i32, i32, i8*, i8*, i8*, i8*)
 declare i8* @llvm.coro.begin(token, i8*)
 declare i8 @llvm.coro.suspend.retcon.i8(...)
 declare i1 @llvm.coro.end(i8*, i1)
 declare i8* @llvm.coro.prepare.retcon(i8*)
 
 declare {i8*, i32} @prototype(i8*, i8 zeroext)
 
 declare noalias i8* @allocate(i32 %size)
 declare void @deallocate(i8* %ptr)
 
 declare void @print(i32)
 

llvm/test/Transforms/Coroutines/coro-retcon.ll

 ;   Unfortunately, we don't seem to fully optimize this right now due
 ;   to some sort of phase-ordering thing.
 ; CHECK-LABEL: define i32 @main
 ; CHECK-NEXT:  entry:
 ; CHECK:         [[BUFFER:%.*]] = alloca [8 x i8], align 4
 ; CHECK:         [[SLOT:%.*]] = bitcast [8 x i8]* [[BUFFER]] to i32*
 ; CHECK-NEXT:    store i32 4, i32* [[SLOT]], align 4
 ; CHECK-NEXT:    call void @print(i32 4)
+; CHECK-NEXT:    call void @llvm.experimental.noalias.scope.decl
 ; CHECK-NEXT:    [[LOAD:%.*]] = load i32, i32* [[SLOT]], align 4
 ; CHECK-NEXT:    [[INC:%.*]] = add i32 [[LOAD]], 1
 ; CHECK-NEXT:    store i32 [[INC]], i32* [[SLOT]], align 4
 ; CHECK-NEXT:    call void @print(i32 [[INC]])
+; CHECK-NEXT:    call void @llvm.experimental.noalias.scope.decl
 ; CHECK-NEXT:    [[LOAD:%.*]] = load i32, i32* [[SLOT]], align 4
 ; CHECK-NEXT:    [[INC:%.*]] = add i32 [[LOAD]], 1
 ; CHECK-NEXT:    call void @print(i32 [[INC]])
+; CHECK-NEXT:    call void @llvm.experimental.noalias.scope.decl
 ; CHECK-NEXT:    ret i32 0
 
 define hidden { i8*, i8* } @g(i8* %buffer, i16* %ptr) {
 entry:
   %id = call token @llvm.coro.id.retcon(i32 8, i32 4, i8* %buffer, i8* bitcast ({ i8*, i8* } (i8*, i1)* @g_prototype to i8*), i8* bitcast (i8* (i32)* @allocate to i8*), i8* bitcast (void (i8*)* @deallocate to i8*))
   %hdl = call i8* @llvm.coro.begin(token %id, i8* null)
   br label %loop
 

llvm/test/Transforms/Coroutines/ex2.ll

entry:
   br i1 %to, label %return, label %destroy
 destroy:
   call void @llvm.coro.destroy(i8* %hdl)
   br label %return
 return:
   ret i32 0
 ; CHECK-NOT:  call i8* @CustomAlloc
 ; CHECK:      call void @print(i32 4)
+; CHECK-NEXT: call void @llvm.experimental.noalias.scope.decl
 ; CHECK-NEXT: call void @print(i32 5)
+; CHECK-NEXT: call void @llvm.experimental.noalias.scope.decl
 ; CHECK-NEXT: call void @print(i32 6)
 ; CHECK-NEXT: ret i32 0
 }
 
 declare i8* @CustomAlloc(i32)
 declare void @CustomFree(i8*)
 declare void @print(i32)
 

llvm/test/Transforms/Coroutines/ex3.ll

entry:
   br i1 %to, label %return, label %destroy
 destroy:
   call void @llvm.coro.destroy(i8* %hdl)
   br label %return
 return:
   ret i32 0
 ; CHECK-NOT:  i8* @malloc
 ; CHECK:      call void @print(i32 4)
+; CHECK-NEXT: call void @llvm.experimental.noalias.scope.decl
 ; CHECK-NEXT: call void @print(i32 -5)
+; CHECK-NEXT: call void @llvm.experimental.noalias.scope.decl
 ; CHECK-NEXT: call void @print(i32 5)
 ; CHECK:      ret i32 0
 }
 
 declare i8* @malloc(i32)
 declare void @free(i8*)
 declare void @print(i32)
 

llvm/test/Transforms/Coroutines/ex4.ll

entry:
   %val1 = load i32, i32* %promise.addr
   call void @print(i32 %val1)
   call void @llvm.coro.resume(i8* %hdl)
   %val2 = load i32, i32* %promise.addr
   call void @print(i32 %val2)
   call void @llvm.coro.destroy(i8* %hdl)
   ret i32 0
 ; CHECK:      call void @print(i32 4)
+; CHECK-NEXT: call void @llvm.experimental.noalias.scope.decl
 ; CHECK-NEXT: call void @print(i32 5)
+; CHECK-NEXT: call void @llvm.experimental.noalias.scope.decl
 ; CHECK-NEXT: call void @print(i32 6)
 ; CHECK:      ret i32 0
 }
 
 declare i8* @llvm.coro.promise(i8*, i32, i1)
 declare i8* @malloc(i32)
 declare void @free(i8*)
 declare void @print(i32)

llvm/test/Transforms/Inline/launder.invariant.group.ll

; CHECK-NOT: noalias
   %6 = getelementptr inbounds %struct.A, %struct.A* %0, i64 0, i32 1
   %7 = load i32, i32* %6, align 8
   ret i32 %7
 }
 
 ; CHECK-LABEL: define i32 @foo(%struct.A* noalias
 define i32 @foo(%struct.A* noalias)  {
   ; CHECK-NOT: call i32 @bar(
-  ; CHECK-NOT: noalias
+  ; CHECK-NOT: !noalias
   %2 = tail call i32 @bar(%struct.A* %0)
   ret i32 %2
 }
 
 
 ; This test checks if invariant group intrinsics have zero cost for inlining.
 ; CHECK-LABEL: define i8* @caller(i8*
 define i8* @caller(i8* %p) {

llvm/test/Transforms/Inline/noalias-calls-always.ll

+; NOTE: Assertions have been autogenerated by utils/update_test_checks.py
 ; RUN: opt -aa-pipeline=basic-aa -passes=always-inline -enable-noalias-to-md-conversion -S < %s | FileCheck %s
 target datalayout = "e-p:64:64:64-i1:8:8-i8:8:8-i16:16:16-i32:32:32-i64:64:64-f32:32:32-f64:64:64-v64:64:64-v128:128:128-a0:0:64-s0:64:64-f80:128:128-n8:16:32:64-S128"
 target triple = "x86_64-unknown-linux-gnu"
 
 declare void @llvm.memcpy.p0i8.p0i8.i64(i8* nocapture, i8* nocapture readonly, i64, i1) #0
 declare void @hey() #0
 
 define void @hello(i8* noalias nocapture %a, i8* noalias nocapture readonly %c, i8* nocapture %b) #1 {
+; CHECK-LABEL: @hello(
+; CHECK-NEXT:  entry:
+; CHECK-NEXT:    [[L:%.*]] = alloca i8, i32 512, align 1
+; CHECK-NEXT:    call void @llvm.memcpy.p0i8.p0i8.i64(i8* align 16 [[A:%.*]], i8* align 16 [[B:%.*]], i64 16, i1 false)
+; CHECK-NEXT:    call void @llvm.memcpy.p0i8.p0i8.i64(i8* align 16 [[B]], i8* align 16 [[C:%.*]], i64 16, i1 false)
+; CHECK-NEXT:    call void @llvm.memcpy.p0i8.p0i8.i64(i8* align 16 [[A]], i8* align 16 [[C]], i64 16, i1 false)
+; CHECK-NEXT:    call void @hey()
+; CHECK-NEXT:    call void @llvm.memcpy.p0i8.p0i8.i64(i8* align 16 [[L]], i8* align 16 [[C]], i64 16, i1 false)
+; CHECK-NEXT:    ret void
+;
 entry:
   %l = alloca i8, i32 512, align 1
   call void @llvm.memcpy.p0i8.p0i8.i64(i8* align 16 %a, i8* align 16 %b, i64 16, i1 0)
   call void @llvm.memcpy.p0i8.p0i8.i64(i8* align 16 %b, i8* align 16 %c, i64 16, i1 0)
   call void @llvm.memcpy.p0i8.p0i8.i64(i8* align 16 %a, i8* align 16 %c, i64 16, i1 0)
   call void @hey()
   call void @llvm.memcpy.p0i8.p0i8.i64(i8* align 16 %l, i8* align 16 %c, i64 16, i1 0)
   ret void
 }
 
 define void @foo(i8* nocapture %a, i8* nocapture readonly %c, i8* nocapture %b) #2 {
+; CHECK-LABEL: @foo(
+; CHECK-NEXT:  entry:
+; CHECK-NEXT:    [[L_I:%.*]] = alloca i8, i32 512, align 1
+; CHECK-NEXT:    call void @llvm.experimental.noalias.scope.decl([[META0:metadata !.*]])
+; CHECK-NEXT:    call void @llvm.experimental.noalias.scope.decl([[META3:metadata !.*]])
+; CHECK-NEXT:    call void @llvm.lifetime.start.p0i8(i64 512, i8* [[L_I]])
+; CHECK-NEXT:    call void @llvm.memcpy.p0i8.p0i8.i64(i8* align 16 [[A:%.*]], i8* align 16 [[B:%.*]], i64 16, i1 false) [[ATTR4:#.*]], !noalias !3
+; CHECK-NEXT:    call void @llvm.memcpy.p0i8.p0i8.i64(i8* align 16 [[B]], i8* align 16 [[C:%.*]], i64 16, i1 false) [[ATTR4]], !noalias !0
+; CHECK-NEXT:    call void @llvm.memcpy.p0i8.p0i8.i64(i8* align 16 [[A]], i8* align 16 [[C]], i64 16, i1 false) [[ATTR4]], !alias.scope !5
+; CHECK-NEXT:    call void @hey() [[ATTR4]], !noalias !5
+; CHECK-NEXT:    call void @llvm.memcpy.p0i8.p0i8.i64(i8* align 16 [[L_I]], i8* align 16 [[C]], i64 16, i1 false) [[ATTR4]], !noalias !0
+; CHECK-NEXT:    call void @llvm.lifetime.end.p0i8(i64 512, i8* [[L_I]])
+; CHECK-NEXT:    ret void
+;
 entry:
   tail call void @hello(i8* %a, i8* %c, i8* %b)
   ret void
 }
 
 define void @hello_cs(i8* nocapture %a, i8* nocapture readonly %c, i8* nocapture %b) #1 {
+; CHECK-LABEL: @hello_cs(
+; CHECK-NEXT:  entry:
+; CHECK-NEXT:    [[L:%.*]] = alloca i8, i32 512, align 1
+; CHECK-NEXT:    call void @llvm.memcpy.p0i8.p0i8.i64(i8* align 16 [[A:%.*]], i8* align 16 [[B:%.*]], i64 16, i1 false)
+; CHECK-NEXT:    call void @llvm.memcpy.p0i8.p0i8.i64(i8* align 16 [[B]], i8* align 16 [[C:%.*]], i64 16, i1 false)
+; CHECK-NEXT:    call void @llvm.memcpy.p0i8.p0i8.i64(i8* align 16 [[A]], i8* align 16 [[C]], i64 16, i1 false)
+; CHECK-NEXT:    call void @hey()
+; CHECK-NEXT:    call void @llvm.memcpy.p0i8.p0i8.i64(i8* align 16 [[L]], i8* align 16 [[C]], i64 16, i1 false)
+; CHECK-NEXT:    ret void
+;
 entry:
   %l = alloca i8, i32 512, align 1
   call void @llvm.memcpy.p0i8.p0i8.i64(i8* align 16 %a, i8* align 16 %b, i64 16, i1 0)
   call void @llvm.memcpy.p0i8.p0i8.i64(i8* align 16 %b, i8* align 16 %c, i64 16, i1 0)
   call void @llvm.memcpy.p0i8.p0i8.i64(i8* align 16 %a, i8* align 16 %c, i64 16, i1 0)
   call void @hey()
   call void @llvm.memcpy.p0i8.p0i8.i64(i8* align 16 %l, i8* align 16 %c, i64 16, i1 0)
   ret void
 }
 
 define void @foo_cs(i8* nocapture %a, i8* nocapture readonly %c, i8* nocapture %b) #2 {
+; CHECK-LABEL: @foo_cs(
+; CHECK-NEXT:  entry:
+; CHECK-NEXT:    [[L_I:%.*]] = alloca i8, i32 512, align 1
+; CHECK-NEXT:    call void @llvm.experimental.noalias.scope.decl([[META6:metadata !.*]])
+; CHECK-NEXT:    call void @llvm.experimental.noalias.scope.decl([[META9:metadata !.*]])
+; CHECK-NEXT:    call void @llvm.lifetime.start.p0i8(i64 512, i8* [[L_I]])
+; CHECK-NEXT:    call void @llvm.memcpy.p0i8.p0i8.i64(i8* align 16 [[A:%.*]], i8* align 16 [[B:%.*]], i64 16, i1 false) [[ATTR4]], !noalias !9
+; CHECK-NEXT:    call void @llvm.memcpy.p0i8.p0i8.i64(i8* align 16 [[B]], i8* align 16 [[C:%.*]], i64 16, i1 false) [[ATTR4]], !noalias !6
+; CHECK-NEXT:    call void @llvm.memcpy.p0i8.p0i8.i64(i8* align 16 [[A]], i8* align 16 [[C]], i64 16, i1 false) [[ATTR4]], !alias.scope !11
+; CHECK-NEXT:    call void @hey() [[ATTR4]], !noalias !11
+; CHECK-NEXT:    call void @llvm.memcpy.p0i8.p0i8.i64(i8* align 16 [[L_I]], i8* align 16 [[C]], i64 16, i1 false) [[ATTR4]], !noalias !6
+; CHECK-NEXT:    call void @llvm.lifetime.end.p0i8(i64 512, i8* [[L_I]])
+; CHECK-NEXT:    ret void
+;
 entry:
   tail call void @hello_cs(i8* noalias %a, i8* noalias %c, i8* %b)
   ret void
 }
 
-; CHECK: define void @foo(i8* nocapture %a, i8* nocapture readonly %c, i8* nocapture %b)
-; CHECK: entry:
-; CHECK:   call void @llvm.memcpy.p0i8.p0i8.i64(i8* align 16 %a, i8* align 16 %b, i64 16, i1 false) #4, !noalias !0
-; CHECK:   call void @llvm.memcpy.p0i8.p0i8.i64(i8* align 16 %b, i8* align 16 %c, i64 16, i1 false) #4, !noalias !3
-; CHECK:   call void @llvm.memcpy.p0i8.p0i8.i64(i8* align 16 %a, i8* align 16 %c, i64 16, i1 false) #4, !alias.scope !5
-; CHECK:   call void @hey() #4, !noalias !5
-; CHECK:   call void @llvm.memcpy.p0i8.p0i8.i64(i8* align 16 %{{.*}}, i8* align 16 %c, i64 16, i1 false) #4, !noalias !3
-; CHECK:   ret void
-; CHECK: }
-
-; CHECK: define void @foo_cs(i8* nocapture %a, i8* nocapture readonly %c, i8* nocapture %b)
-; CHECK: entry:
-; CHECK:   call void @llvm.memcpy.p0i8.p0i8.i64(i8* align 16 %a, i8* align 16 %b, i64 16, i1 false) #4, !noalias !6
-; CHECK:   call void @llvm.memcpy.p0i8.p0i8.i64(i8* align 16 %b, i8* align 16 %c, i64 16, i1 false) #4, !noalias !9
-; CHECK:   call void @llvm.memcpy.p0i8.p0i8.i64(i8* align 16 %a, i8* align 16 %c, i64 16, i1 false) #4, !alias.scope !11
-; CHECK:   call void @hey() #4, !noalias !11
-; CHECK:   call void @llvm.memcpy.p0i8.p0i8.i64(i8* align 16 %{{.*}}, i8* align 16 %c, i64 16, i1 false) #4, !noalias !9
-; CHECK:   ret void
-; CHECK: }
-
 attributes #0 = { nounwind argmemonly willreturn }
 attributes #1 = { nounwind alwaysinline }
 attributes #2 = { nounwind uwtable }
 
 ; CHECK: !0 = !{!1}
-; CHECK: !1 = distinct !{!1, !2, !"hello: %c"}
+; CHECK: !1 = distinct !{!1, !2, !"hello: %a"}
 ; CHECK: !2 = distinct !{!2, !"hello"}
 ; CHECK: !3 = !{!4}
-; CHECK: !4 = distinct !{!4, !2, !"hello: %a"}
-; CHECK: !5 = !{!4, !1}
+; CHECK: !4 = distinct !{!4, !2, !"hello: %c"}
+; CHECK: !5 = !{!1, !4}
 
 ; CHECK: !6 = !{!7}
-; CHECK: !7 = distinct !{!7, !8, !"hello_cs: %c"}
+; CHECK: !7 = distinct !{!7, !8, !"hello_cs: %a"}
 ; CHECK: !8 = distinct !{!8, !"hello_cs"}
 ; CHECK: !9 = !{!10}
-; CHECK: !10 = distinct !{!10, !8, !"hello_cs: %a"}
-; CHECK: !11 = !{!10, !7}
-
+; CHECK: !10 = distinct !{!10, !8, !"hello_cs: %c"}
+; CHECK: !11 = !{!7, !10}

llvm/test/Transforms/Inline/noalias-calls.ll

 ; NOTE: Assertions have been autogenerated by utils/update_test_checks.py UTC_ARGS: --function-signature
 ; RUN: opt -basic-aa -inline -enable-noalias-to-md-conversion -S < %s | FileCheck %s
 ; RUN: opt -aa-pipeline=basic-aa -passes=inline -enable-noalias-to-md-conversion -S < %s | FileCheck %s
 target datalayout = "e-p:64:64:64-i1:8:8-i8:8:8-i16:16:16-i32:32:32-i64:64:64-f32:32:32-f64:64:64-v64:64:64-v128:128:128-a0:0:64-s0:64:64-f80:128:128-n8:16:32:64-S128"
 target triple = "x86_64-unknown-linux-gnu"
 
 declare void @llvm.memcpy.p0i8.p0i8.i64(i8* nocapture, i8* nocapture readonly, i64, i1) #0
 declare void @hey() #0
 
 define void @hello(i8* noalias nocapture %a, i8* noalias nocapture readonly %c, i8* nocapture %b) #1 {
+; CHECK-LABEL: define {{[^@]+}}@hello
+; CHECK-SAME: (i8* noalias nocapture [[A:%.*]], i8* noalias nocapture readonly [[C:%.*]], i8* nocapture [[B:%.*]]) [[ATTR1:#.*]] {
+; CHECK-NEXT:  entry:
+; CHECK-NEXT:    [[L:%.*]] = alloca i8, i32 512, align 1
+; CHECK-NEXT:    call void @llvm.memcpy.p0i8.p0i8.i64(i8* align 16 [[A]], i8* align 16 [[B]], i64 16, i1 false)
+; CHECK-NEXT:    call void @llvm.memcpy.p0i8.p0i8.i64(i8* align 16 [[B]], i8* align 16 [[C]], i64 16, i1 false)
+; CHECK-NEXT:    call void @llvm.memcpy.p0i8.p0i8.i64(i8* align 16 [[A]], i8* align 16 [[C]], i64 16, i1 false)
+; CHECK-NEXT:    call void @hey()
+; CHECK-NEXT:    call void @llvm.memcpy.p0i8.p0i8.i64(i8* align 16 [[L]], i8* align 16 [[C]], i64 16, i1 false)
+; CHECK-NEXT:    ret void
+;
 entry:
   %l = alloca i8, i32 512, align 1
   call void @llvm.memcpy.p0i8.p0i8.i64(i8* align 16 %a, i8* align 16 %b, i64 16, i1 0)
   call void @llvm.memcpy.p0i8.p0i8.i64(i8* align 16 %b, i8* align 16 %c, i64 16, i1 0)
   call void @llvm.memcpy.p0i8.p0i8.i64(i8* align 16 %a, i8* align 16 %c, i64 16, i1 0)
   call void @hey()
   call void @llvm.memcpy.p0i8.p0i8.i64(i8* align 16 %l, i8* align 16 %c, i64 16, i1 0)
   ret void
 }
 
 define void @foo(i8* nocapture %a, i8* nocapture readonly %c, i8* nocapture %b) #2 {
+; CHECK-LABEL: define {{[^@]+}}@foo
+; CHECK-SAME: (i8* nocapture [[A:%.*]], i8* nocapture readonly [[C:%.*]], i8* nocapture [[B:%.*]]) [[ATTR2:#.*]] {
+; CHECK-NEXT:  entry:
+; CHECK-NEXT:    [[L_I:%.*]] = alloca i8, i32 512, align 1
+; CHECK-NEXT:    call void @llvm.experimental.noalias.scope.decl([[META0:metadata !.*]])
+; CHECK-NEXT:    call void @llvm.experimental.noalias.scope.decl([[META3:metadata !.*]])
+; CHECK-NEXT:    call void @llvm.lifetime.start.p0i8(i64 512, i8* [[L_I]])
+; CHECK-NEXT:    call void @llvm.memcpy.p0i8.p0i8.i64(i8* align 16 [[A]], i8* align 16 [[B]], i64 16, i1 false) [[ATTR2]], !noalias !3
+; CHECK-NEXT:    call void @llvm.memcpy.p0i8.p0i8.i64(i8* align 16 [[B]], i8* align 16 [[C]], i64 16, i1 false) [[ATTR2]], !noalias !0
+; CHECK-NEXT:    call void @llvm.memcpy.p0i8.p0i8.i64(i8* align 16 [[A]], i8* align 16 [[C]], i64 16, i1 false) [[ATTR2]], !alias.scope !5
+; CHECK-NEXT:    call void @hey() [[ATTR2]], !noalias !5
+; CHECK-NEXT:    call void @llvm.memcpy.p0i8.p0i8.i64(i8* align 16 [[L_I]], i8* align 16 [[C]], i64 16, i1 false) [[ATTR2]], !noalias !0
+; CHECK-NEXT:    call void @llvm.lifetime.end.p0i8(i64 512, i8* [[L_I]])
+; CHECK-NEXT:    ret void
+;
 entry:
   tail call void @hello(i8* %a, i8* %c, i8* %b)
   ret void
 }
 
 define void @hello_cs(i8* nocapture %a, i8* nocapture readonly %c, i8* nocapture %b) #1 {
+; CHECK-LABEL: define {{[^@]+}}@hello_cs
+; CHECK-SAME: (i8* nocapture [[A:%.*]], i8* nocapture readonly [[C:%.*]], i8* nocapture [[B:%.*]]) [[ATTR1]] {
+; CHECK-NEXT:  entry:
+; CHECK-NEXT:    [[L:%.*]] = alloca i8, i32 512, align 1
+; CHECK-NEXT:    call void @llvm.memcpy.p0i8.p0i8.i64(i8* align 16 [[A]], i8* align 16 [[B]], i64 16, i1 false)
+; CHECK-NEXT:    call void @llvm.memcpy.p0i8.p0i8.i64(i8* align 16 [[B]], i8* align 16 [[C]], i64 16, i1 false)
+; CHECK-NEXT:    call void @llvm.memcpy.p0i8.p0i8.i64(i8* align 16 [[A]], i8* align 16 [[C]], i64 16, i1 false)
+; CHECK-NEXT:    call void @hey()
+; CHECK-NEXT:    call void @llvm.memcpy.p0i8.p0i8.i64(i8* align 16 [[L]], i8* align 16 [[C]], i64 16, i1 false)
+; CHECK-NEXT:    ret void
+;
 entry:
   %l = alloca i8, i32 512, align 1
   call void @llvm.memcpy.p0i8.p0i8.i64(i8* align 16 %a, i8* align 16 %b, i64 16, i1 0)
   call void @llvm.memcpy.p0i8.p0i8.i64(i8* align 16 %b, i8* align 16 %c, i64 16, i1 0)
   call void @llvm.memcpy.p0i8.p0i8.i64(i8* align 16 %a, i8* align 16 %c, i64 16, i1 0)
   call void @hey()
   call void @llvm.memcpy.p0i8.p0i8.i64(i8* align 16 %l, i8* align 16 %c, i64 16, i1 0)
   ret void
 }
 
 define void @foo_cs(i8* nocapture %a, i8* nocapture readonly %c, i8* nocapture %b) #2 {
+; CHECK-LABEL: define {{[^@]+}}@foo_cs
+; CHECK-SAME: (i8* nocapture [[A:%.*]], i8* nocapture readonly [[C:%.*]], i8* nocapture [[B:%.*]]) [[ATTR2]] {
+; CHECK-NEXT:  entry:
+; CHECK-NEXT:    [[L_I:%.*]] = alloca i8, i32 512, align 1
+; CHECK-NEXT:    call void @llvm.experimental.noalias.scope.decl([[META6:metadata !.*]])
+; CHECK-NEXT:    call void @llvm.experimental.noalias.scope.decl([[META9:metadata !.*]])
+; CHECK-NEXT:    call void @llvm.lifetime.start.p0i8(i64 512, i8* [[L_I]])
+; CHECK-NEXT:    call void @llvm.memcpy.p0i8.p0i8.i64(i8* align 16 [[A]], i8* align 16 [[B]], i64 16, i1 false) [[ATTR2]], !noalias !9
+; CHECK-NEXT:    call void @llvm.memcpy.p0i8.p0i8.i64(i8* align 16 [[B]], i8* align 16 [[C]], i64 16, i1 false) [[ATTR2]], !noalias !6
+; CHECK-NEXT:    call void @llvm.memcpy.p0i8.p0i8.i64(i8* align 16 [[A]], i8* align 16 [[C]], i64 16, i1 false) [[ATTR2]], !alias.scope !11
+; CHECK-NEXT:    call void @hey() [[ATTR2]], !noalias !11
+; CHECK-NEXT:    call void @llvm.memcpy.p0i8.p0i8.i64(i8* align 16 [[L_I]], i8* align 16 [[C]], i64 16, i1 false) [[ATTR2]], !noalias !6
+; CHECK-NEXT:    call void @llvm.lifetime.end.p0i8(i64 512, i8* [[L_I]])
+; CHECK-NEXT:    ret void
+;
 entry:
   tail call void @hello_cs(i8* noalias %a, i8* noalias %c, i8* %b)
   ret void
 }
 
-; CHECK: define void @foo(i8* nocapture %a, i8* nocapture readonly %c, i8* nocapture %b) #2 {
-; CHECK: entry:
-; CHECK:   call void @llvm.memcpy.p0i8.p0i8.i64(i8* align 16 %a, i8* align 16 %b, i64 16, i1 false) #2, !noalias !0
-; CHECK:   call void @llvm.memcpy.p0i8.p0i8.i64(i8* align 16 %b, i8* align 16 %c, i64 16, i1 false) #2, !noalias !3
-; CHECK:   call void @llvm.memcpy.p0i8.p0i8.i64(i8* align 16 %a, i8* align 16 %c, i64 16, i1 false) #2, !alias.scope !5
-; CHECK:   call void @hey() #2, !noalias !5
-; CHECK:   call void @llvm.memcpy.p0i8.p0i8.i64(i8* align 16 %{{.*}}, i8* align 16 %c, i64 16, i1 false) #2, !noalias !3
-; CHECK:   ret void
-; CHECK: }
-
-; CHECK: define void @foo_cs(i8* nocapture %a, i8* nocapture readonly %c, i8* nocapture %b) #2 {
-; CHECK: entry:
-; CHECK:   call void @llvm.memcpy.p0i8.p0i8.i64(i8* align 16 %a, i8* align 16 %b, i64 16, i1 false) #2, !noalias !6
-; CHECK:   call void @llvm.memcpy.p0i8.p0i8.i64(i8* align 16 %b, i8* align 16 %c, i64 16, i1 false) #2, !noalias !9
-; CHECK:   call void @llvm.memcpy.p0i8.p0i8.i64(i8* align 16 %a, i8* align 16 %c, i64 16, i1 false) #2, !alias.scope !11
-; CHECK:   call void @hey() #2, !noalias !11
-; CHECK:   call void @llvm.memcpy.p0i8.p0i8.i64(i8* align 16 %{{.*}}, i8* align 16 %c, i64 16, i1 false) #2, !noalias !9
-; CHECK:   ret void
-; CHECK: }
-
 attributes #0 = { argmemonly nofree nosync nounwind willreturn }
 attributes #1 = { argmemonly nounwind willreturn }
 attributes #2 = { nounwind }
 attributes #3 = { nounwind uwtable }
 
 ; CHECK: !0 = !{!1}
-; CHECK: !1 = distinct !{!1, !2, !"hello: %c"}
+; CHECK: !1 = distinct !{!1, !2, !"hello: %a"}
 ; CHECK: !2 = distinct !{!2, !"hello"}
 ; CHECK: !3 = !{!4}
-; CHECK: !4 = distinct !{!4, !2, !"hello: %a"}
-; CHECK: !5 = !{!4, !1}
+; CHECK: !4 = distinct !{!4, !2, !"hello: %c"}
+; CHECK: !5 = !{!1, !4}
 
 ; CHECK: !6 = !{!7}
-; CHECK: !7 = distinct !{!7, !8, !"hello_cs: %c"}
+; CHECK: !7 = distinct !{!7, !8, !"hello_cs: %a"}
 ; CHECK: !8 = distinct !{!8, !"hello_cs"}
 ; CHECK: !9 = !{!10}
-; CHECK: !10 = distinct !{!10, !8, !"hello_cs: %a"}
-; CHECK: !11 = !{!10, !7}
+; CHECK: !10 = distinct !{!10, !8, !"hello_cs: %c"}
+; CHECK: !11 = !{!7, !10}

llvm/test/Transforms/Inline/noalias-calls2.ll

+; NOTE: Assertions have been autogenerated by utils/update_test_checks.py UTC_ARGS: --function-signature
+; RUN: opt -basic-aa -inline -enable-noalias-to-md-conversion -S < %s | FileCheck %s
+; RUN: opt -aa-pipeline=basic-aa -passes=inline -enable-noalias-to-md-conversion -S < %s | FileCheck %s
+
+target datalayout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128"
+target triple = "x86_64-unknown-linux-gnu"
+
+declare void @llvm.experimental.noalias.scope.decl(metadata) #0
+
+define void @caller_equals_callee(i32* noalias %p0, i32* noalias %p1, i32 %cnt) {
+; CHECK-LABEL: define {{[^@]+}}@caller_equals_callee
+; CHECK-SAME: (i32* noalias [[P0:%.*]], i32* noalias [[P1:%.*]], i32 [[CNT:%.*]]) {
+; CHECK-NEXT:  entry:
+; CHECK-NEXT:    [[ADD_PTR:%.*]] = getelementptr inbounds i32, i32* [[P0]], i64 2
+; CHECK-NEXT:    [[ADD_PTR1:%.*]] = getelementptr inbounds i32, i32* [[P1]], i64 2
+; CHECK-NEXT:    tail call void @llvm.experimental.noalias.scope.decl(metadata !0)
+; CHECK-NEXT:    tail call void @llvm.experimental.noalias.scope.decl(metadata !3)
+; CHECK-NEXT:    store i32 10, i32* [[ADD_PTR]], align 4, !alias.scope !0, !noalias !3
+; CHECK-NEXT:    store i32 20, i32* [[ADD_PTR1]], align 4, !alias.scope !3, !noalias !0
+; CHECK-NEXT:    [[CMP:%.*]] = icmp eq i32 [[CNT]], 0
+; CHECK-NEXT:    br i1 [[CMP]], label [[IF_THEN:%.*]], label [[IF_ELSE:%.*]]
+; CHECK:       if.then:
+; CHECK-NEXT:    store i32 11, i32* [[P0]], align 4
+; CHECK-NEXT:    br label [[IF_END:%.*]]
+; CHECK:       if.else:
+; CHECK-NEXT:    [[ADD_PTR2:%.*]] = getelementptr inbounds i32, i32* [[P1]], i64 1
+; CHECK-NEXT:    [[ADD_PTR3:%.*]] = getelementptr inbounds i32, i32* [[P0]], i64 1
+; CHECK-NEXT:    call void @llvm.experimental.noalias.scope.decl(metadata !5)
+; CHECK-NEXT:    call void @llvm.experimental.noalias.scope.decl(metadata !8)
+; CHECK-NEXT:    [[ADD_PTR_I:%.*]] = getelementptr inbounds i32, i32* [[ADD_PTR2]], i64 2
+; CHECK-NEXT:    [[ADD_PTR1_I:%.*]] = getelementptr inbounds i32, i32* [[ADD_PTR3]], i64 2
+; CHECK-NEXT:    tail call void @llvm.experimental.noalias.scope.decl(metadata !10), !noalias !13
+; CHECK-NEXT:    tail call void @llvm.experimental.noalias.scope.decl(metadata !14), !noalias !13
+; CHECK-NEXT:    store i32 10, i32* [[ADD_PTR_I]], align 4, !alias.scope !16, !noalias !17
+; CHECK-NEXT:    store i32 20, i32* [[ADD_PTR1_I]], align 4, !alias.scope !17, !noalias !16
+; CHECK-NEXT:    store i32 11, i32* [[ADD_PTR2]], align 4, !alias.scope !5, !noalias !8
+; CHECK-NEXT:    store i32 12, i32* [[P1]], align 4
+; CHECK-NEXT:    br label [[IF_END]]
+; CHECK:       if.end:
+; CHECK-NEXT:    ret void
+;
+entry:
+  %add.ptr = getelementptr inbounds i32, i32* %p0, i64 2
+  %add.ptr1 = getelementptr inbounds i32, i32* %p1, i64 2
+  tail call void @llvm.experimental.noalias.scope.decl(metadata !0)
+  tail call void @llvm.experimental.noalias.scope.decl(metadata !3)
+  store i32 10, i32* %add.ptr, align 4, !alias.scope !0, !noalias !3
+  store i32 20, i32* %add.ptr1, align 4, !alias.scope !3, !noalias !0
+  %cmp = icmp eq i32 %cnt, 0
+  br i1 %cmp, label %if.then, label %if.else
+
+if.then:                                          ; preds = %entry
+  store i32 11, i32* %p0, align 4
+  br label %if.end
+
+if.else:                                          ; preds = %entry
+  %add.ptr2 = getelementptr inbounds i32, i32* %p1, i64 1
+  %add.ptr3 = getelementptr inbounds i32, i32* %p0, i64 1
+  tail call void @caller_equals_callee(i32* nonnull %add.ptr2, i32* nonnull %add.ptr3, i32 0)
+  store i32 12, i32* %p1, align 4
+  br label %if.end
+
+if.end:                                           ; preds = %if.else, %if.then
+  ret void
+}
+
+define void @test01(i32* noalias %p0, i32* noalias %p1, i32 %cnt) {
+; CHECK-LABEL: define {{[^@]+}}@test01
+; CHECK-SAME: (i32* noalias [[P0:%.*]], i32* noalias [[P1:%.*]], i32 [[CNT:%.*]]) {
+; CHECK-NEXT:  entry:
+; CHECK-NEXT:    store i32 13, i32* [[P0]], align 4
+; CHECK-NEXT:    [[ADD_PTR:%.*]] = getelementptr inbounds i32, i32* [[P0]], i64 1
+; CHECK-NEXT:    [[ADD_PTR1:%.*]] = getelementptr inbounds i32, i32* [[P1]], i64 1
+; CHECK-NEXT:    call void @llvm.experimental.noalias.scope.decl(metadata !18)
+; CHECK-NEXT:    call void @llvm.experimental.noalias.scope.decl(metadata !21)
+; CHECK-NEXT:    [[ADD_PTR_I:%.*]] = getelementptr inbounds i32, i32* [[ADD_PTR]], i64 2
+; CHECK-NEXT:    [[ADD_PTR1_I:%.*]] = getelementptr inbounds i32, i32* [[ADD_PTR1]], i64 2
+; CHECK-NEXT:    call void @llvm.experimental.noalias.scope.decl(metadata !23), !noalias !26
+; CHECK-NEXT:    call void @llvm.experimental.noalias.scope.decl(metadata !27), !noalias !26
+; CHECK-NEXT:    store i32 10, i32* [[ADD_PTR_I]], align 4, !alias.scope !29, !noalias !30
+; CHECK-NEXT:    store i32 20, i32* [[ADD_PTR1_I]], align 4, !alias.scope !30, !noalias !29
+; CHECK-NEXT:    [[CMP_I:%.*]] = icmp eq i32 [[CNT]], 0
+; CHECK-NEXT:    br i1 [[CMP_I]], label [[IF_THEN_I:%.*]], label [[IF_ELSE_I:%.*]]
+; CHECK:       if.then.i:
+; CHECK-NEXT:    store i32 11, i32* [[ADD_PTR]], align 4, !alias.scope !18, !noalias !21
+; CHECK-NEXT:    br label [[CALLER_EQUALS_CALLEE_EXIT:%.*]]
+; CHECK:       if.else.i:
+; CHECK-NEXT:    [[ADD_PTR2_I:%.*]] = getelementptr inbounds i32, i32* [[ADD_PTR1]], i64 1
+; CHECK-NEXT:    [[ADD_PTR3_I:%.*]] = getelementptr inbounds i32, i32* [[ADD_PTR]], i64 1
+; CHECK-NEXT:    call void @llvm.experimental.noalias.scope.decl(metadata !31), !noalias !26
+; CHECK-NEXT:    call void @llvm.experimental.noalias.scope.decl(metadata !34), !noalias !26
+; CHECK-NEXT:    [[ADD_PTR_I_I:%.*]] = getelementptr inbounds i32, i32* [[ADD_PTR2_I]], i64 2
+; CHECK-NEXT:    [[ADD_PTR1_I_I:%.*]] = getelementptr inbounds i32, i32* [[ADD_PTR3_I]], i64 2
+; CHECK-NEXT:    call void @llvm.experimental.noalias.scope.decl(metadata !36), !noalias !39
+; CHECK-NEXT:    call void @llvm.experimental.noalias.scope.decl(metadata !40), !noalias !39
+; CHECK-NEXT:    store i32 10, i32* [[ADD_PTR_I_I]], align 4, !alias.scope !42, !noalias !43
+; CHECK-NEXT:    store i32 20, i32* [[ADD_PTR1_I_I]], align 4, !alias.scope !43, !noalias !42
+; CHECK-NEXT:    store i32 11, i32* [[ADD_PTR2_I]], align 4, !alias.scope !44, !noalias !45
+; CHECK-NEXT:    store i32 12, i32* [[ADD_PTR1]], align 4, !alias.scope !21, !noalias !18
+; CHECK-NEXT:    br label [[CALLER_EQUALS_CALLEE_EXIT]]
+; CHECK:       caller_equals_callee.exit:
+; CHECK-NEXT:    ret void
+;
+entry:
+  store i32 13, i32* %p0, align 4
+  %add.ptr = getelementptr inbounds i32, i32* %p0, i64 1
+  %add.ptr1 = getelementptr inbounds i32, i32* %p1, i64 1
+  call void @caller_equals_callee(i32* nonnull %add.ptr, i32* nonnull %add.ptr1, i32 %cnt)
+  ret void
+}
+
+attributes #0 = { inaccessiblememonly nofree nosync nounwind willreturn }
+
+!0 = !{!1}
+!1 = distinct !{!1, !2, !"do_store: %p0"}
+!2 = distinct !{!2, !"do_store"}
+!3 = !{!4}
+!4 = distinct !{!4, !2, !"do_store: %p1"}
+
+; CHECK: !0 = !{!1}
+; CHECK: !1 = distinct !{!1, !2, !"do_store: %p0"}
+; CHECK: !2 = distinct !{!2, !"do_store"}
+; CHECK: !3 = !{!4}
+; CHECK: !4 = distinct !{!4, !2, !"do_store: %p1"}
+; CHECK: !5 = !{!6}
+; CHECK: !6 = distinct !{!6, !7, !"caller_equals_callee: %p0"}
+; CHECK: !7 = distinct !{!7, !"caller_equals_callee"}
+; CHECK: !8 = !{!9}
+; CHECK: !9 = distinct !{!9, !7, !"caller_equals_callee: %p1"}
+; CHECK: !10 = !{!11}
+; CHECK: !11 = distinct !{!11, !12, !"do_store: %p0"}
+; CHECK: !12 = distinct !{!12, !"do_store"}
+; CHECK: !13 = !{!6, !9}
+; CHECK: !14 = !{!15}
+; CHECK: !15 = distinct !{!15, !12, !"do_store: %p1"}
+; CHECK: !16 = !{!11, !6}
+; CHECK: !17 = !{!15, !9}
+
+; CHECK: !18 = !{!19}
+; CHECK: !19 = distinct !{!19, !20, !"caller_equals_callee: %p0"}
+; CHECK: !20 = distinct !{!20, !"caller_equals_callee"}
+; CHECK: !21 = !{!22}
+; CHECK: !22 = distinct !{!22, !20, !"caller_equals_callee: %p1"}
+; CHECK: !23 = !{!24}
+; CHECK: !24 = distinct !{!24, !25, !"do_store: %p0"}
+; CHECK: !25 = distinct !{!25, !"do_store"}
+; CHECK: !26 = !{!19, !22}
+; CHECK: !27 = !{!28}
+; CHECK: !28 = distinct !{!28, !25, !"do_store: %p1"}
+; CHECK: !29 = !{!24, !19}
+; CHECK: !30 = !{!28, !22}
+; CHECK: !31 = !{!32}
+; CHECK: !32 = distinct !{!32, !33, !"caller_equals_callee: %p0"}
+; CHECK: !33 = distinct !{!33, !"caller_equals_callee"}
+; CHECK: !34 = !{!35}
+; CHECK: !35 = distinct !{!35, !33, !"caller_equals_callee: %p1"}
+; CHECK: !36 = !{!37}
+; CHECK: !37 = distinct !{!37, !38, !"do_store: %p0"}
+; CHECK: !38 = distinct !{!38, !"do_store"}
+; CHECK: !39 = !{!32, !35, !19, !22}
+; CHECK: !40 = !{!41}
+; CHECK: !41 = distinct !{!41, !38, !"do_store: %p1"}
+; CHECK: !42 = !{!37, !32, !22}
+; CHECK: !43 = !{!41, !35, !19}
+; CHECK: !44 = !{!32, !22}
+; CHECK: !45 = !{!35, !19}

llvm/test/Transforms/Inline/noalias-cs.ll

 ; NOTE: Assertions have been autogenerated by utils/update_test_checks.py
 ; RUN: opt -inline -S < %s | FileCheck %s
 target datalayout = "e-i64:64-f80:128-n8:16:32:64-S128"
 target triple = "x86_64-unknown-linux-gnu"
 
 ; This callee uses scoped alias metadata internally itself.
 define void @callee_with_metadata(float* nocapture %a, float* nocapture %b, float* nocapture readonly %c) #0 {
+; CHECK-LABEL: @callee_with_metadata(
+; CHECK-NEXT:  entry:
+; CHECK-NEXT:    call void @llvm.experimental.noalias.scope.decl(metadata !0)
+; CHECK-NEXT:    call void @llvm.experimental.noalias.scope.decl(metadata !3)
+; CHECK-NEXT:    [[TMP0:%.*]] = load float, float* [[C:%.*]], align 4, !noalias !5
+; CHECK-NEXT:    [[ARRAYIDX_I:%.*]] = getelementptr inbounds float, float* [[A:%.*]], i64 5
+; CHECK-NEXT:    store float [[TMP0]], float* [[ARRAYIDX_I]], align 4, !alias.scope !0, !noalias !3
+; CHECK-NEXT:    [[ARRAYIDX1_I:%.*]] = getelementptr inbounds float, float* [[B:%.*]], i64 8
+; CHECK-NEXT:    store float [[TMP0]], float* [[ARRAYIDX1_I]], align 4, !alias.scope !3, !noalias !0
+; CHECK-NEXT:    [[TMP1:%.*]] = load float, float* [[C]], align 4
+; CHECK-NEXT:    [[ARRAYIDX:%.*]] = getelementptr inbounds float, float* [[A]], i64 7
+; CHECK-NEXT:    store float [[TMP1]], float* [[ARRAYIDX]], align 4
+; CHECK-NEXT:    ret void
+;
 entry:
+  call void @llvm.experimental.noalias.scope.decl(metadata !7)
+  call void @llvm.experimental.noalias.scope.decl(metadata !8)
   %0 = load float, float* %c, align 4, !noalias !3
   %arrayidx.i = getelementptr inbounds float, float* %a, i64 5
   store float %0, float* %arrayidx.i, align 4, !alias.scope !7, !noalias !8
   %arrayidx1.i = getelementptr inbounds float, float* %b, i64 8
   store float %0, float* %arrayidx1.i, align 4, !alias.scope !8, !noalias !7
   %1 = load float, float* %c, align 4
   %arrayidx = getelementptr inbounds float, float* %a, i64 7
   store float %1, float* %arrayidx, align 4
   ret void
 }
 
+declare void @llvm.experimental.noalias.scope.decl(metadata);
+
 ; This callee does not make use of scoped alias metadata itself.
 define void @callee_without_metadata(float* nocapture %a, float* nocapture %b, float* nocapture readonly %c) #0 {
+; CHECK-LABEL: @callee_without_metadata(
+; CHECK-NEXT:  entry:
+; CHECK-NEXT:    [[TMP0:%.*]] = load float, float* [[C:%.*]], align 4
+; CHECK-NEXT:    [[ARRAYIDX_I:%.*]] = getelementptr inbounds float, float* [[A:%.*]], i64 5
+; CHECK-NEXT:    store float [[TMP0]], float* [[ARRAYIDX_I]], align 4
+; CHECK-NEXT:    [[ARRAYIDX1_I:%.*]] = getelementptr inbounds float, float* [[B:%.*]], i64 8
+; CHECK-NEXT:    store float [[TMP0]], float* [[ARRAYIDX1_I]], align 4
+; CHECK-NEXT:    [[TMP1:%.*]] = load float, float* [[C]], align 4
+; CHECK-NEXT:    [[ARRAYIDX:%.*]] = getelementptr inbounds float, float* [[A]], i64 7
+; CHECK-NEXT:    store float [[TMP1]], float* [[ARRAYIDX]], align 4
+; CHECK-NEXT:    ret void
+;
 entry:
   %0 = load float, float* %c, align 4
   %arrayidx.i = getelementptr inbounds float, float* %a, i64 5
   store float %0, float* %arrayidx.i, align 4
   %arrayidx1.i = getelementptr inbounds float, float* %b, i64 8
   store float %0, float* %arrayidx1.i, align 4
   %1 = load float, float* %c, align 4
   %arrayidx = getelementptr inbounds float, float* %a, i64 7
   store float %1, float* %arrayidx, align 4
   ret void
 }
 
 define void @caller(float* nocapture %a, float* nocapture %b, float** nocapture readonly %c_ptr) #0 {
 ; CHECK-LABEL: @caller(
 ; CHECK-NEXT:  entry:
 ; CHECK-NEXT:    [[C:%.*]] = load float*, float** [[C_PTR:%.*]], align 8, !alias.scope !6
-; CHECK-NEXT:    [[TMP0:%.*]] = load float, float* [[C]], align 4, !noalias !9
+; CHECK-NEXT:    call void @llvm.experimental.noalias.scope.decl(metadata !9) [[ATTR2:#.*]], !noalias !6
+; CHECK-NEXT:    call void @llvm.experimental.noalias.scope.decl(metadata !12) [[ATTR2]], !noalias !6
+; CHECK-NEXT:    [[TMP0:%.*]] = load float, float* [[C]], align 4, !noalias !14
 ; CHECK-NEXT:    [[ARRAYIDX_I_I:%.*]] = getelementptr inbounds float, float* [[A:%.*]], i64 5
-; CHECK-NEXT:    store float [[TMP0]], float* [[ARRAYIDX_I_I]], align 4, !alias.scope !13, !noalias !14
+; CHECK-NEXT:    store float [[TMP0]], float* [[ARRAYIDX_I_I]], align 4, !alias.scope !9, !noalias !15
 ; CHECK-NEXT:    [[ARRAYIDX1_I_I:%.*]] = getelementptr inbounds float, float* [[B:%.*]], i64 8
-; CHECK-NEXT:    store float [[TMP0]], float* [[ARRAYIDX1_I_I]], align 4, !alias.scope !15, !noalias !16
+; CHECK-NEXT:    store float [[TMP0]], float* [[ARRAYIDX1_I_I]], align 4, !alias.scope !12, !noalias !16
 ; CHECK-NEXT:    [[TMP1:%.*]] = load float, float* [[C]], align 4, !noalias !6
 ; CHECK-NEXT:    [[ARRAYIDX_I:%.*]] = getelementptr inbounds float, float* [[A]], i64 7
 ; CHECK-NEXT:    store float [[TMP1]], float* [[ARRAYIDX_I]], align 4, !noalias !6
-; CHECK-NEXT:    [[TMP2:%.*]] = load float, float* [[A]], align 4, !alias.scope !6, !noalias !17
+; CHECK-NEXT:    call void @llvm.experimental.noalias.scope.decl(metadata !17) [[ATTR2]], !alias.scope !6
+; CHECK-NEXT:    call void @llvm.experimental.noalias.scope.decl(metadata !20) [[ATTR2]], !alias.scope !6
+; CHECK-NEXT:    [[TMP2:%.*]] = load float, float* [[A]], align 4, !alias.scope !6, !noalias !22
 ; CHECK-NEXT:    [[ARRAYIDX_I_I7:%.*]] = getelementptr inbounds float, float* [[B]], i64 5
-; CHECK-NEXT:    store float [[TMP2]], float* [[ARRAYIDX_I_I7]], align 4, !alias.scope !21, !noalias !22
+; CHECK-NEXT:    store float [[TMP2]], float* [[ARRAYIDX_I_I7]], align 4, !alias.scope !23, !noalias !20
 ; CHECK-NEXT:    [[ARRAYIDX1_I_I8:%.*]] = getelementptr inbounds float, float* [[B]], i64 8
-; CHECK-NEXT:    store float [[TMP2]], float* [[ARRAYIDX1_I_I8]], align 4, !alias.scope !23, !noalias !24
+; CHECK-NEXT:    store float [[TMP2]], float* [[ARRAYIDX1_I_I8]], align 4, !alias.scope !24, !noalias !17
 ; CHECK-NEXT:    [[TMP3:%.*]] = load float, float* [[A]], align 4, !alias.scope !6
 ; CHECK-NEXT:    [[ARRAYIDX_I9:%.*]] = getelementptr inbounds float, float* [[B]], i64 7
 ; CHECK-NEXT:    store float [[TMP3]], float* [[ARRAYIDX_I9]], align 4, !alias.scope !6
 ; CHECK-NEXT:    [[TMP4:%.*]] = load float, float* [[C]], align 4, !noalias !6
 ; CHECK-NEXT:    [[ARRAYIDX_I_I4:%.*]] = getelementptr inbounds float, float* [[A]], i64 5
 ; CHECK-NEXT:    store float [[TMP4]], float* [[ARRAYIDX_I_I4]], align 4, !noalias !6
 ; CHECK-NEXT:    [[ARRAYIDX1_I_I5:%.*]] = getelementptr inbounds float, float* [[B]], i64 8
 ; CHECK-NEXT:    store float [[TMP4]], float* [[ARRAYIDX1_I_I5]], align 4, !noalias !6

 !2 = distinct !{!2, !"hello"}
 !3 = !{!4, !6}
 !4 = distinct !{!4, !5, !"hello2: %a"}
 !5 = distinct !{!5, !"hello2"}
 !6 = distinct !{!6, !5, !"hello2: %b"}
 !7 = !{!4}
 !8 = !{!6}
 
-; CHECK: !0 = !{!1, !3}
+; CHECK: !0 = !{!1}
 ; CHECK: !1 = distinct !{!1, !2, !"hello2: %a"}
 ; CHECK: !2 = distinct !{!2, !"hello2"}
-; CHECK: !3 = distinct !{!3, !2, !"hello2: %b"}
-; CHECK: !4 = !{!1}
-; CHECK: !5 = !{!3}
+; CHECK: !3 = !{!4}
+; CHECK: !4 = distinct !{!4, !2, !"hello2: %b"}
+; CHECK: !5 = !{!1, !4}
 ; CHECK: !6 = !{!7}
 ; CHECK: !7 = distinct !{!7, !8, !"hello: %a"}
 ; CHECK: !8 = distinct !{!8, !"hello"}
-; CHECK: !9 = !{!10, !12, !7}
+; CHECK: !9 = !{!10}
 ; CHECK: !10 = distinct !{!10, !11, !"hello2: %a"}
 ; CHECK: !11 = distinct !{!11, !"hello2"}
-; CHECK: !12 = distinct !{!12, !11, !"hello2: %b"}
-; CHECK: !13 = !{!10}
-; CHECK: !14 = !{!12, !7}
-; CHECK: !15 = !{!12}
+; CHECK: !12 = !{!13}
+; CHECK: !13 = distinct !{!13, !11, !"hello2: %b"}
+; CHECK: !14 = !{!10, !13, !7}
+; CHECK: !15 = !{!13, !7}
 ; CHECK: !16 = !{!10, !7}
-; CHECK: !17 = !{!18, !20}
+; CHECK: !17 = !{!18}
 ; CHECK: !18 = distinct !{!18, !19, !"hello2: %a"}
 ; CHECK: !19 = distinct !{!19, !"hello2"}
-; CHECK: !20 = distinct !{!20, !19, !"hello2: %b"}
-; CHECK: !21 = !{!18, !7}
-; CHECK: !22 = !{!20}
-; CHECK: !23 = !{!20, !7}
-; CHECK: !24 = !{!18}
+; CHECK: !20 = !{!21}
+; CHECK: !21 = distinct !{!21, !19, !"hello2: %b"}
+; CHECK: !22 = !{!18, !21}
+; CHECK: !23 = !{!18, !7}
+; CHECK: !24 = !{!21, !7}

llvm/test/Transforms/Inline/noalias.ll

 entry:
   tail call void @hello(float* %a, float* %c)
   %0 = load float, float* %c, align 4
   %arrayidx = getelementptr inbounds float, float* %a, i64 7
   store float %0, float* %arrayidx, align 4
   ret void
 }
 
-; CHECK: define void @foo(float* nocapture %a, float* nocapture readonly %c) #0 {
+; CHECK-LABEL: define void @foo(float* nocapture %a, float* nocapture readonly %c) #0 {
 ; CHECK: entry:
-; CHECK:   %0 = load float, float* %c, align 4, !noalias !0
+; CHECK:   call void @llvm.experimental.noalias.scope.decl
+; CHECK:   [[TMP0:%.+]] = load float, float* %c, align 4, !noalias !0
 ; CHECK:   %arrayidx.i = getelementptr inbounds float, float* %a, i64 5
-; CHECK:   store float %0, float* %arrayidx.i, align 4, !alias.scope !0
-; CHECK:   %1 = load float, float* %c, align 4
+; CHECK:   store float [[TMP0]], float* %arrayidx.i, align 4, !alias.scope !0
+; CHECK:   [[TMP1:%.+]] = load float, float* %c, align 4
 ; CHECK:   %arrayidx = getelementptr inbounds float, float* %a, i64 7
-; CHECK:   store float %1, float* %arrayidx, align 4
+; CHECK:   store float [[TMP1]], float* %arrayidx, align 4
 ; CHECK:   ret void
 ; CHECK: }
 
 define void @hello2(float* noalias nocapture %a, float* noalias nocapture %b, float* nocapture readonly %c) #0 {
 entry:
   %0 = load float, float* %c, align 4
   %arrayidx = getelementptr inbounds float, float* %a, i64 5
   store float %0, float* %arrayidx, align 4
   %arrayidx1 = getelementptr inbounds float, float* %b, i64 8
   store float %0, float* %arrayidx1, align 4
   ret void
 }
 
 define void @foo2(float* nocapture %a, float* nocapture %b, float* nocapture readonly %c) #0 {
 entry:
   tail call void @hello2(float* %a, float* %b, float* %c)
   %0 = load float, float* %c, align 4
   %arrayidx = getelementptr inbounds float, float* %a, i64 7
   store float %0, float* %arrayidx, align 4
   ret void
 }
 
-; CHECK: define void @foo2(float* nocapture %a, float* nocapture %b, float* nocapture readonly %c) #0 {
+; CHECK-LABEL: define void @foo2(float* nocapture %a, float* nocapture %b, float* nocapture readonly %c) #0 {
 ; CHECK: entry:
-; CHECK:   %0 = load float, float* %c, align 4, !noalias !3
+; CHECK:   call void @llvm.experimental.noalias.scope.decl(metadata !3)
+; CHECK:   call void @llvm.experimental.noalias.scope.decl(metadata !6)
+; CHECK:   [[TMP0:%.+]] = load float, float* %c, align 4, !noalias !8
 ; CHECK:   %arrayidx.i = getelementptr inbounds float, float* %a, i64 5
-; CHECK:   store float %0, float* %arrayidx.i, align 4, !alias.scope !7, !noalias !8
+; CHECK:   store float [[TMP0]], float* %arrayidx.i, align 4, !alias.scope !3, !noalias !6
 ; CHECK:   %arrayidx1.i = getelementptr inbounds float, float* %b, i64 8
-; CHECK:   store float %0, float* %arrayidx1.i, align 4, !alias.scope !8, !noalias !7
-; CHECK:   %1 = load float, float* %c, align 4
+; CHECK:   store float [[TMP0]], float* %arrayidx1.i, align 4, !alias.scope !6, !noalias !3
+; CHECK:   [[TMP1:%.+]] = load float, float* %c, align 4
 ; CHECK:   %arrayidx = getelementptr inbounds float, float* %a, i64 7
-; CHECK:   store float %1, float* %arrayidx, align 4
+; CHECK:   store float [[TMP1]], float* %arrayidx, align 4
 ; CHECK:   ret void
 ; CHECK: }
 
 attributes #0 = { nounwind uwtable }
 
 ; CHECK: !0 = !{!1}
 ; CHECK: !1 = distinct !{!1, !2, !"hello: %a"}
 ; CHECK: !2 = distinct !{!2, !"hello"}
-; CHECK: !3 = !{!4, !6}
+; CHECK: !3 = !{!4}
 ; CHECK: !4 = distinct !{!4, !5, !"hello2: %a"}
 ; CHECK: !5 = distinct !{!5, !"hello2"}
-; CHECK: !6 = distinct !{!6, !5, !"hello2: %b"}
-; CHECK: !7 = !{!4}
-; CHECK: !8 = !{!6}
-
+; CHECK: !6 = !{!7}
+; CHECK: !7 = distinct !{!7, !5, !"hello2: %b"}
+; CHECK: !8 = !{!4, !7}

llvm/test/Transforms/Inline/noalias2.ll

entry:
   store float %0, float* %arrayidx, align 4
   ret void
 }
 
 define void @foo(float* noalias nocapture %a, float* noalias nocapture readonly %c) #0 {
 ; CHECK-LABEL: define {{[^@]+}}@foo
 ; CHECK-SAME: (float* noalias nocapture [[A:%.*]], float* noalias nocapture readonly [[C:%.*]]) [[ATTR0]] {
 ; CHECK-NEXT:  entry:
-; CHECK-NEXT:    [[TMP0:%.*]] = load float, float* [[C]], align 4, !alias.scope !0, !noalias !3
+; CHECK-NEXT:    call void @llvm.experimental.noalias.scope.decl(metadata !0)
+; CHECK-NEXT:    call void @llvm.experimental.noalias.scope.decl(metadata !3)
+; CHECK-NEXT:    [[TMP0:%.*]] = load float, float* [[C]], align 4, !alias.scope !3, !noalias !0
 ; CHECK-NEXT:    [[ARRAYIDX_I:%.*]] = getelementptr inbounds float, float* [[A]], i64 5
-; CHECK-NEXT:    store float [[TMP0]], float* [[ARRAYIDX_I]], align 4, !alias.scope !3, !noalias !0
+; CHECK-NEXT:    store float [[TMP0]], float* [[ARRAYIDX_I]], align 4, !alias.scope !0, !noalias !3
 ; CHECK-NEXT:    [[TMP1:%.*]] = load float, float* [[C]], align 4
 ; CHECK-NEXT:    [[ARRAYIDX:%.*]] = getelementptr inbounds float, float* [[A]], i64 7
 ; CHECK-NEXT:    store float [[TMP1]], float* [[ARRAYIDX]], align 4
 ; CHECK-NEXT:    ret void
 ;
 entry:
   tail call void @hello(float* %a, float* %c)
   %0 = load float, float* %c, align 4

 }
 
 ; Check that when hello() is inlined into foo(), and then foo() is inlined into
 ; foo2(), the noalias scopes are properly concatenated.
 define void @foo2(float* nocapture %a, float* nocapture %b, float* nocapture readonly %c) #0 {
 ; CHECK-LABEL: define {{[^@]+}}@foo2
 ; CHECK-SAME: (float* nocapture [[A:%.*]], float* nocapture [[B:%.*]], float* nocapture readonly [[C:%.*]]) [[ATTR0]] {
 ; CHECK-NEXT:  entry:
-; CHECK-NEXT:    [[TMP0:%.*]] = load float, float* [[C]], align 4, !alias.scope !5, !noalias !10
+; CHECK-NEXT:    call void @llvm.experimental.noalias.scope.decl(metadata !5)
+; CHECK-NEXT:    call void @llvm.experimental.noalias.scope.decl(metadata !8)
+; CHECK-NEXT:    call void @llvm.experimental.noalias.scope.decl(metadata !10) [[ATTR2:#.*]], !noalias !13
+; CHECK-NEXT:    call void @llvm.experimental.noalias.scope.decl(metadata !14) [[ATTR2]], !noalias !13
+; CHECK-NEXT:    [[TMP0:%.*]] = load float, float* [[C]], align 4, !alias.scope !16, !noalias !17
 ; CHECK-NEXT:    [[ARRAYIDX_I_I:%.*]] = getelementptr inbounds float, float* [[A]], i64 5
-; CHECK-NEXT:    store float [[TMP0]], float* [[ARRAYIDX_I_I]], align 4, !alias.scope !10, !noalias !5
-; CHECK-NEXT:    [[TMP1:%.*]] = load float, float* [[C]], align 4, !alias.scope !13, !noalias !14
+; CHECK-NEXT:    store float [[TMP0]], float* [[ARRAYIDX_I_I]], align 4, !alias.scope !17, !noalias !16
+; CHECK-NEXT:    [[TMP1:%.*]] = load float, float* [[C]], align 4, !alias.scope !8, !noalias !5
 ; CHECK-NEXT:    [[ARRAYIDX_I:%.*]] = getelementptr inbounds float, float* [[A]], i64 7
-; CHECK-NEXT:    store float [[TMP1]], float* [[ARRAYIDX_I]], align 4, !alias.scope !14, !noalias !13
-; CHECK-NEXT:    [[TMP2:%.*]] = load float, float* [[C]], align 4, !noalias !15
+; CHECK-NEXT:    store float [[TMP1]], float* [[ARRAYIDX_I]], align 4, !alias.scope !5, !noalias !8
+; CHECK-NEXT:    call void @llvm.experimental.noalias.scope.decl(metadata !18)
+; CHECK-NEXT:    call void @llvm.experimental.noalias.scope.decl(metadata !21)
+; CHECK-NEXT:    [[TMP2:%.*]] = load float, float* [[C]], align 4, !noalias !23
 ; CHECK-NEXT:    [[ARRAYIDX_I1:%.*]] = getelementptr inbounds float, float* [[A]], i64 6
-; CHECK-NEXT:    store float [[TMP2]], float* [[ARRAYIDX_I1]], align 4, !alias.scope !19, !noalias !20
+; CHECK-NEXT:    store float [[TMP2]], float* [[ARRAYIDX_I1]], align 4, !alias.scope !18, !noalias !21
 ; CHECK-NEXT:    [[ARRAYIDX1_I:%.*]] = getelementptr inbounds float, float* [[B]], i64 8
-; CHECK-NEXT:    store float [[TMP2]], float* [[ARRAYIDX1_I]], align 4, !alias.scope !20, !noalias !19
+; CHECK-NEXT:    store float [[TMP2]], float* [[ARRAYIDX1_I]], align 4, !alias.scope !21, !noalias !18
 ; CHECK-NEXT:    [[TMP3:%.*]] = load float, float* [[C]], align 4
 ; CHECK-NEXT:    [[ARRAYIDX:%.*]] = getelementptr inbounds float, float* [[A]], i64 7
 ; CHECK-NEXT:    store float [[TMP3]], float* [[ARRAYIDX]], align 4
 ; CHECK-NEXT:    ret void
 ;
 entry:
   tail call void @foo(float* %a, float* %c)
   tail call void @hello2(float* %a, float* %b, float* %c)
   %0 = load float, float* %c, align 4
   %arrayidx = getelementptr inbounds float, float* %a, i64 7
   store float %0, float* %arrayidx, align 4
   ret void
 }
 
 ; CHECK: !0 = !{!1}
-; CHECK: !1 = distinct !{!1, !2, !"hello: %c"}
+; CHECK: !1 = distinct !{!1, !2, !"hello: %a"}
 ; CHECK: !2 = distinct !{!2, !"hello"}
 ; CHECK: !3 = !{!4}
-; CHECK: !4 = distinct !{!4, !2, !"hello: %a"}
-; CHECK: !5 = !{!6, !8}
-; CHECK: !6 = distinct !{!6, !7, !"hello: %c"}
-; CHECK: !7 = distinct !{!7, !"hello"}
-; CHECK: !8 = distinct !{!8, !9, !"foo: %c"}
-; CHECK: !9 = distinct !{!9, !"foo"}
-; CHECK: !10 = !{!11, !12}
-; CHECK: !11 = distinct !{!11, !7, !"hello: %a"}
-; CHECK: !12 = distinct !{!12, !9, !"foo: %a"}
-; CHECK: !13 = !{!8}
-; CHECK: !14 = !{!12}
-; CHECK: !15 = !{!16, !18}
-; CHECK: !16 = distinct !{!16, !17, !"hello2: %a"}
-; CHECK: !17 = distinct !{!17, !"hello2"}
-; CHECK: !18 = distinct !{!18, !17, !"hello2: %b"}
-; CHECK: !19 = !{!16}
-; CHECK: !20 = !{!18}
+; CHECK: !4 = distinct !{!4, !2, !"hello: %c"}
+; CHECK: !5 = !{!6}
+; CHECK: !6 = distinct !{!6, !7, !"foo: %a"}
+; CHECK: !7 = distinct !{!7, !"foo"}
+; CHECK: !8 = !{!9}
+; CHECK: !9 = distinct !{!9, !7, !"foo: %c"}
+; CHECK: !10 = !{!11}
+; CHECK: !11 = distinct !{!11, !12, !"hello: %a"}
+; CHECK: !12 = distinct !{!12, !"hello"}
+; CHECK: !13 = !{!6, !9}
+; CHECK: !14 = !{!15}
+; CHECK: !15 = distinct !{!15, !12, !"hello: %c"}
+; CHECK: !16 = !{!15, !9}
+; CHECK: !17 = !{!11, !6}
+; CHECK: !18 = !{!19}
+; CHECK: !19 = distinct !{!19, !20, !"hello2: %a"}
+; CHECK: !20 = distinct !{!20, !"hello2"}
+; CHECK: !21 = !{!22}
+; CHECK: !22 = distinct !{!22, !20, !"hello2: %b"}
+; CHECK: !23 = !{!19, !22}
 
 attributes #0 = { nounwind uwtable }
 

llvm/test/Transforms/PhaseOrdering/inlining-alignment-assumptions.ll

 
 define internal void @callee2(i64* noalias sret(i64) align 32 %arg) {
   store i64 0, i64* %arg, align 8
   ret void
 }
 
 define amdgpu_kernel void @caller2() {
 ; CHECK-LABEL: @caller2(
+; CHECK-NEXT:    tail call void @llvm.experimental.noalias.scope.decl([[META0:metadata !.*]])
 ; CHECK-NEXT:    ret void
 ;
   %alloca = alloca i64, align 8, addrspace(5)
   %cast = addrspacecast i64 addrspace(5)* %alloca to i64*
   call void @callee2(i64* sret(i64) align 32 %cast)
   ret void
 }

llvm/test/Transforms/PhaseOrdering/instcombine-sroa-inttoptr.ll

 }
 
 define dso_local i32* @_Z3foo1S(%0* byval(%0) align 8 %arg) {
 ; CHECK-LABEL: @_Z3foo1S(
 ; CHECK-NEXT:  bb:
 ; CHECK-NEXT:    [[I2:%.*]] = alloca [[TMP0:%.*]], align 8
 ; CHECK-NEXT:    [[I1_SROA_0_0_I5_SROA_IDX:%.*]] = getelementptr inbounds [[TMP0]], %0* [[ARG:%.*]], i64 0, i32 0
 ; CHECK-NEXT:    [[I1_SROA_0_0_COPYLOAD:%.*]] = load i32*, i32** [[I1_SROA_0_0_I5_SROA_IDX]], align 8
+; CHECK-NEXT:    tail call void @llvm.experimental.noalias.scope.decl([[META0:metadata !.*]])
 ; CHECK-NEXT:    [[I_SROA_0_0_I6_SROA_IDX:%.*]] = getelementptr inbounds [[TMP0]], %0* [[I2]], i64 0, i32 0
 ; CHECK-NEXT:    store i32* [[I1_SROA_0_0_COPYLOAD]], i32** [[I_SROA_0_0_I6_SROA_IDX]], align 8
 ; CHECK-NEXT:    tail call void @_Z7escape01S(%0* nonnull byval(%0) align 8 [[I2]])
 ; CHECK-NEXT:    ret i32* [[I1_SROA_0_0_COPYLOAD]]
 ;
 bb:
   %i = alloca %0, align 8
   %i1 = alloca %0, align 8

 
 declare void @llvm.lifetime.end.p0i8(i64 immarg, i8* nocapture)
 
 define dso_local i32* @_Z3bar1S(%0* byval(%0) align 8 %arg) {
 ; CHECK-LABEL: @_Z3bar1S(
 ; CHECK-NEXT:  bb:
 ; CHECK-NEXT:    [[I1_SROA_0_0_I4_SROA_IDX:%.*]] = getelementptr inbounds [[TMP0:%.*]], %0* [[ARG:%.*]], i64 0, i32 0
 ; CHECK-NEXT:    [[I1_SROA_0_0_COPYLOAD:%.*]] = load i32*, i32** [[I1_SROA_0_0_I4_SROA_IDX]], align 8
+; CHECK-NEXT:    tail call void @llvm.experimental.noalias.scope.decl([[META3:metadata !.*]])
 ; CHECK-NEXT:    [[I5:%.*]] = tail call i32 @_Z4condv()
 ; CHECK-NEXT:    [[I6_NOT:%.*]] = icmp eq i32 [[I5]], 0
 ; CHECK-NEXT:    br i1 [[I6_NOT]], label [[BB10:%.*]], label [[BB7:%.*]]
 ; CHECK:       bb7:
 ; CHECK-NEXT:    tail call void @_Z5sync0v()
 ; CHECK-NEXT:    tail call void @_Z7escape0Pi(i32* [[I1_SROA_0_0_COPYLOAD]])
 ; CHECK-NEXT:    br label [[BB13:%.*]]
 ; CHECK:       bb10:

llvm/test/Transforms/PhaseOrdering/pr39282.ll

 }
 
 ; Consider that %addr1 = %addr2 + 1, in which case %addr2i and %addr1i are
 ; noalias within one iteration, but may alias across iterations.
 ; TODO: This is a micompile.
 define void @pr39282(i32* %addr1, i32* %addr2) {
 ; CHECK-LABEL: @pr39282(
 ; CHECK-NEXT:  start:
-; CHECK-NEXT:    [[X_I:%.*]] = load i32, i32* [[ADDR1:%.*]], align 4, !alias.scope !0, !noalias !3
+; CHECK-NEXT:    tail call void @llvm.experimental.noalias.scope.decl([[META0:metadata !.*]])
+; CHECK-NEXT:    tail call void @llvm.experimental.noalias.scope.decl([[META3:metadata !.*]])
+; CHECK-NEXT:    [[X_I:%.*]] = load i32, i32* [[ADDR1:%.*]], align 4, !alias.scope !3, !noalias !0
 ; CHECK-NEXT:    [[ADDR1I_1:%.*]] = getelementptr inbounds i32, i32* [[ADDR1]], i64 1
 ; CHECK-NEXT:    [[ADDR2I_1:%.*]] = getelementptr inbounds i32, i32* [[ADDR2:%.*]], i64 1
-; CHECK-NEXT:    [[X_I_1:%.*]] = load i32, i32* [[ADDR1I_1]], align 4, !alias.scope !0, !noalias !3
-; CHECK-NEXT:    store i32 [[X_I]], i32* [[ADDR2]], align 4, !alias.scope !3, !noalias !0
-; CHECK-NEXT:    store i32 [[X_I_1]], i32* [[ADDR2I_1]], align 4, !alias.scope !3, !noalias !0
+; CHECK-NEXT:    tail call void @llvm.experimental.noalias.scope.decl([[META0]])
+; CHECK-NEXT:    tail call void @llvm.experimental.noalias.scope.decl([[META3]])
+; CHECK-NEXT:    [[X_I_1:%.*]] = load i32, i32* [[ADDR1I_1]], align 4, !alias.scope !3, !noalias !0
+; CHECK-NEXT:    tail call void @llvm.experimental.noalias.scope.decl([[META0]])
+; CHECK-NEXT:    tail call void @llvm.experimental.noalias.scope.decl([[META3]])
+; CHECK-NEXT:    store i32 [[X_I]], i32* [[ADDR2]], align 4, !alias.scope !0, !noalias !3
+; CHECK-NEXT:    tail call void @llvm.experimental.noalias.scope.decl([[META0]])
+; CHECK-NEXT:    tail call void @llvm.experimental.noalias.scope.decl([[META3]])
+; CHECK-NEXT:    store i32 [[X_I_1]], i32* [[ADDR2I_1]], align 4, !alias.scope !0, !noalias !3
 ; CHECK-NEXT:    ret void
 ;
 start:
   br label %body
 
 body:
   %i = phi i32 [ 0, %start ], [ %i.next, %body ]
   %j = and i32 %i, 1