test/CodeGen/X86/gfni-xor-fold.ll

; NOTE: Assertions have been autogenerated by utils/update_llc_test_checks.py
; RUN: llc < %s -mtriple=x86_64-- -mattr=+gfni,+avx | FileCheck %s --check-prefixes=AVX
; RUN: llc < %s -mtriple=x86_64-- -mattr=+avx512vl,+gfni,+avx512bw | FileCheck %s --check-prefixes=AVX512

declare <16 x i8> @llvm.x86.vgf2p8affineqb.128(<16 x i8>, <16 x i8>, i8)
declare <32 x i8> @llvm.x86.vgf2p8affineqb.256(<32 x i8>, <32 x i8>, i8)

define <16 x i8> @test_affine_xor_fold_128(<16 x i8> %src1, <16 x i8> %src2) nounwind {
;
; AVX-LABEL: test_affine_xor_fold_128:
; AVX:       # %bb.0:
; AVX-NEXT:    vgf2p8affineqb $255, %xmm1, %xmm0, %xmm0
; AVX-NEXT:    retq
;
; AVX512-LABEL: test_affine_xor_fold_128:
; AVX512:       # %bb.0:
; AVX512-NEXT:    vgf2p8affineqb $255, %xmm1, %xmm0, %xmm0
; AVX512-NEXT:    retq
  %gfni = call <16 x i8> @llvm.x86.vgf2p8affineqb.128(<16 x i8> %src1, <16 x i8> %src2, i8 0)
  %xor = xor <16 x i8> %gfni, splat(i8 -1)
  ret <16 x i8> %xor
}

define <16 x i8> @test_affine_xor_fold_nonzero_imm(<16 x i8> %src1, <16 x i8> %src2) nounwind {
;
; AVX-LABEL: test_affine_xor_fold_nonzero_imm:
; AVX:       # %bb.0:
; AVX-NEXT:    vgf2p8affineqb $175, %xmm1, %xmm0, %xmm0
; AVX-NEXT:    retq
;
; AVX512-LABEL: test_affine_xor_fold_nonzero_imm:
; AVX512:       # %bb.0:
; AVX512-NEXT:    vgf2p8affineqb $175, %xmm1, %xmm0, %xmm0
; AVX512-NEXT:    retq
  %gfni = call <16 x i8> @llvm.x86.vgf2p8affineqb.128(<16 x i8> %src1, <16 x i8> %src2, i8 5)
  %xor = xor <16 x i8> %gfni, splat(i8 -86)
  ret <16 x i8> %xor
}

define <16 x i8> @test_affine_xor_fold_hex(<16 x i8> %src1, <16 x i8> %src2) nounwind {
;
; AVX-LABEL: test_affine_xor_fold_hex:
; AVX:       # %bb.0:
; AVX-NEXT:    vgf2p8affineqb $83, %xmm1, %xmm0, %xmm0
; AVX-NEXT:    retq
;
; AVX512-LABEL: test_affine_xor_fold_hex:
; AVX512:       # %bb.0:
; AVX512-NEXT:    vgf2p8affineqb $83, %xmm1, %xmm0, %xmm0
; AVX512-NEXT:    retq
  %gfni = call <16 x i8> @llvm.x86.vgf2p8affineqb.128(<16 x i8> %src1, <16 x i8> %src2, i8 17)
  %xor = xor <16 x i8> %gfni, splat(i8 66)
  ret <16 x i8> %xor
}

define <32 x i8> @test_affine_xor_fold_256(<32 x i8> %src1, <32 x i8> %src2) nounwind {
;
; AVX-LABEL: test_affine_xor_fold_256:
; AVX:       # %bb.0:
; AVX-NEXT:    vgf2p8affineqb $255, %ymm1, %ymm0, %ymm0
; AVX-NEXT:    retq
;
; AVX512-LABEL: test_affine_xor_fold_256:
; AVX512:       # %bb.0:
; AVX512-NEXT:    vgf2p8affineqb $255, %ymm1, %ymm0, %ymm0
; AVX512-NEXT:    retq
  %gfni = call <32 x i8> @llvm.x86.vgf2p8affineqb.256(<32 x i8> %src1, <32 x i8> %src2, i8 0)
  %xor = xor <32 x i8> %gfni, splat(i8 -1)
  ret <32 x i8> %xor
}

define <16 x i8> @test_affine_xor_fold_commutative(<16 x i8> %src1, <16 x i8> %src2) nounwind {
;
; AVX-LABEL: test_affine_xor_fold_commutative:
; AVX:       # %bb.0:
; AVX-NEXT:    vgf2p8affineqb $255, %xmm1, %xmm0, %xmm0
; AVX-NEXT:    retq
;
; AVX512-LABEL: test_affine_xor_fold_commutative:
; AVX512:       # %bb.0:
; AVX512-NEXT:    vgf2p8affineqb $255, %xmm1, %xmm0, %xmm0
; AVX512-NEXT:    retq
  %gfni = call <16 x i8> @llvm.x86.vgf2p8affineqb.128(<16 x i8> %src1, <16 x i8> %src2, i8 0)
  %xor = xor <16 x i8> splat(i8 -1), %gfni
  ret <16 x i8> %xor
}

define <16 x i8> @test_affine_xor_no_fold_multi_use(<16 x i8> %src1, <16 x i8> %src2, ptr %out) nounwind {
;
; AVX-LABEL: test_affine_xor_no_fold_multi_use:
; AVX:       # %bb.0:
; AVX-NEXT:    vgf2p8affineqb $0, %xmm1, %xmm0, %xmm0
; AVX-NEXT:    vmovdqa %xmm0, (%rdi)
; AVX-NEXT:    vpcmpeqd %xmm1, %xmm1, %xmm1
; AVX-NEXT:    vpxor %xmm1, %xmm0, %xmm0
; AVX-NEXT:    retq
;
; AVX512-LABEL: test_affine_xor_no_fold_multi_use:
; AVX512:       # %bb.0:
; AVX512-NEXT:    vgf2p8affineqb $0, %xmm1, %xmm0, %xmm0
; AVX512-NEXT:    vmovdqa %xmm0, (%rdi)
; AVX512-NEXT:    vpternlogq {{.*#+}} xmm0 = ~xmm0
; AVX512-NEXT:    retq
  %gfni = call <16 x i8> @llvm.x86.vgf2p8affineqb.128(<16 x i8> %src1, <16 x i8> %src2, i8 0)
  store <16 x i8> %gfni, ptr %out
  %xor = xor <16 x i8> %gfni, splat(i8 -1)
  ret <16 x i8> %xor
}

define <16 x i8> @test_affine_xor_no_fold_non_splat(<16 x i8> %src1, <16 x i8> %src2) nounwind {
;
; AVX-LABEL: test_affine_xor_no_fold_non_splat:
; AVX:       # %bb.0:
; AVX-NEXT:    vgf2p8affineqb $0, %xmm1, %xmm0, %xmm0
; AVX-NEXT:    vpxor {{\.?LCPI[0-9]+_[0-9]+}}(%rip), %xmm0, %xmm0
; AVX-NEXT:    retq
;
; AVX512-LABEL: test_affine_xor_no_fold_non_splat:
; AVX512:       # %bb.0:
; AVX512-NEXT:    vgf2p8affineqb $0, %xmm1, %xmm0, %xmm0
; AVX512-NEXT:    vpxor {{\.?LCPI[0-9]+_[0-9]+}}(%rip), %xmm0, %xmm0
; AVX512-NEXT:    retq
  %gfni = call <16 x i8> @llvm.x86.vgf2p8affineqb.128(<16 x i8> %src1, <16 x i8> %src2, i8 0)
  %xor = xor <16 x i8> %gfni, <i8 1, i8 2, i8 3, i8 4, i8 5, i8 6, i8 7, i8 8, i8 9, i8 10, i8 11, i8 12, i8 13, i8 14, i8 15, i8 16>
  ret <16 x i8> %xor
}

define <16 x i8> @test_affine_xor_no_fold_variable(<16 x i8> %src1, <16 x i8> %src2, <16 x i8> %var) nounwind {
;
; AVX-LABEL: test_affine_xor_no_fold_variable:
; AVX:       # %bb.0:
; AVX-NEXT:    vgf2p8affineqb $0, %xmm1, %xmm0, %xmm0
; AVX-NEXT:    vpxor %xmm2, %xmm0, %xmm0
; AVX-NEXT:    retq
;
; AVX512-LABEL: test_affine_xor_no_fold_variable:
; AVX512:       # %bb.0:
; AVX512-NEXT:    vgf2p8affineqb $0, %xmm1, %xmm0, %xmm0
; AVX512-NEXT:    vpxor %xmm2, %xmm0, %xmm0
; AVX512-NEXT:    retq
  %gfni = call <16 x i8> @llvm.x86.vgf2p8affineqb.128(<16 x i8> %src1, <16 x i8> %src2, i8 0)
  %xor = xor <16 x i8> %gfni, %var
  ret <16 x i8> %xor
}

define <16 x i8> @test_affine_src_xor_fold_128(<16 x i8> %src) nounwind {
; AVX-LABEL: test_affine_src_xor_fold_128:
; AVX:       # %bb.0:
; AVX-NEXT:    vgf2p8affineqb $0, {{\.?LCPI[0-9]+_[0-9]+}}(%rip), %xmm0, %xmm0 # [129,66,35,20,13,2,5,9,137,74,43,28,5,10,13,17]
; AVX-NEXT:    retq
;
; AVX512-LABEL: test_affine_src_xor_fold_128:
; AVX512:       # %bb.0:
; AVX512-NEXT:    vgf2p8affineqb $0, {{\.?LCPI[0-9]+_[0-9]+}}(%rip), %xmm0, %xmm0 # [129,66,35,20,13,2,5,9,137,74,43,28,5,10,13,17]
; AVX512-NEXT:    retq
  %gfni = call <16 x i8> @llvm.x86.vgf2p8affineqb.128(<16 x i8> %src, <16 x i8> <i8 1, i8 2, i8 3, i8 4, i8 5, i8 6, i8 7, i8 8, i8 9, i8 10, i8 11, i8 12, i8 13, i8 14, i8 15, i8 16>, i8 0)
  %xor = xor <16 x i8> %gfni, %src
  ret <16 x i8> %xor
}

define <32 x i8> @test_affine_src_xor_fold_256(<32 x i8> %src) nounwind {
; AVX-LABEL: test_affine_src_xor_fold_256:
; AVX:       # %bb.0:
; AVX-NEXT:    vgf2p8affineqb $0, {{\.?LCPI[0-9]+_[0-9]+}}(%rip), %ymm0, %ymm0 # [129,66,35,20,13,2,5,9,137,74,43,28,5,10,13,17,145,82,51,4,29,18,21,25,153,90,59,12,21,26,29,33]
; AVX-NEXT:    retq
;
; AVX512-LABEL: test_affine_src_xor_fold_256:
; AVX512:       # %bb.0:
; AVX512-NEXT:    vgf2p8affineqb $0, {{\.?LCPI[0-9]+_[0-9]+}}(%rip), %ymm0, %ymm0 # [129,66,35,20,13,2,5,9,137,74,43,28,5,10,13,17,145,82,51,4,29,18,21,25,153,90,59,12,21,26,29,33]
; AVX512-NEXT:    retq
  %gfni = call <32 x i8> @llvm.x86.vgf2p8affineqb.256(<32 x i8> %src, <32 x i8> <i8 1, i8 2, i8 3, i8 4, i8 5, i8 6, i8 7, i8 8, i8 9, i8 10, i8 11, i8 12, i8 13, i8 14, i8 15, i8 16, i8 17, i8 18, i8 19, i8 20, i8 21, i8 22, i8 23, i8 24, i8 25, i8 26, i8 27, i8 28, i8 29, i8 30, i8 31, i8 32>, i8 0)
  %xor = xor <32 x i8> %gfni, %src
  ret <32 x i8> %xor
}

define <16 x i8> @test_affine_src_xor_fold_alternative_matrix(<16 x i8> %src) nounwind {
; AVX-LABEL: test_affine_src_xor_fold_alternative_matrix:
; AVX:       # %bb.0:
; AVX-NEXT:    vgf2p8affineqb $0, {{\.?LCPI[0-9]+_[0-9]+}}(%rip), %xmm0, %xmm0 # [129,65,33,17,9,5,3,0,129,65,33,17,9,5,3,0]
; AVX-NEXT:    retq
;
; AVX512-LABEL: test_affine_src_xor_fold_alternative_matrix:
; AVX512:       # %bb.0:
; AVX512-NEXT:    vgf2p8affineqb $0, {{\.?LCPI[0-9]+_[0-9]+}}(%rip){1to2}, %xmm0, %xmm0 # [129,65,33,17,9,5,3,0,129,65,33,17,9,5,3,0]
; AVX512-NEXT:    retq
  %gfni = call <16 x i8> @llvm.x86.vgf2p8affineqb.128(<16 x i8> %src, <16 x i8> splat(i8 1), i8 0)
  %xor = xor <16 x i8> %gfni, %src
  ret <16 x i8> %xor
}

define <16 x i8> @test_affine_src_xor_nonzero_imm(<16 x i8> %src) nounwind {
; AVX-LABEL: test_affine_src_xor_nonzero_imm:
; AVX:       # %bb.0:
; AVX-NEXT:    vgf2p8affineqb $107, {{\.?LCPI[0-9]+_[0-9]+}}(%rip), %xmm0, %xmm0 # [129,66,35,20,13,2,5,9,137,74,43,28,5,10,13,17]
; AVX-NEXT:    retq
;
; AVX512-LABEL: test_affine_src_xor_nonzero_imm:
; AVX512:       # %bb.0:
; AVX512-NEXT:    vgf2p8affineqb $107, {{\.?LCPI[0-9]+_[0-9]+}}(%rip), %xmm0, %xmm0 # [129,66,35,20,13,2,5,9,137,74,43,28,5,10,13,17]
; AVX512-NEXT:    retq
  %gfni = call <16 x i8> @llvm.x86.vgf2p8affineqb.128(<16 x i8> %src, <16 x i8> <i8 1, i8 2, i8 3, i8 4, i8 5, i8 6, i8 7, i8 8, i8 9, i8 10, i8 11, i8 12, i8 13, i8 14, i8 15, i8 16>, i8 107)
  %xor = xor <16 x i8> %gfni, %src
  ret <16 x i8> %xor
}

define <16 x i8> @test_affine_src_xor_no_fold_multi_use(<16 x i8> %src, ptr %sink) nounwind {
; AVX-LABEL: test_affine_src_xor_no_fold_multi_use:
; AVX:       # %bb.0:
; AVX-NEXT:    vgf2p8affineqb $0, {{\.?LCPI[0-9]+_[0-9]+}}(%rip), %xmm0, %xmm1 # [1,2,3,4,5,6,7,8,9,10,11,12,13,14,15,16]
; AVX-NEXT:    vmovdqa %xmm1, (%rdi)
; AVX-NEXT:    vpxor %xmm0, %xmm1, %xmm0
; AVX-NEXT:    retq
;
; AVX512-LABEL: test_affine_src_xor_no_fold_multi_use:
; AVX512:       # %bb.0:
; AVX512-NEXT:    vgf2p8affineqb $0, {{\.?LCPI[0-9]+_[0-9]+}}(%rip), %xmm0, %xmm1 # [1,2,3,4,5,6,7,8,9,10,11,12,13,14,15,16]
; AVX512-NEXT:    vmovdqa %xmm1, (%rdi)
; AVX512-NEXT:    vpxor %xmm0, %xmm1, %xmm0
; AVX512-NEXT:    retq
  %gfni = call <16 x i8> @llvm.x86.vgf2p8affineqb.128(<16 x i8> %src, <16 x i8> <i8 1, i8 2, i8 3, i8 4, i8 5, i8 6, i8 7, i8 8, i8 9, i8 10, i8 11, i8 12, i8 13, i8 14, i8 15, i8 16>, i8 0)
  store <16 x i8> %gfni, ptr %sink
  %xor = xor <16 x i8> %gfni, %src
  ret <16 x i8> %xor
}

define <16 x i8> @test_affine_src_xor_no_fold_var_matrix(<16 x i8> %src, <16 x i8> %matrix) nounwind {
; AVX-LABEL: test_affine_src_xor_no_fold_var_matrix:
; AVX:       # %bb.0:
; AVX-NEXT:    vgf2p8affineqb $0, %xmm1, %xmm0, %xmm1
; AVX-NEXT:    vpxor %xmm0, %xmm1, %xmm0
; AVX-NEXT:    retq
;
; AVX512-LABEL: test_affine_src_xor_no_fold_var_matrix:
; AVX512:       # %bb.0:
; AVX512-NEXT:    vgf2p8affineqb $0, %xmm1, %xmm0, %xmm1
; AVX512-NEXT:    vpxor %xmm0, %xmm1, %xmm0
; AVX512-NEXT:    retq
  %gfni = call <16 x i8> @llvm.x86.vgf2p8affineqb.128(<16 x i8> %src, <16 x i8> %matrix, i8 0)
  %xor = xor <16 x i8> %gfni, %src
  ret <16 x i8> %xor
}

;; Test folding XOR of two vgf2p8affineqb with same input - 128-bit
define <16 x i8> @test_affine_affine_xor_same_source_fold_128(<16 x i8> %src, <16 x i8> %m1, <16 x i8> %m2) nounwind {
;
; AVX-LABEL: test_affine_affine_xor_same_source_fold_128:
; AVX:       # %bb.0:
; AVX-NEXT:    vpxor %xmm2, %xmm1, %xmm1
; AVX-NEXT:    vgf2p8affineqb $89, %xmm1, %xmm0, %xmm0
; AVX-NEXT:    retq
;
; AVX512-LABEL: test_affine_affine_xor_same_source_fold_128:
; AVX512:       # %bb.0:
; AVX512-NEXT:    vpxor %xmm2, %xmm1, %xmm1
; AVX512-NEXT:    vgf2p8affineqb $89, %xmm1, %xmm0, %xmm0
; AVX512-NEXT:    retq
  %gfni1 = call <16 x i8> @llvm.x86.vgf2p8affineqb.128(<16 x i8> %src, <16 x i8> %m1, i8 42)
  %gfni2 = call <16 x i8> @llvm.x86.vgf2p8affineqb.128(<16 x i8> %src, <16 x i8> %m2, i8 115)
  %xor = xor <16 x i8> %gfni1, %gfni2
  ret <16 x i8> %xor
}

;; Test with non-zero immediates - 128-bit
define <16 x i8> @test_affine_affine_xor_same_source_fold_128_nonzero(<16 x i8> %src, <16 x i8> %m1, <16 x i8> %m2) nounwind {
;
; AVX-LABEL: test_affine_affine_xor_same_source_fold_128_nonzero:
; AVX:       # %bb.0:
; AVX-NEXT:    vpxor %xmm2, %xmm1, %xmm1
; AVX-NEXT:    vgf2p8affineqb $15, %xmm1, %xmm0, %xmm0
; AVX-NEXT:    retq
;
; AVX512-LABEL: test_affine_affine_xor_same_source_fold_128_nonzero:
; AVX512:       # %bb.0:
; AVX512-NEXT:    vpxor %xmm2, %xmm1, %xmm1
; AVX512-NEXT:    vgf2p8affineqb $15, %xmm1, %xmm0, %xmm0
; AVX512-NEXT:    retq
  %gfni1 = call <16 x i8> @llvm.x86.vgf2p8affineqb.128(<16 x i8> %src, <16 x i8> %m1, i8 5)
  %gfni2 = call <16 x i8> @llvm.x86.vgf2p8affineqb.128(<16 x i8> %src, <16 x i8> %m2, i8 10)
  %xor = xor <16 x i8> %gfni1, %gfni2
  ret <16 x i8> %xor
}

;; Test commutative XOR - 128-bit
define <16 x i8> @test_affine_affine_xor_same_source_fold_128_commutative(<16 x i8> %src, <16 x i8> %m1, <16 x i8> %m2) nounwind {
;
; AVX-LABEL: test_affine_affine_xor_same_source_fold_128_commutative:
; AVX:       # %bb.0:
; AVX-NEXT:    vpxor %xmm1, %xmm2, %xmm1
; AVX-NEXT:    vgf2p8affineqb $166, %xmm1, %xmm0, %xmm0
; AVX-NEXT:    retq
;
; AVX512-LABEL: test_affine_affine_xor_same_source_fold_128_commutative:
; AVX512:       # %bb.0:
; AVX512-NEXT:    vpxor %xmm1, %xmm2, %xmm1
; AVX512-NEXT:    vgf2p8affineqb $166, %xmm1, %xmm0, %xmm0
; AVX512-NEXT:    retq
  %gfni1 = call <16 x i8> @llvm.x86.vgf2p8affineqb.128(<16 x i8> %src, <16 x i8> %m1, i8 199)
  %gfni2 = call <16 x i8> @llvm.x86.vgf2p8affineqb.128(<16 x i8> %src, <16 x i8> %m2, i8 97)
  %xor = xor <16 x i8> %gfni2, %gfni1
  ret <16 x i8> %xor
}

;; Negative test: multi-use should not fold - 128-bit
define <16 x i8> @test_affine_affine_xor_same_source_no_fold_multi_use(<16 x i8> %src, <16 x i8> %m1, <16 x i8> %m2, ptr %out) nounwind {
;
; AVX-LABEL: test_affine_affine_xor_same_source_no_fold_multi_use:
; AVX:       # %bb.0:
; AVX-NEXT:    vgf2p8affineqb $23, %xmm1, %xmm0, %xmm1
; AVX-NEXT:    vgf2p8affineqb $200, %xmm2, %xmm0, %xmm0
; AVX-NEXT:    vmovdqa %xmm1, (%rdi)
; AVX-NEXT:    vpxor %xmm0, %xmm1, %xmm0
; AVX-NEXT:    retq
;
; AVX512-LABEL: test_affine_affine_xor_same_source_no_fold_multi_use:
; AVX512:       # %bb.0:
; AVX512-NEXT:    vgf2p8affineqb $23, %xmm1, %xmm0, %xmm1
; AVX512-NEXT:    vgf2p8affineqb $200, %xmm2, %xmm0, %xmm0
; AVX512-NEXT:    vmovdqa %xmm1, (%rdi)
; AVX512-NEXT:    vpxor %xmm0, %xmm1, %xmm0
; AVX512-NEXT:    retq
  %gfni1 = call <16 x i8> @llvm.x86.vgf2p8affineqb.128(<16 x i8> %src, <16 x i8> %m1, i8 23)
  %gfni2 = call <16 x i8> @llvm.x86.vgf2p8affineqb.128(<16 x i8> %src, <16 x i8> %m2, i8 200)
  store <16 x i8> %gfni1, ptr %out
  %xor = xor <16 x i8> %gfni1, %gfni2
  ret <16 x i8> %xor
}

;; Test folding XOR of two vgf2p8affineqb with same matrix
define <16 x i8> @test_affine_affine_same_matrix_fold_128(<16 x i8> %src1, <16 x i8> %src2, <16 x i8> %m) nounwind {
; AVX-LABEL: test_affine_affine_same_matrix_fold_128:
; AVX:       # %bb.0:
; AVX-NEXT:    vpxor %xmm1, %xmm0, %xmm0
; AVX-NEXT:    vgf2p8affineqb $0, %xmm2, %xmm0, %xmm0
; AVX-NEXT:    retq
;
; AVX512-LABEL: test_affine_affine_same_matrix_fold_128:
; AVX512:       # %bb.0:
; AVX512-NEXT:    vpxor %xmm1, %xmm0, %xmm0
; AVX512-NEXT:    vgf2p8affineqb $0, %xmm2, %xmm0, %xmm0
; AVX512-NEXT:    retq
  %gfni1 = call <16 x i8> @llvm.x86.vgf2p8affineqb.128(<16 x i8> %src1, <16 x i8> %m, i8 0)
  %gfni2 = call <16 x i8> @llvm.x86.vgf2p8affineqb.128(<16 x i8> %src2, <16 x i8> %m, i8 0)
  %xor = xor <16 x i8> %gfni1, %gfni2
  ret <16 x i8> %xor
}

define <16 x i8> @test_affine_affine_same_matrix_fold_immediate(<16 x i8> %src1, <16 x i8> %src2, <16 x i8> %m) nounwind {
; AVX-LABEL: test_affine_affine_same_matrix_fold_immediate:
; AVX:       # %bb.0:
; AVX-NEXT:    vpxor %xmm1, %xmm0, %xmm0
; AVX-NEXT:    vgf2p8affineqb $130, %xmm2, %xmm0, %xmm0
; AVX-NEXT:    retq
;
; AVX512-LABEL: test_affine_affine_same_matrix_fold_immediate:
; AVX512:       # %bb.0:
; AVX512-NEXT:    vpxor %xmm1, %xmm0, %xmm0
; AVX512-NEXT:    vgf2p8affineqb $130, %xmm2, %xmm0, %xmm0
; AVX512-NEXT:    retq
  %gfni1 = call <16 x i8> @llvm.x86.vgf2p8affineqb.128(<16 x i8> %src1, <16 x i8> %m, i8 183)
  %gfni2 = call <16 x i8> @llvm.x86.vgf2p8affineqb.128(<16 x i8> %src2, <16 x i8> %m, i8 53)
  %xor = xor <16 x i8> %gfni1, %gfni2
  ret <16 x i8> %xor
}

define <16 x i8> @test_affine_affine_same_matrix_no_fold_multi_use(<16 x i8> %src1, <16 x i8> %src2, <16 x i8> %m, ptr %sink) nounwind {
; AVX-LABEL: test_affine_affine_same_matrix_no_fold_multi_use:
; AVX:       # %bb.0:
; AVX-NEXT:    vgf2p8affineqb $23, %xmm2, %xmm0, %xmm0
; AVX-NEXT:    vgf2p8affineqb $200, %xmm2, %xmm1, %xmm1
; AVX-NEXT:    vmovdqa %xmm0, (%rdi)
; AVX-NEXT:    vpxor %xmm1, %xmm0, %xmm0
; AVX-NEXT:    retq
;
; AVX512-LABEL: test_affine_affine_same_matrix_no_fold_multi_use:
; AVX512:       # %bb.0:
; AVX512-NEXT:    vgf2p8affineqb $23, %xmm2, %xmm0, %xmm0
; AVX512-NEXT:    vgf2p8affineqb $200, %xmm2, %xmm1, %xmm1
; AVX512-NEXT:    vmovdqa %xmm0, (%rdi)
; AVX512-NEXT:    vpxor %xmm1, %xmm0, %xmm0
; AVX512-NEXT:    retq
  %gfni1 = call <16 x i8> @llvm.x86.vgf2p8affineqb.128(<16 x i8> %src1, <16 x i8> %m, i8 23)
  %gfni2 = call <16 x i8> @llvm.x86.vgf2p8affineqb.128(<16 x i8> %src2, <16 x i8> %m, i8 200)
  store <16 x i8> %gfni1, ptr %sink
  %xor = xor <16 x i8> %gfni1, %gfni2
  ret <16 x i8> %xor
}

;; Negative test: different inputs should not fold - 128-bit
define <16 x i8> @test_affine_affine_xor_no_fold_different_inputs(<16 x i8> %src1, <16 x i8> %src2, <16 x i8> %m1, <16 x i8> %m2) nounwind {
;
; AVX-LABEL: test_affine_affine_xor_no_fold_different_inputs:
; AVX:       # %bb.0:
; AVX-NEXT:    vgf2p8affineqb $55, %xmm2, %xmm0, %xmm0
; AVX-NEXT:    vgf2p8affineqb $77, %xmm3, %xmm1, %xmm1
; AVX-NEXT:    vpxor %xmm1, %xmm0, %xmm0
; AVX-NEXT:    retq
;
; AVX512-LABEL: test_affine_affine_xor_no_fold_different_inputs:
; AVX512:       # %bb.0:
; AVX512-NEXT:    vgf2p8affineqb $55, %xmm2, %xmm0, %xmm0
; AVX512-NEXT:    vgf2p8affineqb $77, %xmm3, %xmm1, %xmm1
; AVX512-NEXT:    vpxor %xmm1, %xmm0, %xmm0
; AVX512-NEXT:    retq
  %gfni1 = call <16 x i8> @llvm.x86.vgf2p8affineqb.128(<16 x i8> %src1, <16 x i8> %m1, i8 55)
  %gfni2 = call <16 x i8> @llvm.x86.vgf2p8affineqb.128(<16 x i8> %src2, <16 x i8> %m2, i8 77)
  %xor = xor <16 x i8> %gfni1, %gfni2
  ret <16 x i8> %xor
}

;; Test 256-bit vectors
define <32 x i8> @test_affine_affine_xor_same_source_fold_256(<32 x i8> %src, <32 x i8> %m1, <32 x i8> %m2) nounwind {
;
; AVX-LABEL: test_affine_affine_xor_same_source_fold_256:
; AVX:       # %bb.0:
; AVX-NEXT:    vxorps %ymm2, %ymm1, %ymm1
; AVX-NEXT:    vgf2p8affineqb $89, %ymm1, %ymm0, %ymm0
; AVX-NEXT:    retq
;
; AVX512-LABEL: test_affine_affine_xor_same_source_fold_256:
; AVX512:       # %bb.0:
; AVX512-NEXT:    vpxor %ymm2, %ymm1, %ymm1
; AVX512-NEXT:    vgf2p8affineqb $89, %ymm1, %ymm0, %ymm0
; AVX512-NEXT:    retq
  %gfni1 = call <32 x i8> @llvm.x86.vgf2p8affineqb.256(<32 x i8> %src, <32 x i8> %m1, i8 42)
  %gfni2 = call <32 x i8> @llvm.x86.vgf2p8affineqb.256(<32 x i8> %src, <32 x i8> %m2, i8 115)
  %xor = xor <32 x i8> %gfni1, %gfni2
  ret <32 x i8> %xor
}

define <32 x i8> @test_affine_affine_same_matrix_fold_256(<32 x i8> %src1, <32 x i8> %src2, <32 x i8> %m) nounwind {
; AVX-LABEL: test_affine_affine_same_matrix_fold_256:
; AVX:       # %bb.0:
; AVX-NEXT:    vxorps %ymm1, %ymm0, %ymm0
; AVX-NEXT:    vgf2p8affineqb $89, %ymm2, %ymm0, %ymm0
; AVX-NEXT:    retq
;
; AVX512-LABEL: test_affine_affine_same_matrix_fold_256:
; AVX512:       # %bb.0:
; AVX512-NEXT:    vpxor %ymm1, %ymm0, %ymm0
; AVX512-NEXT:    vgf2p8affineqb $89, %ymm2, %ymm0, %ymm0
; AVX512-NEXT:    retq
  %gfni1 = call <32 x i8> @llvm.x86.vgf2p8affineqb.256(<32 x i8> %src1, <32 x i8> %m, i8 42)
  %gfni2 = call <32 x i8> @llvm.x86.vgf2p8affineqb.256(<32 x i8> %src2, <32 x i8> %m, i8 115)
  %xor = xor <32 x i8> %gfni1, %gfni2
  ret <32 x i8> %xor
}

define <16 x i8> @test_source_xor_fold_splat2(<16 x i8> %src) nounwind {
; AVX-LABEL: test_source_xor_fold_splat2:
; AVX:       # %bb.0:
; AVX-NEXT:    vgf2p8affineqb $127, {{\.?LCPI[0-9]+_[0-9]+}}(%rip), %xmm0, %xmm0 # [2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,2]
; AVX-NEXT:    retq
;
; AVX512-LABEL: test_source_xor_fold_splat2:
; AVX512:       # %bb.0:
; AVX512-NEXT:    vgf2p8affineqb $127, {{\.?LCPI[0-9]+_[0-9]+}}(%rip){1to2}, %xmm0, %xmm0 # [2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,2]
; AVX512-NEXT:    retq
  %xor = xor <16 x i8> %src, splat(i8 255)
  %bit2 = call <16 x i8> @llvm.x86.vgf2p8affineqb.128(<16 x i8> %xor, <16 x i8> splat(i8 2), i8 128)
  ret <16 x i8> %bit2
}

define <16 x i8> @test_source_xor_fold_bitrev(<16 x i8> %src) nounwind {
; AVX-LABEL: test_source_xor_fold_bitrev:
; AVX:       # %bb.0:
; AVX-NEXT:    vgf2p8affineqb $255, {{\.?LCPI[0-9]+_[0-9]+}}(%rip), %xmm0, %xmm0 # [1,2,4,8,16,32,64,128,1,2,4,8,16,32,64,128]
; AVX-NEXT:    retq
;
; AVX512-LABEL: test_source_xor_fold_bitrev:
; AVX512:       # %bb.0:
; AVX512-NEXT:    vgf2p8affineqb $255, {{\.?LCPI[0-9]+_[0-9]+}}(%rip){1to2}, %xmm0, %xmm0 # [1,2,4,8,16,32,64,128,1,2,4,8,16,32,64,128]
; AVX512-NEXT:    retq
  %xor = xor <16 x i8> %src, splat(i8 15)
  %rev = call <16 x i8> @llvm.x86.vgf2p8affineqb.128(<16 x i8> %xor, <16 x i8> <i8 1, i8 2, i8 4, i8 8, i8 16, i8 32, i8 64, i8 128, i8 1, i8 2, i8 4, i8 8, i8 16, i8 32, i8 64, i8 128>, i8 15)
  ret <16 x i8> %rev
}

define <16 x i8> @test_source_xor_fold_rotl2(<16 x i8> %src) nounwind {
; AVX-LABEL: test_source_xor_fold_rotl2:
; AVX:       # %bb.0:
; AVX-NEXT:    vgf2p8affineqb $5, {{\.?LCPI[0-9]+_[0-9]+}}(%rip), %xmm0, %xmm0 # [32,16,8,4,2,1,128,64,32,16,8,4,2,1,128,64]
; AVX-NEXT:    retq
;
; AVX512-LABEL: test_source_xor_fold_rotl2:
; AVX512:       # %bb.0:
; AVX512-NEXT:    vgf2p8affineqb $5, {{\.?LCPI[0-9]+_[0-9]+}}(%rip){1to2}, %xmm0, %xmm0 # [32,16,8,4,2,1,128,64,32,16,8,4,2,1,128,64]
; AVX512-NEXT:    retq
  %xor = xor <16 x i8> %src, splat(i8 193)
  %rotl2 = call <16 x i8> @llvm.x86.vgf2p8affineqb.128(<16 x i8> %xor, <16 x i8> <i8 32, i8 16, i8 8, i8 4, i8 2, i8 1, i8 128, i8 64, i8 32, i8 16, i8 8, i8 4, i8 2, i8 1, i8 128, i8 64>, i8 2)
  ret <16 x i8> %rotl2
}

define <16 x i8> @test_source_xor_fold_cumulative_parity(<16 x i8> %src) nounwind {
; AVX-LABEL: test_source_xor_fold_cumulative_parity:
; AVX:       # %bb.0:
; AVX-NEXT:    vgf2p8affineqb $158, {{\.?LCPI[0-9]+_[0-9]+}}(%rip), %xmm0, %xmm0 # [255,127,63,31,15,7,3,1,255,127,63,31,15,7,3,1]
; AVX-NEXT:    retq
;
; AVX512-LABEL: test_source_xor_fold_cumulative_parity:
; AVX512:       # %bb.0:
; AVX512-NEXT:    vgf2p8affineqb $158, {{\.?LCPI[0-9]+_[0-9]+}}(%rip){1to2}, %xmm0, %xmm0 # [255,127,63,31,15,7,3,1,255,127,63,31,15,7,3,1]
; AVX512-NEXT:    retq
  %xor = xor <16 x i8> %src, splat(i8 162)
  %parity = call <16 x i8> @llvm.x86.vgf2p8affineqb.128(<16 x i8> %xor, <16 x i8> <i8 255, i8 127, i8 63, i8 31, i8 15, i8 7, i8 3, i8 1, i8 255, i8 127, i8 63, i8 31, i8 15, i8 7, i8 3, i8 1>, i8 0)
  ret <16 x i8> %parity
}

;; Positive test: multi-use still shortens the dependency chain
define <16 x i8> @test_source_xor_fold_multiuse(<16 x i8> %src, ptr %sink) nounwind {
; AVX-LABEL: test_source_xor_fold_multiuse:
; AVX:       # %bb.0:
; AVX-NEXT:    vpcmpeqd %xmm1, %xmm1, %xmm1
; AVX-NEXT:    vpxor %xmm1, %xmm0, %xmm1
; AVX-NEXT:    vmovdqa %xmm1, (%rdi)
; AVX-NEXT:    vgf2p8affineqb $127, {{\.?LCPI[0-9]+_[0-9]+}}(%rip), %xmm0, %xmm0 # [2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,2]
; AVX-NEXT:    retq
;
; AVX512-LABEL: test_source_xor_fold_multiuse:
; AVX512:       # %bb.0:
; AVX512-NEXT:    vgf2p8affineqb $127, {{\.?LCPI[0-9]+_[0-9]+}}(%rip){1to2}, %xmm0, %xmm1 # [2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,2]
; AVX512-NEXT:    vpternlogq {{.*#+}} xmm0 = ~xmm0
; AVX512-NEXT:    vmovdqa %xmm0, (%rdi)
; AVX512-NEXT:    vmovdqa %xmm1, %xmm0
; AVX512-NEXT:    retq
  %xor = xor <16 x i8> %src, splat(i8 255)
  store <16 x i8> %xor, ptr %sink
  %bit2 = call <16 x i8> @llvm.x86.vgf2p8affineqb.128(<16 x i8> %xor, <16 x i8> splat(i8 2), i8 128)
  ret <16 x i8> %bit2
}

define <16 x i8> @test_source_xor_no_fold_nonsplat_xor(<16 x i8> %src) nounwind {
; AVX-LABEL: test_source_xor_no_fold_nonsplat_xor:
; AVX:       # %bb.0:
; AVX-NEXT:    vpxor {{\.?LCPI[0-9]+_[0-9]+}}(%rip), %xmm0, %xmm0
; AVX-NEXT:    vgf2p8affineqb $128, {{\.?LCPI[0-9]+_[0-9]+}}(%rip), %xmm0, %xmm0 # [2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,2]
; AVX-NEXT:    retq
;
; AVX512-LABEL: test_source_xor_no_fold_nonsplat_xor:
; AVX512:       # %bb.0:
; AVX512-NEXT:    vpxor {{\.?LCPI[0-9]+_[0-9]+}}(%rip), %xmm0, %xmm0
; AVX512-NEXT:    vgf2p8affineqb $128, {{\.?LCPI[0-9]+_[0-9]+}}(%rip){1to2}, %xmm0, %xmm0 # [2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,2]
; AVX512-NEXT:    retq
  %xor = xor <16 x i8> %src, <i8 0, i8 1, i8 2, i8 3, i8 4, i8 5, i8 6, i8 7, i8 8, i8 9, i8 10, i8 11, i8 12, i8 13, i8 14, i8 15>
  %bit2 = call <16 x i8> @llvm.x86.vgf2p8affineqb.128(<16 x i8> %xor, <16 x i8> splat(i8 2), i8 128)
  ret <16 x i8> %bit2
}

define <16 x i8> @test_source_xor_no_fold_nonsplat_matrix(<16 x i8> %src) nounwind {
; AVX-LABEL: test_source_xor_no_fold_nonsplat_matrix:
; AVX:       # %bb.0:
; AVX-NEXT:    vpxor {{\.?LCPI[0-9]+_[0-9]+}}(%rip), %xmm0, %xmm0
; AVX-NEXT:    vgf2p8affineqb $15, {{\.?LCPI[0-9]+_[0-9]+}}(%rip), %xmm0, %xmm0 # [0,1,2,3,4,5,6,7,8,9,10,11,12,13,14,15]
; AVX-NEXT:    retq
;
; AVX512-LABEL: test_source_xor_no_fold_nonsplat_matrix:
; AVX512:       # %bb.0:
; AVX512-NEXT:    vpxord {{\.?LCPI[0-9]+_[0-9]+}}(%rip){1to4}, %xmm0, %xmm0
; AVX512-NEXT:    vgf2p8affineqb $15, {{\.?LCPI[0-9]+_[0-9]+}}(%rip), %xmm0, %xmm0 # [0,1,2,3,4,5,6,7,8,9,10,11,12,13,14,15]
; AVX512-NEXT:    retq
  %xor = xor <16 x i8> %src, splat(i8 15)
  %gfni = call <16 x i8> @llvm.x86.vgf2p8affineqb.128(<16 x i8> %xor, <16 x i8> <i8 0, i8 1, i8 2, i8 3, i8 4, i8 5, i8 6, i8 7, i8 8, i8 9, i8 10, i8 11, i8 12, i8 13, i8 14, i8 15>, i8 15)
  ret <16 x i8> %gfni
}

define <16 x i8> @test_source_xor_no_fold_variable_xor(<16 x i8> %src, <16 x i8> %val) nounwind {
; AVX-LABEL: test_source_xor_no_fold_variable_xor:
; AVX:       # %bb.0:
; AVX-NEXT:    vpxor %xmm1, %xmm0, %xmm0
; AVX-NEXT:    vgf2p8affineqb $128, {{\.?LCPI[0-9]+_[0-9]+}}(%rip), %xmm0, %xmm0 # [2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,2]
; AVX-NEXT:    retq
;
; AVX512-LABEL: test_source_xor_no_fold_variable_xor:
; AVX512:       # %bb.0:
; AVX512-NEXT:    vpxor %xmm1, %xmm0, %xmm0
; AVX512-NEXT:    vgf2p8affineqb $128, {{\.?LCPI[0-9]+_[0-9]+}}(%rip){1to2}, %xmm0, %xmm0 # [2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,2]
; AVX512-NEXT:    retq
  %xor = xor <16 x i8> %src, %val
  %bit2 = call <16 x i8> @llvm.x86.vgf2p8affineqb.128(<16 x i8> %xor, <16 x i8> splat(i8 2), i8 128)
  ret <16 x i8> %bit2
}

define <16 x i8> @test_source_xor_no_fold_variable_matrix(<16 x i8> %src, <16 x i8> %matrix) nounwind {
; AVX-LABEL: test_source_xor_no_fold_variable_matrix:
; AVX:       # %bb.0:
; AVX-NEXT:    vpxor {{\.?LCPI[0-9]+_[0-9]+}}(%rip), %xmm0, %xmm0
; AVX-NEXT:    vgf2p8affineqb $15, %xmm1, %xmm0, %xmm0
; AVX-NEXT:    retq
;
; AVX512-LABEL: test_source_xor_no_fold_variable_matrix:
; AVX512:       # %bb.0:
; AVX512-NEXT:    vpxord {{\.?LCPI[0-9]+_[0-9]+}}(%rip){1to4}, %xmm0, %xmm0
; AVX512-NEXT:    vgf2p8affineqb $15, %xmm1, %xmm0, %xmm0
; AVX512-NEXT:    retq
  %xor = xor <16 x i8> %src, splat(i8 15)
  %gfni = call <16 x i8> @llvm.x86.vgf2p8affineqb.128(<16 x i8> %xor, <16 x i8> %matrix, i8 15)
  ret <16 x i8> %gfni
}