[NFC] [LoopLoadElim] Extending type-mismatch testing

[jolanta.jensen]

Summary

Added IR for int-pointer type mismatch and int-vector
type mismatch. Regenerated CHECK lines using
the update_test_checks.py script.

[mgabka]

Could you change the commit message? or at least add [LoopLoadElim] ? it does not make clear that these are LoopLoadElimination tests.

[jolanta.jensen]

Added tests for int-pointer mismatch and int-vector mismatch.

[fhahn]

llvm/test/Transforms/LoopLoadElim/type-mismatch.ll

134

Typed pointers are deprecated, is there any reason to add the new test here instead of `llvm/test/Transforms/LoopLoadElim/type-mismatch-opaque-ptr.ll
`? I'd expect the typed pointer version of the tests to be removed relatively soon.

[jolanta.jensen]

In D132239#3735560, @mgabka wrote:

Could you change the commit message? or at least add [LoopLoadElim] ? it does not make clear that these are LoopLoadElimination tests.

Weird, I changed the commit message to:

[NFC][LoopLoadElim] Extending type-mismatch testing

Added IR for int-pointer type mismatch and int-vector
type mismatch. Regenerated CHECK lines using
the update_test_checks.py script.

but it hasn't been updated.

[fhahn]

In D132239#3739175, @jolanta.jensen wrote:

In D132239#3735560, @mgabka wrote:

Could you change the commit message? or at least add [LoopLoadElim] ? it does not make clear that these are LoopLoadElimination tests.

Weird, I changed the commit message to:

[NFC][LoopLoadElim] Extending type-mismatch testing

Unfortunately arc diff won't update the title/description. You'll need to change that manually in the web interface

[jolanta.jensen]

llvm/test/Transforms/LoopLoadElim/type-mismatch.ll

134

It's purely to make it easier for reviewers of https://reviews.llvm.org/D130233 to see the impact of the change.

[fhahn]

llvm/test/Transforms/LoopLoadElim/type-mismatch.ll

134

right, what I meant is that the test probably should just be converted/moved to the opaque pointer version of the tests

[jolanta.jensen]

Added opaque pointer versions of previously added tests.

[jolanta.jensen]

llvm/test/Transforms/LoopLoadElim/type-mismatch.ll

134

Added opaque pointer versions of f3 and f4.
I hope it's ok to keep them here as well so tests for opaque pointers ant typed pointers match.

[fhahn]

LGTM, thanks!

llvm/test/Transforms/LoopLoadElim/type-mismatch.ll

134

Thanks!

llvm/test/Transforms/LoopLoadElim/type-mismatch-opaque-ptr.ll

+; NOTE: Assertions have been autogenerated by utils/update_test_checks.py
 ; RUN: opt --opaque-pointers -loop-load-elim -S < %s | FileCheck %s
 
 ; Don't crash if the store and the load use different types.
 ;
 ;   for (unsigned i = 0; i < 100; i++) {
 ;     A[i+1] = B[i] + 2;
 ;     C[i] = ((float*)A)[i] * 2;
 ;   }
 
 target datalayout = "e-m:o-i64:64-f80:128-n8:16:32:64-S128"
 
-; CHECK-LABEL: @f(
 define void @f(ptr noalias %A, ptr noalias %B, ptr noalias %C, i64 %N) {
-
+; CHECK-LABEL: @f(
+; CHECK-NEXT:  entry:
+; CHECK-NEXT:    br label [[FOR_BODY:%.*]]
+; CHECK:       for.body:
+; CHECK-NEXT:    [[INDVARS_IV:%.*]] = phi i64 [ 0, [[ENTRY:%.*]] ], [ [[INDVARS_IV_NEXT:%.*]], [[FOR_BODY]] ]
+; CHECK-NEXT:    [[INDVARS_IV_NEXT]] = add nuw nsw i64 [[INDVARS_IV]], 1
+; CHECK-NEXT:    [[AIDX_NEXT:%.*]] = getelementptr inbounds i32, ptr [[A:%.*]], i64 [[INDVARS_IV_NEXT]]
+; CHECK-NEXT:    [[BIDX:%.*]] = getelementptr inbounds i32, ptr [[B:%.*]], i64 [[INDVARS_IV]]
+; CHECK-NEXT:    [[CIDX:%.*]] = getelementptr inbounds i32, ptr [[C:%.*]], i64 [[INDVARS_IV]]
+; CHECK-NEXT:    [[AIDX:%.*]] = getelementptr inbounds i32, ptr [[A]], i64 [[INDVARS_IV]]
+; CHECK-NEXT:    [[B:%.*]] = load i32, ptr [[BIDX]], align 4
+; CHECK-NEXT:    [[A_P1:%.*]] = add i32 [[B]], 2
+; CHECK-NEXT:    store i32 [[A_P1]], ptr [[AIDX_NEXT]], align 4
+; CHECK-NEXT:    [[A:%.*]] = load float, ptr [[AIDX]], align 4
+; CHECK-NEXT:    [[C:%.*]] = fmul float [[A]], 2.000000e+00
+; CHECK-NEXT:    [[C_INT:%.*]] = fptosi float [[C]] to i32
+; CHECK-NEXT:    store i32 [[C_INT]], ptr [[CIDX]], align 4
+; CHECK-NEXT:    [[EXITCOND:%.*]] = icmp eq i64 [[INDVARS_IV_NEXT]], [[N:%.*]]
+; CHECK-NEXT:    br i1 [[EXITCOND]], label [[FOR_END:%.*]], label [[FOR_BODY]]
+; CHECK:       for.end:
+; CHECK-NEXT:    ret void
+;
 entry:
   br label %for.body
 
 for.body:                                         ; preds = %for.body, %entry
   %indvars.iv = phi i64 [ 0, %entry ], [ %indvars.iv.next, %for.body ]
   %indvars.iv.next = add nuw nsw i64 %indvars.iv, 1
 
   %Aidx_next = getelementptr inbounds i32, ptr %A, i64 %indvars.iv.next
   %Bidx = getelementptr inbounds i32, ptr %B, i64 %indvars.iv
   %Cidx = getelementptr inbounds i32, ptr %C, i64 %indvars.iv
   %Aidx = getelementptr inbounds i32, ptr %A, i64 %indvars.iv
 
   %b = load i32, ptr %Bidx, align 4
   %a_p1 = add i32 %b, 2
   store i32 %a_p1, ptr %Aidx_next, align 4
 
-; CHECK: %a = load float, ptr %Aidx, align 4
   %a = load float, ptr %Aidx, align 4
-; CHECK-NEXT: %c = fmul float %a, 2.0
   %c = fmul float %a, 2.0
   %c.int = fptosi float %c to i32
   store i32 %c.int, ptr %Cidx, align 4
 
   %exitcond = icmp eq i64 %indvars.iv.next, %N
   br i1 %exitcond, label %for.end, label %for.body
 
 for.end:                                          ; preds = %for.body
   ret void
 }
 
 ; Don't crash if the store and the load use different types.
 ;
 ;   for (unsigned i = 0; i < 100; i++) {
 ;     A[i+1] = B[i] + 2;
 ;     A[i+1] = B[i] + 3;
 ;     C[i] = ((float*)A)[i] * 2;
 ;   }
 
-; CHECK-LABEL: @f2(
 define void @f2(ptr noalias %A, ptr noalias %B, ptr noalias %C, i64 %N) {
-
+; CHECK-LABEL: @f2(
+; CHECK-NEXT:  entry:
+; CHECK-NEXT:    br label [[FOR_BODY:%.*]]
+; CHECK:       for.body:
+; CHECK-NEXT:    [[INDVARS_IV:%.*]] = phi i64 [ 0, [[ENTRY:%.*]] ], [ [[INDVARS_IV_NEXT:%.*]], [[FOR_BODY]] ]
+; CHECK-NEXT:    [[INDVARS_IV_NEXT]] = add nuw nsw i64 [[INDVARS_IV]], 1
+; CHECK-NEXT:    [[AIDX_NEXT:%.*]] = getelementptr inbounds i32, ptr [[A:%.*]], i64 [[INDVARS_IV_NEXT]]
+; CHECK-NEXT:    [[BIDX:%.*]] = getelementptr inbounds i32, ptr [[B:%.*]], i64 [[INDVARS_IV]]
+; CHECK-NEXT:    [[CIDX:%.*]] = getelementptr inbounds i32, ptr [[C:%.*]], i64 [[INDVARS_IV]]
+; CHECK-NEXT:    [[AIDX:%.*]] = getelementptr inbounds i32, ptr [[A]], i64 [[INDVARS_IV]]
+; CHECK-NEXT:    [[B:%.*]] = load i32, ptr [[BIDX]], align 4
+; CHECK-NEXT:    [[A_P2:%.*]] = add i32 [[B]], 2
+; CHECK-NEXT:    store i32 [[A_P2]], ptr [[AIDX_NEXT]], align 4
+; CHECK-NEXT:    [[A_P3:%.*]] = add i32 [[B]], 3
+; CHECK-NEXT:    store i32 [[A_P3]], ptr [[AIDX_NEXT]], align 4
+; CHECK-NEXT:    [[A:%.*]] = load float, ptr [[AIDX]], align 4
+; CHECK-NEXT:    [[C:%.*]] = fmul float [[A]], 2.000000e+00
+; CHECK-NEXT:    [[C_INT:%.*]] = fptosi float [[C]] to i32
+; CHECK-NEXT:    store i32 [[C_INT]], ptr [[CIDX]], align 4
+; CHECK-NEXT:    [[EXITCOND:%.*]] = icmp eq i64 [[INDVARS_IV_NEXT]], [[N:%.*]]
+; CHECK-NEXT:    br i1 [[EXITCOND]], label [[FOR_END:%.*]], label [[FOR_BODY]]
+; CHECK:       for.end:
+; CHECK-NEXT:    ret void
+;
 entry:
   br label %for.body
 
 for.body:                                         ; preds = %for.body, %entry
   %indvars.iv = phi i64 [ 0, %entry ], [ %indvars.iv.next, %for.body ]
   %indvars.iv.next = add nuw nsw i64 %indvars.iv, 1
 
   %Aidx_next = getelementptr inbounds i32, ptr %A, i64 %indvars.iv.next
   %Bidx = getelementptr inbounds i32, ptr %B, i64 %indvars.iv
   %Cidx = getelementptr inbounds i32, ptr %C, i64 %indvars.iv
   %Aidx = getelementptr inbounds i32, ptr %A, i64 %indvars.iv
 
   %b = load i32, ptr %Bidx, align 4
   %a_p2 = add i32 %b, 2
   store i32 %a_p2, ptr %Aidx_next, align 4
 
   %a_p3 = add i32 %b, 3
   store i32 %a_p3, ptr %Aidx_next, align 4
 
-; CHECK: %a = load float, ptr %Aidx, align 4
   %a = load float, ptr %Aidx, align 4
-; CHECK-NEXT: %c = fmul float %a, 2.0
   %c = fmul float %a, 2.0
   %c.int = fptosi float %c to i32
   store i32 %c.int, ptr %Cidx, align 4
 
   %exitcond = icmp eq i64 %indvars.iv.next, %N
   br i1 %exitcond, label %for.end, label %for.body
 
 for.end:                                          ; preds = %for.body
   ret void
 }
+
+; Don't crash if the store and the load use different types.
+
+define void @f3(ptr noalias %A, ptr noalias %B, ptr noalias %C, i64 %N) {
+; CHECK-LABEL: @f3(
+; CHECK-NEXT:  entry:
+; CHECK-NEXT:    br label [[FOR_BODY:%.*]]
+; CHECK:       for.body:
+; CHECK-NEXT:    [[INDVARS_IV:%.*]] = phi i64 [ 0, [[ENTRY:%.*]] ], [ [[INDVARS_IV_NEXT:%.*]], [[FOR_BODY]] ]
+; CHECK-NEXT:    [[INDVARS_IV_NEXT]] = add nuw nsw i64 [[INDVARS_IV]], 1
+; CHECK-NEXT:    [[AIDX_NEXT:%.*]] = getelementptr inbounds i64, ptr [[A:%.*]], i64 [[INDVARS_IV_NEXT]]
+; CHECK-NEXT:    [[BIDX:%.*]] = getelementptr inbounds i64, ptr [[B:%.*]], i64 [[INDVARS_IV]]
+; CHECK-NEXT:    [[CIDX:%.*]] = getelementptr inbounds i64, ptr [[C:%.*]], i64 [[INDVARS_IV]]
+; CHECK-NEXT:    [[AIDX:%.*]] = getelementptr inbounds i64, ptr [[A]], i64 [[INDVARS_IV]]
+; CHECK-NEXT:    [[B:%.*]] = load i64, ptr [[BIDX]], align 8
+; CHECK-NEXT:    [[A_P1:%.*]] = add i64 [[B]], 2
+; CHECK-NEXT:    store i64 [[A_P1]], ptr [[AIDX_NEXT]], align 8
+; CHECK-NEXT:    [[A:%.*]] = load ptr, ptr [[AIDX]], align 8
+; CHECK-NEXT:    [[C:%.*]] = getelementptr i8, ptr [[A]], i64 57
+; CHECK-NEXT:    [[C_I64P:%.*]] = ptrtoint ptr [[C]] to i64
+; CHECK-NEXT:    store i64 [[C_I64P]], ptr [[CIDX]], align 8
+; CHECK-NEXT:    [[EXITCOND:%.*]] = icmp eq i64 [[INDVARS_IV_NEXT]], [[N:%.*]]
+; CHECK-NEXT:    br i1 [[EXITCOND]], label [[FOR_END:%.*]], label [[FOR_BODY]]
+; CHECK:       for.end:
+; CHECK-NEXT:    ret void
+;
+entry:
+  br label %for.body
+
+for.body:                                         ; preds = %for.body, %entry
+  %indvars.iv = phi i64 [ 0, %entry ], [ %indvars.iv.next, %for.body ]
+  %indvars.iv.next = add nuw nsw i64 %indvars.iv, 1
+
+  %Aidx_next = getelementptr inbounds i64, ptr %A, i64 %indvars.iv.next
+  %Bidx = getelementptr inbounds i64, ptr %B, i64 %indvars.iv
+  %Cidx = getelementptr inbounds i64, ptr %C, i64 %indvars.iv
+  %Aidx = getelementptr inbounds i64, ptr %A, i64 %indvars.iv
+
+  %b = load i64, ptr %Bidx, align 8
+  %a_p1 = add i64 %b, 2
+  store i64 %a_p1, ptr %Aidx_next, align 8
+
+  %a = load ptr, ptr %Aidx , align 8
+  %c = getelementptr i8, ptr %a, i64 57
+  %c.i64p = ptrtoint i8* %c to i64
+  store i64 %c.i64p, ptr %Cidx, align 8
+
+  %exitcond = icmp eq i64 %indvars.iv.next, %N
+  br i1 %exitcond, label %for.end, label %for.body
+
+for.end:                                          ; preds = %for.body
+  ret void
+}
+
+; Don't crash if the store and the load use different types.
+;
+;   for (unsigned i = 0; i < 100; i++) {
+;     A[i+1] = B[i] + 2;
+;     C[i] = ((float*)A)[i] * 2;
+;   }
+
+define void @f4(ptr noalias %A, ptr noalias %B, ptr noalias %C, i64 %N) {
+; CHECK-LABEL: @f4(
+; CHECK-NEXT:  entry:
+; CHECK-NEXT:    br label [[FOR_BODY:%.*]]
+; CHECK:       for.body:
+; CHECK-NEXT:    [[INDVARS_IV:%.*]] = phi i64 [ 0, [[ENTRY:%.*]] ], [ [[INDVARS_IV_NEXT:%.*]], [[FOR_BODY]] ]
+; CHECK-NEXT:    [[INDVARS_IV_NEXT]] = add nuw nsw i64 [[INDVARS_IV]], 1
+; CHECK-NEXT:    [[AIDX_NEXT:%.*]] = getelementptr inbounds i32, ptr [[A:%.*]], i64 [[INDVARS_IV_NEXT]]
+; CHECK-NEXT:    [[BIDX:%.*]] = getelementptr inbounds i32, ptr [[B:%.*]], i64 [[INDVARS_IV]]
+; CHECK-NEXT:    [[CIDX:%.*]] = getelementptr inbounds i32, ptr [[C:%.*]], i64 [[INDVARS_IV]]
+; CHECK-NEXT:    [[AIDX:%.*]] = getelementptr inbounds i32, ptr [[A]], i64 [[INDVARS_IV]]
+; CHECK-NEXT:    [[B:%.*]] = load i32, ptr [[BIDX]], align 4
+; CHECK-NEXT:    [[A_P1:%.*]] = add i32 [[B]], 2
+; CHECK-NEXT:    store i32 [[A_P1]], ptr [[AIDX_NEXT]], align 4
+; CHECK-NEXT:    [[A:%.*]] = load <2 x half>, ptr [[AIDX]], align 4
+; CHECK-NEXT:    [[C:%.*]] = fmul <2 x half> [[A]], <half 0xH4000, half 0xH4000>
+; CHECK-NEXT:    [[C_INT:%.*]] = bitcast <2 x half> [[C]] to i32
+; CHECK-NEXT:    store i32 [[C_INT]], ptr [[CIDX]], align 4
+; CHECK-NEXT:    [[EXITCOND:%.*]] = icmp eq i64 [[INDVARS_IV_NEXT]], [[N:%.*]]
+; CHECK-NEXT:    br i1 [[EXITCOND]], label [[FOR_END:%.*]], label [[FOR_BODY]]
+; CHECK:       for.end:
+; CHECK-NEXT:    ret void
+;
+entry:
+  br label %for.body
+
+for.body:                                         ; preds = %for.body, %entry
+  %indvars.iv = phi i64 [ 0, %entry ], [ %indvars.iv.next, %for.body ]
+  %indvars.iv.next = add nuw nsw i64 %indvars.iv, 1
+
+  %Aidx_next = getelementptr inbounds i32, ptr %A, i64 %indvars.iv.next
+  %Bidx = getelementptr inbounds i32, ptr %B, i64 %indvars.iv
+  %Cidx = getelementptr inbounds i32, ptr %C, i64 %indvars.iv
+  %Aidx = getelementptr inbounds i32, ptr %A, i64 %indvars.iv
+
+  %b = load i32, ptr %Bidx, align 4
+  %a_p1 = add i32 %b, 2
+  store i32 %a_p1, ptr %Aidx_next, align 4
+
+  %a = load <2 x half>, <2 x half>* %Aidx, align 4
+  %c = fmul <2 x half> %a, <half 2.0, half 2.0>
+  %c.int = bitcast <2 x half> %c to i32
+  store i32 %c.int, ptr %Cidx, align 4
+
+  %exitcond = icmp eq i64 %indvars.iv.next, %N
+  br i1 %exitcond, label %for.end, label %for.body
+
+for.end:                                          ; preds = %for.body
+  ret void
+}

llvm/test/Transforms/LoopLoadElim/type-mismatch.ll

+; NOTE: Assertions have been autogenerated by utils/update_test_checks.py
 ; RUN: opt -loop-load-elim -S < %s | FileCheck %s
 
 ; Don't crash if the store and the load use different types.
 ;
 ;   for (unsigned i = 0; i < 100; i++) {
 ;     A[i+1] = B[i] + 2;
 ;     C[i] = ((float*)A)[i] * 2;
 ;   }
 
 target datalayout = "e-m:o-i64:64-f80:128-n8:16:32:64-S128"
 
-; CHECK-LABEL: @f(
 define void @f(i32* noalias %A, i32* noalias %B, i32* noalias %C, i64 %N) {
-
+; CHECK-LABEL: @f(
+; CHECK-NEXT:  entry:
+; CHECK-NEXT:    br label [[FOR_BODY:%.*]]
+; CHECK:       for.body:
+; CHECK-NEXT:    [[INDVARS_IV:%.*]] = phi i64 [ 0, [[ENTRY:%.*]] ], [ [[INDVARS_IV_NEXT:%.*]], [[FOR_BODY]] ]
+; CHECK-NEXT:    [[INDVARS_IV_NEXT]] = add nuw nsw i64 [[INDVARS_IV]], 1
+; CHECK-NEXT:    [[AIDX_NEXT:%.*]] = getelementptr inbounds i32, i32* [[A:%.*]], i64 [[INDVARS_IV_NEXT]]
+; CHECK-NEXT:    [[BIDX:%.*]] = getelementptr inbounds i32, i32* [[B:%.*]], i64 [[INDVARS_IV]]
+; CHECK-NEXT:    [[CIDX:%.*]] = getelementptr inbounds i32, i32* [[C:%.*]], i64 [[INDVARS_IV]]
+; CHECK-NEXT:    [[AIDX:%.*]] = getelementptr inbounds i32, i32* [[A]], i64 [[INDVARS_IV]]
+; CHECK-NEXT:    [[AIDX_FLOAT:%.*]] = bitcast i32* [[AIDX]] to float*
+; CHECK-NEXT:    [[B:%.*]] = load i32, i32* [[BIDX]], align 4
+; CHECK-NEXT:    [[A_P1:%.*]] = add i32 [[B]], 2
+; CHECK-NEXT:    store i32 [[A_P1]], i32* [[AIDX_NEXT]], align 4
+; CHECK-NEXT:    [[A:%.*]] = load float, float* [[AIDX_FLOAT]], align 4
+; CHECK-NEXT:    [[C:%.*]] = fmul float [[A]], 2.000000e+00
+; CHECK-NEXT:    [[C_INT:%.*]] = fptosi float [[C]] to i32
+; CHECK-NEXT:    store i32 [[C_INT]], i32* [[CIDX]], align 4
+; CHECK-NEXT:    [[EXITCOND:%.*]] = icmp eq i64 [[INDVARS_IV_NEXT]], [[N:%.*]]
+; CHECK-NEXT:    br i1 [[EXITCOND]], label [[FOR_END:%.*]], label [[FOR_BODY]]
+; CHECK:       for.end:
+; CHECK-NEXT:    ret void
+;
 entry:
   br label %for.body
 
 for.body:                                         ; preds = %for.body, %entry
   %indvars.iv = phi i64 [ 0, %entry ], [ %indvars.iv.next, %for.body ]
   %indvars.iv.next = add nuw nsw i64 %indvars.iv, 1
 
   %Aidx_next = getelementptr inbounds i32, i32* %A, i64 %indvars.iv.next
   %Bidx = getelementptr inbounds i32, i32* %B, i64 %indvars.iv
   %Cidx = getelementptr inbounds i32, i32* %C, i64 %indvars.iv
   %Aidx = getelementptr inbounds i32, i32* %A, i64 %indvars.iv
   %Aidx.float = bitcast i32* %Aidx to float*
 
   %b = load i32, i32* %Bidx, align 4
   %a_p1 = add i32 %b, 2
   store i32 %a_p1, i32* %Aidx_next, align 4
 
-; CHECK: %a = load float, float* %Aidx.float, align 4
   %a = load float, float* %Aidx.float, align 4
-; CHECK-NEXT: %c = fmul float %a, 2.0
   %c = fmul float %a, 2.0
   %c.int = fptosi float %c to i32
   store i32 %c.int, i32* %Cidx, align 4
 
   %exitcond = icmp eq i64 %indvars.iv.next, %N
   br i1 %exitcond, label %for.end, label %for.body
 
 for.end:                                          ; preds = %for.body
   ret void
 }
 
 ; Don't crash if the store and the load use different types.
 ;
 ;   for (unsigned i = 0; i < 100; i++) {
 ;     A[i+1] = B[i] + 2;
 ;     A[i+1] = B[i] + 3;
 ;     C[i] = ((float*)A)[i] * 2;
 ;   }
 
-; CHECK-LABEL: @f2(
 define void @f2(i32* noalias %A, i32* noalias %B, i32* noalias %C, i64 %N) {
-
+; CHECK-LABEL: @f2(
+; CHECK-NEXT:  entry:
+; CHECK-NEXT:    br label [[FOR_BODY:%.*]]
+; CHECK:       for.body:
+; CHECK-NEXT:    [[INDVARS_IV:%.*]] = phi i64 [ 0, [[ENTRY:%.*]] ], [ [[INDVARS_IV_NEXT:%.*]], [[FOR_BODY]] ]
+; CHECK-NEXT:    [[INDVARS_IV_NEXT]] = add nuw nsw i64 [[INDVARS_IV]], 1
+; CHECK-NEXT:    [[AIDX_NEXT:%.*]] = getelementptr inbounds i32, i32* [[A:%.*]], i64 [[INDVARS_IV_NEXT]]
+; CHECK-NEXT:    [[BIDX:%.*]] = getelementptr inbounds i32, i32* [[B:%.*]], i64 [[INDVARS_IV]]
+; CHECK-NEXT:    [[CIDX:%.*]] = getelementptr inbounds i32, i32* [[C:%.*]], i64 [[INDVARS_IV]]
+; CHECK-NEXT:    [[AIDX:%.*]] = getelementptr inbounds i32, i32* [[A]], i64 [[INDVARS_IV]]
+; CHECK-NEXT:    [[AIDX_FLOAT:%.*]] = bitcast i32* [[AIDX]] to float*
+; CHECK-NEXT:    [[B:%.*]] = load i32, i32* [[BIDX]], align 4
+; CHECK-NEXT:    [[A_P2:%.*]] = add i32 [[B]], 2
+; CHECK-NEXT:    store i32 [[A_P2]], i32* [[AIDX_NEXT]], align 4
+; CHECK-NEXT:    [[A_P3:%.*]] = add i32 [[B]], 3
+; CHECK-NEXT:    store i32 [[A_P3]], i32* [[AIDX_NEXT]], align 4
+; CHECK-NEXT:    [[A:%.*]] = load float, float* [[AIDX_FLOAT]], align 4
+; CHECK-NEXT:    [[C:%.*]] = fmul float [[A]], 2.000000e+00
+; CHECK-NEXT:    [[C_INT:%.*]] = fptosi float [[C]] to i32
+; CHECK-NEXT:    store i32 [[C_INT]], i32* [[CIDX]], align 4
+; CHECK-NEXT:    [[EXITCOND:%.*]] = icmp eq i64 [[INDVARS_IV_NEXT]], [[N:%.*]]
+; CHECK-NEXT:    br i1 [[EXITCOND]], label [[FOR_END:%.*]], label [[FOR_BODY]]
+; CHECK:       for.end:
+; CHECK-NEXT:    ret void
+;
 entry:
   br label %for.body
 
 for.body:                                         ; preds = %for.body, %entry
   %indvars.iv = phi i64 [ 0, %entry ], [ %indvars.iv.next, %for.body ]
   %indvars.iv.next = add nuw nsw i64 %indvars.iv, 1
 
   %Aidx_next = getelementptr inbounds i32, i32* %A, i64 %indvars.iv.next
   %Bidx = getelementptr inbounds i32, i32* %B, i64 %indvars.iv
   %Cidx = getelementptr inbounds i32, i32* %C, i64 %indvars.iv
   %Aidx = getelementptr inbounds i32, i32* %A, i64 %indvars.iv
   %Aidx.float = bitcast i32* %Aidx to float*
 
   %b = load i32, i32* %Bidx, align 4
   %a_p2 = add i32 %b, 2
   store i32 %a_p2, i32* %Aidx_next, align 4
 
   %a_p3 = add i32 %b, 3
   store i32 %a_p3, i32* %Aidx_next, align 4
 
-; CHECK: %a = load float, float* %Aidx.float, align 4
   %a = load float, float* %Aidx.float, align 4
-; CHECK-NEXT: %c = fmul float %a, 2.0
   %c = fmul float %a, 2.0
   %c.int = fptosi float %c to i32
   store i32 %c.int, i32* %Cidx, align 4
 
   %exitcond = icmp eq i64 %indvars.iv.next, %N
   br i1 %exitcond, label %for.end, label %for.body
 
 for.end:                                          ; preds = %for.body
   ret void
 }
+
+; Don't crash if the store and the load use different types.
+
+define void @f3(i64* noalias %A, i64* noalias %B, i64* noalias %C, i64 %N) {
+; CHECK-LABEL: @f3(
+; CHECK-NEXT:  entry:
+; CHECK-NEXT:    br label [[FOR_BODY:%.*]]
+; CHECK:       for.body:
+; CHECK-NEXT:    [[INDVARS_IV:%.*]] = phi i64 [ 0, [[ENTRY:%.*]] ], [ [[INDVARS_IV_NEXT:%.*]], [[FOR_BODY]] ]
+; CHECK-NEXT:    [[INDVARS_IV_NEXT]] = add nuw nsw i64 [[INDVARS_IV]], 1
+; CHECK-NEXT:    [[AIDX_NEXT:%.*]] = getelementptr inbounds i64, i64* [[A:%.*]], i64 [[INDVARS_IV_NEXT]]
+; CHECK-NEXT:    [[BIDX:%.*]] = getelementptr inbounds i64, i64* [[B:%.*]], i64 [[INDVARS_IV]]
+; CHECK-NEXT:    [[CIDX:%.*]] = getelementptr inbounds i64, i64* [[C:%.*]], i64 [[INDVARS_IV]]
+; CHECK-NEXT:    [[AIDX:%.*]] = getelementptr inbounds i64, i64* [[A]], i64 [[INDVARS_IV]]
+; CHECK-NEXT:    [[AIDX_I8P:%.*]] = bitcast i64* [[AIDX]] to i8**
+; CHECK-NEXT:    [[B:%.*]] = load i64, i64* [[BIDX]], align 8
+; CHECK-NEXT:    [[A_P1:%.*]] = add i64 [[B]], 2
+; CHECK-NEXT:    store i64 [[A_P1]], i64* [[AIDX_NEXT]], align 8
+; CHECK-NEXT:    [[A:%.*]] = load i8*, i8** [[AIDX_I8P]], align 8
+; CHECK-NEXT:    [[C:%.*]] = getelementptr i8, i8* [[A]], i64 57
+; CHECK-NEXT:    [[C_I64P:%.*]] = ptrtoint i8* [[C]] to i64
+; CHECK-NEXT:    store i64 [[C_I64P]], i64* [[CIDX]], align 8
+; CHECK-NEXT:    [[EXITCOND:%.*]] = icmp eq i64 [[INDVARS_IV_NEXT]], [[N:%.*]]
+; CHECK-NEXT:    br i1 [[EXITCOND]], label [[FOR_END:%.*]], label [[FOR_BODY]]
+; CHECK:       for.end:
+; CHECK-NEXT:    ret void
+;
+entry:
+  br label %for.body
+
+for.body:                                         ; preds = %for.body, %entry
+  %indvars.iv = phi i64 [ 0, %entry ], [ %indvars.iv.next, %for.body ]
+  %indvars.iv.next = add nuw nsw i64 %indvars.iv, 1
+
+  %Aidx_next = getelementptr inbounds i64, i64* %A, i64 %indvars.iv.next
+  %Bidx = getelementptr inbounds i64, i64* %B, i64 %indvars.iv
+  %Cidx = getelementptr inbounds i64, i64* %C, i64 %indvars.iv
+  %Aidx = getelementptr inbounds i64, i64* %A, i64 %indvars.iv
+  %Aidx.i8p = bitcast i64* %Aidx to i8**
+
+  %b = load i64, i64* %Bidx, align 8
+  %a_p1 = add i64 %b, 2
+  store i64 %a_p1, i64* %Aidx_next, align 8
+
+  %a = load i8*, i8** %Aidx.i8p, align 8
+  %c = getelementptr i8, i8* %a, i64 57
+  %c.i64p = ptrtoint i8* %c to i64
+  store i64 %c.i64p, i64* %Cidx, align 8
+
+  %exitcond = icmp eq i64 %indvars.iv.next, %N
+  br i1 %exitcond, label %for.end, label %for.body
+
+for.end:                                          ; preds = %for.body
+  ret void
+}
+
+; Don't crash if the store and the load use different types.
+;
+;   for (unsigned i = 0; i < 100; i++) {
+;     A[i+1] = B[i] + 2;
+;     C[i] = ((float*)A)[i] * 2;
+;   }
+
+define void @f4(i32* noalias %A, i32* noalias %B, i32* noalias %C, i64 %N) {
+; CHECK-LABEL: @f4(
+; CHECK-NEXT:  entry:
+; CHECK-NEXT:    br label [[FOR_BODY:%.*]]
+; CHECK:       for.body:
+; CHECK-NEXT:    [[INDVARS_IV:%.*]] = phi i64 [ 0, [[ENTRY:%.*]] ], [ [[INDVARS_IV_NEXT:%.*]], [[FOR_BODY]] ]
+; CHECK-NEXT:    [[INDVARS_IV_NEXT]] = add nuw nsw i64 [[INDVARS_IV]], 1
+; CHECK-NEXT:    [[AIDX_NEXT:%.*]] = getelementptr inbounds i32, i32* [[A:%.*]], i64 [[INDVARS_IV_NEXT]]
+; CHECK-NEXT:    [[BIDX:%.*]] = getelementptr inbounds i32, i32* [[B:%.*]], i64 [[INDVARS_IV]]
+; CHECK-NEXT:    [[CIDX:%.*]] = getelementptr inbounds i32, i32* [[C:%.*]], i64 [[INDVARS_IV]]
+; CHECK-NEXT:    [[AIDX:%.*]] = getelementptr inbounds i32, i32* [[A]], i64 [[INDVARS_IV]]
+; CHECK-NEXT:    [[AIDX_FLOAT:%.*]] = bitcast i32* [[AIDX]] to <2 x half>*
+; CHECK-NEXT:    [[B:%.*]] = load i32, i32* [[BIDX]], align 4
+; CHECK-NEXT:    [[A_P1:%.*]] = add i32 [[B]], 2
+; CHECK-NEXT:    store i32 [[A_P1]], i32* [[AIDX_NEXT]], align 4
+; CHECK-NEXT:    [[A:%.*]] = load <2 x half>, <2 x half>* [[AIDX_FLOAT]], align 4
+; CHECK-NEXT:    [[C:%.*]] = fmul <2 x half> [[A]], <half 0xH4000, half 0xH4000>
+; CHECK-NEXT:    [[C_INT:%.*]] = bitcast <2 x half> [[C]] to i32
+; CHECK-NEXT:    store i32 [[C_INT]], i32* [[CIDX]], align 4
+; CHECK-NEXT:    [[EXITCOND:%.*]] = icmp eq i64 [[INDVARS_IV_NEXT]], [[N:%.*]]
+; CHECK-NEXT:    br i1 [[EXITCOND]], label [[FOR_END:%.*]], label [[FOR_BODY]]
+; CHECK:       for.end:
+; CHECK-NEXT:    ret void
+;
+entry:
+  br label %for.body
+
+for.body:                                         ; preds = %for.body, %entry
+  %indvars.iv = phi i64 [ 0, %entry ], [ %indvars.iv.next, %for.body ]
+  %indvars.iv.next = add nuw nsw i64 %indvars.iv, 1
+
+  %Aidx_next = getelementptr inbounds i32, i32* %A, i64 %indvars.iv.next
+  %Bidx = getelementptr inbounds i32, i32* %B, i64 %indvars.iv
+  %Cidx = getelementptr inbounds i32, i32* %C, i64 %indvars.iv
+  %Aidx = getelementptr inbounds i32, i32* %A, i64 %indvars.iv
+  %Aidx.float = bitcast i32* %Aidx to <2 x half>*
+
+  %b = load i32, i32* %Bidx, align 4
+  %a_p1 = add i32 %b, 2
+  store i32 %a_p1, i32* %Aidx_next, align 4
+
+  %a = load <2 x half>, <2 x half>* %Aidx.float, align 4
+  %c = fmul <2 x half> %a, <half 2.0, half 2.0>
+  %c.int = bitcast <2 x half> %c to i32
+  store i32 %c.int, i32* %Cidx, align 4
+
+  %exitcond = icmp eq i64 %indvars.iv.next, %N
+  br i1 %exitcond, label %for.end, label %for.body
+
+for.end:                                          ; preds = %for.body
+  ret void
+}