[InstCombine] Remove unused llvm.experimental.noalias.scope.decl

[jeroen.dobbelaere]

Summary

A @llvm.experimental.noalias.scope.decl is only useful if there is !alias.scope and !noalias metadata that uses the declared scope.
When that is not the case for at least one of the two, the intrinsic call can as well be removed.

[nikic]

InstSimplify is not a good place to put this (it's mostly a testing pass -- you'll find that it's only scheduled once in a standard pipeline). InstCombine is a better place. I would collect scopes during initial worklist population and then delete when the declaration is visited.

[jeroen.dobbelaere]

Moved to InstCombine.

[nikic]

llvm/lib/Transforms/InstCombine/InstructionCombining.cpp

3777

Why only MD_alias_scope and not also MD_noalias?

[jeroen.dobbelaere]

llvm/lib/Transforms/InstCombine/InstructionCombining.cpp

3777

MD_noalias is telling what scopes (variables) are 'active'/'visible' for the memory instruction, but to which it will not alias.
MD_alias_scopeis telling what 'variable(s)' is/are associated to the memory instruction (to which it _will_ alias).

A no-aliasing relationship between two instructions can be deduced by checking if the !alias.scope of one instruction is a subset of the !noalias of the other instruction (also taking into account the 'domain').

Once a scope is not any more used in !alias.scope (aka, those memory instructions have been optimized away, or they lost the metadata), the location of that scope declaration has no influence any more and can be omitted.
(With the full restrict patches, this corresponds the usage count of the declaration becoming 0)

Of course the same reasoning can be done for the !noalias metadata: once a declared scope is not used any more in !noalias you can come to the same conclusion and omit that declaration.

hmm..

My reasoning was that we are more likely to hit this with the '!alias.scope'. But a more complete solution can also track the UsedNoAliasScopes. If the declared scope is not found in one of the two, it (and its declaration) become useless and we can omit it. Removing the declaration is easy and safe. I am not sure if removing the metadata associated with that scope is also easy and safe to do. Shared metadata between functions could make it tricky, although that should only happen in testcases as far as I am aware.

So, the short answer is: focusing on MD_alias_scope is likely the most effective (and corresponds to how the full restrict patches handle it)

But, extending the analysis to also track MD_noalias can provide a more complete solution, at a slightly higher cost.

@hfinkel, do you agree with my reasoning ?

@nikic, @jdoerfert shall I add the UsedNoAliasScopes tracking as well ?
Whatever we choose, some extra explanation why this is valid should also be added.

[nikic]

llvm/lib/Transforms/InstCombine/InstructionCombining.cpp

3777

At least longer term, I would like that every scope use also has a corresponding decl. With that in mind, I don't really like the idea of leading behind "dangling" scope references, even if it is technically correct.

If it doesn't lose much practical optimization power, I would prefer it if we only dropped decls for scopes that are used in neither alias.scope nor noalias. But if this is a significant restriction, then I think your current approach of looking at alias.scope is fine (as it is annotated to loads, and those are much more likely to be eliminated than stores).

[jeroen.dobbelaere]

llvm/lib/Transforms/InstCombine/InstructionCombining.cpp

3777

I understand.

Again, the original idea is based on the full restrict version with the 'usage based' elimination of the scope declarations: when no actual pointer is based on the scope declaration associated with the restrict pointer, that declaration is not needed any more. A 'completely clean' version could combine this with going over _all_ instructions in the function and removing that scope from the metadata. With full restrict, that cost was considered to be too high. There, it is also possible to have multiple declarations using the same scope, but associated to different 'restrict pointers' sharing that scope.

IMHO, it does not make sense to only remove the declaration if the scope is not used at all. Once it is not used by either all !alias.scope, or all !noalias, it can be removed. A further refinement can indeed spend time in actually removing the unused/ineffective scope from the metadata. But I would rather do that as a followup change.

[jeroen.dobbelaere]

I noticed that D93040 added a decent 2% penalty for trampd3d-v4. In https://llvm-compile-time-tracker.com/index.php?config=O3&stat=instructions&branch=dobbelaj-snps/perf/D95141_20210123_01 you can see that the cleanup wins back most of this regression.

[xbolva00]

In D95141#2517490, @jeroen.dobbelaere wrote:

I noticed that D93040 added a decent 2% penalty for trampd3d-v4. In https://llvm-compile-time-tracker.com/index.php?config=O3&stat=instructions&branch=dobbelaj-snps/perf/D95141_20210123_01 you can see that the cleanup wins back most of this regression.

4% for LTO.
It would be good to revert D93040 maybe.. Or be sure this fix goes in before llvm 12.
It is kinda unfortunate to introduce new regressions few days before rc1.

[jeroen.dobbelaere]

In D95141#2517496, @xbolva00 wrote:

In D95141#2517490, @jeroen.dobbelaere wrote:

I noticed that D93040 added a decent 2% penalty for trampd3d-v4. In https://llvm-compile-time-tracker.com/index.php?config=O3&stat=instructions&branch=dobbelaj-snps/perf/D95141_20210123_01 you can see that the cleanup wins back most of this regression.

It would be good to revert D93040 maybe.. Or be sure this fix goes in before llvm 12.

The goal is to have everything in before llvm-12 (unless other big blockers pop up)

[jeroen.dobbelaere]

Look at both !alias.scope and !noalias to decide when to omit a declaration.
During the analysis of !alias.scope and !nolias : when a 'list of scopes' was already analysed we do not need to go over it again.

See https://llvm-compile-time-tracker.com/index.php?config=O3&stat=instructions&branch=dobbelaj-snps/perf/D95141_20210123_02 for the compile time effect.

[jdoerfert]

Logic seems sounds to me. Code as well, one minor nit below. I have no objections to this.

llvm/lib/Transforms/InstCombine/InstructionCombining.cpp

3789

Style: I would prefer early exits but feel free to ignore if you think its not better.

const auto *MDScopeList = dyn_cast_or_null<MDNode>(ScopeList);
if (!MDScopeList || !Container.insert(MDSCopeList).second)
  return;
for (auto &MDOperand : MDScopeList->operands())
  if (auto *MDScope = dyn_cast<MDNode>(MDOperand))
    Container.insert(MDScope);

---

Is it legal that the cast fails? If the verifier would complain we might just assume it is an MDNode.

llvm/test/Transforms/Coroutines/ex4.ll

56

I'm confused where these come from in the first place but that is unrelated.

[nikic]

During the analysis of !alias.scope and !nolias : when a 'list of scopes' was already analysed we do not need to go over it again.

I would expect that analysing scope list multiple times isn't really what's causing the compile-time hit here. It's probably the fact that you're looking up two kinds of metadata for each instruction, and metadata lookup is pretty expensive. You might want to check what the impact is if you only analyze mayReadOrWriteMemory() instructions.

llvm/lib/Transforms/InstCombine/InstructionCombining.cpp

3804

I've just pushed a NoAliasScopeDeclInst class to make this kind of code nicer.

auto *Decl = dyn_cast<NoAliasScopeDeclInst>(Inst);
if (!Decl)
  return false;

const MDNode *MD = Decl->getScopeList();

[nikic]

In D95141#2517795, @nikic wrote:

During the analysis of !alias.scope and !nolias : when a 'list of scopes' was already analysed we do not need to go over it again.

I would expect that analysing scope list multiple times isn't really what's causing the compile-time hit here. It's probably the fact that you're looking up two kinds of metadata for each instruction, and metadata lookup is pretty expensive. You might want to check what the impact is if you only analyze mayReadOrWriteMemory() instructions.

Though possibly that won't help, as it's exactly loads, stores and calls that typically carry metadata anyway. Maybe just skipping DbgInfoIntrinsic would help to avoid a larger hit for -g builds...

[jeroen.dobbelaere]

In D95141#2517801, @nikic wrote:

In D95141#2517795, @nikic wrote:

During the analysis of !alias.scope and !nolias : when a 'list of scopes' was already analysed we do not need to go over it again.

I would expect that analysing scope list multiple times isn't really what's causing the compile-time hit here. It's probably the fact that you're looking up two kinds of metadata for each instruction, and metadata lookup is pretty expensive. You might want to check what the impact is if you only analyze mayReadOrWriteMemory() instructions.

Though possibly that won't help, as it's exactly loads, stores and calls that typically carry metadata anyway. Maybe just skipping DbgInfoIntrinsic would help to avoid a larger hit for -g builds...

Thanks for the feedback ! I'll check some variants tomorrow (Sunday). First getting some sleep ;)

[jeroen.dobbelaere]

llvm/test/Transforms/Coroutines/ex4.ll

56

I would assume the inlining of a function that returns a struct. Those typically have a noalias attribute for the return argument.

[jeroen.dobbelaere]

Use NoAliasScopeDeclInst. Only analyze non-debug instructions with metadata. (*1)

This seems to be faster than analyzing non-debug instruction that are reading or writing memory. (*2)

See https://llvm-compile-time-tracker.com/index.php?config=O3&stat=instructions&branch=dobbelaj-snps/perf/D95141_20210124_01 for some comparisons:

• *1 corresponds to: 374c7514b58d963cbab82341ad8383fcc89f588d
• *2 corresponds to: 26ed00968ed9925ead692dfd8a75bdf8dc4a3492

[nikic]

LGTM

[jeroen.dobbelaere]

Thanks. I'll still do the small refactoring recommended by @jdoerfert and then do the commits.

llvm/lib/Transforms/InstCombine/InstructionCombining.cpp

3789

ok.

I don't think the verifier is already complaining. I am all for making this more strict, but rather do this in a followup patch.

[jeroen.dobbelaere]

Small refactoring as recommended by @jdoerfert

llvm/lib/Transforms/InstCombine/InstructionCombining.cpp

if (Instruction *Result = visit(*I)) {
       MadeIRChange = true;
     }
   }
 
   Worklist.zap();
   return MadeIRChange;
 }
 
+// Track the scopes used by !alias.scope and !noalias. In a function, a
+// @llvm.experimental.noalias.scope.decl is only useful if that scope is used
+// by both sets. If not, the declaration of the scope can be safely omitted.
+// The MDNode of the scope can be omitted as well for the instructions that are
+// part of this function. We do not do that at this point, as this might become
+// too time consuming to do.
+class AliasScopeTracker {
+  SmallPtrSet<const MDNode *, 8> UsedAliasScopesAndLists;
+  SmallPtrSet<const MDNode *, 8> UsedNoAliasScopesAndLists;
+
+public:
+  void analyse(Instruction *I) {
+    // This seems to be faster than checking 'mayReadOrWriteMemory()'.
+    if (!I->hasMetadataOtherThanDebugLoc())
+      return;
+
+    auto Track = [](Metadata *ScopeList, auto &Container) {
+      const auto *MDScopeList = dyn_cast_or_null<MDNode>(ScopeList);
+      if (!MDScopeList || !Container.insert(MDScopeList).second)
+        return;
+      for (auto &MDOperand : MDScopeList->operands())
+        if (auto *MDScope = dyn_cast<MDNode>(MDOperand))
+          Container.insert(MDScope);
+    };
+
+    Track(I->getMetadata(LLVMContext::MD_alias_scope), UsedAliasScopesAndLists);
+    Track(I->getMetadata(LLVMContext::MD_noalias), UsedNoAliasScopesAndLists);
+  }
+
+  bool isNoAliasScopeDeclDead(Instruction *Inst) {
+    NoAliasScopeDeclInst *Decl = dyn_cast<NoAliasScopeDeclInst>(Inst);
+    if (!Decl)
+      return false;
+
+    assert(Decl->use_empty() &&
+           "llvm.experimental.noalias.scope.decl in use ?");
+    const MDNode *MDSL = Decl->getScopeList();
+    assert(MDSL->getNumOperands() == 1 &&
+           "llvm.experimental.noalias.scope should refer to a single scope");
+    auto &MDOperand = MDSL->getOperand(0);
+    if (auto *MD = dyn_cast<MDNode>(MDOperand))
+      return !UsedAliasScopesAndLists.contains(MD) ||
+             !UsedNoAliasScopesAndLists.contains(MD);
+
+    // Not an MDNode ? throw away.
+    return true;
+  }
+};
+
 /// Populate the IC worklist from a function, by walking it in depth-first
 /// order and adding all reachable code to the worklist.
 ///
 /// This has a couple of tricks to make the code faster and more powerful.  In
 /// particular, we constant fold and DCE instructions as we go, to avoid adding
 /// them to the worklist (this significantly speeds up instcombine on code where
 /// many instructions are dead or constant).  Additionally, if we find a branch
 /// whose condition is a known constant, we only visit the reachable successors.
 static bool prepareICWorklistFromFunction(Function &F, const DataLayout &DL,
                                           const TargetLibraryInfo *TLI,
                                           InstCombineWorklist &ICWorklist) {
   bool MadeIRChange = false;
   SmallPtrSet<BasicBlock *, 32> Visited;
   SmallVector<BasicBlock*, 256> Worklist;
   Worklist.push_back(&F.front());
 
   SmallVector<Instruction*, 128> InstrsForInstCombineWorklist;
   DenseMap<Constant *, Constant *> FoldedConstants;
+  AliasScopeTracker SeenAliasScopes;
 
   do {
     BasicBlock *BB = Worklist.pop_back_val();
 
     // We have now visited this block!  If we've already been here, ignore it.
     if (!Visited.insert(BB).second)
       continue;
 
for (BasicBlock::iterator BBI = BB->begin(), E = BB->end(); BBI != E; ) {
                             << "\n    New = " << *FoldRes << '\n');
           U = FoldRes;
           MadeIRChange = true;
         }
       }
 
       // Skip processing debug intrinsics in InstCombine. Processing these call instructions
       // consumes non-trivial amount of time and provides no value for the optimization.
-      if (!isa<DbgInfoIntrinsic>(Inst))
+      if (!isa<DbgInfoIntrinsic>(Inst)) {
         InstrsForInstCombineWorklist.push_back(Inst);
+        SeenAliasScopes.analyse(Inst);
+      }
     }
 
     // Recursively visit successors.  If this is a branch or switch on a
     // constant, only visit the reachable successor.
     Instruction *TI = BB->getTerminator();
     if (BranchInst *BI = dyn_cast<BranchInst>(TI)) {
       if (BI->isConditional() && isa<ConstantInt>(BI->getCondition())) {
         bool CondVal = cast<ConstantInt>(BI->getCondition())->getZExtValue();
static bool prepareICWorklistFromFunction(Function &F, const DataLayout &DL,
   // add them in reverse order.  This way instcombine will visit from the top
   // of the function down.  This jives well with the way that it adds all uses
   // of instructions to the worklist after doing a transformation, thus avoiding
   // some N^2 behavior in pathological cases.
   ICWorklist.reserve(InstrsForInstCombineWorklist.size());
   for (Instruction *Inst : reverse(InstrsForInstCombineWorklist)) {
     // DCE instruction if trivially dead. As we iterate in reverse program
     // order here, we will clean up whole chains of dead instructions.
-    if (isInstructionTriviallyDead(Inst, TLI)) {
+    if (isInstructionTriviallyDead(Inst, TLI) ||
+        SeenAliasScopes.isNoAliasScopeDeclDead(Inst)) {
       ++NumDeadInst;
       LLVM_DEBUG(dbgs() << "IC: DCE: " << *Inst << '\n');
       salvageDebugInfo(*Inst);
       Inst->eraseFromParent();
       MadeIRChange = true;
       continue;
     }
 

llvm/test/Transforms/Coroutines/coro-retcon-resume-values.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:    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

 ; 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/InstCombine/noalias-scope-decl.ll

+; NOTE: Assertions have been autogenerated by utils/update_test_checks.py
+; RUN: opt -instcombine -S < %s | FileCheck %s
+
+define void @test01(i8* %ptr0, i8* %ptr1) {
+; CHECK-LABEL: @test01(
+; CHECK-NEXT:    store i8 42, i8* [[PTR0:%.*]], align 1
+; CHECK-NEXT:    store i8 43, i8* [[PTR1:%.*]], align 1
+; CHECK-NEXT:    ret void
+;
+  call void @llvm.experimental.noalias.scope.decl(metadata !0)
+  store i8 42, i8* %ptr0
+  store i8 43, i8* %ptr1
+  ret void
+}
+
+define void @test02_keep(i8* %ptr0, i8* %ptr1) {
+; CHECK-LABEL: @test02_keep(
+; CHECK-NEXT:    call void @llvm.experimental.noalias.scope.decl(metadata !0)
+; CHECK-NEXT:    store i8 42, i8* [[PTR0:%.*]], align 1, !alias.scope !0
+; CHECK-NEXT:    store i8 43, i8* [[PTR1:%.*]], align 1, !noalias !3
+; CHECK-NEXT:    ret void
+;
+  call void @llvm.experimental.noalias.scope.decl(metadata !0)
+  store i8 42, i8* %ptr0, !alias.scope !0
+  store i8 43, i8* %ptr1, !noalias !5
+  ret void
+}
+
+define void @test03(i8* %ptr0, i8* %ptr1) {
+; CHECK-LABEL: @test03(
+; CHECK-NEXT:    store i8 42, i8* [[PTR0:%.*]], align 1, !alias.scope !4
+; CHECK-NEXT:    store i8 43, i8* [[PTR1:%.*]], align 1, !noalias !3
+; CHECK-NEXT:    ret void
+;
+  call void @llvm.experimental.noalias.scope.decl(metadata !0)
+  store i8 42, i8* %ptr0, !alias.scope !4
+  store i8 43, i8* %ptr1, !noalias !5
+  ret void
+}
+
+define void @test04_keep(i8* %ptr0, i8* %ptr1) {
+; CHECK-LABEL: @test04_keep(
+; CHECK-NEXT:    call void @llvm.experimental.noalias.scope.decl(metadata !0)
+; CHECK-NEXT:    store i8 42, i8* [[PTR0:%.*]], align 1, !alias.scope !3
+; CHECK-NEXT:    store i8 43, i8* [[PTR1:%.*]], align 1, !noalias !3
+; CHECK-NEXT:    ret void
+;
+  call void @llvm.experimental.noalias.scope.decl(metadata !0)
+  store i8 42, i8* %ptr0, !alias.scope !5
+  store i8 43, i8* %ptr1, !noalias !5
+  ret void
+}
+
+define void @test05_keep(i8* %ptr0, i8* %ptr1) {
+; CHECK-LABEL: @test05_keep(
+; CHECK-NEXT:    call void @llvm.experimental.noalias.scope.decl(metadata !0)
+; CHECK-NEXT:    store i8 42, i8* [[PTR0:%.*]], align 1, !alias.scope !3
+; CHECK-NEXT:    store i8 43, i8* [[PTR1:%.*]], align 1, !noalias !0
+; CHECK-NEXT:    ret void
+;
+  call void @llvm.experimental.noalias.scope.decl(metadata !0)
+  store i8 42, i8* %ptr0, !alias.scope !5
+  store i8 43, i8* %ptr1, !noalias !0
+  ret void
+}
+
+define void @test06(i8* %ptr0, i8* %ptr1) {
+; CHECK-LABEL: @test06(
+; CHECK-NEXT:    store i8 42, i8* [[PTR0:%.*]], align 1, !alias.scope !3
+; CHECK-NEXT:    store i8 43, i8* [[PTR1:%.*]], align 1, !noalias !4
+; CHECK-NEXT:    ret void
+;
+  call void @llvm.experimental.noalias.scope.decl(metadata !0)
+  store i8 42, i8* %ptr0, !alias.scope !5
+  store i8 43, i8* %ptr1, !noalias !4
+  ret void
+}
+
+define void @test07(i8* %ptr0, i8* %ptr1) {
+; CHECK-LABEL: @test07(
+; CHECK-NEXT:    store i8 42, i8* [[PTR0:%.*]], align 1, !alias.scope !0
+; CHECK-NEXT:    store i8 43, i8* [[PTR1:%.*]], align 1, !noalias !4
+; CHECK-NEXT:    ret void
+;
+  call void @llvm.experimental.noalias.scope.decl(metadata !0)
+  store i8 42, i8* %ptr0, !alias.scope !0
+  store i8 43, i8* %ptr1, !noalias !4
+  ret void
+}
+
+define void @test08(i8* %ptr0, i8* %ptr1) {
+; CHECK-LABEL: @test08(
+; CHECK-NEXT:    store i8 42, i8* [[PTR0:%.*]], align 1, !alias.scope !4
+; CHECK-NEXT:    store i8 43, i8* [[PTR1:%.*]], align 1, !noalias !0
+; CHECK-NEXT:    ret void
+;
+  call void @llvm.experimental.noalias.scope.decl(metadata !0)
+  store i8 42, i8* %ptr0, !alias.scope !4
+  store i8 43, i8* %ptr1, !noalias !0
+  ret void
+}
+
+define void @test11(i8* %ptr0) {
+; CHECK-LABEL: @test11(
+; CHECK-NEXT:    store i8 42, i8* [[PTR0:%.*]], align 1, !alias.scope !0
+; CHECK-NEXT:    ret void
+;
+  call void @llvm.experimental.noalias.scope.decl(metadata !0)
+  store i8 42, i8* %ptr0, !alias.scope !0
+  ret void
+}
+
+define void @test12(i8* %ptr0) {
+; CHECK-LABEL: @test12(
+; CHECK-NEXT:    store i8 42, i8* [[PTR0:%.*]], align 1, !alias.scope !4
+; CHECK-NEXT:    ret void
+;
+  call void @llvm.experimental.noalias.scope.decl(metadata !0)
+  store i8 42, i8* %ptr0, !alias.scope !4
+  ret void
+}
+
+define void @test13(i8* %ptr0) {
+; CHECK-LABEL: @test13(
+; CHECK-NEXT:    store i8 42, i8* [[PTR0:%.*]], align 1, !alias.scope !3
+; CHECK-NEXT:    ret void
+;
+  call void @llvm.experimental.noalias.scope.decl(metadata !0)
+  store i8 42, i8* %ptr0, !alias.scope !5
+  ret void
+}
+
+define void @test14(i8* %ptr0) {
+; CHECK-LABEL: @test14(
+; CHECK-NEXT:    store i8 42, i8* [[PTR0:%.*]], align 1, !noalias !0
+; CHECK-NEXT:    ret void
+;
+  call void @llvm.experimental.noalias.scope.decl(metadata !0)
+  store i8 42, i8* %ptr0, !noalias !0
+  ret void
+}
+
+define void @test15(i8* %ptr0) {
+; CHECK-LABEL: @test15(
+; CHECK-NEXT:    store i8 42, i8* [[PTR0:%.*]], align 1, !noalias !4
+; CHECK-NEXT:    ret void
+;
+  call void @llvm.experimental.noalias.scope.decl(metadata !0)
+  store i8 42, i8* %ptr0, !noalias !4
+  ret void
+}
+
+define void @test16(i8* %ptr0) {
+; CHECK-LABEL: @test16(
+; CHECK-NEXT:    store i8 42, i8* [[PTR0:%.*]], align 1, !noalias !3
+; CHECK-NEXT:    ret void
+;
+  call void @llvm.experimental.noalias.scope.decl(metadata !0)
+  store i8 42, i8* %ptr0, !noalias !5
+  ret void
+}
+
+declare void @llvm.experimental.noalias.scope.decl(metadata)
+
+!0 = !{ !1 }
+!1 = distinct !{ !1, !2 }
+!2 = distinct !{ !2 }
+!3 = !{ !4 }
+!4 = distinct !{ !4, !2 }
+!5 = !{ !1, !4 }

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: