llvm/test/Transforms/AggressiveInstCombine/fold-split-cttz.ll

; NOTE: Assertions have been autogenerated by utils/update_test_checks.py
; RUN: opt < %s -passes=aggressive-instcombine -S | FileCheck %s

; Select-based split i64 cttz
define i32 @split_cttz_select(i64 %val) {
; CHECK-LABEL: @split_cttz_select(
; CHECK-NEXT:  entry:
; CHECK-NEXT:    [[TMP0:%.*]] = call i64 @llvm.cttz.i64(i64 [[VAL:%.*]], i1 false)
; CHECK-NEXT:    [[TMP1:%.*]] = trunc i64 [[TMP0]] to i32
; CHECK-NEXT:    ret i32 [[TMP1]]
;
entry:
  %conv1 = trunc i64 %val to i32
  %cmp = icmp eq i32 %conv1, 0
  %shr = lshr i64 %val, 32
  %conv = trunc i64 %shr to i32
  %0 = call i32 @llvm.cttz.i32(i32 %conv, i1 false)
  %add = add i32 %0, 32
  %1 = call i32 @llvm.cttz.i32(i32 %conv1, i1 false)
  %retval = select i1 %cmp, i32 %add, i32 %1
  ret i32 %retval
}

; Select-based with or instead of add.
define i32 @split_cttz_select_or(i64 %val) {
; CHECK-LABEL: @split_cttz_select_or(
; CHECK-NEXT:  entry:
; CHECK-NEXT:    [[TMP0:%.*]] = call i64 @llvm.cttz.i64(i64 [[VAL:%.*]], i1 false)
; CHECK-NEXT:    [[TMP1:%.*]] = trunc i64 [[TMP0]] to i32
; CHECK-NEXT:    ret i32 [[TMP1]]
;
entry:
  %conv1 = trunc i64 %val to i32
  %cmp = icmp eq i32 %conv1, 0
  %shr = lshr i64 %val, 32
  %conv = trunc i64 %shr to i32
  %0 = call i32 @llvm.cttz.i32(i32 %conv, i1 false)
  %add = or disjoint i32 %0, 32
  %1 = call i32 @llvm.cttz.i32(i32 %conv1, i1 false)
  %retval = select i1 %cmp, i32 %add, i32 %1
  ret i32 %retval
}

; Select-based with icmp ne (inverted condition).
define i32 @split_cttz_select_ne(i64 %val) {
; CHECK-LABEL: @split_cttz_select_ne(
; CHECK-NEXT:  entry:
; CHECK-NEXT:    [[TMP0:%.*]] = call i64 @llvm.cttz.i64(i64 [[VAL:%.*]], i1 false)
; CHECK-NEXT:    [[TMP1:%.*]] = trunc i64 [[TMP0]] to i32
; CHECK-NEXT:    ret i32 [[TMP1]]
;
entry:
  %conv1 = trunc i64 %val to i32
  %cmp = icmp ne i32 %conv1, 0
  %shr = lshr i64 %val, 32
  %conv = trunc i64 %shr to i32
  %0 = call i32 @llvm.cttz.i32(i32 %conv, i1 false)
  %add = add i32 %0, 32
  %1 = call i32 @llvm.cttz.i32(i32 %conv1, i1 false)
  %retval = select i1 %cmp, i32 %1, i32 %add
  ret i32 %retval
}

; Select-based cttz used inside a larger expression (>> 3)
define i32 @split_cttz_select_shift(i64 %val) {
; CHECK-LABEL: @split_cttz_select_shift(
; CHECK-NEXT:  entry:
; CHECK-NEXT:    [[TMP0:%.*]] = call i64 @llvm.cttz.i64(i64 [[VAL:%.*]], i1 false)
; CHECK-NEXT:    [[TMP1:%.*]] = trunc i64 [[TMP0]] to i32
; CHECK-NEXT:    [[RESULT:%.*]] = lshr i32 [[TMP1]], 3
; CHECK-NEXT:    ret i32 [[RESULT]]
;
entry:
  %conv1 = trunc i64 %val to i32
  %cmp = icmp eq i32 %conv1, 0
  %shr = lshr i64 %val, 32
  %conv = trunc i64 %shr to i32
  %0 = call i32 @llvm.cttz.i32(i32 %conv, i1 false)
  %add = add i32 %0, 32
  %1 = call i32 @llvm.cttz.i32(i32 %conv1, i1 false)
  %retval = select i1 %cmp, i32 %add, i32 %1
  %result = lshr i32 %retval, 3
  ret i32 %result
}

; i32 split into two i16 cttz.
define i16 @split_cttz_select_i32(i32 %val) {
; CHECK-LABEL: @split_cttz_select_i32(
; CHECK-NEXT:  entry:
; CHECK-NEXT:    [[TMP0:%.*]] = call i32 @llvm.cttz.i32(i32 [[VAL:%.*]], i1 false)
; CHECK-NEXT:    [[TMP1:%.*]] = trunc i32 [[TMP0]] to i16
; CHECK-NEXT:    ret i16 [[TMP1]]
;
entry:
  %conv1 = trunc i32 %val to i16
  %cmp = icmp eq i16 %conv1, 0
  %shr = lshr i32 %val, 16
  %conv = trunc i32 %shr to i16
  %0 = call i16 @llvm.cttz.i16(i16 %conv, i1 false)
  %add = add i16 %0, 16
  %1 = call i16 @llvm.cttz.i16(i16 %conv1, i1 false)
  %retval = select i1 %cmp, i16 %add, i16 %1
  ret i16 %retval
}

; i128 split into two i64 cttz.
define i64 @split_cttz_select_i128(i128 %val) {
; CHECK-LABEL: @split_cttz_select_i128(
; CHECK-NEXT:  entry:
; CHECK-NEXT:    [[TMP0:%.*]] = call i128 @llvm.cttz.i128(i128 [[VAL:%.*]], i1 false)
; CHECK-NEXT:    [[TMP1:%.*]] = trunc i128 [[TMP0]] to i64
; CHECK-NEXT:    ret i64 [[TMP1]]
;
entry:
  %conv1 = trunc i128 %val to i64
  %cmp = icmp eq i64 %conv1, 0
  %shr = lshr i128 %val, 64
  %conv = trunc i128 %shr to i64
  %0 = call i64 @llvm.cttz.i64(i64 %conv, i1 false)
  %add = add i64 %0, 64
  %1 = call i64 @llvm.cttz.i64(i64 %conv1, i1 false)
  %retval = select i1 %cmp, i64 %add, i64 %1
  ret i64 %retval
}

; i16 split into two i8 cttz.
define i8 @split_cttz_select_i16(i16 %val) {
; CHECK-LABEL: @split_cttz_select_i16(
; CHECK-NEXT:  entry:
; CHECK-NEXT:    [[TMP0:%.*]] = call i16 @llvm.cttz.i16(i16 [[VAL:%.*]], i1 false)
; CHECK-NEXT:    [[TMP1:%.*]] = trunc i16 [[TMP0]] to i8
; CHECK-NEXT:    ret i8 [[TMP1]]
;
entry:
  %conv1 = trunc i16 %val to i8
  %cmp = icmp eq i8 %conv1, 0
  %shr = lshr i16 %val, 8
  %conv = trunc i16 %shr to i8
  %0 = call i8 @llvm.cttz.i8(i8 %conv, i1 false)
  %add = add i8 %0, 8
  %1 = call i8 @llvm.cttz.i8(i8 %conv1, i1 false)
  %retval = select i1 %cmp, i8 %add, i8 %1
  ret i8 %retval
}

; i256 split into two i128 cttz.
; This tests m_APInt matching for shift amounts > 64 bits.
define i128 @split_cttz_select_i256(i256 %val) {
; CHECK-LABEL: @split_cttz_select_i256(
; CHECK-NEXT:  entry:
; CHECK-NEXT:    [[TMP0:%.*]] = call i256 @llvm.cttz.i256(i256 [[VAL:%.*]], i1 false)
; CHECK-NEXT:    [[TMP1:%.*]] = trunc i256 [[TMP0]] to i128
; CHECK-NEXT:    ret i128 [[TMP1]]
;
entry:
  %conv1 = trunc i256 %val to i128
  %cmp = icmp eq i128 %conv1, 0
  %shr = lshr i256 %val, 128
  %conv = trunc i256 %shr to i128
  %0 = call i128 @llvm.cttz.i128(i128 %conv, i1 false)
  %add = add i128 %0, 128
  %1 = call i128 @llvm.cttz.i128(i128 %conv1, i1 false)
  %retval = select i1 %cmp, i128 %add, i128 %1
  ret i128 %retval
}

; Negative test: mismatched source values, should NOT be folded.
define i32 @split_cttz_different_sources(i64 %val, i64 %val2) {
; CHECK-LABEL: @split_cttz_different_sources(
; CHECK-NEXT:  entry:
; CHECK-NEXT:    [[CONV1:%.*]] = trunc i64 [[VAL:%.*]] to i32
; CHECK-NEXT:    [[CMP:%.*]] = icmp eq i32 [[CONV1]], 0
; CHECK-NEXT:    [[SHR:%.*]] = lshr i64 [[VAL2:%.*]], 32
; CHECK-NEXT:    [[CONV:%.*]] = trunc i64 [[SHR]] to i32
; CHECK-NEXT:    [[TMP0:%.*]] = call i32 @llvm.cttz.i32(i32 [[CONV]], i1 false)
; CHECK-NEXT:    [[ADD:%.*]] = add i32 [[TMP0]], 32
; CHECK-NEXT:    [[TMP1:%.*]] = call i32 @llvm.cttz.i32(i32 [[CONV1]], i1 false)
; CHECK-NEXT:    [[RETVAL:%.*]] = select i1 [[CMP]], i32 [[ADD]], i32 [[TMP1]]
; CHECK-NEXT:    ret i32 [[RETVAL]]
;
entry:
  %conv1 = trunc i64 %val to i32
  %cmp = icmp eq i32 %conv1, 0
  %shr = lshr i64 %val2, 32
  %conv = trunc i64 %shr to i32
  %0 = call i32 @llvm.cttz.i32(i32 %conv, i1 false)
  %add = add i32 %0, 32
  %1 = call i32 @llvm.cttz.i32(i32 %conv1, i1 false)
  %retval = select i1 %cmp, i32 %add, i32 %1
  ret i32 %retval
}

; Negative test: shift amount is not 32, should NOT be folded.
define i32 @split_cttz_wrong_shift(i64 %val) {
; CHECK-LABEL: @split_cttz_wrong_shift(
; CHECK-NEXT:  entry:
; CHECK-NEXT:    [[CONV1:%.*]] = trunc i64 [[VAL:%.*]] to i32
; CHECK-NEXT:    [[CMP:%.*]] = icmp eq i32 [[CONV1]], 0
; CHECK-NEXT:    [[SHR:%.*]] = lshr i64 [[VAL]], 16
; CHECK-NEXT:    [[CONV:%.*]] = trunc i64 [[SHR]] to i32
; CHECK-NEXT:    [[TMP0:%.*]] = call i32 @llvm.cttz.i32(i32 [[CONV]], i1 false)
; CHECK-NEXT:    [[ADD:%.*]] = add i32 [[TMP0]], 32
; CHECK-NEXT:    [[TMP1:%.*]] = call i32 @llvm.cttz.i32(i32 [[CONV1]], i1 false)
; CHECK-NEXT:    [[RETVAL:%.*]] = select i1 [[CMP]], i32 [[ADD]], i32 [[TMP1]]
; CHECK-NEXT:    ret i32 [[RETVAL]]
;
entry:
  %conv1 = trunc i64 %val to i32
  %cmp = icmp eq i32 %conv1, 0
  %shr = lshr i64 %val, 16
  %conv = trunc i64 %shr to i32
  %0 = call i32 @llvm.cttz.i32(i32 %conv, i1 false)
  %add = add i32 %0, 32
  %1 = call i32 @llvm.cttz.i32(i32 %conv1, i1 false)
  %retval = select i1 %cmp, i32 %add, i32 %1
  ret i32 %retval
}

; Negative test: plain or (without disjoint flag), should NOT be folded
; in select-based pattern because or(32, 32)=32 != add(32, 32)=64.
define i32 @split_cttz_select_plain_or(i64 %val) {
; CHECK-LABEL: @split_cttz_select_plain_or(
; CHECK-NEXT:  entry:
; CHECK-NEXT:    [[CONV1:%.*]] = trunc i64 [[VAL:%.*]] to i32
; CHECK-NEXT:    [[CMP:%.*]] = icmp eq i32 [[CONV1]], 0
; CHECK-NEXT:    [[SHR:%.*]] = lshr i64 [[VAL]], 32
; CHECK-NEXT:    [[CONV:%.*]] = trunc i64 [[SHR]] to i32
; CHECK-NEXT:    [[TMP0:%.*]] = call i32 @llvm.cttz.i32(i32 [[CONV]], i1 false)
; CHECK-NEXT:    [[ADD:%.*]] = or i32 [[TMP0]], 32
; CHECK-NEXT:    [[TMP1:%.*]] = call i32 @llvm.cttz.i32(i32 [[CONV1]], i1 false)
; CHECK-NEXT:    [[RETVAL:%.*]] = select i1 [[CMP]], i32 [[ADD]], i32 [[TMP1]]
; CHECK-NEXT:    ret i32 [[RETVAL]]
;
entry:
  %conv1 = trunc i64 %val to i32
  %cmp = icmp eq i32 %conv1, 0
  %shr = lshr i64 %val, 32
  %conv = trunc i64 %shr to i32
  %0 = call i32 @llvm.cttz.i32(i32 %conv, i1 false)
  %add = or i32 %0, 32
  %1 = call i32 @llvm.cttz.i32(i32 %conv1, i1 false)
  %retval = select i1 %cmp, i32 %add, i32 %1
  ret i32 %retval
}

; Negative test: multi-use of cttz_lo prevents folding.
define i32 @split_cttz_select_multiuse(i64 %val) {
; CHECK-LABEL: @split_cttz_select_multiuse(
; CHECK-NEXT:  entry:
; CHECK-NEXT:    [[CONV1:%.*]] = trunc i64 [[VAL:%.*]] to i32
; CHECK-NEXT:    [[CMP:%.*]] = icmp eq i32 [[CONV1]], 0
; CHECK-NEXT:    [[SHR:%.*]] = lshr i64 [[VAL]], 32
; CHECK-NEXT:    [[CONV:%.*]] = trunc i64 [[SHR]] to i32
; CHECK-NEXT:    [[TMP0:%.*]] = call i32 @llvm.cttz.i32(i32 [[CONV]], i1 false)
; CHECK-NEXT:    [[ADD:%.*]] = add i32 [[TMP0]], 32
; CHECK-NEXT:    [[TMP1:%.*]] = call i32 @llvm.cttz.i32(i32 [[CONV1]], i1 false)
; CHECK-NEXT:    [[RETVAL:%.*]] = select i1 [[CMP]], i32 [[ADD]], i32 [[TMP1]]
; CHECK-NEXT:    call void @use_i32(i32 [[TMP1]])
; CHECK-NEXT:    ret i32 [[RETVAL]]
;
entry:
  %conv1 = trunc i64 %val to i32
  %cmp = icmp eq i32 %conv1, 0
  %shr = lshr i64 %val, 32
  %conv = trunc i64 %shr to i32
  %0 = call i32 @llvm.cttz.i32(i32 %conv, i1 false)
  %add = add i32 %0, 32
  %1 = call i32 @llvm.cttz.i32(i32 %conv1, i1 false)
  %retval = select i1 %cmp, i32 %add, i32 %1
  call void @use_i32(i32 %1)
  ret i32 %retval
}

declare void @use_i32(i32)