[MemLoc] Support memcmp in MemoryLocation::getForArgument.

[fhahn]

Summary

This patch adds support for memcmp in MemoryLocation::getForArgument.
memcmp reads from the first 2 arguments up to the number of bytes of the
third argument.

[efriedma]

llvm/lib/Analysis/MemoryLocation.cpp

214

While you're here, can we switch this to use TLI->getLibFunc(*Call, F)

[fhahn]

Change TLI->getLibFunc(*Call->getCalledFunction(), F) to TLI->getLibFunc(*Call, F)` as suggested, thanks!

[efriedma]

LGTM

llvm/lib/Analysis/MemoryLocation.cpp

214–236

Call->getCalledFunction() is redundant.

[fhahn]

Thanks!

[xbolva00]

llvm/lib/Analysis/MemoryLocation.cpp

226

bcmp too?

LLVM transforms memcmp(...) == 0 to bcmp == 0.

[fhahn]

llvm/lib/Analysis/MemoryLocation.cpp

226

Yes, there are a lot of cases missing that we could support here. I won't have time to add all those in the near future unfortunately, any help/patches would be very welcome :)

[xbolva00]

Okey, so as a starting point, bcmo case: https://reviews.llvm.org/D87964

pi 28. 8. 2020 o 13:08 Florian Hahn via Phabricator
<[e-mail]> napísal(a):

fhahn added inline comments.

Comment at: llvm/lib/Analysis/MemoryLocation.cpp:225
+ break;
+ case LibFunc_memcmp:

+ assert((ArgIdx == 0 || ArgIdx == 1) &&

xbolva00 wrote:

bcmp too?

LLVM transforms memcmp(...) == 0 to bcmp == 0.

Yes, there are a lot of cases missing that we could support here. I won't have time to add all those in the near future unfortunately, any help/patches would be very welcome :)

Repository:

rG LLVM Github Monorepo

CHANGES SINCE LAST ACTION

https://reviews.llvm.org/D86725/new/

https://reviews.llvm.org/D86725

llvm/lib/Analysis/MemoryLocation.cpp

MemoryLocation MemoryLocation::getForArgument(const CallBase *Call,
   }
 
   // We can bound the aliasing properties of memset_pattern16 just as we can
   // for memcpy/memset.  This is particularly important because the
   // LoopIdiomRecognizer likes to turn loops into calls to memset_pattern16
   // whenever possible.
   LibFunc F;
   if (TLI && Call->getCalledFunction() &&
-      TLI->getLibFunc(*Call->getCalledFunction(), F) &&
-      F == LibFunc_memset_pattern16 && TLI->has(F)) {
+      TLI->getLibFunc(*Call->getCalledFunction(), F) && TLI->has(F)) {
+    switch (F) {
+    case LibFunc_memset_pattern16:
       assert((ArgIdx == 0 || ArgIdx == 1) &&
              "Invalid argument index for memset_pattern16");
       if (ArgIdx == 1)
         return MemoryLocation(Arg, LocationSize::precise(16), AATags);
       if (const ConstantInt *LenCI =
               dyn_cast<ConstantInt>(Call->getArgOperand(2)))
         return MemoryLocation(Arg, LocationSize::precise(LenCI->getZExtValue()),
                               AATags);
+      break;
+    case LibFunc_memcmp:
+      assert((ArgIdx == 0 || ArgIdx == 1) &&
+             "Invalid argument index for memcmp");
+      if (const ConstantInt *LenCI =
+              dyn_cast<ConstantInt>(Call->getArgOperand(2)))
+        return MemoryLocation(Arg, LocationSize::precise(LenCI->getZExtValue()),
+                              AATags);
+      break;
+    default:
+      break;
+    };
   }
   // FIXME: Handle memset_pattern4 and memset_pattern8 also.
 
   return MemoryLocation(Call->getArgOperand(ArgIdx), LocationSize::unknown(),
                         AATags);
 }

llvm/test/Analysis/BasicAA/libfuncs.ll

 ; RUN: opt -inferattrs -basic-aa -aa-eval -print-all-alias-modref-info -disable-output 2>&1 %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"
 target triple = "x86_64-apple-macosx10.7"
 
 ; CHECK-LABEL: Function: test_memcmp_const_size
 ; CHECK:      Just Ref:  Ptr: i8* %a  <->  %res = tail call i32 @memcmp(i8* %a, i8* %b, i64 4)
 ; CHECK-NEXT: Just Ref:  Ptr: i8* %b  <->  %res = tail call i32 @memcmp(i8* %a, i8* %b, i64 4)
 ; CHECK-NEXT: Just Ref:  Ptr: i8* %a.gep.1  <->  %res = tail call i32 @memcmp(i8* %a, i8* %b, i64 4)
-; CHECK-NEXT: Just Ref:  Ptr: i8* %a.gep.5  <->  %res = tail call i32 @memcmp(i8* %a, i8* %b, i64 4)
+; CHECK-NEXT: NoModRef:  Ptr: i8* %a.gep.5  <->  %res = tail call i32 @memcmp(i8* %a, i8* %b, i64 4)
 ; CHECK-NEXT: Just Ref:  Ptr: i8* %b.gep.1  <->  %res = tail call i32 @memcmp(i8* %a, i8* %b, i64 4)
-; CHECK-NEXT: Just Ref:  Ptr: i8* %b.gep.5  <->  %res = tail call i32 @memcmp(i8* %a, i8* %b, i64 4)
+; CHECK-NEXT: NoModRef:  Ptr: i8* %b.gep.5  <->  %res = tail call i32 @memcmp(i8* %a, i8* %b, i64 4)
 define i32 @test_memcmp_const_size(i8* noalias %a, i8* noalias %b) {
 entry:
   %res = tail call i32 @memcmp(i8* %a, i8* %b, i64 4)
   %a.gep.1 = getelementptr i8, i8* %a, i32 1
   store i8 0, i8* %a.gep.1
   %a.gep.5 = getelementptr i8, i8* %a, i32 5
   store i8 1, i8* %a.gep.5
   %b.gep.1 = getelementptr i8, i8* %b, i32 1

llvm/test/Transforms/DeadStoreElimination/MSSA/libcalls.ll

 define i32 @test_memcmp_const_size(i8* noalias %foo) {
 ; CHECK-LABEL: @test_memcmp_const_size(
 ; CHECK-NEXT:  entry:
 ; CHECK-NEXT:    [[STACK:%.*]] = alloca [10 x i8], align 1
 ; CHECK-NEXT:    [[STACK_PTR:%.*]] = bitcast [10 x i8]* [[STACK]] to i8*
 ; CHECK-NEXT:    store i8 49, i8* [[STACK_PTR]], align 1
 ; CHECK-NEXT:    [[GEP_1:%.*]] = getelementptr i8, i8* [[STACK_PTR]], i64 1
 ; CHECK-NEXT:    store i8 50, i8* [[GEP_1]], align 1
-; CHECK-NEXT:    [[GEP_2:%.*]] = getelementptr i8, i8* [[STACK_PTR]], i64 2
-; CHECK-NEXT:    store i8 51, i8* [[GEP_2]], align 1
-; CHECK-NEXT:    [[GEP_3:%.*]] = getelementptr i8, i8* [[STACK_PTR]], i64 3
-; CHECK-NEXT:    store i8 52, i8* [[GEP_3]], align 1
 ; CHECK-NEXT:    [[RES:%.*]] = call i32 @memcmp(i8* nonnull dereferenceable(2) [[FOO:%.*]], i8* nonnull dereferenceable(2) [[STACK_PTR]], i64 2)
 ; CHECK-NEXT:    ret i32 [[RES]]
 ;
 entry:
   %stack = alloca [10 x i8]
   %stack.ptr = bitcast [10 x i8]* %stack to i8*
   store i8 49, i8* %stack.ptr, align 1
   %gep.1 = getelementptr i8, i8* %stack.ptr, i64 1