[Inliner][NoAlias] Use call site attributes too

[jdoerfert]

Summary

If we had noalias on an argument the inliner created alias scope
metadata already. However, the call site noalias annotation was not
considered. Since the Attributor can derive such call site noalias
annotation we should treat them the same as argument annotations.

[merge_guards_bot]

Unit tests: fail. 62233 tests passed, 18 failed and 816 were skipped.

failed: Clang.CodeGen/arm-v8.2a-neon-intrinsics.c
failed: Clang.CodeGen/arm-vector-arguments.c
failed: Clang.CodeGen/arm_neon_intrinsics.c
failed: Clang.CodeGen/parameter-passing.c
failed: LLVM.Transforms/Coroutines/ArgAddr.ll
failed: LLVM.Transforms/Coroutines/coro-retcon-resume-values.ll
failed: LLVM.Transforms/Coroutines/coro-retcon-value.ll
failed: LLVM.Transforms/Coroutines/coro-retcon.ll
failed: LLVM.Transforms/Coroutines/ex0.ll
failed: LLVM.Transforms/Coroutines/ex1.ll
failed: LLVM.Transforms/Coroutines/ex2.ll
failed: LLVM.Transforms/Coroutines/ex3.ll
failed: LLVM.Transforms/Coroutines/ex4.ll
failed: LLVM.Transforms/Coroutines/ex5.ll
failed: LLVM.Transforms/Inline/launder.invariant.group.ll
failed: LLVM.Transforms/Inline/noalias.ll
failed: LLVM.Transforms/Inline/noalias2.ll
failed: LLVM.Transforms/Inline/parallel-loop-md-merge.ll

clang-tidy: pass.

clang-format: pass.

Build artifacts: diff.json, clang-tidy.txt, clang-format.patch, CMakeCache.txt, console-log.txt, test-results.xml

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

[jdoerfert]

Fixed a problem caused by misinterpretation of the existing code

[merge_guards_bot]

Unit tests: pass. 62251 tests passed, 0 failed and 816 were skipped.

clang-tidy: pass.

clang-format: pass.

Build artifacts: diff.json, clang-tidy.txt, clang-format.patch, CMakeCache.txt, console-log.txt, test-results.xml

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

[hfinkel]

LGTM

llvm/lib/Transforms/Utils/InlineFunction.cpp

static void AddAliasScopeMetadata(CallSite CS, ValueToValueMapTy &VMap,
                                   const DataLayout &DL, AAResults *CalleeAAR) {
   if (!EnableNoAliasConversion)
     return;
 
   const Function *CalledFunc = CS.getCalledFunction();
   SmallVector<const Argument *, 4> NoAliasArgs;
 
   for (const Argument &Arg : CalledFunc->args())
-    if (Arg.hasNoAliasAttr() && !Arg.use_empty())
+    if (CS.paramHasAttr(Arg.getArgNo(), Attribute::NoAlias) && !Arg.use_empty())
       NoAliasArgs.push_back(&Arg);
 
   if (NoAliasArgs.empty())
     return;
 
   // To do a good job, if a noalias variable is captured, we need to know if
   // the capture point dominates the particular use we're considering.
   DominatorTree DT;
if (const Instruction *I = dyn_cast<Instruction>(VMI->first)) {
                              isa<ConstantDataVector>(V) || isa<UndefValue>(V);
         if (IsNonPtrConst)
           continue;
 
         // If this is anything other than a noalias argument, then we cannot
         // completely describe the aliasing properties using alias.scope
         // metadata (and, thus, won't add any).
         if (const Argument *A = dyn_cast<Argument>(V)) {
-          if (!A->hasNoAliasAttr())
+          if (!CS.paramHasAttr(A->getArgNo(), Attribute::NoAlias))
             UsesAliasingPtr = true;
         } else {
           UsesAliasingPtr = true;
         }
 
         // If this is not some identified function-local object (which cannot
         // directly alias a noalias argument), or some other argument (which,
         // by definition, also cannot alias a noalias argument), then we could

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

 }
 
 define void @foo(i8* nocapture %a, i8* nocapture readonly %c, i8* nocapture %b) #2 {
 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 {
+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 {
+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) #1, !noalias !0
 ; CHECK:   call void @llvm.memcpy.p0i8.p0i8.i64(i8* align 16 %b, i8* align 16 %c, i64 16, i1 false) #1, !noalias !3
 ; CHECK:   call void @llvm.memcpy.p0i8.p0i8.i64(i8* align 16 %a, i8* align 16 %c, i64 16, i1 false) #1, !alias.scope !5
 ; CHECK:   call void @hey() #1, !noalias !5
 ; CHECK:   call void @llvm.memcpy.p0i8.p0i8.i64(i8* align 16 %{{.*}}, i8* align 16 %c, i64 16, i1 false) #1, !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) #1, !noalias !6
+; CHECK:   call void @llvm.memcpy.p0i8.p0i8.i64(i8* align 16 %b, i8* align 16 %c, i64 16, i1 false) #1, !noalias !9
+; CHECK:   call void @llvm.memcpy.p0i8.p0i8.i64(i8* align 16 %a, i8* align 16 %c, i64 16, i1 false) #1, !alias.scope !11
+; CHECK:   call void @hey() #1, !noalias !11
+; CHECK:   call void @llvm.memcpy.p0i8.p0i8.i64(i8* align 16 %{{.*}}, i8* align 16 %c, i64 16, i1 false) #1, !noalias !9
+; CHECK:   ret void
+; CHECK: }
+
 attributes #0 = { nounwind argmemonly willreturn }
 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}
 
+; CHECK: !6 = !{!7}
+; CHECK: !7 = distinct !{!7, !8, !"hello_cs: %c"}
+; CHECK: !8 = distinct !{!8, !"hello_cs"}
+; CHECK: !9 = !{!10}
+; CHECK: !10 = distinct !{!10, !8, !"hello_cs: %a"}
+; CHECK: !11 = !{!10, !7}
+