[MemLoc] Adjust memccpy support in MemoryLocation::getForArgument

[xbolva00]

Summary

Use LocationSize::upperBound instead of precise since we only know an upper bound on the number of bytes read/written.

[xbolva00]

Ping

[xbolva00]

Ping

[fhahn]

llvm/lib/Analysis/MemoryLocation.cpp

261

I think it might be slightly better to mention here that we only know an upper bound on the number of bytes written and this upper bound is unsafe to use for writes.

[xbolva00]

llvm/lib/Analysis/MemoryLocation.cpp

261

Ok, I will change the comment.

There is a LocationSize::upperBound(..), maybe it should be possible to use it here?

[fhahn]

llvm/lib/Analysis/MemoryLocation.cpp

261

Yes, it would probably be best to use upperBound unconditionally here for both read and write.

[xbolva00]

Use upperBound.

[fhahn]

LGTM, thanks! It would be good to update the description before committing.

llvm/lib/Analysis/MemoryLocation.cpp

case LibFunc_memchr:
       if (const ConstantInt *LenCI =
               dyn_cast<ConstantInt>(Call->getArgOperand(2)))
         return MemoryLocation(Arg, LocationSize::precise(LenCI->getZExtValue()),
                               AATags);
       break;
     case LibFunc_memccpy:
       assert((ArgIdx == 0 || ArgIdx == 1) &&
              "Invalid argument index for memccpy");
+      // We only know an upper bound on the number of bytes read/written.
       if (const ConstantInt *LenCI =
               dyn_cast<ConstantInt>(Call->getArgOperand(3)))
-        return MemoryLocation(Arg, LocationSize::precise(LenCI->getZExtValue()),
-                              AATags);
+        return MemoryLocation(
+            Arg, LocationSize::upperBound(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

 
 declare i8* @memccpy(i8*, i8*, i32, i64)
 
 ; CHECK-LABEL: Function: test_memccpy_const_size
 ; CHECK:      Both ModRef:  Ptr: i8* %a     <->  %res = call i8* @memccpy(i8* %a, i8* %b, i32 42, i64 4)
 ; CHECK-NEXT: Just Ref:  Ptr: i8* %b        <->  %res = call i8* @memccpy(i8* %a, i8* %b, i32 42, i64 4)
 ; CHECK-NEXT: Both ModRef:  Ptr: i8* %res   <->  %res = call i8* @memccpy(i8* %a, i8* %b, i32 42, i64 4)
 ; CHECK-NEXT: Both ModRef:  Ptr: i8* %a.gep.1       <->  %res = call i8* @memccpy(i8* %a, i8* %b, i32 42, i64 4)
-; CHECK-NEXT: NoModRef:  Ptr: i8* %a.gep.5  <->  %res = call i8* @memccpy(i8* %a, i8* %b, i32 42, i64 4)
+; CHECK-NEXT: NoModRef:  Ptr: i8* %a.gep.5       <->  %res = call i8* @memccpy(i8* %a, i8* %b, i32 42, i64 4)
 ; CHECK-NEXT: Just Ref:  Ptr: i8* %b.gep.1  <->  %res = call i8* @memccpy(i8* %a, i8* %b, i32 42, i64 4)
 ; CHECK-NEXT: NoModRef:  Ptr: i8* %b.gep.5  <->  %res = call i8* @memccpy(i8* %a, i8* %b, i32 42, i64 4)
 define i8* @test_memccpy_const_size(i8* noalias %a, i8* noalias %b) {
 entry:
   %res = call i8* @memccpy(i8* %a, i8* %b, i32 42, 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
   store i8 2, i8* %b.gep.1
   %b.gep.5 = getelementptr i8, i8* %b, i32 5
   store i8 3, i8* %b.gep.5
   ret i8* %res
 }