Properly handle byval arguments in getPointerDereferenceableBytes()

[dotdash]

Summary

For byval arguments, the number of dereferenceable bytes is equal to
the size of the pointee, not the pointer.

[efriedma]

lib/IR/Value.cpp

632

The verifier checks isSized(); you don't need to check it here.

[dotdash]

Removed the unnecessary isSized() check

[efriedma]

LGTM

lib/IR/Value.cpp

 unsigned Value::getPointerDereferenceableBytes(const DataLayout &DL,
                                                bool &CanBeNull) const {
   assert(getType()->isPointerTy() && "must be pointer");
 
   unsigned DerefBytes = 0;
   CanBeNull = false;
   if (const Argument *A = dyn_cast<Argument>(this)) {
     DerefBytes = A->getDereferenceableBytes();
-    if (DerefBytes == 0 && A->hasByValAttr() && A->getType()->isSized()) {
-      DerefBytes = DL.getTypeStoreSize(A->getType());
-      CanBeNull = false;
+    if (DerefBytes == 0 && A->hasByValAttr()) {
+      Type *PT = cast<PointerType>(A->getType())->getElementType();
+      DerefBytes = DL.getTypeStoreSize(PT);
     }
     if (DerefBytes == 0) {
       DerefBytes = A->getDereferenceableOrNullBytes();
       CanBeNull = true;
     }
   } else if (auto CS = ImmutableCallSite(this)) {
     DerefBytes = CS.getDereferenceableBytes(AttributeList::ReturnIndex);
     if (DerefBytes == 0) {

test/Analysis/ValueTracking/memory-dereferenceable.ll

 @globalstruct = external global %struct.A
 
 @globalptr.align1 = external global i8, align 1
 @globalptr.align16 = external global i8, align 16
 
 ; CHECK-LABEL: 'test'
 define void @test(i32 addrspace(1)* dereferenceable(8) %dparam,
                   i8 addrspace(1)* dereferenceable(32) align 1 %dparam.align1,
-                  i8 addrspace(1)* dereferenceable(32) align 16 %dparam.align16)
+                  i8 addrspace(1)* dereferenceable(32) align 16 %dparam.align16,
+                  i8* byval %i8_byval,
+                  %struct.A* byval %A_byval)
     gc "statepoint-example" {
 ; CHECK: The following are dereferenceable:
 entry:
 ; CHECK: %globalptr{{.*}}(aligned)
     %globalptr = getelementptr inbounds [6 x i8], [6 x i8]* @globalstr, i32 0, i32 0
     %load1 = load i8, i8* %globalptr
 
 ; CHECK: %alloca{{.*}}(aligned)
; CHECK: @globalptr.align16{{.*}}(aligned)
     %load14 = load i8, i8* @globalptr.align16, align 16
 
     ; Loads from aligned arguments
 ; CHECK: %dparam.align1{{.*}}(unaligned)
 ; CHECK: %dparam.align16{{.*}}(aligned)
     %load15 = load i8, i8 addrspace(1)* %dparam.align1, align 16
     %load16 = load i8, i8 addrspace(1)* %dparam.align16, align 16
 
+    ; Loads from byval arguments
+; CHECK: %i8_byval{{.*}}(aligned)
+    %i8_byval_load = load i8, i8* %i8_byval
+
+; CHECK-NOT: %byval_cast
+    %byval_cast = bitcast i8* %i8_byval to i32*
+    %bad_byval_load = load i32, i32* %byval_cast
+
+; CHECK: %byval_gep{{.*}}(aligned)
+    %byval_gep = getelementptr inbounds %struct.A, %struct.A* %A_byval, i64 0, i32 1, i64 2
+    load i8, i8* %byval_gep
+
     ; Loads from aligned allocas
 ; CHECK: %alloca.align1{{.*}}(unaligned)
 ; CHECK: %alloca.align16{{.*}}(aligned)
     %alloca.align1 = alloca i1, align 1
     %alloca.align16 = alloca i1, align 16
     %load17 = load i1, i1* %alloca.align1, align 16
     %load18 = load i1, i1* %alloca.align16, align 16