llvm.noalias - Use noalias intrinsics when inlining (and update them when cloning metadata)

[hfinkel]

Summary

This is part of the series started by D9375, and have two related changes:

1. When inlining a function, and cloning the alias scope metadata, we need to clone the corresponding metadata within the calls to llvm.noalias too.
2. When inlining a function, instead of adding noalias metadata and alias.scope metadata (and doing the corresponding pointer-derivation and capturing analysis), add noalias metadata and use llvm.noalias intrinsics. This is more expressive (keeps the necessary dominance information), and is simpler (and faster).

[reames]

Resigning as a reviewer to get a very stale review off my list of blocking tasks in phabricator. Please reopen when desired.

[hfinkel]

Rebased.

[majnemer]

lib/Transforms/Utils/InlineFunction.cpp

887–888

Formatting looks like it got weird.

[hfinkel]

lib/Transforms/Utils/InlineFunction.cpp

887–888

Indeed; tabs :(

[hfinkel]

Remove tabs.

[majnemer]

lib/Transforms/Utils/InlineFunction.cpp

792–794

const auto *

883–885

Ditto.

908–909

I'd use the range variant, args()

941

Does it make sense to hoist this out of the loop and clear it on each iteration?

963

You could reduce indentation by doing a continue; if !isa<Instruction>.

967

auto *

[hfinkel]

lib/Transforms/Utils/InlineFunction.cpp

941

Actually, this is not needed at all. ArrayRef has a single-element constructor, and this array only ever has one element (oops).

[hfinkel]

Rebased (and addressed reviewer feedback)

[hfinkel]

Ping.

[hfinkel]

Rebased.

[jeroen.dobbelaere]

Compare following testcases (which should have an equivalent result):

void set_nnn(int* pA, int* pB, int* dummy) {
  int* lpA; lpA=pA;
  int* lpB; lpB=pB;
  int* ldummy; ldummy=dummy;
  *lpA=42;
  *lpB=43;

  *ldummy=99;
}
 
int test_rr_nnn(int* pA, int* pB, int* dummy) {
  int* __restrict lpA; lpA=pA;
  int* __restrict lpB; lpB=pB;

  set_nnn(lpA,lpB,dummy);
  return *lpA;
}

versus:

int test_rr_local(int* pA, int* pB, int* dummy) {
  int* __restrict lpA; lpA=pA;
  int* __restrict lpB; lpB=pB;
  int* ldummy; ldummy=dummy;
  { // inlined code:
    int* l2pA; l2pA=lpA;
    int* l2pB; l2pB=lpB;
    int* l2dummy; l2dummy=ldummy;
    *l2pA=42;
    *l2pB=43;

    *l2dummy=99;
  }
  return *lpA;
}

After inlining, 'test_rr_nnn' will not contain !noalias references for the three store instructions that have been inlined.

While inlining, even when the callee does not have noalias args or noalias/scope metadata, it might be needed to add the information to the load/stores

[jeroen.dobbelaere]

lib/Transforms/Utils/InlineFunction.cpp

799

This early exit blocks propagation of the call's metadata, when the callee has no annotated instructions. This has the effect of blocking local restrict for the inlined call.

lib/Transforms/Utils/InlineFunction.cpp

 using namespace llvm;
 
 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::init(true),
+  cl::desc("Use the llvm.noalias intrinsic during inlining."));
+
+static cl::opt<bool>
 PreserveAlignmentAssumptions("preserve-alignment-assumptions-during-inlining",
   cl::init(true), cl::Hidden,
   cl::desc("Convert align attributes to assumptions during inlining."));
 
 bool llvm::InlineFunction(CallInst *CI, InlineFunctionInfo &IFI,
                           AAResults *CalleeAAR, bool InsertLifetime) {
   return InlineFunction(CallSite(CI), IFI, CalleeAAR, InsertLifetime);
 }
static void CloneAliasScopeMetadata(CallSite CS, ValueToValueMapTy &VMap) {
   // 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))
         MD.insert(M);
       if (const MDNode *M = J.getMetadata(LLVMContext::MD_noalias))
         MD.insert(M);
+
+      // We also need to clone the metadata in noalias intrinsics.
+      if (const auto *II = dyn_cast<IntrinsicInst>(&J))
+        if (II->getIntrinsicID() == Intrinsic::noalias)
+          if (const auto *M = dyn_cast<MDNode>(cast<MetadataAsValue>(
+                                  II->getOperand(1))->getMetadata()))
+            MD.insert(M);
     }
 
   if (MD.empty())
     return;
 
   // Walk the existing metadata, adding the complete (perhaps cyclic) chain to
   // the set.
   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 (MDNode *M = NI->getMetadata(LLVMContext::MD_noalias)) {
       if (MDNode *CSM =
               CS.getInstruction()->getMetadata(LLVMContext::MD_noalias))
         NewMD = MDNode::concatenate(NewMD, CSM);
       NI->setMetadata(LLVMContext::MD_noalias, NewMD);
     } else if (NI->mayReadOrWriteMemory()) {
       if (MDNode *M = CS.getInstruction()->getMetadata(LLVMContext::MD_noalias))
         NI->setMetadata(LLVMContext::MD_noalias, M);
     }
+
+    // Update the metadata referenced by a noalias intrinsic
+    if (auto *II = dyn_cast<IntrinsicInst>(NI))
+      if (II->getIntrinsicID() == Intrinsic::noalias)
+        if (auto *M = dyn_cast<MDNode>(cast<MetadataAsValue>(
+                          II->getOperand(1))->getMetadata())) {
+          // If the metadata is not in the map, it could be a new intrinsic
+          // that was just added.
+          auto MI = MDMap.find(M);
+          if (MI != MDMap.end())
+            II->setOperand(1, MetadataAsValue::get(CalledFunc->getContext(),
+                                                   MI->second));
+        }
+  }
+}
+
+/// If the inlined function has noalias arguments,
+/// then add a new alias scope to instructions that might access memory, and
+/// noalias intrinsics corresponding to the noalias arguments.
+static void AddNoAliasIntrinsics(CallSite CS, ValueToValueMapTy &VMap,
+                                 MDNode *&NewScopeList) {
+  if (!EnableNoAliasConversion || !UseNoAliasIntrinsic)
+    return;
+
+  const Function *CalledFunc = CS.getCalledFunction();
+  SmallVector<const Argument *, 4> NoAliasArgs;
+
+  for (const auto &Arg : CalledFunc->args()) {
+    if (Arg.hasNoAliasAttr() && !Arg.use_empty())
+      NoAliasArgs.push_back(&Arg);
+  }
+
+  if (NoAliasArgs.empty())
+    return;
+
+  MDBuilder MDB(CalledFunc->getContext());
+  // Create a new scope domain for this function.
+  MDNode *NewDomain =
+    MDB.createAnonymousAliasScopeDomain(CalledFunc->getName());
+
+  // Create a new scope for each noalias argument.
+  SmallVector<Metadata *, 8> Scopes;
+
+  // For each noalias argument, add a noalias intrinsic call, and update the
+  // value map to refer to the new result of the noalias call.
+  for (const Argument *A : NoAliasArgs) {
+    std::string Name = CalledFunc->getName();
+    if (A->hasName()) {
+      Name += ": %";
+      Name += A->getName();
+    } else {
+      Name += ": argument ";
+      Name += utostr(A->getArgNo());
+    }
+
+    MDNode *AScope =
+      MDB.createAnonymousAliasScope(NewDomain, Name);
+    Scopes.push_back(AScope);
+
+    MDNode *AScopeList =
+      MDNode::get(CalledFunc->getContext(), AScope);
+
+    Value *NA =
+      IRBuilder<>(CS.getInstruction()).CreateNoAliasPointer(VMap[A],
+                                                            AScopeList);
+    VMap[A] = NA;
+  }
+
+  NewScopeList = MDNode::get(CalledFunc->getContext(), Scopes);
+}
+
+static void AddNoAliasIntrinsicsScope(CallSite CS, ValueToValueMapTy &VMap,
+                                      MDNode *NewScopeList) {
+  if (!EnableNoAliasConversion || !UseNoAliasIntrinsic || !NewScopeList)
+    return;
+
+  // 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 (!isa<Instruction>(VMI->first) || !VMI->second)
+      continue;
+
+    auto *NI = dyn_cast<Instruction>(VMI->second);
+    if (!NI || !NI->mayReadOrWriteMemory())
+      continue;
+
+    NI->setMetadata(
+        LLVMContext::MD_noalias,
+        MDNode::concatenate(NI->getMetadata(LLVMContext::MD_noalias),
+                            NewScopeList));
   }
 }
 
 /// 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(CallSite CS, ValueToValueMapTy &VMap,
                                   const DataLayout &DL, AAResults *CalleeAAR) {
-  if (!EnableNoAliasConversion)
+  if (!EnableNoAliasConversion || UseNoAliasIntrinsic)
     return;
 
   const Function *CalledFunc = CS.getCalledFunction();
   SmallVector<const Argument *, 4> NoAliasArgs;
 
   for (const Argument &Arg : CalledFunc->args())
     if (Arg.hasNoAliasAttr() && !Arg.use_empty())
       NoAliasArgs.push_back(&Arg);
bool llvm::InlineFunction(CallSite CS, InlineFunctionInfo &IFI,
   SmallVector<ReturnInst*, 8> Returns;
   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;
+    MDNode *NAScopeList = nullptr;
 
     auto &DL = Caller->getParent()->getDataLayout();
 
     assert(CalledFunc->arg_size() == CS.arg_size() &&
            "No varargs calls can be inlined!");
 
     // Calculate the vector of arguments to pass into the function cloner, which
     // matches up the formal to the actual argument values.
for (Function::arg_iterator I = CalledFunc->arg_begin(),
       VMap[&*I] = ActualArg;
     }
 
     // Add alignment assumptions if necessary. We do this before the inlined
     // instructions are actually cloned into the caller so that we can easily
     // check what will be known at the start of the inlined code.
     AddAlignmentAssumptions(CS, IFI);
 
+    // Add noalias intrinsics corresponding to noalias function arguments.
+    AddNoAliasIntrinsics(CS, VMap, NAScopeList);
+
     // We want the inliner to prune the code as it copies.  We would LOVE to
     // have no dead or constant instructions leftover after inlining occurs
     // (which can happen, e.g., because an argument was constant), but we'll be
     // happy with whatever the cloner can do.
     CloneAndPruneFunctionInto(Caller, CalledFunc, VMap,
                               /*ModuleLevelChanges=*/false, Returns, ".i",
                               &InlinedFunctionInfo, TheCall);
     // Remember the first block that is newly cloned over.
Function::iterator FirstNewBlock;
     if (IFI.GetAssumptionCache)
       for (BasicBlock &NewBlock :
            make_range(FirstNewBlock->getIterator(), Caller->end()))
         for (Instruction &I : NewBlock) {
           if (auto *II = dyn_cast<IntrinsicInst>(&I))
             if (II->getIntrinsicID() == Intrinsic::assume)
               (*IFI.GetAssumptionCache)(*Caller).registerAssumption(II);
         }
+
+    // Add scopes to memory accesses corresponding to added noalias intrinsics.
+    AddNoAliasIntrinsicsScope(CS, VMap, NAScopeList);
   }
 
   // If there are any alloca instructions in the block that used to be the entry
   // block for the callee, move them to the entry block of the caller.  First
   // calculate which instruction they should be inserted before.  We insert the
   // instructions at the end of the current alloca list.
   {
     BasicBlock::iterator InsertPoint = Caller->begin()->begin();

test/Transforms/Inline/noalias-calls.ll

-; RUN: opt -basicaa -inline -enable-noalias-to-md-conversion -S < %s | FileCheck %s
+; RUN: opt -basicaa -inline -enable-noalias-to-md-conversion -use-noalias-intrinsic-during-inlining=0 -S < %s | FileCheck %s -check-prefix=MD-SCOPE
+; RUN: opt -inline -enable-noalias-to-md-conversion -S < %s | FileCheck %s -check-prefix=INTR-SCOPE
 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, i32, i1) #0
-declare void @hey() #0
+declare void @hey() #1
 
 define void @hello(i8* noalias nocapture %a, i8* noalias nocapture readonly %c, i8* nocapture %b) #1 {
 entry:
   %l = alloca i8, i32 512, align 1
   call void @llvm.memcpy.p0i8.p0i8.i64(i8* %a, i8* %b, i64 16, i32 16, i1 0)
   call void @llvm.memcpy.p0i8.p0i8.i64(i8* %b, i8* %c, i64 16, i32 16, i1 0)
   call void @llvm.memcpy.p0i8.p0i8.i64(i8* %a, i8* %c, i64 16, i32 16, i1 0)
   call void @hey()
   call void @llvm.memcpy.p0i8.p0i8.i64(i8* %l, i8* %c, i64 16, i32 16, i1 0)
   ret void
 }
 
-define void @foo(i8* nocapture %a, i8* nocapture readonly %c, i8* nocapture %b) #2 {
+define void @foo(i8* nocapture %a, i8* nocapture readonly %c, i8* nocapture %b) #1 {
 entry:
   tail call void @hello(i8* %a, i8* %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* %a, i8* %b, i64 16, i32 16, i1 false) #1, !noalias !0
-; CHECK:   call void @llvm.memcpy.p0i8.p0i8.i64(i8* %b, i8* %c, i64 16, i32 16, i1 false) #1, !noalias !3
-; CHECK:   call void @llvm.memcpy.p0i8.p0i8.i64(i8* %a, i8* %c, i64 16, i32 16, i1 false) #1, !alias.scope !5
-; CHECK:   call void @hey() #1, !noalias !5
-; CHECK:   call void @llvm.memcpy.p0i8.p0i8.i64(i8* %{{.*}}, i8* %c, i64 16, i32 16, i1 false) #1, !noalias !3
-; CHECK:   ret void
-; CHECK: }
+; MD-SCOPE: define void @foo(i8* nocapture %a, i8* nocapture readonly %c, i8* nocapture %b) #1 {
+; MD-SCOPE: entry:
+; MD-SCOPE:   call void @llvm.memcpy.p0i8.p0i8.i64(i8* %a, i8* %b, i64 16, i32 16, i1 false) #1, !noalias !0
+; MD-SCOPE:   call void @llvm.memcpy.p0i8.p0i8.i64(i8* %b, i8* %c, i64 16, i32 16, i1 false) #1, !noalias !3
+; MD-SCOPE:   call void @llvm.memcpy.p0i8.p0i8.i64(i8* %a, i8* %c, i64 16, i32 16, i1 false) #1, !alias.scope !5
+; MD-SCOPE:   call void @hey() #1, !noalias !5
+; MD-SCOPE:   call void @llvm.memcpy.p0i8.p0i8.i64(i8* %{{.*}}, i8* %c, i64 16, i32 16, i1 false) #1, !noalias !3
+; MD-SCOPE:   ret void
+; MD-SCOPE: }
+
+; INTR-SCOPE: define void @foo(i8* nocapture %a, i8* nocapture readonly %c, i8* nocapture %b) #1 {
+; INTR-SCOPE: entry:
+; INTR-SCOPE:   %l.i = alloca i8, i32 512, align 1
+; INTR-SCOPE:   %0 = call i8* @llvm.noalias.p0i8(i8* %a, metadata !0)
+; INTR-SCOPE:   %1 = call i8* @llvm.noalias.p0i8(i8* %c, metadata !3)
+; INTR-SCOPE:   call void @llvm.memcpy.p0i8.p0i8.i64(i8* %0, i8* %b, i64 16, i32 16, i1 false) #1, !noalias !5
+; INTR-SCOPE:   call void @llvm.memcpy.p0i8.p0i8.i64(i8* %b, i8* %1, i64 16, i32 16, i1 false) #1, !noalias !5
+; INTR-SCOPE:   call void @llvm.memcpy.p0i8.p0i8.i64(i8* %0, i8* %1, i64 16, i32 16, i1 false) #1, !noalias !5
+; INTR-SCOPE:   call void @hey() #1, !noalias !5
+; INTR-SCOPE:   call void @llvm.memcpy.p0i8.p0i8.i64(i8* %l.i, i8* %1, i64 16, i32 16, i1 false) #1, !noalias !5
+; INTR-SCOPE:   ret void
+; INTR-SCOPE: }
 
 attributes #0 = { nounwind argmemonly }
 attributes #1 = { nounwind }
-attributes #2 = { nounwind uwtable }
 
-; CHECK: !0 = !{!1}
-; CHECK: !1 = distinct !{!1, !2, !"hello: %c"}
-; CHECK: !2 = distinct !{!2, !"hello"}
-; CHECK: !3 = !{!4}
-; CHECK: !4 = distinct !{!4, !2, !"hello: %a"}
-; CHECK: !5 = !{!4, !1}
+; MD-SCOPE: !0 = !{!1}
+; MD-SCOPE: !1 = distinct !{!1, !2, !"hello: %c"}
+; MD-SCOPE: !2 = distinct !{!2, !"hello"}
+; MD-SCOPE: !3 = !{!4}
+; MD-SCOPE: !4 = distinct !{!4, !2, !"hello: %a"}
+; MD-SCOPE: !5 = !{!4, !1}
+ 
+; INTR-SCOPE: !0 = !{!1}
+; INTR-SCOPE: !1 = distinct !{!1, !2, !"hello: %a"}
+; INTR-SCOPE: !2 = distinct !{!2, !"hello"}
+; INTR-SCOPE: !3 = !{!4}
+; INTR-SCOPE: !4 = distinct !{!4, !2, !"hello: %c"}
+; INTR-SCOPE: !5 = !{!1, !4}
 

test/Transforms/Inline/noalias.ll

-; RUN: opt -inline -enable-noalias-to-md-conversion -S < %s | FileCheck %s
+; RUN: opt -inline -enable-noalias-to-md-conversion -use-noalias-intrinsic-during-inlining=0 -S < %s | FileCheck %s -check-prefix=MD-SCOPE
+; RUN: opt -inline -enable-noalias-to-md-conversion -S < %s | FileCheck %s -check-prefix=INTR-SCOPE
 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"
 
 define void @hello(float* noalias nocapture %a, 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
   ret void
 }
 
 define void @foo(float* nocapture %a, float* nocapture readonly %c) #0 {
 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: entry:
-; CHECK:   %0 = 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:   %arrayidx = getelementptr inbounds float, float* %a, i64 7
-; CHECK:   store float %1, float* %arrayidx, align 4
-; CHECK:   ret void
-; CHECK: }
+; MD-SCOPE: define void @foo(float* nocapture %a, float* nocapture readonly %c) #0 {
+; MD-SCOPE: entry:
+; MD-SCOPE:   %0 = load float, float* %c, align 4, !noalias !0
+; MD-SCOPE:   %arrayidx.i = getelementptr inbounds float, float* %a, i64 5
+; MD-SCOPE:   store float %0, float* %arrayidx.i, align 4, !alias.scope !0
+; MD-SCOPE:   %1 = load float, float* %c, align 4
+; MD-SCOPE:   %arrayidx = getelementptr inbounds float, float* %a, i64 7
+; MD-SCOPE:   store float %1, float* %arrayidx, align 4
+; MD-SCOPE:   ret void
+; MD-SCOPE: }
+
+; INTR-SCOPE: define void @foo(float* nocapture %a, float* nocapture readonly %c) #0 {
+; INTR-SCOPE: entry:
+; INTR-SCOPE:   %0 = call float* @llvm.noalias.p0f32(float* %a, metadata !0)
+; INTR-SCOPE:   %1 = load float, float* %c, align 4, !noalias !0
+; INTR-SCOPE:   %arrayidx.i = getelementptr inbounds float, float* %0, i64 5
+; INTR-SCOPE:   store float %1, float* %arrayidx.i, align 4, !noalias !0
+; INTR-SCOPE:   %2 = load float, float* %c, align 4
+; INTR-SCOPE:   %arrayidx = getelementptr inbounds float, float* %a, i64 7
+; INTR-SCOPE:   store float %2, float* %arrayidx, align 4
+; INTR-SCOPE:   ret void
+; INTR-SCOPE: }
 
 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: entry:
-; CHECK:   %0 = load float, float* %c, align 4, !noalias !3
-; 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:   %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:   %arrayidx = getelementptr inbounds float, float* %a, i64 7
-; CHECK:   store float %1, float* %arrayidx, align 4
-; CHECK:   ret void
-; CHECK: }
+; MD-SCOPE: define void @foo2(float* nocapture %a, float* nocapture %b, float* nocapture readonly %c) #0 {
+; MD-SCOPE: entry:
+; MD-SCOPE:   %0 = load float, float* %c, align 4, !noalias !3
+; MD-SCOPE:   %arrayidx.i = getelementptr inbounds float, float* %a, i64 5
+; MD-SCOPE:   store float %0, float* %arrayidx.i, align 4, !alias.scope !7, !noalias !8
+; MD-SCOPE:   %arrayidx1.i = getelementptr inbounds float, float* %b, i64 8
+; MD-SCOPE:   store float %0, float* %arrayidx1.i, align 4, !alias.scope !8, !noalias !7
+; MD-SCOPE:   %1 = load float, float* %c, align 4
+; MD-SCOPE:   %arrayidx = getelementptr inbounds float, float* %a, i64 7
+; MD-SCOPE:   store float %1, float* %arrayidx, align 4
+; MD-SCOPE:   ret void
+; MD-SCOPE: }
+
+; INTR-SCOPE: define void @foo2(float* nocapture %a, float* nocapture %b, float* nocapture readonly %c) #0 {
+; INTR-SCOPE: entry:
+; INTR-SCOPE:   %0 = call float* @llvm.noalias.p0f32(float* %a, metadata !3)
+; INTR-SCOPE:   %1 = call float* @llvm.noalias.p0f32(float* %b, metadata !6)
+; INTR-SCOPE:   %2 = load float, float* %c, align 4, !noalias !8
+; INTR-SCOPE:   %arrayidx.i = getelementptr inbounds float, float* %0, i64 5
+; INTR-SCOPE:   store float %2, float* %arrayidx.i, align 4, !noalias !8
+; INTR-SCOPE:   %arrayidx1.i = getelementptr inbounds float, float* %1, i64 8
+; INTR-SCOPE:   store float %2, float* %arrayidx1.i, align 4, !noalias !8
+; INTR-SCOPE:   %3 = load float, float* %c, align 4
+; INTR-SCOPE:   %arrayidx = getelementptr inbounds float, float* %a, i64 7
+; INTR-SCOPE:   store float %3, float* %arrayidx, align 4
+; INTR-SCOPE:   ret void
+; INTR-SCOPE: }
 
 attributes #0 = { nounwind uwtable }
+attributes #1 = { argmemonly nounwind }
 
-; CHECK: !0 = !{!1}
-; CHECK: !1 = distinct !{!1, !2, !"hello: %a"}
-; CHECK: !2 = distinct !{!2, !"hello"}
-; CHECK: !3 = !{!4, !6}
-; 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}
+; MD-SCOPE: !0 = !{!1}
+; MD-SCOPE: !1 = distinct !{!1, !2, !"hello: %a"}
+; MD-SCOPE: !2 = distinct !{!2, !"hello"}
+; MD-SCOPE: !3 = !{!4, !6}
+; MD-SCOPE: !4 = distinct !{!4, !5, !"hello2: %a"}
+; MD-SCOPE: !5 = distinct !{!5, !"hello2"}
+; MD-SCOPE: !6 = distinct !{!6, !5, !"hello2: %b"}
+; MD-SCOPE: !7 = !{!4}
+; MD-SCOPE: !8 = !{!6}
+
+; INTR-SCOPE: !0 = !{!1}
+; INTR-SCOPE: !1 = distinct !{!1, !2, !"hello: %a"}
+; INTR-SCOPE: !2 = distinct !{!2, !"hello"}
+; INTR-SCOPE: !3 = !{!4}
+; INTR-SCOPE: !4 = distinct !{!4, !5, !"hello2: %a"}
+; INTR-SCOPE: !5 = distinct !{!5, !"hello2"}
+; INTR-SCOPE: !6 = !{!7}
+; INTR-SCOPE: !7 = distinct !{!7, !5, !"hello2: %b"}
+; INTR-SCOPE: !8 = !{!4, !7}
 

test/Transforms/Inline/noalias2.ll

-; RUN: opt -inline -enable-noalias-to-md-conversion -S < %s | FileCheck %s
+; RUN: opt -inline -enable-noalias-to-md-conversion -use-noalias-intrinsic-during-inlining=0 -S < %s | FileCheck %s -check-prefix=MD-SCOPE
+; RUN: opt -inline -enable-noalias-to-md-conversion -S < %s | FileCheck %s -check-prefix=INTR-SCOPE
+
 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"
 
 define void @hello(float* noalias nocapture %a, float* noalias 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
   ret void
 }
 
 define void @foo(float* noalias nocapture %a, float* noalias nocapture readonly %c) #0 {
 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* noalias nocapture %a, float* noalias nocapture readonly %c) #0 {
-; CHECK: entry:
-; CHECK:   %0 = load float, float* %c, align 4, !alias.scope !0, !noalias !3
-; CHECK:   %arrayidx.i = getelementptr inbounds float, float* %a, i64 5
-; CHECK:   store float %0, float* %arrayidx.i, align 4, !alias.scope !3, !noalias !0
-; CHECK:   %1 = load float, float* %c, align 4
-; CHECK:   %arrayidx = getelementptr inbounds float, float* %a, i64 7
-; CHECK:   store float %1, float* %arrayidx, align 4
-; CHECK:   ret void
-; CHECK: }
+; MD-SCOPE: define void @foo(float* noalias nocapture %a, float* noalias nocapture readonly %c) #0 {
+; MD-SCOPE: entry:
+; MD-SCOPE:   %0 = load float, float* %c, align 4, !alias.scope !0, !noalias !3
+; MD-SCOPE:   %arrayidx.i = getelementptr inbounds float, float* %a, i64 5
+; MD-SCOPE:   store float %0, float* %arrayidx.i, align 4, !alias.scope !3, !noalias !0
+; MD-SCOPE:   %1 = load float, float* %c, align 4
+; MD-SCOPE:   %arrayidx = getelementptr inbounds float, float* %a, i64 7
+; MD-SCOPE:   store float %1, float* %arrayidx, align 4
+; MD-SCOPE:   ret void
+; MD-SCOPE: }
+
+; INTR-SCOPE: define void @foo(float* noalias nocapture %a, float* noalias nocapture readonly %c) #0 {
+; INTR-SCOPE: entry:
+; INTR-SCOPE:   %0 = call float* @llvm.noalias.p0f32(float* %a, metadata !0)
+; INTR-SCOPE:   %1 = call float* @llvm.noalias.p0f32(float* %c, metadata !3)
+; INTR-SCOPE:   %2 = load float, float* %1, align 4, !noalias !5
+; INTR-SCOPE:   %arrayidx.i = getelementptr inbounds float, float* %0, i64 5
+; INTR-SCOPE:   store float %2, float* %arrayidx.i, align 4, !noalias !5
+; INTR-SCOPE:   %3 = load float, float* %c, align 4
+; INTR-SCOPE:   %arrayidx = getelementptr inbounds float, float* %a, i64 7
+; INTR-SCOPE:   store float %3, float* %arrayidx, align 4
+; INTR-SCOPE:   ret void
+; INTR-SCOPE: }
 
 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 6
   store float %0, float* %arrayidx, align 4
   %arrayidx1 = getelementptr inbounds float, float* %b, i64 8
   store float %0, float* %arrayidx1, align 4
   ret void
 }
 
 ; 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 {
 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: define void @foo2(float* nocapture %a, float* nocapture %b, float* nocapture readonly %c) #0 {
-; CHECK: entry:
-; CHECK:   %0 = load float, float* %c, align 4, !alias.scope !5, !noalias !10
-; CHECK:   %arrayidx.i.i = getelementptr inbounds float, float* %a, i64 5
-; CHECK:   store float %0, float* %arrayidx.i.i, align 4, !alias.scope !10, !noalias !5
-; CHECK:   %1 = load float, float* %c, align 4, !alias.scope !13, !noalias !14
-; CHECK:   %arrayidx.i = getelementptr inbounds float, float* %a, i64 7
-; CHECK:   store float %1, float* %arrayidx.i, align 4, !alias.scope !14, !noalias !13
-; CHECK:   %2 = load float, float* %c, align 4, !noalias !15
-; CHECK:   %arrayidx.i1 = getelementptr inbounds float, float* %a, i64 6
-; CHECK:   store float %2, float* %arrayidx.i1, align 4, !alias.scope !19, !noalias !20
-; CHECK:   %arrayidx1.i = getelementptr inbounds float, float* %b, i64 8
-; CHECK:   store float %2, float* %arrayidx1.i, align 4, !alias.scope !20, !noalias !19
-; CHECK:   %3 = load float, float* %c, align 4
-; CHECK:   %arrayidx = getelementptr inbounds float, float* %a, i64 7
-; CHECK:   store float %3, float* %arrayidx, align 4
-; CHECK:   ret void
-; CHECK: }
-
-; CHECK: !0 = !{!1}
-; CHECK: !1 = distinct !{!1, !2, !"hello: %c"}
-; 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}
+; MD-SCOPE: define void @foo2(float* nocapture %a, float* nocapture %b, float* nocapture readonly %c) #0 {
+; MD-SCOPE: entry:
+; MD-SCOPE:   %0 = load float, float* %c, align 4, !alias.scope !5, !noalias !10
+; MD-SCOPE:   %arrayidx.i.i = getelementptr inbounds float, float* %a, i64 5
+; MD-SCOPE:   store float %0, float* %arrayidx.i.i, align 4, !alias.scope !10, !noalias !5
+; MD-SCOPE:   %1 = load float, float* %c, align 4, !alias.scope !13, !noalias !14
+; MD-SCOPE:   %arrayidx.i = getelementptr inbounds float, float* %a, i64 7
+; MD-SCOPE:   store float %1, float* %arrayidx.i, align 4, !alias.scope !14, !noalias !13
+; MD-SCOPE:   %2 = load float, float* %c, align 4, !noalias !15
+; MD-SCOPE:   %arrayidx.i1 = getelementptr inbounds float, float* %a, i64 6
+; MD-SCOPE:   store float %2, float* %arrayidx.i1, align 4, !alias.scope !19, !noalias !20
+; MD-SCOPE:   %arrayidx1.i = getelementptr inbounds float, float* %b, i64 8
+; MD-SCOPE:   store float %2, float* %arrayidx1.i, align 4, !alias.scope !20, !noalias !19
+; MD-SCOPE:   %3 = load float, float* %c, align 4
+; MD-SCOPE:   %arrayidx = getelementptr inbounds float, float* %a, i64 7
+; MD-SCOPE:   store float %3, float* %arrayidx, align 4
+; MD-SCOPE:   ret void
+; MD-SCOPE: }
+
+; INTR-SCOPE: define void @foo2(float* nocapture %a, float* nocapture %b, float* nocapture readonly %c) #0 {
+; INTR-SCOPE: entry:
+; INTR-SCOPE:   %0 = call float* @llvm.noalias.p0f32(float* %a, metadata !6)
+; INTR-SCOPE:   %1 = call float* @llvm.noalias.p0f32(float* %c, metadata !9)
+; INTR-SCOPE:   %2 = call float* @llvm.noalias.p0f32(float* %0, metadata !11) #2, !noalias !14
+; INTR-SCOPE:   %3 = call float* @llvm.noalias.p0f32(float* %1, metadata !15) #2, !noalias !14
+; INTR-SCOPE:   %4 = load float, float* %3, align 4, !noalias !17
+; INTR-SCOPE:   %arrayidx.i.i = getelementptr inbounds float, float* %2, i64 5
+; INTR-SCOPE:   store float %4, float* %arrayidx.i.i, align 4, !noalias !17
+; INTR-SCOPE:   %5 = load float, float* %1, align 4, !noalias !14
+; INTR-SCOPE:   %arrayidx.i = getelementptr inbounds float, float* %0, i64 7
+; INTR-SCOPE:   store float %5, float* %arrayidx.i, align 4, !noalias !14
+; INTR-SCOPE:   %6 = call float* @llvm.noalias.p0f32(float* %a, metadata !18)
+; INTR-SCOPE:   %7 = call float* @llvm.noalias.p0f32(float* %b, metadata !21)
+; INTR-SCOPE:   %8 = load float, float* %c, align 4, !noalias !23
+; INTR-SCOPE:   %arrayidx.i1 = getelementptr inbounds float, float* %6, i64 6
+; INTR-SCOPE:   store float %8, float* %arrayidx.i1, align 4, !noalias !23
+; INTR-SCOPE:   %arrayidx1.i = getelementptr inbounds float, float* %7, i64 8
+; INTR-SCOPE:   store float %8, float* %arrayidx1.i, align 4, !noalias !23
+; INTR-SCOPE:   %9 = load float, float* %c, align 4
+; INTR-SCOPE:   %arrayidx = getelementptr inbounds float, float* %a, i64 7
+; INTR-SCOPE:   store float %9, float* %arrayidx, align 4
+; INTR-SCOPE:   ret void
+; INTR-SCOPE: }
+
+; MD-SCOPE: !0 = !{!1}
+; MD-SCOPE: !1 = distinct !{!1, !2, !"hello: %c"}
+; MD-SCOPE: !2 = distinct !{!2, !"hello"}
+; MD-SCOPE: !3 = !{!4}
+; MD-SCOPE: !4 = distinct !{!4, !2, !"hello: %a"}
+; MD-SCOPE: !5 = !{!6, !8}
+; MD-SCOPE: !6 = distinct !{!6, !7, !"hello: %c"}
+; MD-SCOPE: !7 = distinct !{!7, !"hello"}
+; MD-SCOPE: !8 = distinct !{!8, !9, !"foo: %c"}
+; MD-SCOPE: !9 = distinct !{!9, !"foo"}
+; MD-SCOPE: !10 = !{!11, !12}
+; MD-SCOPE: !11 = distinct !{!11, !7, !"hello: %a"}
+; MD-SCOPE: !12 = distinct !{!12, !9, !"foo: %a"}
+; MD-SCOPE: !13 = !{!8}
+; MD-SCOPE: !14 = !{!12}
+; MD-SCOPE: !15 = !{!16, !18}
+; MD-SCOPE: !16 = distinct !{!16, !17, !"hello2: %a"}
+; MD-SCOPE: !17 = distinct !{!17, !"hello2"}
+; MD-SCOPE: !18 = distinct !{!18, !17, !"hello2: %b"}
+; MD-SCOPE: !19 = !{!16}
+; MD-SCOPE: !20 = !{!18}
+
+; INTR-SCOPE: !0 = !{!1}
+; INTR-SCOPE: !1 = distinct !{!1, !2, !"hello: %a"}
+; INTR-SCOPE: !2 = distinct !{!2, !"hello"}
+; INTR-SCOPE: !3 = !{!4}
+; INTR-SCOPE: !4 = distinct !{!4, !2, !"hello: %c"}
+; INTR-SCOPE: !5 = !{!1, !4}
+; INTR-SCOPE: !6 = !{!7}
+; INTR-SCOPE: !7 = distinct !{!7, !8, !"foo: %a"}
+; INTR-SCOPE: !8 = distinct !{!8, !"foo"}
+; INTR-SCOPE: !9 = !{!10}
+; INTR-SCOPE: !10 = distinct !{!10, !8, !"foo: %c"}
+; INTR-SCOPE: !11 = !{!12}
+; INTR-SCOPE: !12 = distinct !{!12, !13, !"hello: %a"}
+; INTR-SCOPE: !13 = distinct !{!13, !"hello"}
+; INTR-SCOPE: !14 = !{!7, !10}
+; INTR-SCOPE: !15 = !{!16}
+; INTR-SCOPE: !16 = distinct !{!16, !13, !"hello: %c"}
+; INTR-SCOPE: !17 = !{!12, !16, !7, !10}
+; INTR-SCOPE: !18 = !{!19}
+; INTR-SCOPE: !19 = distinct !{!19, !20, !"hello2: %a"}
+; INTR-SCOPE: !20 = distinct !{!20, !"hello2"}
+; INTR-SCOPE: !21 = !{!22}
+; INTR-SCOPE: !22 = distinct !{!22, !20, !"hello2: %b"}
+; INTR-SCOPE: !23 = !{!19, !22}
 
 attributes #0 = { nounwind uwtable }