; REQUIRES: asserts

; RUN: opt -mtriple arm64-linux -passes=loop-vectorize -mattr=+sve -debug-only=loop-vectorize,vplan -disable-output <%s 2>&1 | FileCheck %s

; Invariant register usage calculation should take into account if the
; invariant would be used in widened instructions. Only in such cases, a vector
; register would be required for holding the invariant. For all other cases
; such as below(where usage of %0 in loop doesnt require vector register), a
; general purpose register suffices.
; Check that below test doesn't crash while calculating register usage for
; invariant %0

@string = internal unnamed_addr constant [5 x i8] c"abcd\00", align 1

define void @get_invariant_reg_usage(ptr %z) {
; CHECK-LABEL: LV: Checking a loop in 'get_invariant_reg_usage'
; CHECK: LV(REG): VF = 16
; CHECK-NEXT: LV(REG): Found max usage: 2 item
; CHECK-NEXT: LV(REG): RegisterClass: Generic::ScalarRC, 2 registers
; CHECK-NEXT: LV(REG): RegisterClass: Generic::VectorRC, 1 registers
; CHECK-NEXT: LV(REG): Found invariant usage: 1 item
; CHECK-NEXT: LV(REG): RegisterClass: Generic::ScalarRC, 3 registers

L.entry:
  %0 = load i128, ptr %z, align 16
  %1 = icmp slt i128 %0, 1
  %a = getelementptr i8, ptr %z, i64 1
  br i1 %1, label %return, label %loopbody

loopbody:                  ;preds = %L.entry, %loopbody
  %b = phi ptr [ %2, %loopbody ], [ @string, %L.entry ]
  %len_input = phi i128 [ %len, %loopbody ], [ %0, %L.entry ]
  %len = add nsw i128 %len_input, -1
  %2 = getelementptr i8, ptr %b, i64 1
  %3 = load i8, ptr %b, align 1
  store i8 %3, ptr %a, align 4
  %.not = icmp eq i128 %len, 0
  br i1 %.not, label %return, label %loopbody

return:                    ;preds = %loopexit, %L.entry
  ret void
}

define void @load_and_compare_only_used_by_assume(ptr %a, ptr noalias %b) {
; CHECK-LABEL: LV: Checking a loop in 'load_and_compare_only_used_by_assume'
; CHECK: LV(REG): VF = vscale x 4
; CHECK-NEXT: LV(REG): Found max usage: 2 item
; CHECK-NEXT: LV(REG): RegisterClass: Generic::ScalarRC, 3 registers
; CHECK-NEXT: LV(REG): RegisterClass: Generic::VectorRC, 1 registers
; CHECK-NEXT: LV(REG): Found invariant usage: 1 item

entry:
  br label %loop

loop:
  %iv = phi i64 [ 0, %entry ], [ %iv.next, %loop ]
  %gep.a = getelementptr inbounds i32, ptr %a, i64 %iv
  %l.a = load i32, ptr %gep.a
  %gep.b = getelementptr inbounds i32, ptr %b, i64 %iv
  %l.b = load i32, ptr %gep.b
  %c = icmp ugt i32 %l.b, 10
  call void @llvm.assume(i1 %c)
  store i32 %l.a, ptr %gep.b
  %iv.next = add i64 %iv, 1
  %ec = icmp eq i64 %iv.next, 1000
  br i1 %ec, label %exit, label %loop

exit:
  ret void
}

define dso_local void @dotp_high_register_pressure(ptr %a, ptr %b, ptr %sum, i32 %n) #1 {
; CHECK-LABEL: LV: Checking a loop in 'dotp_high_register_pressure' from <stdin>
; CHECK:       LV(REG): VF = 16
; CHECK-NEXT:  LV(REG): Found max usage: 2 item
; CHECK-NEXT:  LV(REG): RegisterClass: Generic::ScalarRC, 3 registers
; CHECK-NEXT:  LV(REG): RegisterClass: Generic::VectorRC, 47 registers
; CHECK-NEXT:  LV(REG): Found invariant usage: 1 item
entry:
  %cmp100 = icmp sgt i32 %n, 0
  br i1 %cmp100, label %for.body.lr.ph, label %for.cond.cleanup

for.body.lr.ph:                                   ; preds = %entry
  %arrayidx13 = getelementptr inbounds nuw i8, ptr %sum, i64 4
  %gep.b.12 = getelementptr inbounds nuw i8, ptr %sum, i64 8
  %arrayidx31 = getelementptr inbounds nuw i8, ptr %sum, i64 12
  %arrayidx40 = getelementptr inbounds nuw i8, ptr %sum, i64 16
  %arrayidx49 = getelementptr inbounds nuw i8, ptr %sum, i64 20
  %arrayidx58 = getelementptr inbounds nuw i8, ptr %sum, i64 24
  %arrayidx67 = getelementptr inbounds nuw i8, ptr %sum, i64 28
  %sum.promoted = load i32, ptr %sum, align 4
  %arrayidx13.promoted = load i32, ptr %arrayidx13, align 4
  %gep.b.12.promoted = load i32, ptr %gep.b.12, align 4
  %arrayidx31.promoted = load i32, ptr %arrayidx31, align 4
  %arrayidx40.promoted = load i32, ptr %arrayidx40, align 4
  %arrayidx49.promoted = load i32, ptr %arrayidx49, align 4
  %arrayidx58.promoted = load i32, ptr %arrayidx58, align 4
  %arrayidx67.promoted = load i32, ptr %arrayidx67, align 4
  %wide.trip.count = zext nneg i32 %n to i64
  br label %for.body

for.cond.for.cond.cleanup_crit_edge:              ; preds = %for.body
  %add.lcssa = phi i32 [ %add.1, %for.body ]
  %add.2.lcssa = phi i32 [ %add.2, %for.body ]
  %add.3.lcssa = phi i32 [ %add.3, %for.body ]
  %add.4.lcssa = phi i32 [ %add.4, %for.body ]
  %add.5.lcssa = phi i32 [ %add.5, %for.body ]
  %add.6.lcssa = phi i32 [ %add.6, %for.body ]
  %add.7.lcssa = phi i32 [ %add.7, %for.body ]
  %add.8.lcssa = phi i32 [ %add.8, %for.body ]
  store i32 %add.lcssa, ptr %sum, align 4
  store i32 %add.2.lcssa, ptr %arrayidx13, align 4
  store i32 %add.3.lcssa, ptr %gep.b.12, align 4
  store i32 %add.4.lcssa, ptr %arrayidx31, align 4
  store i32 %add.5.lcssa, ptr %arrayidx40, align 4
  store i32 %add.6.lcssa, ptr %arrayidx49, align 4
  store i32 %add.7.lcssa, ptr %arrayidx58, align 4
  store i32 %add.8.lcssa, ptr %arrayidx67, align 4
  br label %for.cond.cleanup

for.cond.cleanup:                                 ; preds = %for.cond.for.cond.cleanup_crit_edge, %entry
  ret void

for.body:                                         ; preds = %for.body.lr.ph, %for.body
  %indvars.iv = phi i64 [ 0, %for.body.lr.ph ], [ %indvars.iv.next, %for.body ]
  %0 = phi i32 [ %arrayidx67.promoted, %for.body.lr.ph ], [ %add.8, %for.body ]
  %1 = phi i32 [ %arrayidx58.promoted, %for.body.lr.ph ], [ %add.7, %for.body ]
  %2 = phi i32 [ %arrayidx49.promoted, %for.body.lr.ph ], [ %add.6, %for.body ]
  %3 = phi i32 [ %arrayidx40.promoted, %for.body.lr.ph ], [ %add.5, %for.body ]
  %4 = phi i32 [ %arrayidx31.promoted, %for.body.lr.ph ], [ %add.4, %for.body ]
  %5 = phi i32 [ %gep.b.12.promoted, %for.body.lr.ph ], [ %add.3, %for.body ]
  %6 = phi i32 [ %arrayidx13.promoted, %for.body.lr.ph ], [ %add.2, %for.body ]
  %7 = phi i32 [ %sum.promoted, %for.body.lr.ph ], [ %add.1, %for.body ]
  %arrayidx = getelementptr inbounds nuw i8, ptr %a, i64 %indvars.iv
  %load.a = load i8, ptr %arrayidx, align 1
  %ext.a = zext i8 %load.a to i32
  %9 = shl nsw i64 %indvars.iv, 3
  %gep.b.1 = getelementptr inbounds nuw i8, ptr %b, i64 %9
  %load.b.1 = load i8, ptr %gep.b.1, align 1
  %ext.b.1 = sext i8 %load.b.1 to i32
  %mul.1 = mul nsw i32 %ext.b.1, %ext.a
  %add.1 = add nsw i32 %mul.1, %7
  %11 = or disjoint i64 %9, 1
  %gep.b.2 = getelementptr inbounds nuw i8, ptr %b, i64 %11
  %load.b.2 = load i8, ptr %gep.b.2, align 1
  %ext.b.2 = sext i8 %load.b.2 to i32
  %mul.2 = mul nsw i32 %ext.b.2, %ext.a
  %add.2 = add nsw i32 %mul.2, %6
  %13 = or disjoint i64 %9, 2
  %gep.b.3 = getelementptr inbounds nuw i8, ptr %b, i64 %13
  %load.b.3 = load i8, ptr %gep.b.3, align 1
  %ext.b.3 = sext i8 %load.b.3 to i32
  %mul.3 = mul nsw i32 %ext.b.3, %ext.a
  %add.3 = add nsw i32 %mul.3, %5
  %15 = or disjoint i64 %9, 3
  %gep.b.4 = getelementptr inbounds nuw i8, ptr %b, i64 %15
  %load.b.4 = load i8, ptr %gep.b.4, align 1
  %ext.b.4 = sext i8 %load.b.4 to i32
  %mul.4 = mul nsw i32 %ext.b.4, %ext.a
  %add.4 = add nsw i32 %mul.4, %4
  %17 = or disjoint i64 %9, 4
  %gep.b.5 = getelementptr inbounds nuw i8, ptr %b, i64 %17
  %load.b.5 = load i8, ptr %gep.b.5, align 1
  %ext.b.5 = sext i8 %load.b.5 to i32
  %mul.5 = mul nsw i32 %ext.b.5, %ext.a
  %add.5 = add nsw i32 %mul.5, %3
  %19 = or disjoint i64 %9, 5
  %gep.b.6 = getelementptr inbounds nuw i8, ptr %b, i64 %19
  %load.b.6 = load i8, ptr %gep.b.6, align 1
  %ext.b.6 = sext i8 %load.b.6 to i32
  %mul.6 = mul nsw i32 %ext.b.6, %ext.a
  %add.6 = add nsw i32 %mul.6, %2
  %21 = or disjoint i64 %9, 6
  %gep.b.7 = getelementptr inbounds nuw i8, ptr %b, i64 %21
  %load.b.7 = load i8, ptr %gep.b.7, align 1
  %ext.b.7 = sext i8 %load.b.7 to i32
  %mul.7 = mul nsw i32 %ext.b.7, %ext.a
  %add.7 = add nsw i32 %mul.7, %1
  %23 = or disjoint i64 %9, 7
  %gep.b.8 = getelementptr inbounds nuw i8, ptr %b, i64 %23
  %load.b.8 = load i8, ptr %gep.b.8, align 1
  %ext.b.8 = sext i8 %load.b.8 to i32
  %mul.8 = mul nsw i32 %ext.b.8, %ext.a
  %add.8 = add nsw i32 %mul.8, %0
  %indvars.iv.next = add nuw nsw i64 %indvars.iv, 1
  %exitcond.not = icmp eq i64 %indvars.iv.next, %wide.trip.count
  br i1 %exitcond.not, label %for.cond.for.cond.cleanup_crit_edge, label %for.body
}

define i32 @dotp_unrolled(i32 %num_out, i64 %num_in, ptr %a, ptr %b) {
; CHECK-LABEL: LV: Checking a loop in 'dotp_unrolled' from <stdin>
; CHECK:       LV(REG): VF = 16
; CHECK-NEXT:  LV(REG): Found max usage: 2 item
; CHECK-NEXT:  LV(REG): RegisterClass: Generic::ScalarRC, 9 registers
; CHECK-NEXT:  LV(REG): RegisterClass: Generic::VectorRC, 6 registers
; CHECK-NEXT:  LV(REG): Found invariant usage: 1 item
entry:
  br label %for.body

for.body:                                    ; preds = %entry, %for.body
  %iv = phi i64 [ 0, %entry ], [ %iv.next, %for.body ]
  %accum3 = phi i32 [ 0, %entry ], [ %add.a3, %for.body ]
  %accum2 = phi i32 [ 0, %entry ], [ %add.a2, %for.body ]
  %accum1 = phi i32 [ 0, %entry ], [ %add.a1, %for.body ]
  %accum0 = phi i32 [ 0, %entry ], [ %add.a0, %for.body ]
  %gep.a0 = getelementptr inbounds i8, ptr %a, i64 %iv
  %gep.b0 = getelementptr inbounds i8, ptr %b, i64 %iv
  %offset.1 = or disjoint i64 %iv, 1
  %gep.a1 = getelementptr inbounds i8, ptr %a, i64 %offset.1
  %gep.b1 = getelementptr inbounds i8, ptr %b, i64 %offset.1
  %offset.2 = or disjoint i64 %iv, 2
  %gep.a2 = getelementptr inbounds i8, ptr %a, i64 %offset.2
  %gep.b2 = getelementptr inbounds i8, ptr %b, i64 %offset.2
  %offset.3 = or disjoint i64 %iv, 3
  %gep.a3 = getelementptr inbounds i8, ptr %a, i64 %offset.3
  %gep.b3 = getelementptr inbounds i8, ptr %b, i64 %offset.3
  %load.a0 = load i8, ptr %gep.a0, align 1
  %ext.a0 = sext i8 %load.a0 to i32
  %load.b0 = load i8, ptr %gep.b0, align 1
  %ext.b0 = sext i8 %load.b0 to i32
  %mul.a0 = mul nsw i32 %ext.b0, %ext.a0
  %add.a0 = add nsw i32 %mul.a0, %accum0
  %load.a1 = load i8, ptr %gep.a1, align 1
  %ext.a1 = sext i8 %load.a1 to i32
  %load.b1 = load i8, ptr %gep.b1, align 1
  %ext.b1 = sext i8 %load.b1 to i32
  %mul.a1 = mul nsw i32 %ext.a1, %ext.b1
  %add.a1 = add nsw i32 %mul.a1, %accum1
  %load.a2 = load i8, ptr %gep.a2, align 1
  %ext.a2 = sext i8 %load.a2 to i32
  %load.b2 = load i8, ptr %gep.b2, align 1
  %ext.b2 = sext i8 %load.b2 to i32
  %mul.a2 = mul nsw i32 %ext.a2, %ext.b2
  %add.a2 = add nsw i32 %mul.a2, %accum2
  %load.a3 = load i8, ptr %gep.a3, align 1
  %ext.a3 = sext i8 %load.a3 to i32
  %load.b3 = load i8, ptr %gep.b3, align 1
  %ext.b3 = sext i8 %load.b3 to i32
  %mul.a3 = mul nsw i32 %ext.a3, %ext.b3
  %add.a3 = add nsw i32 %mul.a3, %accum3
  %iv.next = add nuw nsw i64 %iv, 1
  %exitcond.not = icmp eq i64 %iv.next, %num_in
  br i1 %exitcond.not, label %exit, label %for.body

exit:                                        ; preds = %for.body
  %result0 = add nsw i32 %add.a0, %add.a1
  %result1 = add nsw i32 %add.a2, %add.a3
  %result = add nsw i32 %result0, %result1
  ret i32 %result
}

define i64 @loop_reduction_and_store_last_element(ptr %src, ptr writeonly %dst) {
; CHECK-LABEL: LV: Checking a loop in 'loop_reduction_and_store_last_element'
; CHECK:       LV(REG): VF = 16
; CHECK-NEXT:  LV(REG): Found max usage: 2 item
; CHECK-NEXT:  LV(REG): RegisterClass: Generic::ScalarRC, 2 registers
; CHECK-NEXT:  LV(REG): RegisterClass: Generic::VectorRC, 16 registers
; CHECK-NEXT:  LV(REG): Found invariant usage: 1 item
entry:
  br label %loop

loop:
  %iv = phi i32 [ 1, %entry ], [ %iv.next, %loop ]
  %red = phi i64 [ 0, %entry ], [ %red.next, %loop ]
  %ptr = phi ptr [ %src, %entry ], [ %ptr.next, %loop ]
  %iv.next = add nuw i32 %iv, 1
  %ptr.next = getelementptr i8, ptr %ptr, i64 1
  store ptr %ptr, ptr %dst, align 8
  %val = load i8, ptr %ptr, align 1
  %val.ext = zext i8 %val to i64
  %red.next = or i64 %red, %val.ext
  %ec = icmp eq i32 %iv.next, 1000
  br i1 %ec, label %exit, label %loop

exit:
  ret i64 %red.next
}