llvm/test/CodeGen/PowerPC/funnel-shift-rot.ll

; NOTE: Assertions have been autogenerated by utils/update_llc_test_checks.py
; RUN: llc < %s -mtriple=ppc32-- | FileCheck %s --check-prefixes=CHECK,CHECK32,CHECK32_32
; RUN: llc < %s -mtriple=ppc32-- -mcpu=ppc64 | FileCheck %s --check-prefixes=CHECK,CHECK32,CHECK32_64
; RUN: llc < %s -mtriple=powerpc64le-- | FileCheck %s --check-prefixes=CHECK,CHECK64
; RUN: llc < %s -mcpu=future -mtriple=powerpc64le-- | FileCheck %s --check-prefix=FUTURE

declare i8 @llvm.fshl.i8(i8, i8, i8)
declare i16 @llvm.fshl.i16(i16, i16, i16)
declare i32 @llvm.fshl.i32(i32, i32, i32)
declare i64 @llvm.fshl.i64(i64, i64, i64)
declare <4 x i32> @llvm.fshl.v4i32(<4 x i32>, <4 x i32>, <4 x i32>)

declare i8 @llvm.fshr.i8(i8, i8, i8)
declare i16 @llvm.fshr.i16(i16, i16, i16)
declare i32 @llvm.fshr.i32(i32, i32, i32)
declare i64 @llvm.fshr.i64(i64, i64, i64)
declare <4 x i32> @llvm.fshr.v4i32(<4 x i32>, <4 x i32>, <4 x i32>)

; When first 2 operands match, it's a rotate.

define i8 @rotl_i8_const_shift(i8 %x) {
; CHECK-LABEL: rotl_i8_const_shift:
; CHECK:       # %bb.0:
; CHECK-NEXT:    rotlwi 4, 3, 27
; CHECK-NEXT:    rlwimi 4, 3, 3, 0, 28
; CHECK-NEXT:    mr 3, 4
; CHECK-NEXT:    blr
;
; FUTURE-LABEL: rotl_i8_const_shift:
; FUTURE:       # %bb.0:
; FUTURE-NEXT:    rotlwi 4, 3, 27
; FUTURE-NEXT:    rlwimi 4, 3, 3, 0, 28
; FUTURE-NEXT:    mr 3, 4
; FUTURE-NEXT:    blr
  %f = call i8 @llvm.fshl.i8(i8 %x, i8 %x, i8 3)
  ret i8 %f
}

define i64 @rotl_i64_const_shift(i64 %x) {
; CHECK32-LABEL: rotl_i64_const_shift:
; CHECK32:       # %bb.0:
; CHECK32-NEXT:    rotlwi 5, 4, 3
; CHECK32-NEXT:    rotlwi 6, 3, 3
; CHECK32-NEXT:    rlwimi 5, 3, 3, 0, 28
; CHECK32-NEXT:    rlwimi 6, 4, 3, 0, 28
; CHECK32-NEXT:    mr 3, 5
; CHECK32-NEXT:    mr 4, 6
; CHECK32-NEXT:    blr
;
; CHECK64-LABEL: rotl_i64_const_shift:
; CHECK64:       # %bb.0:
; CHECK64-NEXT:    rotldi 3, 3, 3
; CHECK64-NEXT:    blr
;
; FUTURE-LABEL: rotl_i64_const_shift:
; FUTURE:       # %bb.0:
; FUTURE-NEXT:    rotldi 3, 3, 3
; FUTURE-NEXT:    blr
  %f = call i64 @llvm.fshl.i64(i64 %x, i64 %x, i64 3)
  ret i64 %f
}

; When first 2 operands match, it's a rotate (by variable amount).

define i16 @rotl_i16(i16 %x, i16 %z) {
; CHECK-LABEL: rotl_i16:
; CHECK:       # %bb.0:
; CHECK-NEXT:    clrlwi 6, 4, 28
; CHECK-NEXT:    neg 4, 4
; CHECK-NEXT:    clrlwi 5, 3, 16
; CHECK-NEXT:    clrlwi 4, 4, 28
; CHECK-NEXT:    slw 3, 3, 6
; CHECK-NEXT:    srw 4, 5, 4
; CHECK-NEXT:    or 3, 3, 4
; CHECK-NEXT:    blr
;
; FUTURE-LABEL: rotl_i16:
; FUTURE:       # %bb.0:
; FUTURE-NEXT:    clrlwi 6, 4, 28
; FUTURE-NEXT:    neg 4, 4
; FUTURE-NEXT:    clrlwi 5, 3, 16
; FUTURE-NEXT:    clrlwi 4, 4, 28
; FUTURE-NEXT:    slw 3, 3, 6
; FUTURE-NEXT:    srw 4, 5, 4
; FUTURE-NEXT:    or 3, 3, 4
; FUTURE-NEXT:    blr
  %f = call i16 @llvm.fshl.i16(i16 %x, i16 %x, i16 %z)
  ret i16 %f
}

define i32 @rotl_i32(i32 %x, i32 %z) {
; CHECK-LABEL: rotl_i32:
; CHECK:       # %bb.0:
; CHECK-NEXT:    rotlw 3, 3, 4
; CHECK-NEXT:    blr
;
; FUTURE-LABEL: rotl_i32:
; FUTURE:       # %bb.0:
; FUTURE-NEXT:    rotlw 3, 3, 4
; FUTURE-NEXT:    blr
  %f = call i32 @llvm.fshl.i32(i32 %x, i32 %x, i32 %z)
  ret i32 %f
}

define i64 @rotl_i64(i64 %x, i64 %z) {
; CHECK32-LABEL: rotl_i64:
; CHECK32:       # %bb.0:
; CHECK32-NEXT:    andi. 5, 6, 32
; CHECK32-NEXT:    mr 5, 3
; CHECK32-NEXT:    bne 0, .LBB4_2
; CHECK32-NEXT:  # %bb.1:
; CHECK32-NEXT:    mr 5, 4
; CHECK32-NEXT:  .LBB4_2:
; CHECK32-NEXT:    clrlwi 6, 6, 27
; CHECK32-NEXT:    subfic 8, 6, 32
; CHECK32-NEXT:    srw 7, 5, 8
; CHECK32-NEXT:    bne 0, .LBB4_4
; CHECK32-NEXT:  # %bb.3:
; CHECK32-NEXT:    mr 4, 3
; CHECK32-NEXT:  .LBB4_4:
; CHECK32-NEXT:    slw 3, 4, 6
; CHECK32-NEXT:    srw 4, 4, 8
; CHECK32-NEXT:    slw 5, 5, 6
; CHECK32-NEXT:    or 3, 3, 7
; CHECK32-NEXT:    or 4, 5, 4
; CHECK32-NEXT:    blr
;
; CHECK64-LABEL: rotl_i64:
; CHECK64:       # %bb.0:
; CHECK64-NEXT:    rotld 3, 3, 4
; CHECK64-NEXT:    blr
;
; FUTURE-LABEL: rotl_i64:
; FUTURE:       # %bb.0:
; FUTURE-NEXT:    rotld 3, 3, 4
; FUTURE-NEXT:    blr
  %f = call i64 @llvm.fshl.i64(i64 %x, i64 %x, i64 %z)
  ret i64 %f
}

; Vector rotate.

define <4 x i32> @rotl_v4i32(<4 x i32> %x, <4 x i32> %z) {
; CHECK32_32-LABEL: rotl_v4i32:
; CHECK32_32:       # %bb.0:
; CHECK32_32-NEXT:    rotlw 3, 3, 7
; CHECK32_32-NEXT:    rotlw 4, 4, 8
; CHECK32_32-NEXT:    rotlw 5, 5, 9
; CHECK32_32-NEXT:    rotlw 6, 6, 10
; CHECK32_32-NEXT:    blr
;
; CHECK32_64-LABEL: rotl_v4i32:
; CHECK32_64:       # %bb.0:
; CHECK32_64-NEXT:    vrlw 2, 2, 3
; CHECK32_64-NEXT:    blr
;
; CHECK64-LABEL: rotl_v4i32:
; CHECK64:       # %bb.0:
; CHECK64-NEXT:    vrlw 2, 2, 3
; CHECK64-NEXT:    blr
;
; FUTURE-LABEL: rotl_v4i32:
; FUTURE:       # %bb.0:
; FUTURE-NEXT:    xvrlw 34, 34, 35
; FUTURE-NEXT:    blr
  %f = call <4 x i32> @llvm.fshl.v4i32(<4 x i32> %x, <4 x i32> %x, <4 x i32> %z)
  ret <4 x i32> %f
}

; Vector rotate by constant splat amount.

define <4 x i32> @rotl_v4i32_const_shift(<4 x i32> %x) {
; CHECK32_32-LABEL: rotl_v4i32_const_shift:
; CHECK32_32:       # %bb.0:
; CHECK32_32-NEXT:    rotlwi 3, 3, 3
; CHECK32_32-NEXT:    rotlwi 4, 4, 3
; CHECK32_32-NEXT:    rotlwi 5, 5, 3
; CHECK32_32-NEXT:    rotlwi 6, 6, 3
; CHECK32_32-NEXT:    blr
;
; CHECK32_64-LABEL: rotl_v4i32_const_shift:
; CHECK32_64:       # %bb.0:
; CHECK32_64-NEXT:    vspltisw 3, 3
; CHECK32_64-NEXT:    vrlw 2, 2, 3
; CHECK32_64-NEXT:    blr
;
; CHECK64-LABEL: rotl_v4i32_const_shift:
; CHECK64:       # %bb.0:
; CHECK64-NEXT:    vspltisw 3, 3
; CHECK64-NEXT:    vrlw 2, 2, 3
; CHECK64-NEXT:    blr
;
; FUTURE-LABEL: rotl_v4i32_const_shift:
; FUTURE:       # %bb.0:
; FUTURE-NEXT:    vspltisw 3, 3
; FUTURE-NEXT:    xvrlw 34, 34, 35
; FUTURE-NEXT:    blr
  %f = call <4 x i32> @llvm.fshl.v4i32(<4 x i32> %x, <4 x i32> %x, <4 x i32> <i32 3, i32 3, i32 3, i32 3>)
  ret <4 x i32> %f
}

; Repeat everything for funnel shift right.

define i8 @rotr_i8_const_shift(i8 %x) {
; CHECK-LABEL: rotr_i8_const_shift:
; CHECK:       # %bb.0:
; CHECK-NEXT:    rotlwi 4, 3, 29
; CHECK-NEXT:    rlwimi 4, 3, 5, 0, 26
; CHECK-NEXT:    mr 3, 4
; CHECK-NEXT:    blr
;
; FUTURE-LABEL: rotr_i8_const_shift:
; FUTURE:       # %bb.0:
; FUTURE-NEXT:    rotlwi 4, 3, 29
; FUTURE-NEXT:    rlwimi 4, 3, 5, 0, 26
; FUTURE-NEXT:    mr 3, 4
; FUTURE-NEXT:    blr
  %f = call i8 @llvm.fshr.i8(i8 %x, i8 %x, i8 3)
  ret i8 %f
}

define i32 @rotr_i32_const_shift(i32 %x) {
; CHECK-LABEL: rotr_i32_const_shift:
; CHECK:       # %bb.0:
; CHECK-NEXT:    rotlwi 3, 3, 29
; CHECK-NEXT:    blr
;
; FUTURE-LABEL: rotr_i32_const_shift:
; FUTURE:       # %bb.0:
; FUTURE-NEXT:    rotlwi 3, 3, 29
; FUTURE-NEXT:    blr
  %f = call i32 @llvm.fshr.i32(i32 %x, i32 %x, i32 3)
  ret i32 %f
}

; When first 2 operands match, it's a rotate (by variable amount).

define i16 @rotr_i16(i16 %x, i16 %z) {
; CHECK-LABEL: rotr_i16:
; CHECK:       # %bb.0:
; CHECK-NEXT:    clrlwi 4, 4, 28
; CHECK-NEXT:    rlwimi 3, 3, 16, 0, 15
; CHECK-NEXT:    srw 3, 3, 4
; CHECK-NEXT:    blr
;
; FUTURE-LABEL: rotr_i16:
; FUTURE:       # %bb.0:
; FUTURE-NEXT:    clrlwi 4, 4, 28
; FUTURE-NEXT:    rlwimi 3, 3, 16, 0, 15
; FUTURE-NEXT:    srw 3, 3, 4
; FUTURE-NEXT:    blr
  %f = call i16 @llvm.fshr.i16(i16 %x, i16 %x, i16 %z)
  ret i16 %f
}

define i32 @rotr_i32(i32 %x, i32 %z) {
; CHECK-LABEL: rotr_i32:
; CHECK:       # %bb.0:
; CHECK-NEXT:    neg 4, 4
; CHECK-NEXT:    rotlw 3, 3, 4
; CHECK-NEXT:    blr
;
; FUTURE-LABEL: rotr_i32:
; FUTURE:       # %bb.0:
; FUTURE-NEXT:    neg 4, 4
; FUTURE-NEXT:    rotlw 3, 3, 4
; FUTURE-NEXT:    blr
  %f = call i32 @llvm.fshr.i32(i32 %x, i32 %x, i32 %z)
  ret i32 %f
}

define i64 @rotr_i64(i64 %x, i64 %z) {
; CHECK32-LABEL: rotr_i64:
; CHECK32:       # %bb.0:
; CHECK32-NEXT:    andi. 5, 6, 32
; CHECK32-NEXT:    mr 5, 3
; CHECK32-NEXT:    beq 0, .LBB11_2
; CHECK32-NEXT:  # %bb.1:
; CHECK32-NEXT:    mr 5, 4
; CHECK32-NEXT:  .LBB11_2:
; CHECK32-NEXT:    clrlwi 7, 6, 27
; CHECK32-NEXT:    srw 6, 5, 7
; CHECK32-NEXT:    beq 0, .LBB11_4
; CHECK32-NEXT:  # %bb.3:
; CHECK32-NEXT:    mr 4, 3
; CHECK32-NEXT:  .LBB11_4:
; CHECK32-NEXT:    subfic 3, 7, 32
; CHECK32-NEXT:    srw 7, 4, 7
; CHECK32-NEXT:    slw 4, 4, 3
; CHECK32-NEXT:    slw 5, 5, 3
; CHECK32-NEXT:    or 3, 4, 6
; CHECK32-NEXT:    or 4, 5, 7
; CHECK32-NEXT:    blr
;
; CHECK64-LABEL: rotr_i64:
; CHECK64:       # %bb.0:
; CHECK64-NEXT:    neg 4, 4
; CHECK64-NEXT:    rotld 3, 3, 4
; CHECK64-NEXT:    blr
;
; FUTURE-LABEL: rotr_i64:
; FUTURE:       # %bb.0:
; FUTURE-NEXT:    neg 4, 4
; FUTURE-NEXT:    rotld 3, 3, 4
; FUTURE-NEXT:    blr
  %f = call i64 @llvm.fshr.i64(i64 %x, i64 %x, i64 %z)
  ret i64 %f
}

; Vector rotate.

define <4 x i32> @rotr_v4i32(<4 x i32> %x, <4 x i32> %z) {
; CHECK32_32-LABEL: rotr_v4i32:
; CHECK32_32:       # %bb.0:
; CHECK32_32-NEXT:    neg 7, 7
; CHECK32_32-NEXT:    neg 8, 8
; CHECK32_32-NEXT:    neg 9, 9
; CHECK32_32-NEXT:    neg 10, 10
; CHECK32_32-NEXT:    rotlw 3, 3, 7
; CHECK32_32-NEXT:    rotlw 4, 4, 8
; CHECK32_32-NEXT:    rotlw 5, 5, 9
; CHECK32_32-NEXT:    rotlw 6, 6, 10
; CHECK32_32-NEXT:    blr
;
; CHECK32_64-LABEL: rotr_v4i32:
; CHECK32_64:       # %bb.0:
; CHECK32_64-NEXT:    vxor 4, 4, 4
; CHECK32_64-NEXT:    vsubuwm 3, 4, 3
; CHECK32_64-NEXT:    vrlw 2, 2, 3
; CHECK32_64-NEXT:    blr
;
; CHECK64-LABEL: rotr_v4i32:
; CHECK64:       # %bb.0:
; CHECK64-NEXT:    xxlxor 36, 36, 36
; CHECK64-NEXT:    vsubuwm 3, 4, 3
; CHECK64-NEXT:    vrlw 2, 2, 3
; CHECK64-NEXT:    blr
;
; FUTURE-LABEL: rotr_v4i32:
; FUTURE:       # %bb.0:
; FUTURE-NEXT:    vnegw 3, 3
; FUTURE-NEXT:    xvrlw 34, 34, 35
; FUTURE-NEXT:    blr
  %f = call <4 x i32> @llvm.fshr.v4i32(<4 x i32> %x, <4 x i32> %x, <4 x i32> %z)
  ret <4 x i32> %f
}

; Vector rotate by constant splat amount.

define <4 x i32> @rotr_v4i32_const_shift(<4 x i32> %x) {
; CHECK32_32-LABEL: rotr_v4i32_const_shift:
; CHECK32_32:       # %bb.0:
; CHECK32_32-NEXT:    rotlwi 3, 3, 29
; CHECK32_32-NEXT:    rotlwi 4, 4, 29
; CHECK32_32-NEXT:    rotlwi 5, 5, 29
; CHECK32_32-NEXT:    rotlwi 6, 6, 29
; CHECK32_32-NEXT:    blr
;
; CHECK32_64-LABEL: rotr_v4i32_const_shift:
; CHECK32_64:       # %bb.0:
; CHECK32_64-NEXT:    vspltisw 3, -16
; CHECK32_64-NEXT:    vspltisw 4, 13
; CHECK32_64-NEXT:    vsubuwm 3, 4, 3
; CHECK32_64-NEXT:    vrlw 2, 2, 3
; CHECK32_64-NEXT:    blr
;
; CHECK64-LABEL: rotr_v4i32_const_shift:
; CHECK64:       # %bb.0:
; CHECK64-NEXT:    vspltisw 3, -16
; CHECK64-NEXT:    vspltisw 4, 13
; CHECK64-NEXT:    vsubuwm 3, 4, 3
; CHECK64-NEXT:    vrlw 2, 2, 3
; CHECK64-NEXT:    blr
;
; FUTURE-LABEL: rotr_v4i32_const_shift:
; FUTURE:       # %bb.0:
; FUTURE-NEXT:    xxspltiw 0, 29
; FUTURE-NEXT:    xvrlw 34, 34, 0
; FUTURE-NEXT:    blr
  %f = call <4 x i32> @llvm.fshr.v4i32(<4 x i32> %x, <4 x i32> %x, <4 x i32> <i32 3, i32 3, i32 3, i32 3>)
  ret <4 x i32> %f
}

define i32 @rotl_i32_shift_by_bitwidth(i32 %x) {
; CHECK-LABEL: rotl_i32_shift_by_bitwidth:
; CHECK:       # %bb.0:
; CHECK-NEXT:    blr
;
; FUTURE-LABEL: rotl_i32_shift_by_bitwidth:
; FUTURE:       # %bb.0:
; FUTURE-NEXT:    blr
  %f = call i32 @llvm.fshl.i32(i32 %x, i32 %x, i32 32)
  ret i32 %f
}

define i32 @rotr_i32_shift_by_bitwidth(i32 %x) {
; CHECK-LABEL: rotr_i32_shift_by_bitwidth:
; CHECK:       # %bb.0:
; CHECK-NEXT:    blr
;
; FUTURE-LABEL: rotr_i32_shift_by_bitwidth:
; FUTURE:       # %bb.0:
; FUTURE-NEXT:    blr
  %f = call i32 @llvm.fshr.i32(i32 %x, i32 %x, i32 32)
  ret i32 %f
}

define <4 x i32> @rotl_v4i32_shift_by_bitwidth(<4 x i32> %x) {
; CHECK-LABEL: rotl_v4i32_shift_by_bitwidth:
; CHECK:       # %bb.0:
; CHECK-NEXT:    blr
;
; FUTURE-LABEL: rotl_v4i32_shift_by_bitwidth:
; FUTURE:       # %bb.0:
; FUTURE-NEXT:    blr
  %f = call <4 x i32> @llvm.fshl.v4i32(<4 x i32> %x, <4 x i32> %x, <4 x i32> <i32 32, i32 32, i32 32, i32 32>)
  ret <4 x i32> %f
}

define <4 x i32> @rotr_v4i32_shift_by_bitwidth(<4 x i32> %x) {
; CHECK-LABEL: rotr_v4i32_shift_by_bitwidth:
; CHECK:       # %bb.0:
; CHECK-NEXT:    blr
;
; FUTURE-LABEL: rotr_v4i32_shift_by_bitwidth:
; FUTURE:       # %bb.0:
; FUTURE-NEXT:    blr
  %f = call <4 x i32> @llvm.fshr.v4i32(<4 x i32> %x, <4 x i32> %x, <4 x i32> <i32 32, i32 32, i32 32, i32 32>)
  ret <4 x i32> %f
}