llvm/test/Transforms/LoopIdiom/memset-multiple-accesses.ll

; NOTE: Assertions have been autogenerated by utils/update_test_checks.py UTC_ARGS: --check-globals none --version 6
; RUN: opt -passes=loop-idiom %s -S | FileCheck %s

define void @zero_two_disjoint_fields(ptr %p, i64 %n) {
; CHECK-LABEL: define void @zero_two_disjoint_fields(
; CHECK-SAME: ptr [[P:%.*]], i64 [[N:%.*]]) {
; CHECK-NEXT:  [[ENTRY:.*]]:
; CHECK-NEXT:    [[SCEVGEP:%.*]] = getelementptr nuw i8, ptr [[P]], i64 4
; CHECK-NEXT:    [[TMP0:%.*]] = shl nuw i64 [[N]], 2
; CHECK-NEXT:    call void @llvm.memset.p0.i64(ptr align 4 [[SCEVGEP]], i8 0, i64 [[TMP0]], i1 false)
; CHECK-NEXT:    [[SCEVGEP1:%.*]] = getelementptr nuw i8, ptr [[P]], i64 868
; CHECK-NEXT:    call void @llvm.memset.p0.i64(ptr align 4 [[SCEVGEP1]], i8 0, i64 [[TMP0]], i1 false)
; CHECK-NEXT:    br label %[[LOOP:.*]]
; CHECK:       [[LOOP]]:
; CHECK-NEXT:    [[IV:%.*]] = phi i64 [ 0, %[[ENTRY]] ], [ [[IV_NEXT:%.*]], %[[LOOP]] ]
; CHECK-NEXT:    [[FIELD_A:%.*]] = getelementptr inbounds nuw i8, ptr [[P]], i64 4
; CHECK-NEXT:    [[GEP_A:%.*]] = getelementptr inbounds nuw float, ptr [[FIELD_A]], i64 [[IV]]
; CHECK-NEXT:    [[FIELD_B:%.*]] = getelementptr inbounds nuw i8, ptr [[P]], i64 868
; CHECK-NEXT:    [[GEP_B:%.*]] = getelementptr inbounds nuw float, ptr [[FIELD_B]], i64 [[IV]]
; CHECK-NEXT:    [[IV_NEXT]] = add nuw nsw i64 [[IV]], 1
; CHECK-NEXT:    [[EC:%.*]] = icmp ne i64 [[IV_NEXT]], [[N]]
; CHECK-NEXT:    br i1 [[EC]], label %[[LOOP]], label %[[EXIT:.*]]
; CHECK:       [[EXIT]]:
; CHECK-NEXT:    ret void
;
entry:
  br label %loop

loop:
  %iv = phi i64 [ 0, %entry ], [ %iv.next, %loop ]
  %field.a = getelementptr inbounds nuw i8, ptr %p, i64 4
  %gep.a = getelementptr inbounds nuw float, ptr %field.a, i64 %iv
  store float 0.000000e+00, ptr %gep.a, align 4
  %field.b = getelementptr inbounds nuw i8, ptr %p, i64 868
  %gep.b = getelementptr inbounds nuw float, ptr %field.b, i64 %iv
  store float 0.000000e+00, ptr %gep.b, align 4
  %iv.next = add nuw nsw i64 %iv, 1
  %ec = icmp ne i64 %iv.next, %n
  br i1 %ec, label %loop, label %exit

exit:
  ret void
}

define void @zero_two_unknown_pointers(ptr %a, ptr %b, i64 %n) {
; CHECK-LABEL: define void @zero_two_unknown_pointers(
; CHECK-SAME: ptr [[A:%.*]], ptr [[B:%.*]], i64 [[N:%.*]]) {
; CHECK-NEXT:  [[ENTRY:.*]]:
; CHECK-NEXT:    [[TMP0:%.*]] = shl nuw i64 [[N]], 2
; CHECK-NEXT:    call void @llvm.memset.p0.i64(ptr align 4 [[A]], i8 0, i64 [[TMP0]], i1 false)
; CHECK-NEXT:    call void @llvm.memset.p0.i64(ptr align 4 [[B]], i8 0, i64 [[TMP0]], i1 false)
; CHECK-NEXT:    br label %[[LOOP:.*]]
; CHECK:       [[LOOP]]:
; CHECK-NEXT:    [[IV:%.*]] = phi i64 [ 0, %[[ENTRY]] ], [ [[IV_NEXT:%.*]], %[[LOOP]] ]
; CHECK-NEXT:    [[GEP_A:%.*]] = getelementptr inbounds nuw float, ptr [[A]], i64 [[IV]]
; CHECK-NEXT:    [[GEP_B:%.*]] = getelementptr inbounds nuw float, ptr [[B]], i64 [[IV]]
; CHECK-NEXT:    [[IV_NEXT]] = add nuw nsw i64 [[IV]], 1
; CHECK-NEXT:    [[EC:%.*]] = icmp ne i64 [[IV_NEXT]], [[N]]
; CHECK-NEXT:    br i1 [[EC]], label %[[LOOP]], label %[[EXIT:.*]]
; CHECK:       [[EXIT]]:
; CHECK-NEXT:    ret void
;
entry:
  br label %loop

loop:
  %iv = phi i64 [ 0, %entry ], [ %iv.next, %loop ]
  %gep.a = getelementptr inbounds nuw float, ptr %a, i64 %iv
  store float 0.000000e+00, ptr %gep.a, align 4
  %gep.b = getelementptr inbounds nuw float, ptr %b, i64 %iv
  store float 0.000000e+00, ptr %gep.b, align 4
  %iv.next = add nuw nsw i64 %iv, 1
  %ec = icmp ne i64 %iv.next, %n
  br i1 %ec, label %loop, label %exit

exit:
  ret void
}

define void @diff_size(ptr %a, ptr %b, i64 %n) {
; CHECK-LABEL: define void @diff_size(
; CHECK-SAME: ptr [[A:%.*]], ptr [[B:%.*]], i64 [[N:%.*]]) {
; CHECK-NEXT:  [[ENTRY:.*]]:
; CHECK-NEXT:    [[TMP0:%.*]] = shl nuw i64 [[N]], 2
; CHECK-NEXT:    call void @llvm.memset.p0.i64(ptr align 4 [[A]], i8 0, i64 [[TMP0]], i1 false)
; CHECK-NEXT:    call void @llvm.memset.p0.i64(ptr align 1 [[B]], i8 0, i64 [[N]], i1 false)
; CHECK-NEXT:    br label %[[LOOP:.*]]
; CHECK:       [[LOOP]]:
; CHECK-NEXT:    [[IV:%.*]] = phi i64 [ 0, %[[ENTRY]] ], [ [[IV_NEXT:%.*]], %[[LOOP]] ]
; CHECK-NEXT:    [[GEP_A:%.*]] = getelementptr inbounds nuw i32, ptr [[A]], i64 [[IV]]
; CHECK-NEXT:    [[GEP_B:%.*]] = getelementptr inbounds nuw i8, ptr [[B]], i64 [[IV]]
; CHECK-NEXT:    [[IV_NEXT]] = add nuw nsw i64 [[IV]], 1
; CHECK-NEXT:    [[EC:%.*]] = icmp ne i64 [[IV_NEXT]], [[N]]
; CHECK-NEXT:    br i1 [[EC]], label %[[LOOP]], label %[[EXIT:.*]]
; CHECK:       [[EXIT]]:
; CHECK-NEXT:    ret void
;
entry:
  br label %loop

loop:
  %iv = phi i64 [ 0, %entry ], [ %iv.next, %loop ]
  %gep.a = getelementptr inbounds nuw i32, ptr %a, i64 %iv
  store i32 0, ptr %gep.a, align 4
  %gep.b = getelementptr inbounds nuw i8, ptr %b, i64 %iv
  store i8 0, ptr %gep.b, align 1
  %iv.next = add nuw nsw i64 %iv, 1
  %ec = icmp ne i64 %iv.next, %n
  br i1 %ec, label %loop, label %exit

exit:
  ret void
}

define void @diff_value_unknown_pointers(ptr %a, ptr %b, i64 %n) {
; CHECK-LABEL: define void @diff_value_unknown_pointers(
; CHECK-SAME: ptr [[A:%.*]], ptr [[B:%.*]], i64 [[N:%.*]]) {
; CHECK-NEXT:  [[ENTRY:.*]]:
; CHECK-NEXT:    br label %[[LOOP:.*]]
; CHECK:       [[LOOP]]:
; CHECK-NEXT:    [[IV:%.*]] = phi i64 [ 0, %[[ENTRY]] ], [ [[IV_NEXT:%.*]], %[[LOOP]] ]
; CHECK-NEXT:    [[GEP_A:%.*]] = getelementptr inbounds nuw i8, ptr [[A]], i64 [[IV]]
; CHECK-NEXT:    store i8 0, ptr [[GEP_A]], align 1
; CHECK-NEXT:    [[GEP_B:%.*]] = getelementptr inbounds nuw i8, ptr [[B]], i64 [[IV]]
; CHECK-NEXT:    store i8 1, ptr [[GEP_B]], align 1
; CHECK-NEXT:    [[IV_NEXT]] = add nuw nsw i64 [[IV]], 1
; CHECK-NEXT:    [[EC:%.*]] = icmp ne i64 [[IV_NEXT]], [[N]]
; CHECK-NEXT:    br i1 [[EC]], label %[[LOOP]], label %[[EXIT:.*]]
; CHECK:       [[EXIT]]:
; CHECK-NEXT:    ret void
;
entry:
  br label %loop

loop:
  %iv = phi i64 [ 0, %entry ], [ %iv.next, %loop ]
  %gep.a = getelementptr inbounds nuw i8, ptr %a, i64 %iv
  store i8 0, ptr %gep.a, align 1
  %gep.b = getelementptr inbounds nuw i8, ptr %b, i64 %iv
  store i8 1, ptr %gep.b, align 1
  %iv.next = add nuw nsw i64 %iv, 1
  %ec = icmp ne i64 %iv.next, %n
  br i1 %ec, label %loop, label %exit

exit:
  ret void
}

declare void @use(ptr)

define void @zero_with_call(ptr %a, ptr %b, i64 %n) {
; CHECK-LABEL: define void @zero_with_call(
; CHECK-SAME: ptr [[A:%.*]], ptr [[B:%.*]], i64 [[N:%.*]]) {
; CHECK-NEXT:  [[ENTRY:.*]]:
; CHECK-NEXT:    br label %[[LOOP:.*]]
; CHECK:       [[LOOP]]:
; CHECK-NEXT:    [[IV:%.*]] = phi i64 [ 0, %[[ENTRY]] ], [ [[IV_NEXT:%.*]], %[[LOOP]] ]
; CHECK-NEXT:    [[GEP_A:%.*]] = getelementptr inbounds nuw i8, ptr [[A]], i64 [[IV]]
; CHECK-NEXT:    store i8 0, ptr [[GEP_A]], align 1
; CHECK-NEXT:    call void @use(ptr [[B]])
; CHECK-NEXT:    [[IV_NEXT]] = add nuw nsw i64 [[IV]], 1
; CHECK-NEXT:    [[EC:%.*]] = icmp ne i64 [[IV_NEXT]], [[N]]
; CHECK-NEXT:    br i1 [[EC]], label %[[LOOP]], label %[[EXIT:.*]]
; CHECK:       [[EXIT]]:
; CHECK-NEXT:    ret void
;
entry:
  br label %loop

loop:
  %iv = phi i64 [ 0, %entry ], [ %iv.next, %loop ]
  %gep.a = getelementptr inbounds nuw i8, ptr %a, i64 %iv
  store i8 0, ptr %gep.a, align 1
  call void @use(ptr %b)
  %iv.next = add nuw nsw i64 %iv, 1
  %ec = icmp ne i64 %iv.next, %n
  br i1 %ec, label %loop, label %exit

exit:
  ret void
}

define void @zero_three_unknown_pointers(ptr %a, ptr %b, ptr %c, i64 %n) {
; CHECK-LABEL: define void @zero_three_unknown_pointers(
; CHECK-SAME: ptr [[A:%.*]], ptr [[B:%.*]], ptr [[C:%.*]], i64 [[N:%.*]]) {
; CHECK-NEXT:  [[ENTRY:.*]]:
; CHECK-NEXT:    [[TMP0:%.*]] = shl nuw i64 [[N]], 2
; CHECK-NEXT:    call void @llvm.memset.p0.i64(ptr align 4 [[A]], i8 0, i64 [[TMP0]], i1 false)
; CHECK-NEXT:    call void @llvm.memset.p0.i64(ptr align 4 [[B]], i8 0, i64 [[TMP0]], i1 false)
; CHECK-NEXT:    call void @llvm.memset.p0.i64(ptr align 4 [[C]], i8 0, i64 [[TMP0]], i1 false)
; CHECK-NEXT:    br label %[[LOOP:.*]]
; CHECK:       [[LOOP]]:
; CHECK-NEXT:    [[IV:%.*]] = phi i64 [ 0, %[[ENTRY]] ], [ [[IV_NEXT:%.*]], %[[LOOP]] ]
; CHECK-NEXT:    [[GEP_A:%.*]] = getelementptr inbounds nuw float, ptr [[A]], i64 [[IV]]
; CHECK-NEXT:    [[GEP_B:%.*]] = getelementptr inbounds nuw float, ptr [[B]], i64 [[IV]]
; CHECK-NEXT:    [[GEP_C:%.*]] = getelementptr inbounds nuw float, ptr [[C]], i64 [[IV]]
; CHECK-NEXT:    [[IV_NEXT]] = add nuw nsw i64 [[IV]], 1
; CHECK-NEXT:    [[EC:%.*]] = icmp ne i64 [[IV_NEXT]], [[N]]
; CHECK-NEXT:    br i1 [[EC]], label %[[LOOP]], label %[[EXIT:.*]]
; CHECK:       [[EXIT]]:
; CHECK-NEXT:    ret void
;
entry:
  br label %loop

loop:
  %iv = phi i64 [ 0, %entry ], [ %iv.next, %loop ]
  %gep.a = getelementptr inbounds nuw float, ptr %a, i64 %iv
  store float 0.000000e+00, ptr %gep.a, align 4
  %gep.b = getelementptr inbounds nuw float, ptr %b, i64 %iv
  store float 0.000000e+00, ptr %gep.b, align 4
  %gep.c = getelementptr inbounds nuw float, ptr %c, i64 %iv
  store float 0.000000e+00, ptr %gep.c, align 4
  %iv.next = add nuw nsw i64 %iv, 1
  %ec = icmp ne i64 %iv.next, %n
  br i1 %ec, label %loop, label %exit

exit:
  ret void
}

define void @zero_three_negstride(ptr %a, ptr %b, ptr %c, i64 %n) {
; CHECK-LABEL: define void @zero_three_negstride(
; CHECK-SAME: ptr [[A:%.*]], ptr [[B:%.*]], ptr [[C:%.*]], i64 [[N:%.*]]) {
; CHECK-NEXT:  [[ENTRY:.*]]:
; CHECK-NEXT:    [[SCEVGEP:%.*]] = getelementptr i8, ptr [[A]], i64 4
; CHECK-NEXT:    [[TMP0:%.*]] = shl nuw i64 [[N]], 2
; CHECK-NEXT:    call void @llvm.memset.p0.i64(ptr align 4 [[SCEVGEP]], i8 0, i64 [[TMP0]], i1 false)
; CHECK-NEXT:    [[SCEVGEP1:%.*]] = getelementptr i8, ptr [[B]], i64 4
; CHECK-NEXT:    call void @llvm.memset.p0.i64(ptr align 4 [[SCEVGEP1]], i8 0, i64 [[TMP0]], i1 false)
; CHECK-NEXT:    [[SCEVGEP2:%.*]] = getelementptr i8, ptr [[C]], i64 4
; CHECK-NEXT:    call void @llvm.memset.p0.i64(ptr align 4 [[SCEVGEP2]], i8 0, i64 [[TMP0]], i1 false)
; CHECK-NEXT:    br label %[[LOOP:.*]]
; CHECK:       [[LOOP]]:
; CHECK-NEXT:    [[IV:%.*]] = phi i64 [ [[N]], %[[ENTRY]] ], [ [[IV_NEXT:%.*]], %[[LOOP]] ]
; CHECK-NEXT:    [[GEP_A:%.*]] = getelementptr inbounds i32, ptr [[A]], i64 [[IV]]
; CHECK-NEXT:    [[GEP_B:%.*]] = getelementptr inbounds i32, ptr [[B]], i64 [[IV]]
; CHECK-NEXT:    [[GEP_C:%.*]] = getelementptr inbounds i32, ptr [[C]], i64 [[IV]]
; CHECK-NEXT:    [[IV_NEXT]] = add nsw i64 [[IV]], -1
; CHECK-NEXT:    [[EC:%.*]] = icmp ne i64 [[IV_NEXT]], 0
; CHECK-NEXT:    br i1 [[EC]], label %[[LOOP]], label %[[EXIT:.*]]
; CHECK:       [[EXIT]]:
; CHECK-NEXT:    ret void
;
entry:
  br label %loop

loop:
  %iv = phi i64 [ %n, %entry ], [ %iv.next, %loop ]
  %gep.a = getelementptr inbounds i32, ptr %a, i64 %iv
  store i32 0, ptr %gep.a, align 4
  %gep.b = getelementptr inbounds i32, ptr %b, i64 %iv
  store i32 0, ptr %gep.b, align 4
  %gep.c = getelementptr inbounds i32, ptr %c, i64 %iv
  store i32 0, ptr %gep.c, align 4
  %iv.next = add nsw i64 %iv, -1
  %ec = icmp ne i64 %iv.next, 0
  br i1 %ec, label %loop, label %exit

exit:
  ret void
}

define void @zero_three_partial_overlap(ptr %a, i64 %n) {
; CHECK-LABEL: define void @zero_three_partial_overlap(
; CHECK-SAME: ptr [[A:%.*]], i64 [[N:%.*]]) {
; CHECK-NEXT:  [[ENTRY:.*]]:
; CHECK-NEXT:    [[TMP0:%.*]] = shl nuw i64 [[N]], 2
; CHECK-NEXT:    call void @llvm.memset.p0.i64(ptr align 4 [[A]], i8 0, i64 [[TMP0]], i1 false)
; CHECK-NEXT:    [[SCEVGEP:%.*]] = getelementptr nuw i8, ptr [[A]], i64 2
; CHECK-NEXT:    call void @llvm.memset.p0.i64(ptr align 4 [[SCEVGEP]], i8 0, i64 [[TMP0]], i1 false)
; CHECK-NEXT:    [[SCEVGEP1:%.*]] = getelementptr nuw i8, ptr [[A]], i64 4
; CHECK-NEXT:    call void @llvm.memset.p0.i64(ptr align 4 [[SCEVGEP1]], i8 0, i64 [[TMP0]], i1 false)
; CHECK-NEXT:    br label %[[LOOP:.*]]
; CHECK:       [[LOOP]]:
; CHECK-NEXT:    [[IV:%.*]] = phi i64 [ 0, %[[ENTRY]] ], [ [[IV_NEXT:%.*]], %[[LOOP]] ]
; CHECK-NEXT:    [[GEP_0:%.*]] = getelementptr inbounds nuw i32, ptr [[A]], i64 [[IV]]
; CHECK-NEXT:    [[A_2:%.*]] = getelementptr inbounds nuw i8, ptr [[A]], i64 2
; CHECK-NEXT:    [[GEP_2:%.*]] = getelementptr inbounds nuw i32, ptr [[A_2]], i64 [[IV]]
; CHECK-NEXT:    [[A_4:%.*]] = getelementptr inbounds nuw i8, ptr [[A]], i64 4
; CHECK-NEXT:    [[GEP_4:%.*]] = getelementptr inbounds nuw i32, ptr [[A_4]], i64 [[IV]]
; CHECK-NEXT:    [[IV_NEXT]] = add nuw nsw i64 [[IV]], 1
; CHECK-NEXT:    [[EC:%.*]] = icmp ne i64 [[IV_NEXT]], [[N]]
; CHECK-NEXT:    br i1 [[EC]], label %[[LOOP]], label %[[EXIT:.*]]
; CHECK:       [[EXIT]]:
; CHECK-NEXT:    ret void
;
entry:
  br label %loop

loop:
  %iv = phi i64 [ 0, %entry ], [ %iv.next, %loop ]
  %gep.0 = getelementptr inbounds nuw i32, ptr %a, i64 %iv
  store i32 0, ptr %gep.0, align 4
  %a.2 = getelementptr inbounds nuw i8, ptr %a, i64 2
  %gep.2 = getelementptr inbounds nuw i32, ptr %a.2, i64 %iv
  store i32 0, ptr %gep.2, align 4
  %a.4 = getelementptr inbounds nuw i8, ptr %a, i64 4
  %gep.4 = getelementptr inbounds nuw i32, ptr %a.4, i64 %iv
  store i32 0, ptr %gep.4, align 4
  %iv.next = add nuw nsw i64 %iv, 1
  %ec = icmp ne i64 %iv.next, %n
  br i1 %ec, label %loop, label %exit

exit:
  ret void
}

define void @three_unknown_pointers_one_diff_value(ptr %a, ptr %b, ptr %c, i64 %n) {
; CHECK-LABEL: define void @three_unknown_pointers_one_diff_value(
; CHECK-SAME: ptr [[A:%.*]], ptr [[B:%.*]], ptr [[C:%.*]], i64 [[N:%.*]]) {
; CHECK-NEXT:  [[ENTRY:.*]]:
; CHECK-NEXT:    br label %[[LOOP:.*]]
; CHECK:       [[LOOP]]:
; CHECK-NEXT:    [[IV:%.*]] = phi i64 [ 0, %[[ENTRY]] ], [ [[IV_NEXT:%.*]], %[[LOOP]] ]
; CHECK-NEXT:    [[GEP_A:%.*]] = getelementptr inbounds nuw i8, ptr [[A]], i64 [[IV]]
; CHECK-NEXT:    store i8 0, ptr [[GEP_A]], align 1
; CHECK-NEXT:    [[GEP_B:%.*]] = getelementptr inbounds nuw i8, ptr [[B]], i64 [[IV]]
; CHECK-NEXT:    store i8 0, ptr [[GEP_B]], align 1
; CHECK-NEXT:    [[GEP_C:%.*]] = getelementptr inbounds nuw i8, ptr [[C]], i64 [[IV]]
; CHECK-NEXT:    store i8 1, ptr [[GEP_C]], align 1
; CHECK-NEXT:    [[IV_NEXT]] = add nuw nsw i64 [[IV]], 1
; CHECK-NEXT:    [[EC:%.*]] = icmp ne i64 [[IV_NEXT]], [[N]]
; CHECK-NEXT:    br i1 [[EC]], label %[[LOOP]], label %[[EXIT:.*]]
; CHECK:       [[EXIT]]:
; CHECK-NEXT:    ret void
;
entry:
  br label %loop

loop:
  %iv = phi i64 [ 0, %entry ], [ %iv.next, %loop ]
  %gep.a = getelementptr inbounds nuw i8, ptr %a, i64 %iv
  store i8 0, ptr %gep.a, align 1
  %gep.b = getelementptr inbounds nuw i8, ptr %b, i64 %iv
  store i8 0, ptr %gep.b, align 1
  %gep.c = getelementptr inbounds nuw i8, ptr %c, i64 %iv
  store i8 1, ptr %gep.c, align 1
  %iv.next = add nuw nsw i64 %iv, 1
  %ec = icmp ne i64 %iv.next, %n
  br i1 %ec, label %loop, label %exit

exit:
  ret void
}

define void @loop_variant_value(ptr %a, i64 %n) {
; CHECK-LABEL: define void @loop_variant_value(
; CHECK-SAME: ptr [[A:%.*]], i64 [[N:%.*]]) {
; CHECK-NEXT:  [[ENTRY:.*]]:
; CHECK-NEXT:    br label %[[LOOP:.*]]
; CHECK:       [[LOOP]]:
; CHECK-NEXT:    [[IV:%.*]] = phi i64 [ 0, %[[ENTRY]] ], [ [[IV_NEXT:%.*]], %[[LOOP]] ]
; CHECK-NEXT:    [[GEP_A:%.*]] = getelementptr inbounds nuw i8, ptr [[A]], i64 [[IV]]
; CHECK-NEXT:    store i8 0, ptr [[GEP_A]], align 1
; CHECK-NEXT:    [[IV_TRUNC:%.*]] = trunc i64 [[IV]] to i8
; CHECK-NEXT:    [[GEP_B:%.*]] = getelementptr inbounds nuw i8, ptr [[A]], i64 [[IV]]
; CHECK-NEXT:    store i8 [[IV_TRUNC]], ptr [[GEP_B]], align 1
; CHECK-NEXT:    [[IV_NEXT]] = add nuw nsw i64 [[IV]], 1
; CHECK-NEXT:    [[EC:%.*]] = icmp ne i64 [[IV_NEXT]], [[N]]
; CHECK-NEXT:    br i1 [[EC]], label %[[LOOP]], label %[[EXIT:.*]]
; CHECK:       [[EXIT]]:
; CHECK-NEXT:    ret void
;
entry:
  br label %loop

loop:
  %iv = phi i64 [ 0, %entry ], [ %iv.next, %loop ]
  %gep.a = getelementptr inbounds nuw i8, ptr %a, i64 %iv
  store i8 0, ptr %gep.a, align 1
  %iv.trunc = trunc i64 %iv to i8
  %gep.b = getelementptr inbounds nuw i8, ptr %a, i64 %iv
  store i8 %iv.trunc, ptr %gep.b, align 1
  %iv.next = add nuw nsw i64 %iv, 1
  %ec = icmp ne i64 %iv.next, %n
  br i1 %ec, label %loop, label %exit

exit:
  ret void
}

define void @three_streams_with_call(ptr %a, ptr %b, ptr %c, i64 %n) {
; CHECK-LABEL: define void @three_streams_with_call(
; CHECK-SAME: ptr [[A:%.*]], ptr [[B:%.*]], ptr [[C:%.*]], i64 [[N:%.*]]) {
; CHECK-NEXT:  [[ENTRY:.*]]:
; CHECK-NEXT:    br label %[[LOOP:.*]]
; CHECK:       [[LOOP]]:
; CHECK-NEXT:    [[IV:%.*]] = phi i64 [ 0, %[[ENTRY]] ], [ [[IV_NEXT:%.*]], %[[LOOP]] ]
; CHECK-NEXT:    [[GEP_A:%.*]] = getelementptr inbounds nuw i32, ptr [[A]], i64 [[IV]]
; CHECK-NEXT:    store i32 0, ptr [[GEP_A]], align 4
; CHECK-NEXT:    [[GEP_B:%.*]] = getelementptr inbounds nuw i32, ptr [[B]], i64 [[IV]]
; CHECK-NEXT:    store i32 0, ptr [[GEP_B]], align 4
; CHECK-NEXT:    call void @use(ptr [[C]])
; CHECK-NEXT:    [[IV_NEXT]] = add nuw nsw i64 [[IV]], 1
; CHECK-NEXT:    [[EC:%.*]] = icmp ne i64 [[IV_NEXT]], [[N]]
; CHECK-NEXT:    br i1 [[EC]], label %[[LOOP]], label %[[EXIT:.*]]
; CHECK:       [[EXIT]]:
; CHECK-NEXT:    ret void
;
entry:
  br label %loop

loop:
  %iv = phi i64 [ 0, %entry ], [ %iv.next, %loop ]
  %gep.a = getelementptr inbounds nuw i32, ptr %a, i64 %iv
  store i32 0, ptr %gep.a, align 4
  %gep.b = getelementptr inbounds nuw i32, ptr %b, i64 %iv
  store i32 0, ptr %gep.b, align 4
  call void @use(ptr %c)
  %iv.next = add nuw nsw i64 %iv, 1
  %ec = icmp ne i64 %iv.next, %n
  br i1 %ec, label %loop, label %exit

exit:
  ret void
}