Treat sret arguments as being dereferenceable in getPointerDereferenceableBytes()

[rnk]

lgtm

lib/IR/Value.cpp

 uint64_t Value::getPointerDereferenceableBytes(const DataLayout &DL,
                                                bool &CanBeNull) const {
   assert(getType()->isPointerTy() && "must be pointer");
 
   uint64_t DerefBytes = 0;
   CanBeNull = false;
   if (const Argument *A = dyn_cast<Argument>(this)) {
     DerefBytes = A->getDereferenceableBytes();
-    if (DerefBytes == 0 && A->hasByValAttr()) {
+    if (DerefBytes == 0 && (A->hasByValAttr() || A->hasStructRetAttr())) {
       Type *PT = cast<PointerType>(A->getType())->getElementType();
+      if (PT->isSized())
         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

 
 %struct.A = type { [8 x i8], [5 x i8] }
 @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,
+define void @test(%struct.A* sret %result,
+                  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* byval %i8_byval,
                   %struct.A* byval %A_byval)
     gc "statepoint-example" {
 ; CHECK: The following are dereferenceable:
 entry:
 ; CHECK: %globalptr{{.*}}(aligned)
; CHECK-NOT: %small_array_alloca
     %saa_load = load i32, i32* %saa_cast
 
     ; Load from array alloca
 ; CHECK: %big_array_alloca{{.*}}(unaligned)
     %big_array_alloca = alloca i8, i64 4
     %baa_cast = bitcast i8* %big_array_alloca to i32*
     %baa_load = load i32, i32* %baa_cast
 
+    ; Loads from sret arguments
+; CHECK: %sret_gep{{.*}}(aligned)
+    %sret_gep = getelementptr inbounds %struct.A, %struct.A* %result, i64 0, i32 1, i64 2
+    load i8, i8* %sret_gep
+
+; CHECK-NOT: %sret_gep_outside
+    %sret_gep_outside = getelementptr %struct.A, %struct.A* %result, i64 0, i32 1, i64 7
+    load i8, i8* %sret_gep_outside
+
 ; CHECK: %dparam{{.*}}(aligned)
     %load3 = load i32, i32 addrspace(1)* %dparam
 
 ; CHECK: %relocate{{.*}}(aligned)
     %tok = tail call token (i64, i32, i1 ()*, i32, i32, ...) @llvm.experimental.gc.statepoint.p0f_i1f(i64 0, i32 0, i1 ()* @return_i1, i32 0, i32 0, i32 0, i32 0, i32 addrspace(1)* %dparam)
     %relocate = call i32 addrspace(1)* @llvm.experimental.gc.relocate.p1i32(token %tok, i32 7, i32 7)
     %load4 = load i32, i32 addrspace(1)* %relocate