test/Analysis/ScalarEvolution/logical-operations.ll

; NOTE: Assertions have been autogenerated by utils/update_analyze_test_checks.py
; RUN: opt -passes='print<scalar-evolution>' < %s -disable-output 2>&1 | FileCheck %s

@constant = dso_local global i8 0, align 4
@another_constant = dso_local global i8 0, align 4

define i1 @binary_or.i1(i1 %x, i1 %y) {
; CHECK-LABEL: 'binary_or.i1'
; CHECK-NEXT:  Classifying expressions for: @binary_or.i1
; CHECK-NEXT:    %r = or i1 %x, %y
; CHECK-NEXT:    --> (%x umax %y) U: full-set S: full-set
; CHECK-NEXT:  Determining loop execution counts for: @binary_or.i1
;
  %r = or i1 %x, %y
  ret i1 %r
}

define i2 @binary_or.i2(i2 %x, i2 %y) {
; CHECK-LABEL: 'binary_or.i2'
; CHECK-NEXT:  Classifying expressions for: @binary_or.i2
; CHECK-NEXT:    %r = or i2 %x, %y
; CHECK-NEXT:    --> %r U: full-set S: full-set
; CHECK-NEXT:  Determining loop execution counts for: @binary_or.i2
;
  %r = or i2 %x, %y
  ret i2 %r
}

define i1 @binary_or.4ops.i1(i1 %x, i1 %y, i1 %z, i1 %a) {
; CHECK-LABEL: 'binary_or.4ops.i1'
; CHECK-NEXT:  Classifying expressions for: @binary_or.4ops.i1
; CHECK-NEXT:    %t0 = or i1 %x, %y
; CHECK-NEXT:    --> (%x umax %y) U: full-set S: full-set
; CHECK-NEXT:    %t1 = or i1 %z, %a
; CHECK-NEXT:    --> (%z umax %a) U: full-set S: full-set
; CHECK-NEXT:    %r = or i1 %t0, %t1
; CHECK-NEXT:    --> (%x umax %y umax %z umax %a) U: full-set S: full-set
; CHECK-NEXT:  Determining loop execution counts for: @binary_or.4ops.i1
;
  %t0 = or i1 %x, %y
  %t1 = or i1 %z, %a
  %r = or i1 %t0, %t1
  ret i1 %r
}

define i1 @binary_and.i1(i1 %x, i1 %y) {
; CHECK-LABEL: 'binary_and.i1'
; CHECK-NEXT:  Classifying expressions for: @binary_and.i1
; CHECK-NEXT:    %r = and i1 %x, %y
; CHECK-NEXT:    --> (%x umin %y) U: full-set S: full-set
; CHECK-NEXT:  Determining loop execution counts for: @binary_and.i1
;
  %r = and i1 %x, %y
  ret i1 %r
}

define i2 @binary_and.i2(i2 %x, i2 %y) {
; CHECK-LABEL: 'binary_and.i2'
; CHECK-NEXT:  Classifying expressions for: @binary_and.i2
; CHECK-NEXT:    %r = and i2 %x, %y
; CHECK-NEXT:    --> %r U: full-set S: full-set
; CHECK-NEXT:  Determining loop execution counts for: @binary_and.i2
;
  %r = and i2 %x, %y
  ret i2 %r
}

define i1 @binary_and.4ops.i1(i1 %x, i1 %y, i1 %z, i1 %a) {
; CHECK-LABEL: 'binary_and.4ops.i1'
; CHECK-NEXT:  Classifying expressions for: @binary_and.4ops.i1
; CHECK-NEXT:    %t0 = and i1 %x, %y
; CHECK-NEXT:    --> (%x umin %y) U: full-set S: full-set
; CHECK-NEXT:    %t1 = and i1 %z, %a
; CHECK-NEXT:    --> (%z umin %a) U: full-set S: full-set
; CHECK-NEXT:    %r = and i1 %t0, %t1
; CHECK-NEXT:    --> (%x umin %y umin %z umin %a) U: full-set S: full-set
; CHECK-NEXT:  Determining loop execution counts for: @binary_and.4ops.i1
;
  %t0 = and i1 %x, %y
  %t1 = and i1 %z, %a
  %r = and i1 %t0, %t1
  ret i1 %r
}

define i1 @binary_xor.i1(i1 %x, i1 %y) {
; CHECK-LABEL: 'binary_xor.i1'
; CHECK-NEXT:  Classifying expressions for: @binary_xor.i1
; CHECK-NEXT:    %r = xor i1 %x, %y
; CHECK-NEXT:    --> (%x + %y) U: full-set S: full-set
; CHECK-NEXT:  Determining loop execution counts for: @binary_xor.i1
;
  %r = xor i1 %x, %y
  ret i1 %r
}

define i2 @binary_xor.i2(i2 %x, i2 %y) {
; CHECK-LABEL: 'binary_xor.i2'
; CHECK-NEXT:  Classifying expressions for: @binary_xor.i2
; CHECK-NEXT:    %r = xor i2 %x, %y
; CHECK-NEXT:    --> %r U: full-set S: full-set
; CHECK-NEXT:  Determining loop execution counts for: @binary_xor.i2
;
  %r = xor i2 %x, %y
  ret i2 %r
}

define i1 @binary_xor.4ops.i1(i1 %x, i1 %y, i1 %z, i1 %a) {
; CHECK-LABEL: 'binary_xor.4ops.i1'
; CHECK-NEXT:  Classifying expressions for: @binary_xor.4ops.i1
; CHECK-NEXT:    %t0 = xor i1 %x, %y
; CHECK-NEXT:    --> (%x + %y) U: full-set S: full-set
; CHECK-NEXT:    %t1 = xor i1 %z, %a
; CHECK-NEXT:    --> (%z + %a) U: full-set S: full-set
; CHECK-NEXT:    %r = xor i1 %t0, %t1
; CHECK-NEXT:    --> (%x + %y + %z + %a) U: full-set S: full-set
; CHECK-NEXT:  Determining loop execution counts for: @binary_xor.4ops.i1
;
  %t0 = xor i1 %x, %y
  %t1 = xor i1 %z, %a
  %r = xor i1 %t0, %t1
  ret i1 %r
}

define i1 @logical_or(i1 %x, i1 %y) {
; CHECK-LABEL: 'logical_or'
; CHECK-NEXT:  Classifying expressions for: @logical_or
; CHECK-NEXT:    %r = select i1 %x, i1 true, i1 %y
; CHECK-NEXT:    --> (true + ((true + %x) umin_seq (true + %y))) U: full-set S: full-set
; CHECK-NEXT:  Determining loop execution counts for: @logical_or
;
  %r = select i1 %x, i1 true, i1 %y
  ret i1 %r
}

define i1 @logical_and(i1 %x, i1 %y) {
; CHECK-LABEL: 'logical_and'
; CHECK-NEXT:  Classifying expressions for: @logical_and
; CHECK-NEXT:    %r = select i1 %x, i1 %y, i1 false
; CHECK-NEXT:    --> (%x umin_seq %y) U: full-set S: full-set
; CHECK-NEXT:  Determining loop execution counts for: @logical_and
;
  %r = select i1 %x, i1 %y, i1 false
  ret i1 %r
}

define i1 @select_x_or_false(i1 %c, i1 %x) {
; CHECK-LABEL: 'select_x_or_false'
; CHECK-NEXT:  Classifying expressions for: @select_x_or_false
; CHECK-NEXT:    %r = select i1 %c, i1 %x, i1 false
; CHECK-NEXT:    --> (%c umin_seq %x) U: full-set S: full-set
; CHECK-NEXT:  Determining loop execution counts for: @select_x_or_false
;
  %r = select i1 %c, i1 %x, i1 false
  ret i1 %r
}

define i1 @select_false_or_x(i1 %c, i1 %x) {
; CHECK-LABEL: 'select_false_or_x'
; CHECK-NEXT:  Classifying expressions for: @select_false_or_x
; CHECK-NEXT:    %r = select i1 %c, i1 false, i1 %x
; CHECK-NEXT:    --> ((true + %c) umin_seq %x) U: full-set S: full-set
; CHECK-NEXT:  Determining loop execution counts for: @select_false_or_x
;
  %r = select i1 %c, i1 false, i1 %x
  ret i1 %r
}

define i1 @select_x_or_true(i1 %c, i1 %x) {
; CHECK-LABEL: 'select_x_or_true'
; CHECK-NEXT:  Classifying expressions for: @select_x_or_true
; CHECK-NEXT:    %r = select i1 %c, i1 %x, i1 true
; CHECK-NEXT:    --> (true + (%c umin_seq (true + %x))) U: full-set S: full-set
; CHECK-NEXT:  Determining loop execution counts for: @select_x_or_true
;
  %r = select i1 %c, i1 %x, i1 true
  ret i1 %r
}

define i1 @select_true_or_x(i1 %c, i1 %x) {
; CHECK-LABEL: 'select_true_or_x'
; CHECK-NEXT:  Classifying expressions for: @select_true_or_x
; CHECK-NEXT:    %r = select i1 %c, i1 true, i1 %x
; CHECK-NEXT:    --> (true + ((true + %c) umin_seq (true + %x))) U: full-set S: full-set
; CHECK-NEXT:  Determining loop execution counts for: @select_true_or_x
;
  %r = select i1 %c, i1 true, i1 %x
  ret i1 %r
}

define i32 @select_x_or_zero(i1 %c, i32 %x) {
; CHECK-LABEL: 'select_x_or_zero'
; CHECK-NEXT:  Classifying expressions for: @select_x_or_zero
; CHECK-NEXT:    %r = select i1 %c, i32 %x, i32 0
; CHECK-NEXT:    --> %r U: full-set S: full-set
; CHECK-NEXT:  Determining loop execution counts for: @select_x_or_zero
;
  %r = select i1 %c, i32 %x, i32 0
  ret i32 %r
}

define i32 @select_zero_or_x(i1 %c, i32 %x) {
; CHECK-LABEL: 'select_zero_or_x'
; CHECK-NEXT:  Classifying expressions for: @select_zero_or_x
; CHECK-NEXT:    %r = select i1 %c, i32 0, i32 %x
; CHECK-NEXT:    --> %r U: full-set S: full-set
; CHECK-NEXT:  Determining loop execution counts for: @select_zero_or_x
;
  %r = select i1 %c, i32 0, i32 %x
  ret i32 %r
}

define i32 @select_x_or_allones(i1 %c, i32 %x) {
; CHECK-LABEL: 'select_x_or_allones'
; CHECK-NEXT:  Classifying expressions for: @select_x_or_allones
; CHECK-NEXT:    %r = select i1 %c, i32 %x, i32 -1
; CHECK-NEXT:    --> %r U: full-set S: full-set
; CHECK-NEXT:  Determining loop execution counts for: @select_x_or_allones
;
  %r = select i1 %c, i32 %x, i32 -1
  ret i32 %r
}

define i32 @select_allones_or_x(i1 %c, i32 %x) {
; CHECK-LABEL: 'select_allones_or_x'
; CHECK-NEXT:  Classifying expressions for: @select_allones_or_x
; CHECK-NEXT:    %r = select i1 %c, i32 -1, i32 %x
; CHECK-NEXT:    --> %r U: full-set S: full-set
; CHECK-NEXT:  Determining loop execution counts for: @select_allones_or_x
;
  %r = select i1 %c, i32 -1, i32 %x
  ret i32 %r
}

define i32 @select_x_or_intmax(i1 %c, i32 %x) {
; CHECK-LABEL: 'select_x_or_intmax'
; CHECK-NEXT:  Classifying expressions for: @select_x_or_intmax
; CHECK-NEXT:    %r = select i1 %c, i32 %x, i32 2147483647
; CHECK-NEXT:    --> %r U: full-set S: full-set
; CHECK-NEXT:  Determining loop execution counts for: @select_x_or_intmax
;
  %r = select i1 %c, i32 %x, i32 2147483647
  ret i32 %r
}

define i32 @select_intmax_or_x(i1 %c, i32 %x) {
; CHECK-LABEL: 'select_intmax_or_x'
; CHECK-NEXT:  Classifying expressions for: @select_intmax_or_x
; CHECK-NEXT:    %r = select i1 %c, i32 2147483647, i32 %x
; CHECK-NEXT:    --> %r U: full-set S: full-set
; CHECK-NEXT:  Determining loop execution counts for: @select_intmax_or_x
;
  %r = select i1 %c, i32 2147483647, i32 %x
  ret i32 %r
}

define i32 @select_x_or_intmin(i1 %c, i32 %x) {
; CHECK-LABEL: 'select_x_or_intmin'
; CHECK-NEXT:  Classifying expressions for: @select_x_or_intmin
; CHECK-NEXT:    %r = select i1 %c, i32 %x, i32 -2147483648
; CHECK-NEXT:    --> %r U: full-set S: full-set
; CHECK-NEXT:  Determining loop execution counts for: @select_x_or_intmin
;
  %r = select i1 %c, i32 %x, i32 -2147483648
  ret i32 %r
}

define i32 @select_intmin_or_x(i1 %c, i32 %x) {
; CHECK-LABEL: 'select_intmin_or_x'
; CHECK-NEXT:  Classifying expressions for: @select_intmin_or_x
; CHECK-NEXT:    %r = select i1 %c, i32 -2147483648, i32 %x
; CHECK-NEXT:    --> %r U: full-set S: full-set
; CHECK-NEXT:  Determining loop execution counts for: @select_intmin_or_x
;
  %r = select i1 %c, i32 -2147483648, i32 %x
  ret i32 %r
}

define i32 @select_x_or_constant(i1 %c, i32 %x) {
; CHECK-LABEL: 'select_x_or_constant'
; CHECK-NEXT:  Classifying expressions for: @select_x_or_constant
; CHECK-NEXT:    %r = select i1 %c, i32 %x, i32 42
; CHECK-NEXT:    --> %r U: full-set S: full-set
; CHECK-NEXT:  Determining loop execution counts for: @select_x_or_constant
;
  %r = select i1 %c, i32 %x, i32 42
  ret i32 %r
}

define i32 @select_constant_or_x(i1 %c, i32 %y) {
; CHECK-LABEL: 'select_constant_or_x'
; CHECK-NEXT:  Classifying expressions for: @select_constant_or_x
; CHECK-NEXT:    %r = select i1 %c, i32 42, i32 %y
; CHECK-NEXT:    --> %r U: full-set S: full-set
; CHECK-NEXT:  Determining loop execution counts for: @select_constant_or_x
;
  %r = select i1 %c, i32 42, i32 %y
  ret i32 %r
}

define i32 @select_between_constants(i1 %c, i32 %y) {
; CHECK-LABEL: 'select_between_constants'
; CHECK-NEXT:  Classifying expressions for: @select_between_constants
; CHECK-NEXT:    %r = select i1 %c, i32 42, i32 24
; CHECK-NEXT:    --> %r U: [8,59) S: [8,59)
; CHECK-NEXT:  Determining loop execution counts for: @select_between_constants
;
  %r = select i1 %c, i32 42, i32 24
  ret i32 %r
}

define i32 @select_x_or_y(i1 %c, i32 %x, i32 %y) {
; CHECK-LABEL: 'select_x_or_y'
; CHECK-NEXT:  Classifying expressions for: @select_x_or_y
; CHECK-NEXT:    %r = select i1 %c, i32 %x, i32 %y
; CHECK-NEXT:    --> %r U: full-set S: full-set
; CHECK-NEXT:  Determining loop execution counts for: @select_x_or_y
;
  %r = select i1 %c, i32 %x, i32 %y
  ret i32 %r
}

define i32 @select_x_or_y__noundef(i1 %c, i32 noundef %x, i32 noundef %y) {
; CHECK-LABEL: 'select_x_or_y__noundef'
; CHECK-NEXT:  Classifying expressions for: @select_x_or_y__noundef
; CHECK-NEXT:    %r = select i1 %c, i32 %x, i32 %y
; CHECK-NEXT:    --> %r U: full-set S: full-set
; CHECK-NEXT:  Determining loop execution counts for: @select_x_or_y__noundef
;
  %r = select i1 %c, i32 %x, i32 %y
  ret i32 %r
}

define i32 @select_x_or_constantexpr(i1 %c, i32 %x) {
; CHECK-LABEL: 'select_x_or_constantexpr'
; CHECK-NEXT:  Classifying expressions for: @select_x_or_constantexpr
; CHECK-NEXT:    %r = select i1 %c, i32 %x, i32 ptrtoint (i8* @constant to i32)
; CHECK-NEXT:    --> %r U: full-set S: full-set
; CHECK-NEXT:  Determining loop execution counts for: @select_x_or_constantexpr
;
  %r = select i1 %c, i32 %x, i32 ptrtoint (i8* @constant to i32)
  ret i32 %r
}

define i32 @select_constantexpr_or_x(i1 %c, i32 %x) {
; CHECK-LABEL: 'select_constantexpr_or_x'
; CHECK-NEXT:  Classifying expressions for: @select_constantexpr_or_x
; CHECK-NEXT:    %r = select i1 %c, i32 ptrtoint (i8* @constant to i32), i32 %x
; CHECK-NEXT:    --> %r U: full-set S: full-set
; CHECK-NEXT:  Determining loop execution counts for: @select_constantexpr_or_x
;
  %r = select i1 %c, i32 ptrtoint (i8* @constant to i32), i32 %x
  ret i32 %r
}

define i8* @select_x_or_nullptr(i1 %c, i8* %x) {
; CHECK-LABEL: 'select_x_or_nullptr'
; CHECK-NEXT:  Classifying expressions for: @select_x_or_nullptr
; CHECK-NEXT:    %r = select i1 %c, i8* %x, i8* null
; CHECK-NEXT:    --> %r U: full-set S: full-set
; CHECK-NEXT:  Determining loop execution counts for: @select_x_or_nullptr
;
  %r = select i1 %c, i8* %x, i8* null
  ret i8* %r
}

define i8* @select_null_or_x(i1 %c, i8* %x) {
; CHECK-LABEL: 'select_null_or_x'
; CHECK-NEXT:  Classifying expressions for: @select_null_or_x
; CHECK-NEXT:    %r = select i1 %c, i8* null, i8* %x
; CHECK-NEXT:    --> %r U: full-set S: full-set
; CHECK-NEXT:  Determining loop execution counts for: @select_null_or_x
;
  %r = select i1 %c, i8* null, i8* %x
  ret i8* %r
}

define i8* @select_x_or_constantptr(i1 %c, i8* %x) {
; CHECK-LABEL: 'select_x_or_constantptr'
; CHECK-NEXT:  Classifying expressions for: @select_x_or_constantptr
; CHECK-NEXT:    %r = select i1 %c, i8* %x, i8* @constant
; CHECK-NEXT:    --> %r U: full-set S: full-set
; CHECK-NEXT:  Determining loop execution counts for: @select_x_or_constantptr
;
  %r = select i1 %c, i8* %x, i8* @constant
  ret i8* %r
}

define i8* @select_constantptr_or_x(i1 %c, i8* %x) {
; CHECK-LABEL: 'select_constantptr_or_x'
; CHECK-NEXT:  Classifying expressions for: @select_constantptr_or_x
; CHECK-NEXT:    %r = select i1 %c, i8* @constant, i8* %x
; CHECK-NEXT:    --> %r U: full-set S: full-set
; CHECK-NEXT:  Determining loop execution counts for: @select_constantptr_or_x
;
  %r = select i1 %c, i8* @constant, i8* %x
  ret i8* %r
}

define i8* @select_between_constantptrs(i1 %c, i8* %x) {
; CHECK-LABEL: 'select_between_constantptrs'
; CHECK-NEXT:  Classifying expressions for: @select_between_constantptrs
; CHECK-NEXT:    %r = select i1 %c, i8* @constant, i8* @another_constant
; CHECK-NEXT:    --> %r U: [0,-3) S: [-9223372036854775808,9223372036854775805)
; CHECK-NEXT:  Determining loop execution counts for: @select_between_constantptrs
;
  %r = select i1 %c, i8* @constant, i8* @another_constant
  ret i8* %r
}

define i8* @tautological_select() {
; CHECK-LABEL: 'tautological_select'
; CHECK-NEXT:  Classifying expressions for: @tautological_select
; CHECK-NEXT:    %r = getelementptr i8, i8* @constant, i32 0
; CHECK-NEXT:    --> @constant U: [0,-3) S: [-9223372036854775808,9223372036854775805)
; CHECK-NEXT:  Determining loop execution counts for: @tautological_select
;
  %r = getelementptr i8, i8* select (i1 true, i8* @constant, i8* @another_constant), i32 0
  ret i8* %r
}

define i8* @tautological_select_like_phi(i32 %tc) {
; CHECK-LABEL: 'tautological_select_like_phi'
; CHECK-NEXT:  Classifying expressions for: @tautological_select_like_phi
; CHECK-NEXT:    %iv = phi i32 [ 0, %entry ], [ %iv.next, %latch ]
; CHECK-NEXT:    --> {0,+,1}<%loop> U: [0,101) S: [0,101) Exits: 100 LoopDispositions: { %loop: Computable }
; CHECK-NEXT:    %r = phi i8* [ @constant, %truebb ], [ @another_constant, %falsebb ]
; CHECK-NEXT:    --> %r U: [0,-3) S: [-9223372036854775808,9223372036854775805) Exits: <<Unknown>> LoopDispositions: { %loop: Variant }
; CHECK-NEXT:    %iv.next = add i32 %iv, 1
; CHECK-NEXT:    --> {1,+,1}<%loop> U: [1,102) S: [1,102) Exits: 101 LoopDispositions: { %loop: Computable }
; CHECK-NEXT:  Determining loop execution counts for: @tautological_select_like_phi
; CHECK-NEXT:  Loop %loop: backedge-taken count is 100
; CHECK-NEXT:  Loop %loop: max backedge-taken count is 100
; CHECK-NEXT:  Loop %loop: Predicated backedge-taken count is 100
; CHECK-NEXT:   Predicates:
; CHECK:       Loop %loop: Trip multiple is 101
;
entry:
  br label %loop

loop:
  %iv = phi i32[ 0, %entry ], [ %iv.next, %latch ]
  br i1 true, label %truebb, label %falsebb

truebb:
  br label %latch

falsebb:
  br label %latch

latch:
  %r = phi i8* [ @constant, %truebb], [ @another_constant, %falsebb]
  %iv.next = add i32 %iv, 1
  %done = icmp eq i32 %iv, 100
  br i1 %done, label %end, label %loop

end:
  ret i8* %r
}

define i32 @umin_seq_x_y(i32 %x, i32 %y) {
; CHECK-LABEL: 'umin_seq_x_y'
; CHECK-NEXT:  Classifying expressions for: @umin_seq_x_y
; CHECK-NEXT:    %umin = call i32 @llvm.umin.i32(i32 %y, i32 %x)
; CHECK-NEXT:    --> (%x umin %y) U: full-set S: full-set
; CHECK-NEXT:    %r = select i1 %x.is.zero, i32 0, i32 %umin
; CHECK-NEXT:    --> (%x umin_seq %y) U: full-set S: full-set
; CHECK-NEXT:  Determining loop execution counts for: @umin_seq_x_y
;
  %umin = call i32 @llvm.umin(i32 %y, i32 %x)
  %x.is.zero = icmp eq i32 %x, 0
  %r = select i1 %x.is.zero, i32 0, i32 %umin
  ret i32 %r
}

define i32 @umin_seq_x_y_tautological(i32 %x, i32 %y) {
; CHECK-LABEL: 'umin_seq_x_y_tautological'
; CHECK-NEXT:  Classifying expressions for: @umin_seq_x_y_tautological
; CHECK-NEXT:    %umin = call i32 @llvm.umin.i32(i32 %y, i32 %x)
; CHECK-NEXT:    --> (%x umin %y) U: full-set S: full-set
; CHECK-NEXT:    %r = select i1 %umin.is.zero, i32 0, i32 %umin
; CHECK-NEXT:    --> (%x umin %y) U: full-set S: full-set
; CHECK-NEXT:  Determining loop execution counts for: @umin_seq_x_y_tautological
;
  %umin = call i32 @llvm.umin(i32 %y, i32 %x)
  %umin.is.zero = icmp eq i32 %umin, 0
  %r = select i1 %umin.is.zero, i32 0, i32 %umin
  ret i32 %r
}
define i32 @umin_seq_x_y_tautological_wrongtype(i32 %x, i32 %y) {
; CHECK-LABEL: 'umin_seq_x_y_tautological_wrongtype'
; CHECK-NEXT:  Classifying expressions for: @umin_seq_x_y_tautological_wrongtype
; CHECK-NEXT:    %umax = call i32 @llvm.umax.i32(i32 %y, i32 %x)
; CHECK-NEXT:    --> (%x umax %y) U: full-set S: full-set
; CHECK-NEXT:    %r = select i1 %umax.is.zero, i32 0, i32 %umax
; CHECK-NEXT:    --> (%x umax %y) U: full-set S: full-set
; CHECK-NEXT:  Determining loop execution counts for: @umin_seq_x_y_tautological_wrongtype
;
  %umax = call i32 @llvm.umax(i32 %y, i32 %x)
  %umax.is.zero = icmp eq i32 %umax, 0
  %r = select i1 %umax.is.zero, i32 0, i32 %umax
  ret i32 %r
}

define i32 @umin_seq_x_y_wrongtype0(i32 %x, i32 %y) {
; CHECK-LABEL: 'umin_seq_x_y_wrongtype0'
; CHECK-NEXT:  Classifying expressions for: @umin_seq_x_y_wrongtype0
; CHECK-NEXT:    %umax = call i32 @llvm.umax.i32(i32 %y, i32 %x)
; CHECK-NEXT:    --> (%x umax %y) U: full-set S: full-set
; CHECK-NEXT:    %r = select i1 %x.is.zero, i32 0, i32 %umax
; CHECK-NEXT:    --> %r U: full-set S: full-set
; CHECK-NEXT:  Determining loop execution counts for: @umin_seq_x_y_wrongtype0
;
  %umax = call i32 @llvm.umax(i32 %y, i32 %x)
  %x.is.zero = icmp eq i32 %x, 0
  %r = select i1 %x.is.zero, i32 0, i32 %umax
  ret i32 %r
}
define i32 @umin_seq_x_y_wrongtype1(i32 %x, i32 %y) {
; CHECK-LABEL: 'umin_seq_x_y_wrongtype1'
; CHECK-NEXT:  Classifying expressions for: @umin_seq_x_y_wrongtype1
; CHECK-NEXT:    %smax = call i32 @llvm.smax.i32(i32 %y, i32 %x)
; CHECK-NEXT:    --> (%x smax %y) U: full-set S: full-set
; CHECK-NEXT:    %r = select i1 %x.is.zero, i32 0, i32 %smax
; CHECK-NEXT:    --> %r U: full-set S: full-set
; CHECK-NEXT:  Determining loop execution counts for: @umin_seq_x_y_wrongtype1
;
  %smax = call i32 @llvm.smax(i32 %y, i32 %x)
  %x.is.zero = icmp eq i32 %x, 0
  %r = select i1 %x.is.zero, i32 0, i32 %smax
  ret i32 %r
}
define i32 @umin_seq_x_y_wrongtype2(i32 %x, i32 %y) {
; CHECK-LABEL: 'umin_seq_x_y_wrongtype2'
; CHECK-NEXT:  Classifying expressions for: @umin_seq_x_y_wrongtype2
; CHECK-NEXT:    %smin = call i32 @llvm.smin.i32(i32 %y, i32 %x)
; CHECK-NEXT:    --> (%x smin %y) U: full-set S: full-set
; CHECK-NEXT:    %r = select i1 %x.is.zero, i32 0, i32 %smin
; CHECK-NEXT:    --> %r U: full-set S: full-set
; CHECK-NEXT:  Determining loop execution counts for: @umin_seq_x_y_wrongtype2
;
  %smin = call i32 @llvm.smin(i32 %y, i32 %x)
  %x.is.zero = icmp eq i32 %x, 0
  %r = select i1 %x.is.zero, i32 0, i32 %smin
  ret i32 %r
}

define i32 @umin_seq_x_y_wrongtype3(i32 %x, i32 %y, i32 %z) {
; CHECK-LABEL: 'umin_seq_x_y_wrongtype3'
; CHECK-NEXT:  Classifying expressions for: @umin_seq_x_y_wrongtype3
; CHECK-NEXT:    %umax = call i32 @llvm.umax.i32(i32 %x, i32 %z)
; CHECK-NEXT:    --> (%x umax %z) U: full-set S: full-set
; CHECK-NEXT:    %umin = call i32 @llvm.umin.i32(i32 %umax, i32 %y)
; CHECK-NEXT:    --> ((%x umax %z) umin %y) U: full-set S: full-set
; CHECK-NEXT:    %r = select i1 %x.is.zero, i32 0, i32 %umin
; CHECK-NEXT:    --> %r U: full-set S: full-set
; CHECK-NEXT:  Determining loop execution counts for: @umin_seq_x_y_wrongtype3
;
  %umax = call i32 @llvm.umax(i32 %x, i32 %z)
  %umin = call i32 @llvm.umin(i32 %umax, i32 %y)
  %x.is.zero = icmp eq i32 %x, 0
  %r = select i1 %x.is.zero, i32 0, i32 %umin
  ret i32 %r
}

define i32 @umin_seq_y_x(i32 %x, i32 %y) {
; CHECK-LABEL: 'umin_seq_y_x'
; CHECK-NEXT:  Classifying expressions for: @umin_seq_y_x
; CHECK-NEXT:    %umin = call i32 @llvm.umin.i32(i32 %x, i32 %y)
; CHECK-NEXT:    --> (%x umin %y) U: full-set S: full-set
; CHECK-NEXT:    %r = select i1 %x.is.zero, i32 0, i32 %umin
; CHECK-NEXT:    --> (%y umin_seq %x) U: full-set S: full-set
; CHECK-NEXT:  Determining loop execution counts for: @umin_seq_y_x
;
  %umin = call i32 @llvm.umin(i32 %x, i32 %y)
  %x.is.zero = icmp eq i32 %y, 0
  %r = select i1 %x.is.zero, i32 0, i32 %umin
  ret i32 %r
}

define i32 @umin_seq_x_x_y_z(i32 %x, i32 %y, i32 %z) {
; CHECK-LABEL: 'umin_seq_x_x_y_z'
; CHECK-NEXT:  Classifying expressions for: @umin_seq_x_x_y_z
; CHECK-NEXT:    %umin0 = call i32 @llvm.umin.i32(i32 %z, i32 %x)
; CHECK-NEXT:    --> (%x umin %z) U: full-set S: full-set
; CHECK-NEXT:    %umin = call i32 @llvm.umin.i32(i32 %umin0, i32 %y)
; CHECK-NEXT:    --> (%x umin %y umin %z) U: full-set S: full-set
; CHECK-NEXT:    %r0 = select i1 %x.is.zero, i32 0, i32 %umin
; CHECK-NEXT:    --> (%x umin_seq (%y umin %z)) U: full-set S: full-set
; CHECK-NEXT:    %r = select i1 %x.is.zero, i32 0, i32 %r0
; CHECK-NEXT:    --> (%x umin_seq (%y umin %z)) U: full-set S: full-set
; CHECK-NEXT:  Determining loop execution counts for: @umin_seq_x_x_y_z
;
  %umin0 = call i32 @llvm.umin(i32 %z, i32 %x)
  %umin = call i32 @llvm.umin(i32 %umin0, i32 %y)
  %x.is.zero = icmp eq i32 %x, 0
  %r0 = select i1 %x.is.zero, i32 0, i32 %umin
  %r = select i1 %x.is.zero, i32 0, i32 %r0
  ret i32 %r
}

define i32 @umin_seq_x_y_z(i32 %x, i32 %y, i32 %z) {
; CHECK-LABEL: 'umin_seq_x_y_z'
; CHECK-NEXT:  Classifying expressions for: @umin_seq_x_y_z
; CHECK-NEXT:    %umin0 = call i32 @llvm.umin.i32(i32 %z, i32 %x)
; CHECK-NEXT:    --> (%x umin %z) U: full-set S: full-set
; CHECK-NEXT:    %umin = call i32 @llvm.umin.i32(i32 %umin0, i32 %y)
; CHECK-NEXT:    --> (%x umin %y umin %z) U: full-set S: full-set
; CHECK-NEXT:    %r0 = select i1 %y.is.zero, i32 0, i32 %umin
; CHECK-NEXT:    --> (%y umin_seq (%x umin %z)) U: full-set S: full-set
; CHECK-NEXT:    %r = select i1 %x.is.zero, i32 0, i32 %r0
; CHECK-NEXT:    --> (%x umin_seq %y umin_seq %z) U: full-set S: full-set
; CHECK-NEXT:  Determining loop execution counts for: @umin_seq_x_y_z
;
  %umin0 = call i32 @llvm.umin(i32 %z, i32 %x)
  %umin = call i32 @llvm.umin(i32 %umin0, i32 %y)
  %x.is.zero = icmp eq i32 %x, 0
  %y.is.zero = icmp eq i32 %y, 0
  %r0 = select i1 %y.is.zero, i32 0, i32 %umin
  %r = select i1 %x.is.zero, i32 0, i32 %r0
  ret i32 %r
}

define i32 @umin_seq_a_b_c_d(i32 %a, i32 %b, i32 %c, i32 %d) {
; CHECK-LABEL: 'umin_seq_a_b_c_d'
; CHECK-NEXT:  Classifying expressions for: @umin_seq_a_b_c_d
; CHECK-NEXT:    %umin1 = call i32 @llvm.umin.i32(i32 %c, i32 %d)
; CHECK-NEXT:    --> (%c umin %d) U: full-set S: full-set
; CHECK-NEXT:    %r1 = select i1 %c.is.zero, i32 0, i32 %umin1
; CHECK-NEXT:    --> (%c umin_seq %d) U: full-set S: full-set
; CHECK-NEXT:    %umin0 = call i32 @llvm.umin.i32(i32 %a, i32 %b)
; CHECK-NEXT:    --> (%a umin %b) U: full-set S: full-set
; CHECK-NEXT:    %umin = call i32 @llvm.umin.i32(i32 %umin0, i32 %r1)
; CHECK-NEXT:    --> ((%c umin_seq %d) umin %a umin %b) U: full-set S: full-set
; CHECK-NEXT:    %r = select i1 %d.is.zero, i32 0, i32 %umin
; CHECK-NEXT:    --> (%d umin_seq (%a umin %b umin %c)) U: full-set S: full-set
; CHECK-NEXT:  Determining loop execution counts for: @umin_seq_a_b_c_d
;
  %umin1 = call i32 @llvm.umin(i32 %c, i32 %d)
  %c.is.zero = icmp eq i32 %c, 0
  %r1 = select i1 %c.is.zero, i32 0, i32 %umin1

  %umin0 = call i32 @llvm.umin(i32 %a, i32 %b)
  %umin = call i32 @llvm.umin(i32 %umin0, i32 %r1)
  %d.is.zero = icmp eq i32 %d, 0
  %r = select i1 %d.is.zero, i32 0, i32 %umin
  ret i32 %r
}

define i32 @umin_seq_x_y_zext_both(i8 %x.narrow, i32 %y) {
; CHECK-LABEL: 'umin_seq_x_y_zext_both'
; CHECK-NEXT:  Classifying expressions for: @umin_seq_x_y_zext_both
; CHECK-NEXT:    %x = zext i8 %x.narrow to i32
; CHECK-NEXT:    --> (zext i8 %x.narrow to i32) U: [0,256) S: [0,256)
; CHECK-NEXT:    %umin = call i32 @llvm.umin.i32(i32 %y, i32 %x)
; CHECK-NEXT:    --> ((zext i8 %x.narrow to i32) umin %y) U: [0,256) S: [0,256)
; CHECK-NEXT:    %r = select i1 %x.is.zero, i32 0, i32 %umin
; CHECK-NEXT:    --> ((zext i8 %x.narrow to i32) umin_seq %y) U: [0,256) S: [0,256)
; CHECK-NEXT:  Determining loop execution counts for: @umin_seq_x_y_zext_both
;
  %x = zext i8 %x.narrow to i32
  %umin = call i32 @llvm.umin(i32 %y, i32 %x)
  %x.is.zero = icmp eq i32 %x, 0
  %r = select i1 %x.is.zero, i32 0, i32 %umin
  ret i32 %r
}

define i32 @umin_seq_x_y_zext_in_umin(i8 %x.narrow, i32 %y) {
; CHECK-LABEL: 'umin_seq_x_y_zext_in_umin'
; CHECK-NEXT:  Classifying expressions for: @umin_seq_x_y_zext_in_umin
; CHECK-NEXT:    %x = zext i8 %x.narrow to i32
; CHECK-NEXT:    --> (zext i8 %x.narrow to i32) U: [0,256) S: [0,256)
; CHECK-NEXT:    %umin = call i32 @llvm.umin.i32(i32 %y, i32 %x)
; CHECK-NEXT:    --> ((zext i8 %x.narrow to i32) umin %y) U: [0,256) S: [0,256)
; CHECK-NEXT:    %r = select i1 %x.is.zero, i32 0, i32 %umin
; CHECK-NEXT:    --> ((zext i8 %x.narrow to i32) umin_seq %y) U: [0,256) S: [0,256)
; CHECK-NEXT:  Determining loop execution counts for: @umin_seq_x_y_zext_in_umin
;
  %x = zext i8 %x.narrow to i32
  %umin = call i32 @llvm.umin(i32 %y, i32 %x)
  %x.is.zero = icmp eq i8 %x.narrow, 0
  %r = select i1 %x.is.zero, i32 0, i32 %umin
  ret i32 %r
}

define i8 @umin_seq_x_y_zext_in_iszero(i8 %x, i8 %y) {
; CHECK-LABEL: 'umin_seq_x_y_zext_in_iszero'
; CHECK-NEXT:  Classifying expressions for: @umin_seq_x_y_zext_in_iszero
; CHECK-NEXT:    %x.wide = zext i8 %x to i32
; CHECK-NEXT:    --> (zext i8 %x to i32) U: [0,256) S: [0,256)
; CHECK-NEXT:    %umin = call i8 @llvm.umin.i8(i8 %y, i8 %x)
; CHECK-NEXT:    --> (%x umin %y) U: full-set S: full-set
; CHECK-NEXT:    %r = select i1 %x.is.zero, i8 0, i8 %umin
; CHECK-NEXT:    --> (%x umin_seq %y) U: full-set S: full-set
; CHECK-NEXT:  Determining loop execution counts for: @umin_seq_x_y_zext_in_iszero
;
  %x.wide = zext i8 %x to i32
  %umin = call i8 @llvm.umin.i8(i8 %y, i8 %x)
  %x.is.zero = icmp eq i32 %x.wide, 0
  %r = select i1 %x.is.zero, i8 0, i8 %umin
  ret i8 %r
}

define i32 @umin_seq_x_y_zext_of_umin(i8 %x, i8 %y) {
; CHECK-LABEL: 'umin_seq_x_y_zext_of_umin'
; CHECK-NEXT:  Classifying expressions for: @umin_seq_x_y_zext_of_umin
; CHECK-NEXT:    %umin.narrow = call i8 @llvm.umin.i8(i8 %y, i8 %x)
; CHECK-NEXT:    --> (%x umin %y) U: full-set S: full-set
; CHECK-NEXT:    %umin = zext i8 %umin.narrow to i32
; CHECK-NEXT:    --> (zext i8 (%x umin %y) to i32) U: [0,256) S: [0,256)
; CHECK-NEXT:    %r = select i1 %x.is.zero, i32 0, i32 %umin
; CHECK-NEXT:    --> ((zext i8 %x to i32) umin_seq (zext i8 (%x umin %y) to i32)) U: [0,256) S: [0,256)
; CHECK-NEXT:  Determining loop execution counts for: @umin_seq_x_y_zext_of_umin
;
  %umin.narrow = call i8 @llvm.umin.i8(i8 %y, i8 %x)
  %umin = zext i8 %umin.narrow to i32
  %x.is.zero = icmp eq i8 %x, 0
  %r = select i1 %x.is.zero, i32 0, i32 %umin
  ret i32 %r
}

define i32 @umin_seq_x_y_sext_both(i8 %x.narrow, i32 %y) {
; CHECK-LABEL: 'umin_seq_x_y_sext_both'
; CHECK-NEXT:  Classifying expressions for: @umin_seq_x_y_sext_both
; CHECK-NEXT:    %x = sext i8 %x.narrow to i32
; CHECK-NEXT:    --> (sext i8 %x.narrow to i32) U: [-128,128) S: [-128,128)
; CHECK-NEXT:    %umin = call i32 @llvm.umin.i32(i32 %y, i32 %x)
; CHECK-NEXT:    --> ((sext i8 %x.narrow to i32) umin %y) U: full-set S: full-set
; CHECK-NEXT:    %r = select i1 %x.is.zero, i32 0, i32 %umin
; CHECK-NEXT:    --> ((sext i8 %x.narrow to i32) umin_seq %y) U: full-set S: full-set
; CHECK-NEXT:  Determining loop execution counts for: @umin_seq_x_y_sext_both
;
  %x = sext i8 %x.narrow to i32
  %umin = call i32 @llvm.umin(i32 %y, i32 %x)
  %x.is.zero = icmp eq i32 %x, 0
  %r = select i1 %x.is.zero, i32 0, i32 %umin
  ret i32 %r
}

define i32 @umin_seq_x_y_sext_in_umin(i8 %x.narrow, i32 %y) {
; CHECK-LABEL: 'umin_seq_x_y_sext_in_umin'
; CHECK-NEXT:  Classifying expressions for: @umin_seq_x_y_sext_in_umin
; CHECK-NEXT:    %x = sext i8 %x.narrow to i32
; CHECK-NEXT:    --> (sext i8 %x.narrow to i32) U: [-128,128) S: [-128,128)
; CHECK-NEXT:    %umin = call i32 @llvm.umin.i32(i32 %y, i32 %x)
; CHECK-NEXT:    --> ((sext i8 %x.narrow to i32) umin %y) U: full-set S: full-set
; CHECK-NEXT:    %r = select i1 %x.is.zero, i32 0, i32 %umin
; CHECK-NEXT:    --> %r U: full-set S: full-set
; CHECK-NEXT:  Determining loop execution counts for: @umin_seq_x_y_sext_in_umin
;
  %x = sext i8 %x.narrow to i32
  %umin = call i32 @llvm.umin(i32 %y, i32 %x)
  %x.is.zero = icmp eq i8 %x.narrow, 0
  %r = select i1 %x.is.zero, i32 0, i32 %umin
  ret i32 %r
}

define i8 @umin_seq_x_y_sext_in_iszero(i8 %x, i8 %y) {
; CHECK-LABEL: 'umin_seq_x_y_sext_in_iszero'
; CHECK-NEXT:  Classifying expressions for: @umin_seq_x_y_sext_in_iszero
; CHECK-NEXT:    %x.wide = sext i8 %x to i32
; CHECK-NEXT:    --> (sext i8 %x to i32) U: [-128,128) S: [-128,128)
; CHECK-NEXT:    %umin = call i8 @llvm.umin.i8(i8 %y, i8 %x)
; CHECK-NEXT:    --> (%x umin %y) U: full-set S: full-set
; CHECK-NEXT:    %r = select i1 %x.is.zero, i8 0, i8 %umin
; CHECK-NEXT:    --> %r U: full-set S: full-set
; CHECK-NEXT:  Determining loop execution counts for: @umin_seq_x_y_sext_in_iszero
;
  %x.wide = sext i8 %x to i32
  %umin = call i8 @llvm.umin.i8(i8 %y, i8 %x)
  %x.is.zero = icmp eq i32 %x.wide, 0
  %r = select i1 %x.is.zero, i8 0, i8 %umin
  ret i8 %r
}

define i32 @umin_seq_x_y_sext_of_umin(i8 %x, i8 %y) {
; CHECK-LABEL: 'umin_seq_x_y_sext_of_umin'
; CHECK-NEXT:  Classifying expressions for: @umin_seq_x_y_sext_of_umin
; CHECK-NEXT:    %umin.narrow = call i8 @llvm.umin.i8(i8 %y, i8 %x)
; CHECK-NEXT:    --> (%x umin %y) U: full-set S: full-set
; CHECK-NEXT:    %umin = sext i8 %umin.narrow to i32
; CHECK-NEXT:    --> (sext i8 (%x umin %y) to i32) U: [-128,128) S: [-128,128)
; CHECK-NEXT:    %r = select i1 %x.is.zero, i32 0, i32 %umin
; CHECK-NEXT:    --> %r U: [-128,128) S: [-128,128)
; CHECK-NEXT:  Determining loop execution counts for: @umin_seq_x_y_sext_of_umin
;
  %umin.narrow = call i8 @llvm.umin.i8(i8 %y, i8 %x)
  %umin = sext i8 %umin.narrow to i32
  %x.is.zero = icmp eq i8 %x, 0
  %r = select i1 %x.is.zero, i32 0, i32 %umin
  ret i32 %r
}

define i32 @umin_seq_x_y_zext_vs_sext(i8 %x.narrow, i32 %y) {
; CHECK-LABEL: 'umin_seq_x_y_zext_vs_sext'
; CHECK-NEXT:  Classifying expressions for: @umin_seq_x_y_zext_vs_sext
; CHECK-NEXT:    %x.zext = zext i8 %x.narrow to i32
; CHECK-NEXT:    --> (zext i8 %x.narrow to i32) U: [0,256) S: [0,256)
; CHECK-NEXT:    %x.sext = sext i8 %x.narrow to i32
; CHECK-NEXT:    --> (sext i8 %x.narrow to i32) U: [-128,128) S: [-128,128)
; CHECK-NEXT:    %umin = call i32 @llvm.umin.i32(i32 %y, i32 %x.zext)
; CHECK-NEXT:    --> ((zext i8 %x.narrow to i32) umin %y) U: [0,256) S: [0,256)
; CHECK-NEXT:    %r = select i1 %x.is.zero, i32 0, i32 %umin
; CHECK-NEXT:    --> %r U: [0,256) S: [0,256)
; CHECK-NEXT:  Determining loop execution counts for: @umin_seq_x_y_zext_vs_sext
;
  %x.zext = zext i8 %x.narrow to i32
  %x.sext = sext i8 %x.narrow to i32
  %umin = call i32 @llvm.umin(i32 %y, i32 %x.zext)
  %x.is.zero = icmp eq i32 %x.sext, 0
  %r = select i1 %x.is.zero, i32 0, i32 %umin
  ret i32 %r
}
define i32 @umin_seq_x_y_sext_vs_zext(i8 %x.narrow, i32 %y) {
; CHECK-LABEL: 'umin_seq_x_y_sext_vs_zext'
; CHECK-NEXT:  Classifying expressions for: @umin_seq_x_y_sext_vs_zext
; CHECK-NEXT:    %x.zext = zext i8 %x.narrow to i32
; CHECK-NEXT:    --> (zext i8 %x.narrow to i32) U: [0,256) S: [0,256)
; CHECK-NEXT:    %x.sext = sext i8 %x.narrow to i32
; CHECK-NEXT:    --> (sext i8 %x.narrow to i32) U: [-128,128) S: [-128,128)
; CHECK-NEXT:    %umin = call i32 @llvm.umin.i32(i32 %y, i32 %x.sext)
; CHECK-NEXT:    --> ((sext i8 %x.narrow to i32) umin %y) U: full-set S: full-set
; CHECK-NEXT:    %r = select i1 %x.is.zero, i32 0, i32 %umin
; CHECK-NEXT:    --> %r U: full-set S: full-set
; CHECK-NEXT:  Determining loop execution counts for: @umin_seq_x_y_sext_vs_zext
;
  %x.zext = zext i8 %x.narrow to i32
  %x.sext = sext i8 %x.narrow to i32
  %umin = call i32 @llvm.umin(i32 %y, i32 %x.sext)
  %x.is.zero = icmp eq i32 %x.zext, 0
  %r = select i1 %x.is.zero, i32 0, i32 %umin
  ret i32 %r
}

define i32 @select_x_or_zero_expanded(i1 %c, i32 %x) {
; CHECK-LABEL: 'select_x_or_zero_expanded'
; CHECK-NEXT:  Classifying expressions for: @select_x_or_zero_expanded
; CHECK-NEXT:    %c.splat = sext i1 %c to i32
; CHECK-NEXT:    --> (sext i1 %c to i32) U: [-1,1) S: [-1,1)
; CHECK-NEXT:    %umin = call i32 @llvm.umin.i32(i32 %c.splat, i32 %x)
; CHECK-NEXT:    --> ((sext i1 %c to i32) umin %x) U: full-set S: full-set
; CHECK-NEXT:    %r = select i1 %v0.is.zero, i32 0, i32 %umin
; CHECK-NEXT:    --> ((sext i1 %c to i32) umin_seq %x) U: full-set S: full-set
; CHECK-NEXT:  Determining loop execution counts for: @select_x_or_zero_expanded
;
  %c.splat = sext i1 %c to i32
  %umin = call i32 @llvm.umin(i32 %c.splat, i32 %x)
  %v0.is.zero = icmp eq i32 %c.splat, 0
  %r = select i1 %v0.is.zero, i32 0, i32 %umin
  ret i32 %r
}

define i32 @select_zero_or_x_expanded(i1 %c, i32 %y) {
; CHECK-LABEL: 'select_zero_or_x_expanded'
; CHECK-NEXT:  Classifying expressions for: @select_zero_or_x_expanded
; CHECK-NEXT:    %c.splat = sext i1 %c to i32
; CHECK-NEXT:    --> (sext i1 %c to i32) U: [-1,1) S: [-1,1)
; CHECK-NEXT:    %c.splat.not = xor i32 %c.splat, -1
; CHECK-NEXT:    --> (-1 + (-1 * (sext i1 %c to i32))<nsw>)<nsw> U: [-1,1) S: [-1,1)
; CHECK-NEXT:    %umin = call i32 @llvm.umin.i32(i32 %c.splat.not, i32 %y)
; CHECK-NEXT:    --> ((-1 + (-1 * (sext i1 %c to i32))<nsw>)<nsw> umin %y) U: full-set S: full-set
; CHECK-NEXT:    %r = select i1 %v0.is.zero, i32 0, i32 %umin
; CHECK-NEXT:    --> ((-1 + (-1 * (sext i1 %c to i32))<nsw>)<nsw> umin_seq %y) U: full-set S: full-set
; CHECK-NEXT:  Determining loop execution counts for: @select_zero_or_x_expanded
;
  %c.splat = sext i1 %c to i32
  %c.splat.not = xor i32 %c.splat, -1
  %umin = call i32 @llvm.umin(i32 %c.splat.not, i32 %y)
  %v0.is.zero = icmp eq i32 %c.splat.not, 0
  %r = select i1 %v0.is.zero, i32 0, i32 %umin
  ret i32 %r
}
define i32 @select_zero_or_x_expanded2(i1 %c, i32 %y) {
; CHECK-LABEL: 'select_zero_or_x_expanded2'
; CHECK-NEXT:  Classifying expressions for: @select_zero_or_x_expanded2
; CHECK-NEXT:    %c.not = xor i1 %c, true
; CHECK-NEXT:    --> (true + %c) U: full-set S: full-set
; CHECK-NEXT:    %c.not.splat = sext i1 %c.not to i32
; CHECK-NEXT:    --> (sext i1 (true + %c) to i32) U: [-1,1) S: [-1,1)
; CHECK-NEXT:    %umin = call i32 @llvm.umin.i32(i32 %c.not.splat, i32 %y)
; CHECK-NEXT:    --> ((sext i1 (true + %c) to i32) umin %y) U: full-set S: full-set
; CHECK-NEXT:    %r = select i1 %v0.is.zero, i32 0, i32 %umin
; CHECK-NEXT:    --> ((sext i1 (true + %c) to i32) umin_seq %y) U: full-set S: full-set
; CHECK-NEXT:  Determining loop execution counts for: @select_zero_or_x_expanded2
;
  %c.not = xor i1 %c, -1
  %c.not.splat = sext i1 %c.not to i32
  %umin = call i32 @llvm.umin(i32 %c.not.splat, i32 %y)
  %v0.is.zero = icmp eq i32 %c.not.splat, 0
  %r = select i1 %v0.is.zero, i32 0, i32 %umin
  ret i32 %r
}

define i32 @select_x_or_constant_expanded(i1 %c, i32 %x) {
; CHECK-LABEL: 'select_x_or_constant_expanded'
; CHECK-NEXT:  Classifying expressions for: @select_x_or_constant_expanded
; CHECK-NEXT:    %c.splat = sext i1 %c to i32
; CHECK-NEXT:    --> (sext i1 %c to i32) U: [-1,1) S: [-1,1)
; CHECK-NEXT:    %x.off = sub i32 %x, 42
; CHECK-NEXT:    --> (-42 + %x) U: full-set S: full-set
; CHECK-NEXT:    %umin = call i32 @llvm.umin.i32(i32 %c.splat, i32 %x.off)
; CHECK-NEXT:    --> ((sext i1 %c to i32) umin (-42 + %x)) U: full-set S: full-set
; CHECK-NEXT:    %r.off = select i1 %v0.is.zero, i32 0, i32 %umin
; CHECK-NEXT:    --> ((sext i1 %c to i32) umin_seq (-42 + %x)) U: full-set S: full-set
; CHECK-NEXT:    %r = add i32 %r.off, 42
; CHECK-NEXT:    --> (42 + ((sext i1 %c to i32) umin_seq (-42 + %x))) U: full-set S: full-set
; CHECK-NEXT:  Determining loop execution counts for: @select_x_or_constant_expanded
;
  %c.splat = sext i1 %c to i32
  %x.off = sub i32 %x, 42
  %umin = call i32 @llvm.umin(i32 %c.splat, i32 %x.off)
  %v0.is.zero = icmp eq i32 %c.splat, 0
  %r.off = select i1 %v0.is.zero, i32 0, i32 %umin
  %r = add i32 %r.off, 42
  ret i32 %r
}

define i32 @select_constant_or_y_expanded(i1 %c, i32 %y) {
; CHECK-LABEL: 'select_constant_or_y_expanded'
; CHECK-NEXT:  Classifying expressions for: @select_constant_or_y_expanded
; CHECK-NEXT:    %c.splat = sext i1 %c to i32
; CHECK-NEXT:    --> (sext i1 %c to i32) U: [-1,1) S: [-1,1)
; CHECK-NEXT:    %c.splat.not = xor i32 %c.splat, -1
; CHECK-NEXT:    --> (-1 + (-1 * (sext i1 %c to i32))<nsw>)<nsw> U: [-1,1) S: [-1,1)
; CHECK-NEXT:    %y.off = sub i32 %y, 42
; CHECK-NEXT:    --> (-42 + %y) U: full-set S: full-set
; CHECK-NEXT:    %umin = call i32 @llvm.umin.i32(i32 %c.splat.not, i32 %y.off)
; CHECK-NEXT:    --> ((-42 + %y) umin (-1 + (-1 * (sext i1 %c to i32))<nsw>)<nsw>) U: full-set S: full-set
; CHECK-NEXT:    %r.off = select i1 %v0.is.zero, i32 0, i32 %umin
; CHECK-NEXT:    --> ((-1 + (-1 * (sext i1 %c to i32))<nsw>)<nsw> umin_seq (-42 + %y)) U: full-set S: full-set
; CHECK-NEXT:    %r = add i32 %r.off, 42
; CHECK-NEXT:    --> (42 + ((-1 + (-1 * (sext i1 %c to i32))<nsw>)<nsw> umin_seq (-42 + %y))) U: full-set S: full-set
; CHECK-NEXT:  Determining loop execution counts for: @select_constant_or_y_expanded
;
  %c.splat = sext i1 %c to i32
  %c.splat.not = xor i32 %c.splat, -1
  %y.off = sub i32 %y, 42
  %umin = call i32 @llvm.umin(i32 %c.splat.not, i32 %y.off)
  %v0.is.zero = icmp eq i32 %c.splat.not, 0
  %r.off = select i1 %v0.is.zero, i32 0, i32 %umin
  %r = add i32 %r.off, 42
  ret i32 %r
}

declare i8 @llvm.umin.i8(i8, i8)
declare i8 @llvm.umax.i8(i8, i8)
declare i8 @llvm.smin.i8(i8, i8)
declare i8 @llvm.smax.i8(i8, i8)

declare i32 @llvm.umin(i32, i32)
declare i32 @llvm.umax(i32, i32)
declare i32 @llvm.smin(i32, i32)
declare i32 @llvm.smax(i32, i32)