Don't look through addrspace cast which changes pointer size

[apilipenko]

Summary

Make the behavior of Value::stripAndAccumulateInBoundsConstantOffsets and ValueTracking::isDereferenceableAndAlignedPointer in sync with D24729

[• tstellarAMD]

I think this may solve the same problem: https://reviews.llvm.org/D24774

[reames]

Is this review still relevant? If not, can you close. If so, can you summarize how this interacts with the other patches in this area recently?

lib/Analysis/Loads.cpp

return isDereferenceableAndAlignedPointer(Base, Align, Offset + Size, DL,
                                               CtxI, DT, Visited);
   }
 
   // For gc.relocate, look through relocations
   if (const GCRelocateInst *RelocateInst = dyn_cast<GCRelocateInst>(V))
     return isDereferenceableAndAlignedPointer(
         RelocateInst->getDerivedPtr(), Align, Size, DL, CtxI, DT, Visited);
 
-  if (const AddrSpaceCastInst *ASC = dyn_cast<AddrSpaceCastInst>(V))
-    return isDereferenceableAndAlignedPointer(ASC->getOperand(0), Align, Size,
-                                              DL, CtxI, DT, Visited);
+  if (const AddrSpaceCastInst *ASC = dyn_cast<AddrSpaceCastInst>(V)) {
+    const Value *Ptr = ASC->getPointerOperand();
+    if (Size.getBitWidth() == DL.getPointerTypeSizeInBits(Ptr->getType()))
+      return isDereferenceableAndAlignedPointer(ASC->getOperand(0), Align,
+                                                Size, DL, CtxI, DT, Visited);
+  }
 
   if (auto CS = ImmutableCallSite(V))
     if (const Value *RV = CS.getReturnedArgOperand())
       return isDereferenceableAndAlignedPointer(RV, Align, Size, DL, CtxI, DT,
                                                 Visited);
 
   // If we don't know, assume the worst.
   return false;

lib/IR/Value.cpp

if (GEPOperator *GEP = dyn_cast<GEPOperator>(V)) {
         return V;
       APInt GEPOffset(Offset);
       if (!GEP->accumulateConstantOffset(DL, GEPOffset))
         return V;
       Offset = GEPOffset;
       V = GEP->getPointerOperand();
     } else if (Operator::getOpcode(V) == Instruction::BitCast) {
       V = cast<Operator>(V)->getOperand(0);
+    } else if (AddrSpaceCastInst *ASCI = dyn_cast<AddrSpaceCastInst>(V)) {
+      Value *SourcePtr = ASCI->getPointerOperand();
+      // Don't look through addrspace cast which changes pointer size
+      if (Offset.getBitWidth() !=
+            DL.getPointerTypeSizeInBits(SourcePtr->getType()))
+        return V;
+      V = SourcePtr;
     } else if (GlobalAlias *GA = dyn_cast<GlobalAlias>(V)) {
       V = GA->getAliasee();
     } else {
       if (auto CS = CallSite(V))
         if (Value *RV = CS.getReturnedArgOperand()) {
           V = RV;
           continue;
         }

test/Analysis/ValueTracking/dereferenceable-addrspace-cast.ll

+; RUN: opt -default-data-layout="e-m:e-p:16:16-p1:32:16-i32:16-i64:16-n8:16" -print-memderefs -analyze -S <%s | FileCheck %s --check-prefix=CHECK-DL
+; RUN: opt -print-memderefs -analyze -S <%s | FileCheck %s --check-prefix=CHECK-NO-DL
+
+; CHECK-DL-LABEL: 'test'
+; CHECK-DL: The following are dereferenceable:
+; CHECK-DL-NOT: %cast{{.*}}(aligned)
+; CHECK-NO-DL-LABEL: 'test'
+; CHECK-NO-DL: The following are dereferenceable:
+; CHECK-NO-DL: %cast{{.*}}(aligned)
+define void @test(i32 addrspace(1)* dereferenceable(8) %dparam) {
+entry:
+    %cast = addrspacecast i32 addrspace(1)* %dparam to i32*
+    %load3 = load i32, i32* %cast
+    ret void
+}

test/Transforms/InstSimplify/addrspace-cast.ll

+; RUN: opt -S -instsimplify -default-data-layout="p:32:32-p1:32:32" < %s | FileCheck %s --check-prefix=CHECK-32
+; RUN: opt -S -instsimplify -default-data-layout="p:32:32-p1:64:64" < %s | FileCheck %s --check-prefix=CHECK-64
+
+; Check that we don't look through an addrspacecast if it changes pointer size
+; and that we do look if it doesn't
+
+define i32 @test4() {
+; CHECK-32-LABEL: @test4(
+; CHECK-32-NEXT: ret i32 4
+; CHECK-64-LABEL: @test4(
+; CHECK-64: ret i32 %add_to_int
+  %alloca = alloca i32, align 4                                     ; alloca + 0
+  %gep = getelementptr inbounds i32, i32* %alloca, i32 1            ; alloca + 4
+  %bc = bitcast i32* %gep to [4 x i8]*                              ; alloca + 4
+  %ac = addrspacecast [4 x i8]* %bc to [4 x i8] addrspace(1)*       ; alloca + 4
+  %pti = ptrtoint i32* %alloca to i32                               ; alloca
+  %sub = sub i32 0, %pti                                            ; -alloca
+  %add = getelementptr [4 x i8], [4 x i8] addrspace(1)* %ac, i32 0, i32 %sub     ; alloca + 4 - alloca == 4
+  %add_to_int = ptrtoint i8 addrspace(1)* %add to i32               ; 4
+  ret i32 %add_to_int                                               ; 4
+}

test/Transforms/LoopUnswitch/2015-09-18-Addrspace.ll

 ; RUN: opt < %s -loop-unswitch -S | FileCheck %s
 
 ; In cases where two address spaces do not have the same size pointer, the
 ; input for the addrspacecast should not be used as a substitute for itself
 ; when manipulating the pointer.
 
 target datalayout = "e-m:e-p:16:16-p1:32:16-i32:16-i64:16-n8:16"
 
-define void @foo() {
+define void @foo(i16* %p) {
 ; CHECK-LABEL: @foo
 entry:
-  %arrayidx.i1 = getelementptr inbounds i16, i16* undef, i16 undef
+  %arrayidx.i1 = getelementptr inbounds i16, i16* %p, i16 4
   %arrayidx.i = addrspacecast i16* %arrayidx.i1 to i16 addrspace(1)*
   br i1 undef, label %for.body.i, label %bar.exit
 
 for.body.i:                                       ; preds = %for.body.i, %entry
 ; When we call makeLoopInvariant (i.e. trivial LICM) on this load, it 
 ; will try to find the base object to prove deferenceability.  If we look
 ; through the addrspacecast, we'll fail an assertion about bitwidths matching
 ; CHECK-LABEL: for.body.i
 ; CHECK:   %0 = load i16, i16 addrspace(1)* %arrayidx.i, align 2
   %0 = load i16, i16 addrspace(1)* %arrayidx.i, align 2
   %cmp1.i = icmp eq i16 %0, 0
   br i1 %cmp1.i, label %bar.exit, label %for.body.i
 
 bar.exit:                                         ; preds = %for.body.i, %entry
   ret void
 }