From 132c67da44998f951f10f0f1d933f21bf9b705bb Mon Sep 17 00:00:00 2001 From: Klaus Post Date: Sun, 27 Nov 2022 13:57:57 +0100 Subject: [PATCH 01/10] Add GFNI tables GFNI instructions added as 'extras'. See #335 --- internal/inst/ztable.go | 675 ++++++++++++++++++++++++++++ internal/opcodesextra/gfni.go | 822 ++++++++++++++++++++++++++++++++++ 2 files changed, 1497 insertions(+) create mode 100644 internal/opcodesextra/gfni.go diff --git a/internal/inst/ztable.go b/internal/inst/ztable.go index dd1b04f5..b9460240 100644 --- a/internal/inst/ztable.go +++ b/internal/inst/ztable.go @@ -4698,6 +4698,78 @@ var Instructions = []Instruction{ }, }, }, + { + Opcode: "GF2P8AFFINEINVQB", + Summary: "Galois Field Affine Transformation Inverse", + Forms: []Form{ + { + ISA: []string{"SSE2", "GFNI"}, + Operands: []Operand{ + {Type: "imm8", Action: 0x1}, + {Type: "m128", Action: 0x1}, + {Type: "xmm", Action: 0x2}, + }, + EncodingType: 0x2, + }, + { + ISA: []string{"SSE2", "GFNI"}, + Operands: []Operand{ + {Type: "imm8", Action: 0x1}, + {Type: "xmm", Action: 0x1}, + {Type: "xmm", Action: 0x2}, + }, + EncodingType: 0x2, + }, + }, + }, + { + Opcode: "GF2P8AFFINEQB", + Summary: "Galois Field Affine Transformation", + Forms: []Form{ + { + ISA: []string{"SSE2", "GFNI"}, + Operands: []Operand{ + {Type: "imm8", Action: 0x1}, + {Type: "m128", Action: 0x1}, + {Type: "xmm", Action: 0x2}, + }, + EncodingType: 0x2, + }, + { + ISA: []string{"SSE2", "GFNI"}, + Operands: []Operand{ + {Type: "imm8", Action: 0x1}, + {Type: "xmm", Action: 0x1}, + {Type: "xmm", Action: 0x2}, + }, + EncodingType: 0x2, + }, + }, + }, + { + Opcode: "GF2P8MULB", + Summary: "Galois Field Multiply Bytes", + Forms: []Form{ + { + ISA: []string{"SSE2", "GFNI"}, + Operands: []Operand{ + {Type: "imm8", Action: 0x1}, + {Type: "m128", Action: 0x1}, + {Type: "xmm", Action: 0x2}, + }, + EncodingType: 0x2, + }, + { + ISA: []string{"SSE2", "GFNI"}, + Operands: []Operand{ + {Type: "imm8", Action: 0x1}, + {Type: "xmm", Action: 0x1}, + {Type: "xmm", Action: 0x2}, + }, + EncodingType: 0x2, + }, + }, + }, { Opcode: "HADDPD", Summary: "Packed Double-FP Horizontal Add", @@ -50572,6 +50644,609 @@ var Instructions = []Instruction{ }, }, }, + { + Opcode: "VGF2P8AFFINEINVQB", + Summary: "Galois Field Affine Transformation Inverse", + Forms: []Form{ + { + ISA: []string{"AVX", "GFNI"}, + Operands: []Operand{ + {Type: "imm8", Action: 0x1}, + {Type: "m128", Action: 0x1}, + {Type: "xmm", Action: 0x1}, + {Type: "xmm", Action: 0x2}, + }, + EncodingType: 0x3, + }, + { + ISA: []string{"AVX", "GFNI"}, + Operands: []Operand{ + {Type: "imm8", Action: 0x1}, + {Type: "m256", Action: 0x1}, + {Type: "ymm", Action: 0x1}, + {Type: "ymm", Action: 0x2}, + }, + EncodingType: 0x3, + }, + { + ISA: []string{"AVX", "GFNI"}, + Operands: []Operand{ + {Type: "imm8", Action: 0x1}, + {Type: "xmm", Action: 0x1}, + {Type: "xmm", Action: 0x1}, + {Type: "xmm", Action: 0x2}, + }, + EncodingType: 0x3, + }, + { + ISA: []string{"AVX", "GFNI"}, + Operands: []Operand{ + {Type: "imm8", Action: 0x1}, + {Type: "ymm", Action: 0x1}, + {Type: "ymm", Action: 0x1}, + {Type: "ymm", Action: 0x2}, + }, + EncodingType: 0x3, + }, + { + ISA: []string{"AVX512F", "GFNI"}, + Operands: []Operand{ + {Type: "imm8", Action: 0x1}, + {Type: "m512", Action: 0x1}, + {Type: "zmm", Action: 0x1}, + {Type: "k", Action: 0x1}, + {Type: "zmm", Action: 0x2}, + }, + EncodingType: 0x4, + }, + { + ISA: []string{"AVX512F", "GFNI"}, + Operands: []Operand{ + {Type: "imm8", Action: 0x1}, + {Type: "m512", Action: 0x1}, + {Type: "zmm", Action: 0x1}, + {Type: "zmm", Action: 0x2}, + }, + EncodingType: 0x4, + }, + { + ISA: []string{"AVX512F", "GFNI"}, + Operands: []Operand{ + {Type: "imm8", Action: 0x1}, + {Type: "m64", Action: 0x1}, + {Type: "zmm", Action: 0x1}, + {Type: "k", Action: 0x1}, + {Type: "zmm", Action: 0x2}, + }, + EncodingType: 0x4, + Broadcast: true, + }, + { + ISA: []string{"AVX512F", "GFNI"}, + Operands: []Operand{ + {Type: "imm8", Action: 0x1}, + {Type: "m64", Action: 0x1}, + {Type: "zmm", Action: 0x1}, + {Type: "zmm", Action: 0x2}, + }, + EncodingType: 0x4, + Broadcast: true, + }, + { + ISA: []string{"AVX512F", "GFNI"}, + Operands: []Operand{ + {Type: "imm8", Action: 0x1}, + {Type: "zmm", Action: 0x1}, + {Type: "zmm", Action: 0x1}, + {Type: "k", Action: 0x1}, + {Type: "zmm", Action: 0x2}, + }, + EncodingType: 0x4, + }, + { + ISA: []string{"AVX512F", "GFNI"}, + Operands: []Operand{ + {Type: "imm8", Action: 0x1}, + {Type: "zmm", Action: 0x1}, + {Type: "zmm", Action: 0x1}, + {Type: "zmm", Action: 0x2}, + }, + EncodingType: 0x4, + }, + { + ISA: []string{"AVX512VL", "GFNI"}, + Operands: []Operand{ + {Type: "imm8", Action: 0x1}, + {Type: "m128", Action: 0x1}, + {Type: "xmm", Action: 0x1}, + {Type: "k", Action: 0x1}, + {Type: "xmm", Action: 0x2}, + }, + EncodingType: 0x4, + }, + { + ISA: []string{"AVX512VL", "GFNI"}, + Operands: []Operand{ + {Type: "imm8", Action: 0x1}, + {Type: "m256", Action: 0x1}, + {Type: "ymm", Action: 0x1}, + {Type: "k", Action: 0x1}, + {Type: "ymm", Action: 0x2}, + }, + EncodingType: 0x4, + }, + { + ISA: []string{"AVX512VL", "GFNI"}, + Operands: []Operand{ + {Type: "imm8", Action: 0x1}, + {Type: "m64", Action: 0x1}, + {Type: "xmm", Action: 0x1}, + {Type: "k", Action: 0x1}, + {Type: "xmm", Action: 0x2}, + }, + EncodingType: 0x4, + Broadcast: true, + }, + { + ISA: []string{"AVX512VL", "GFNI"}, + Operands: []Operand{ + {Type: "imm8", Action: 0x1}, + {Type: "m64", Action: 0x1}, + {Type: "xmm", Action: 0x1}, + {Type: "xmm", Action: 0x2}, + }, + EncodingType: 0x4, + Broadcast: true, + }, + { + ISA: []string{"AVX512VL", "GFNI"}, + Operands: []Operand{ + {Type: "imm8", Action: 0x1}, + {Type: "m64", Action: 0x1}, + {Type: "ymm", Action: 0x1}, + {Type: "k", Action: 0x1}, + {Type: "ymm", Action: 0x2}, + }, + EncodingType: 0x4, + Broadcast: true, + }, + { + ISA: []string{"AVX512VL", "GFNI"}, + Operands: []Operand{ + {Type: "imm8", Action: 0x1}, + {Type: "m64", Action: 0x1}, + {Type: "ymm", Action: 0x1}, + {Type: "ymm", Action: 0x2}, + }, + EncodingType: 0x4, + Broadcast: true, + }, + { + ISA: []string{"AVX512VL", "GFNI"}, + Operands: []Operand{ + {Type: "imm8", Action: 0x1}, + {Type: "xmm", Action: 0x1}, + {Type: "xmm", Action: 0x1}, + {Type: "k", Action: 0x1}, + {Type: "xmm", Action: 0x2}, + }, + EncodingType: 0x4, + }, + { + ISA: []string{"AVX512VL", "GFNI"}, + Operands: []Operand{ + {Type: "imm8", Action: 0x1}, + {Type: "ymm", Action: 0x1}, + {Type: "ymm", Action: 0x1}, + {Type: "k", Action: 0x1}, + {Type: "ymm", Action: 0x2}, + }, + EncodingType: 0x4, + }, + }, + }, + { + Opcode: "VGF2P8AFFINEQB", + Summary: "Galois Field Affine Transformation", + Forms: []Form{ + { + ISA: []string{"AVX", "GFNI"}, + Operands: []Operand{ + {Type: "imm8", Action: 0x1}, + {Type: "m128", Action: 0x1}, + {Type: "xmm", Action: 0x1}, + {Type: "xmm", Action: 0x2}, + }, + EncodingType: 0x3, + }, + { + ISA: []string{"AVX", "GFNI"}, + Operands: []Operand{ + {Type: "imm8", Action: 0x1}, + {Type: "m256", Action: 0x1}, + {Type: "ymm", Action: 0x1}, + {Type: "ymm", Action: 0x2}, + }, + EncodingType: 0x3, + }, + { + ISA: []string{"AVX", "GFNI"}, + Operands: []Operand{ + {Type: "imm8", Action: 0x1}, + {Type: "xmm", Action: 0x1}, + {Type: "xmm", Action: 0x1}, + {Type: "xmm", Action: 0x2}, + }, + EncodingType: 0x3, + }, + { + ISA: []string{"AVX", "GFNI"}, + Operands: []Operand{ + {Type: "imm8", Action: 0x1}, + {Type: "ymm", Action: 0x1}, + {Type: "ymm", Action: 0x1}, + {Type: "ymm", Action: 0x2}, + }, + EncodingType: 0x3, + }, + { + ISA: []string{"AVX512F", "GFNI"}, + Operands: []Operand{ + {Type: "imm8", Action: 0x1}, + {Type: "m512", Action: 0x1}, + {Type: "zmm", Action: 0x1}, + {Type: "k", Action: 0x1}, + {Type: "zmm", Action: 0x2}, + }, + EncodingType: 0x4, + }, + { + ISA: []string{"AVX512F", "GFNI"}, + Operands: []Operand{ + {Type: "imm8", Action: 0x1}, + {Type: "m512", Action: 0x1}, + {Type: "zmm", Action: 0x1}, + {Type: "zmm", Action: 0x2}, + }, + EncodingType: 0x4, + }, + { + ISA: []string{"AVX512F", "GFNI"}, + Operands: []Operand{ + {Type: "imm8", Action: 0x1}, + {Type: "m64", Action: 0x1}, + {Type: "zmm", Action: 0x1}, + {Type: "k", Action: 0x1}, + {Type: "zmm", Action: 0x2}, + }, + EncodingType: 0x4, + Broadcast: true, + }, + { + ISA: []string{"AVX512F", "GFNI"}, + Operands: []Operand{ + {Type: "imm8", Action: 0x1}, + {Type: "m64", Action: 0x1}, + {Type: "zmm", Action: 0x1}, + {Type: "zmm", Action: 0x2}, + }, + EncodingType: 0x4, + Broadcast: true, + }, + { + ISA: []string{"AVX512F", "GFNI"}, + Operands: []Operand{ + {Type: "imm8", Action: 0x1}, + {Type: "zmm", Action: 0x1}, + {Type: "zmm", Action: 0x1}, + {Type: "k", Action: 0x1}, + {Type: "zmm", Action: 0x2}, + }, + EncodingType: 0x4, + }, + { + ISA: []string{"AVX512F", "GFNI"}, + Operands: []Operand{ + {Type: "imm8", Action: 0x1}, + {Type: "zmm", Action: 0x1}, + {Type: "zmm", Action: 0x1}, + {Type: "zmm", Action: 0x2}, + }, + EncodingType: 0x4, + }, + { + ISA: []string{"AVX512VL", "GFNI"}, + Operands: []Operand{ + {Type: "imm8", Action: 0x1}, + {Type: "m128", Action: 0x1}, + {Type: "xmm", Action: 0x1}, + {Type: "k", Action: 0x1}, + {Type: "xmm", Action: 0x2}, + }, + EncodingType: 0x4, + }, + { + ISA: []string{"AVX512VL", "GFNI"}, + Operands: []Operand{ + {Type: "imm8", Action: 0x1}, + {Type: "m256", Action: 0x1}, + {Type: "ymm", Action: 0x1}, + {Type: "k", Action: 0x1}, + {Type: "ymm", Action: 0x2}, + }, + EncodingType: 0x4, + }, + { + ISA: []string{"AVX512VL", "GFNI"}, + Operands: []Operand{ + {Type: "imm8", Action: 0x1}, + {Type: "m64", Action: 0x1}, + {Type: "xmm", Action: 0x1}, + {Type: "k", Action: 0x1}, + {Type: "xmm", Action: 0x2}, + }, + EncodingType: 0x4, + Broadcast: true, + }, + { + ISA: []string{"AVX512VL", "GFNI"}, + Operands: []Operand{ + {Type: "imm8", Action: 0x1}, + {Type: "m64", Action: 0x1}, + {Type: "xmm", Action: 0x1}, + {Type: "xmm", Action: 0x2}, + }, + EncodingType: 0x4, + Broadcast: true, + }, + { + ISA: []string{"AVX512VL", "GFNI"}, + Operands: []Operand{ + {Type: "imm8", Action: 0x1}, + {Type: "m64", Action: 0x1}, + {Type: "ymm", Action: 0x1}, + {Type: "k", Action: 0x1}, + {Type: "ymm", Action: 0x2}, + }, + EncodingType: 0x4, + Broadcast: true, + }, + { + ISA: []string{"AVX512VL", "GFNI"}, + Operands: []Operand{ + {Type: "imm8", Action: 0x1}, + {Type: "m64", Action: 0x1}, + {Type: "ymm", Action: 0x1}, + {Type: "ymm", Action: 0x2}, + }, + EncodingType: 0x4, + Broadcast: true, + }, + { + ISA: []string{"AVX512VL", "GFNI"}, + Operands: []Operand{ + {Type: "imm8", Action: 0x1}, + {Type: "xmm", Action: 0x1}, + {Type: "xmm", Action: 0x1}, + {Type: "k", Action: 0x1}, + {Type: "xmm", Action: 0x2}, + }, + EncodingType: 0x4, + }, + { + ISA: []string{"AVX512VL", "GFNI"}, + Operands: []Operand{ + {Type: "imm8", Action: 0x1}, + {Type: "ymm", Action: 0x1}, + {Type: "ymm", Action: 0x1}, + {Type: "k", Action: 0x1}, + {Type: "ymm", Action: 0x2}, + }, + EncodingType: 0x4, + }, + }, + }, + { + Opcode: "VGF2P8MULB", + Summary: "Galois Field Multiply Bytes", + Forms: []Form{ + { + ISA: []string{"AVX", "GFNI"}, + Operands: []Operand{ + {Type: "imm8", Action: 0x1}, + {Type: "m128", Action: 0x1}, + {Type: "xmm", Action: 0x1}, + {Type: "xmm", Action: 0x2}, + }, + EncodingType: 0x3, + }, + { + ISA: []string{"AVX", "GFNI"}, + Operands: []Operand{ + {Type: "imm8", Action: 0x1}, + {Type: "m256", Action: 0x1}, + {Type: "ymm", Action: 0x1}, + {Type: "ymm", Action: 0x2}, + }, + EncodingType: 0x3, + }, + { + ISA: []string{"AVX", "GFNI"}, + Operands: []Operand{ + {Type: "imm8", Action: 0x1}, + {Type: "xmm", Action: 0x1}, + {Type: "xmm", Action: 0x1}, + {Type: "xmm", Action: 0x2}, + }, + EncodingType: 0x3, + }, + { + ISA: []string{"AVX", "GFNI"}, + Operands: []Operand{ + {Type: "imm8", Action: 0x1}, + {Type: "ymm", Action: 0x1}, + {Type: "ymm", Action: 0x1}, + {Type: "ymm", Action: 0x2}, + }, + EncodingType: 0x3, + }, + { + ISA: []string{"AVX512F", "GFNI"}, + Operands: []Operand{ + {Type: "imm8", Action: 0x1}, + {Type: "m512", Action: 0x1}, + {Type: "zmm", Action: 0x1}, + {Type: "k", Action: 0x1}, + {Type: "zmm", Action: 0x2}, + }, + EncodingType: 0x4, + }, + { + ISA: []string{"AVX512F", "GFNI"}, + Operands: []Operand{ + {Type: "imm8", Action: 0x1}, + {Type: "m512", Action: 0x1}, + {Type: "zmm", Action: 0x1}, + {Type: "zmm", Action: 0x2}, + }, + EncodingType: 0x4, + }, + { + ISA: []string{"AVX512F", "GFNI"}, + Operands: []Operand{ + {Type: "imm8", Action: 0x1}, + {Type: "m64", Action: 0x1}, + {Type: "zmm", Action: 0x1}, + {Type: "k", Action: 0x1}, + {Type: "zmm", Action: 0x2}, + }, + EncodingType: 0x4, + Broadcast: true, + }, + { + ISA: []string{"AVX512F", "GFNI"}, + Operands: []Operand{ + {Type: "imm8", Action: 0x1}, + {Type: "m64", Action: 0x1}, + {Type: "zmm", Action: 0x1}, + {Type: "zmm", Action: 0x2}, + }, + EncodingType: 0x4, + Broadcast: true, + }, + { + ISA: []string{"AVX512F", "GFNI"}, + Operands: []Operand{ + {Type: "imm8", Action: 0x1}, + {Type: "zmm", Action: 0x1}, + {Type: "zmm", Action: 0x1}, + {Type: "k", Action: 0x1}, + {Type: "zmm", Action: 0x2}, + }, + EncodingType: 0x4, + }, + { + ISA: []string{"AVX512F", "GFNI"}, + Operands: []Operand{ + {Type: "imm8", Action: 0x1}, + {Type: "zmm", Action: 0x1}, + {Type: "zmm", Action: 0x1}, + {Type: "zmm", Action: 0x2}, + }, + EncodingType: 0x4, + }, + { + ISA: []string{"AVX512VL", "GFNI"}, + Operands: []Operand{ + {Type: "imm8", Action: 0x1}, + {Type: "m128", Action: 0x1}, + {Type: "xmm", Action: 0x1}, + {Type: "k", Action: 0x1}, + {Type: "xmm", Action: 0x2}, + }, + EncodingType: 0x4, + }, + { + ISA: []string{"AVX512VL", "GFNI"}, + Operands: []Operand{ + {Type: "imm8", Action: 0x1}, + {Type: "m256", Action: 0x1}, + {Type: "ymm", Action: 0x1}, + {Type: "k", Action: 0x1}, + {Type: "ymm", Action: 0x2}, + }, + EncodingType: 0x4, + }, + { + ISA: []string{"AVX512VL", "GFNI"}, + Operands: []Operand{ + {Type: "imm8", Action: 0x1}, + {Type: "m64", Action: 0x1}, + {Type: "xmm", Action: 0x1}, + {Type: "k", Action: 0x1}, + {Type: "xmm", Action: 0x2}, + }, + EncodingType: 0x4, + Broadcast: true, + }, + { + ISA: []string{"AVX512VL", "GFNI"}, + Operands: []Operand{ + {Type: "imm8", Action: 0x1}, + {Type: "m64", Action: 0x1}, + {Type: "xmm", Action: 0x1}, + {Type: "xmm", Action: 0x2}, + }, + EncodingType: 0x4, + Broadcast: true, + }, + { + ISA: []string{"AVX512VL", "GFNI"}, + Operands: []Operand{ + {Type: "imm8", Action: 0x1}, + {Type: "m64", Action: 0x1}, + {Type: "ymm", Action: 0x1}, + {Type: "k", Action: 0x1}, + {Type: "ymm", Action: 0x2}, + }, + EncodingType: 0x4, + Broadcast: true, + }, + { + ISA: []string{"AVX512VL", "GFNI"}, + Operands: []Operand{ + {Type: "imm8", Action: 0x1}, + {Type: "m64", Action: 0x1}, + {Type: "ymm", Action: 0x1}, + {Type: "ymm", Action: 0x2}, + }, + EncodingType: 0x4, + Broadcast: true, + }, + { + ISA: []string{"AVX512VL", "GFNI"}, + Operands: []Operand{ + {Type: "imm8", Action: 0x1}, + {Type: "xmm", Action: 0x1}, + {Type: "xmm", Action: 0x1}, + {Type: "k", Action: 0x1}, + {Type: "xmm", Action: 0x2}, + }, + EncodingType: 0x4, + }, + { + ISA: []string{"AVX512VL", "GFNI"}, + Operands: []Operand{ + {Type: "imm8", Action: 0x1}, + {Type: "ymm", Action: 0x1}, + {Type: "ymm", Action: 0x1}, + {Type: "k", Action: 0x1}, + {Type: "ymm", Action: 0x2}, + }, + EncodingType: 0x4, + }, + }, + }, { Opcode: "VHADDPD", Summary: "Packed Double-FP Horizontal Add", diff --git a/internal/opcodesextra/gfni.go b/internal/opcodesextra/gfni.go new file mode 100644 index 00000000..210aff13 --- /dev/null +++ b/internal/opcodesextra/gfni.go @@ -0,0 +1,822 @@ +package opcodesextra + +import "github.com/mmcloughlin/avo/internal/inst" + +var gfni = []*inst.Instruction{ + // From https://www.felixcloutier.com/x86/gf2p8affineqb + { + Opcode: "GF2P8AFFINEQB", + Summary: "Galois Field Affine Transformation", + Forms: []inst.Form{ + // 66 0F3A CE /r /ib GF2P8AFFINEQB xmm1, xmm2/m128, imm8 + { + Operands: []inst.Operand{ + {Type: "imm8", Action: inst.R}, + {Type: "xmm", Action: inst.R}, + {Type: "xmm", Action: inst.W}, + }, + EncodingType: inst.EncodingTypeREX, + ISA: []string{"SSE2", "GFNI"}, + }, + { + Operands: []inst.Operand{ + {Type: "imm8", Action: inst.R}, + {Type: "m128", Action: inst.R}, + {Type: "xmm", Action: inst.W}, + }, + EncodingType: inst.EncodingTypeREX, + ISA: []string{"SSE2", "GFNI"}, + }, + }, + }, + { + Opcode: "VGF2P8AFFINEQB", + Summary: "Galois Field Affine Transformation", + Forms: []inst.Form{ + // VEX.128.66.0F3A.W1 CE /r /ib VGF2P8AFFINEQB xmm1, xmm2, xmm3/m128, imm8 + { + Operands: []inst.Operand{ + {Type: "imm8", Action: inst.R}, + {Type: "xmm", Action: inst.R}, + {Type: "xmm", Action: inst.R}, + {Type: "xmm", Action: inst.W}, + }, + EncodingType: inst.EncodingTypeVEX, + ISA: []string{"AVX", "GFNI"}, + }, + { + Operands: []inst.Operand{ + {Type: "imm8", Action: inst.R}, + {Type: "m128", Action: inst.R}, + {Type: "xmm", Action: inst.R}, + {Type: "xmm", Action: inst.W}, + }, + EncodingType: inst.EncodingTypeVEX, + ISA: []string{"AVX", "GFNI"}, + }, + // VEX.256.66.0F3A.W1 CE /r /ib VGF2P8AFFINEQB ymm1, ymm2, ymm3/m256, imm8 + { + Operands: []inst.Operand{ + {Type: "imm8", Action: inst.R}, + {Type: "ymm", Action: inst.R}, + {Type: "ymm", Action: inst.R}, + {Type: "ymm", Action: inst.W}, + }, + EncodingType: inst.EncodingTypeVEX, + ISA: []string{"AVX", "GFNI"}, + }, + { + Operands: []inst.Operand{ + {Type: "imm8", Action: inst.R}, + {Type: "m256", Action: inst.R}, + {Type: "ymm", Action: inst.R}, + {Type: "ymm", Action: inst.W}, + }, + EncodingType: inst.EncodingTypeVEX, + ISA: []string{"AVX", "GFNI"}, + }, + // EVEX.128.66.0F3A.W1 CE /r /ib VGF2P8AFFINEQB xmm1{k1}{z}, xmm2, xmm3/m128/m64bcst, imm8 + { + Operands: []inst.Operand{ + {Type: "imm8", Action: inst.R}, + {Type: "xmm", Action: inst.R}, + {Type: "xmm", Action: inst.R}, + {Type: "xmm", Action: inst.W}, + }, + EncodingType: inst.EncodingTypeEVEX, + ISA: []string{"AVX512VL", "GFNI"}, + }, + { + Operands: []inst.Operand{ + {Type: "imm8", Action: inst.R}, + {Type: "xmm", Action: inst.R}, + {Type: "xmm", Action: inst.R}, + {Type: "k", Action: inst.R}, + {Type: "xmm", Action: inst.W}, + }, + EncodingType: inst.EncodingTypeEVEX, + ISA: []string{"AVX512VL", "GFNI"}, + }, + { + Operands: []inst.Operand{ + {Type: "imm8", Action: inst.R}, + {Type: "m128", Action: inst.R}, + {Type: "xmm", Action: inst.R}, + {Type: "xmm", Action: inst.W}, + }, + EncodingType: inst.EncodingTypeEVEX, + ISA: []string{"AVX512VL", "GFNI"}, + }, + { + Operands: []inst.Operand{ + {Type: "imm8", Action: inst.R}, + {Type: "m128", Action: inst.R}, + {Type: "xmm", Action: inst.R}, + {Type: "k", Action: inst.R}, + {Type: "xmm", Action: inst.W}, + }, + EncodingType: inst.EncodingTypeEVEX, + ISA: []string{"AVX512VL", "GFNI"}, + }, + { + Operands: []inst.Operand{ + {Type: "imm8", Action: inst.R}, + {Type: "m64", Action: inst.R}, + {Type: "xmm", Action: inst.R}, + {Type: "xmm", Action: inst.W}, + }, + EncodingType: inst.EncodingTypeEVEX, + ISA: []string{"AVX512VL", "GFNI"}, + Broadcast: true, + }, + { + Operands: []inst.Operand{ + {Type: "imm8", Action: inst.R}, + {Type: "m64", Action: inst.R}, + {Type: "xmm", Action: inst.R}, + {Type: "k", Action: inst.R}, + {Type: "xmm", Action: inst.W}, + }, + EncodingType: inst.EncodingTypeEVEX, + ISA: []string{"AVX512VL", "GFNI"}, + Broadcast: true, + }, + // EVEX.256.66.0F3A.W1 CE /r /ib VGF2P8AFFINEQB ymm1{k1}{z}, ymm2, ymm3/m256/m64bcst, imm8 + { + Operands: []inst.Operand{ + {Type: "imm8", Action: inst.R}, + {Type: "ymm", Action: inst.R}, + {Type: "ymm", Action: inst.R}, + {Type: "ymm", Action: inst.W}, + }, + EncodingType: inst.EncodingTypeEVEX, + ISA: []string{"AVX512VL", "GFNI"}, + }, + { + Operands: []inst.Operand{ + {Type: "imm8", Action: inst.R}, + {Type: "ymm", Action: inst.R}, + {Type: "ymm", Action: inst.R}, + {Type: "k", Action: inst.R}, + {Type: "ymm", Action: inst.W}, + }, + EncodingType: inst.EncodingTypeEVEX, + ISA: []string{"AVX512VL", "GFNI"}, + }, + { + Operands: []inst.Operand{ + {Type: "imm8", Action: inst.R}, + {Type: "m256", Action: inst.R}, + {Type: "ymm", Action: inst.R}, + {Type: "ymm", Action: inst.W}, + }, + EncodingType: inst.EncodingTypeEVEX, + ISA: []string{"AVX512VL", "GFNI"}, + }, + { + Operands: []inst.Operand{ + {Type: "imm8", Action: inst.R}, + {Type: "m256", Action: inst.R}, + {Type: "ymm", Action: inst.R}, + {Type: "k", Action: inst.R}, + {Type: "ymm", Action: inst.W}, + }, + EncodingType: inst.EncodingTypeEVEX, + ISA: []string{"AVX512VL", "GFNI"}, + }, + { + Operands: []inst.Operand{ + {Type: "imm8", Action: inst.R}, + {Type: "m64", Action: inst.R}, + {Type: "ymm", Action: inst.R}, + {Type: "ymm", Action: inst.W}, + }, + EncodingType: inst.EncodingTypeEVEX, + ISA: []string{"AVX512VL", "GFNI"}, + Broadcast: true, + }, + { + Operands: []inst.Operand{ + {Type: "imm8", Action: inst.R}, + {Type: "m64", Action: inst.R}, + {Type: "ymm", Action: inst.R}, + {Type: "k", Action: inst.R}, + {Type: "ymm", Action: inst.W}, + }, + EncodingType: inst.EncodingTypeEVEX, + ISA: []string{"AVX512VL", "GFNI"}, + Broadcast: true, + }, + // EVEX.512.66.0F3A.W1 CE /r /ib VGF2P8AFFINEQB zmm1{k1}{z}, zmm2, zmm3/m512/m64bcst, imm8 + { + Operands: []inst.Operand{ + {Type: "imm8", Action: inst.R}, + {Type: "zmm", Action: inst.R}, + {Type: "zmm", Action: inst.R}, + {Type: "zmm", Action: inst.W}, + }, + EncodingType: inst.EncodingTypeEVEX, + ISA: []string{"AVX512F", "GFNI"}, + }, + { + Operands: []inst.Operand{ + {Type: "imm8", Action: inst.R}, + {Type: "zmm", Action: inst.R}, + {Type: "zmm", Action: inst.R}, + {Type: "k", Action: inst.R}, + {Type: "zmm", Action: inst.W}, + }, + EncodingType: inst.EncodingTypeEVEX, + ISA: []string{"AVX512F", "GFNI"}, + }, + { + Operands: []inst.Operand{ + {Type: "imm8", Action: inst.R}, + {Type: "m512", Action: inst.R}, + {Type: "zmm", Action: inst.R}, + {Type: "zmm", Action: inst.W}, + }, + EncodingType: inst.EncodingTypeEVEX, + ISA: []string{"AVX512F", "GFNI"}, + }, + { + Operands: []inst.Operand{ + {Type: "imm8", Action: inst.R}, + {Type: "m512", Action: inst.R}, + {Type: "zmm", Action: inst.R}, + {Type: "k", Action: inst.R}, + {Type: "zmm", Action: inst.W}, + }, + EncodingType: inst.EncodingTypeEVEX, + ISA: []string{"AVX512F", "GFNI"}, + }, + { + Operands: []inst.Operand{ + {Type: "imm8", Action: inst.R}, + {Type: "m64", Action: inst.R}, + {Type: "zmm", Action: inst.R}, + {Type: "zmm", Action: inst.W}, + }, + EncodingType: inst.EncodingTypeEVEX, + ISA: []string{"AVX512F", "GFNI"}, + Broadcast: true, + }, + { + Operands: []inst.Operand{ + {Type: "imm8", Action: inst.R}, + {Type: "m64", Action: inst.R}, + {Type: "zmm", Action: inst.R}, + {Type: "k", Action: inst.R}, + {Type: "zmm", Action: inst.W}, + }, + EncodingType: inst.EncodingTypeEVEX, + ISA: []string{"AVX512F", "GFNI"}, + Broadcast: true, + }, + }, + }, + // From https://www.felixcloutier.com/x86/gf2p8affineinvqb + { + Opcode: "GF2P8AFFINEINVQB", + Summary: "Galois Field Affine Transformation Inverse", + Forms: []inst.Form{ + // 66 0F3A CF /r /ib GF2P8AFFINEINVQB xmm1, xmm2/m128, imm8 + { + Operands: []inst.Operand{ + {Type: "imm8", Action: inst.R}, + {Type: "xmm", Action: inst.R}, + {Type: "xmm", Action: inst.W}, + }, + EncodingType: inst.EncodingTypeREX, + ISA: []string{"SSE2", "GFNI"}, + }, + { + Operands: []inst.Operand{ + {Type: "imm8", Action: inst.R}, + {Type: "m128", Action: inst.R}, + {Type: "xmm", Action: inst.W}, + }, + EncodingType: inst.EncodingTypeREX, + ISA: []string{"SSE2", "GFNI"}, + }, + }, + }, + { + Opcode: "VGF2P8AFFINEINVQB", + Summary: "Galois Field Affine Transformation Inverse", + Forms: []inst.Form{ + // VEX.128.66.0F3A.W1 CF /r /ib VGF2P8AFFINEINVQB xmm1, xmm2, xmm3/m128, imm8 + { + Operands: []inst.Operand{ + {Type: "imm8", Action: inst.R}, + {Type: "xmm", Action: inst.R}, + {Type: "xmm", Action: inst.R}, + {Type: "xmm", Action: inst.W}, + }, + EncodingType: inst.EncodingTypeVEX, + ISA: []string{"AVX", "GFNI"}, + }, + { + Operands: []inst.Operand{ + {Type: "imm8", Action: inst.R}, + {Type: "m128", Action: inst.R}, + {Type: "xmm", Action: inst.R}, + {Type: "xmm", Action: inst.W}, + }, + EncodingType: inst.EncodingTypeVEX, + ISA: []string{"AVX", "GFNI"}, + }, + // VEX.256.66.0F3A.W1 CF /r /ib VGF2P8AFFINEINVQB ymm1, ymm2, ymm3/m256, imm8 + { + Operands: []inst.Operand{ + {Type: "imm8", Action: inst.R}, + {Type: "ymm", Action: inst.R}, + {Type: "ymm", Action: inst.R}, + {Type: "ymm", Action: inst.W}, + }, + EncodingType: inst.EncodingTypeVEX, + ISA: []string{"AVX", "GFNI"}, + }, + { + Operands: []inst.Operand{ + {Type: "imm8", Action: inst.R}, + {Type: "m256", Action: inst.R}, + {Type: "ymm", Action: inst.R}, + {Type: "ymm", Action: inst.W}, + }, + EncodingType: inst.EncodingTypeVEX, + ISA: []string{"AVX", "GFNI"}, + }, + // EVEX.128.66.0F3A.W1 CF /r /ib VGF2P8AFFINEINVQB xmm1{k1}{z}, xmm2, xmm3/m128/m64bcst, imm8 + { + Operands: []inst.Operand{ + {Type: "imm8", Action: inst.R}, + {Type: "xmm", Action: inst.R}, + {Type: "xmm", Action: inst.R}, + {Type: "xmm", Action: inst.W}, + }, + EncodingType: inst.EncodingTypeEVEX, + ISA: []string{"AVX512VL", "GFNI"}, + }, + { + Operands: []inst.Operand{ + {Type: "imm8", Action: inst.R}, + {Type: "xmm", Action: inst.R}, + {Type: "xmm", Action: inst.R}, + {Type: "k", Action: inst.R}, + {Type: "xmm", Action: inst.W}, + }, + EncodingType: inst.EncodingTypeEVEX, + ISA: []string{"AVX512VL", "GFNI"}, + }, + { + Operands: []inst.Operand{ + {Type: "imm8", Action: inst.R}, + {Type: "m128", Action: inst.R}, + {Type: "xmm", Action: inst.R}, + {Type: "xmm", Action: inst.W}, + }, + EncodingType: inst.EncodingTypeEVEX, + ISA: []string{"AVX512VL", "GFNI"}, + }, + { + Operands: []inst.Operand{ + {Type: "imm8", Action: inst.R}, + {Type: "m128", Action: inst.R}, + {Type: "xmm", Action: inst.R}, + {Type: "k", Action: inst.R}, + {Type: "xmm", Action: inst.W}, + }, + EncodingType: inst.EncodingTypeEVEX, + ISA: []string{"AVX512VL", "GFNI"}, + }, + { + Operands: []inst.Operand{ + {Type: "imm8", Action: inst.R}, + {Type: "m64", Action: inst.R}, + {Type: "xmm", Action: inst.R}, + {Type: "xmm", Action: inst.W}, + }, + EncodingType: inst.EncodingTypeEVEX, + ISA: []string{"AVX512VL", "GFNI"}, + Broadcast: true, + }, + { + Operands: []inst.Operand{ + {Type: "imm8", Action: inst.R}, + {Type: "m64", Action: inst.R}, + {Type: "xmm", Action: inst.R}, + {Type: "k", Action: inst.R}, + {Type: "xmm", Action: inst.W}, + }, + EncodingType: inst.EncodingTypeEVEX, + ISA: []string{"AVX512VL", "GFNI"}, + Broadcast: true, + }, + // EVEX.256.66.0F3A.W1 CF /r /ib VGF2P8AFFINEINVQB ymm1{k1}{z}, ymm2, ymm3/m256/m64bcst, imm8 + { + Operands: []inst.Operand{ + {Type: "imm8", Action: inst.R}, + {Type: "ymm", Action: inst.R}, + {Type: "ymm", Action: inst.R}, + {Type: "ymm", Action: inst.W}, + }, + EncodingType: inst.EncodingTypeEVEX, + ISA: []string{"AVX512VL", "GFNI"}, + }, + { + Operands: []inst.Operand{ + {Type: "imm8", Action: inst.R}, + {Type: "ymm", Action: inst.R}, + {Type: "ymm", Action: inst.R}, + {Type: "k", Action: inst.R}, + {Type: "ymm", Action: inst.W}, + }, + EncodingType: inst.EncodingTypeEVEX, + ISA: []string{"AVX512VL", "GFNI"}, + }, + { + Operands: []inst.Operand{ + {Type: "imm8", Action: inst.R}, + {Type: "m256", Action: inst.R}, + {Type: "ymm", Action: inst.R}, + {Type: "ymm", Action: inst.W}, + }, + EncodingType: inst.EncodingTypeEVEX, + ISA: []string{"AVX512VL", "GFNI"}, + }, + { + Operands: []inst.Operand{ + {Type: "imm8", Action: inst.R}, + {Type: "m256", Action: inst.R}, + {Type: "ymm", Action: inst.R}, + {Type: "k", Action: inst.R}, + {Type: "ymm", Action: inst.W}, + }, + EncodingType: inst.EncodingTypeEVEX, + ISA: []string{"AVX512VL", "GFNI"}, + }, + { + Operands: []inst.Operand{ + {Type: "imm8", Action: inst.R}, + {Type: "m64", Action: inst.R}, + {Type: "ymm", Action: inst.R}, + {Type: "ymm", Action: inst.W}, + }, + EncodingType: inst.EncodingTypeEVEX, + ISA: []string{"AVX512VL", "GFNI"}, + Broadcast: true, + }, + { + Operands: []inst.Operand{ + {Type: "imm8", Action: inst.R}, + {Type: "m64", Action: inst.R}, + {Type: "ymm", Action: inst.R}, + {Type: "k", Action: inst.R}, + {Type: "ymm", Action: inst.W}, + }, + EncodingType: inst.EncodingTypeEVEX, + ISA: []string{"AVX512VL", "GFNI"}, + Broadcast: true, + }, + // EVEX.512.66.0F3A.W1 CF /r /ib VGF2P8AFFINEINVQB zmm1{k1}{z}, zmm2, zmm3/m512/m64bcst, imm8 + { + Operands: []inst.Operand{ + {Type: "imm8", Action: inst.R}, + {Type: "zmm", Action: inst.R}, + {Type: "zmm", Action: inst.R}, + {Type: "zmm", Action: inst.W}, + }, + EncodingType: inst.EncodingTypeEVEX, + ISA: []string{"AVX512F", "GFNI"}, + }, + { + Operands: []inst.Operand{ + {Type: "imm8", Action: inst.R}, + {Type: "zmm", Action: inst.R}, + {Type: "zmm", Action: inst.R}, + {Type: "k", Action: inst.R}, + {Type: "zmm", Action: inst.W}, + }, + EncodingType: inst.EncodingTypeEVEX, + ISA: []string{"AVX512F", "GFNI"}, + }, + { + Operands: []inst.Operand{ + {Type: "imm8", Action: inst.R}, + {Type: "m512", Action: inst.R}, + {Type: "zmm", Action: inst.R}, + {Type: "zmm", Action: inst.W}, + }, + EncodingType: inst.EncodingTypeEVEX, + ISA: []string{"AVX512F", "GFNI"}, + }, + { + Operands: []inst.Operand{ + {Type: "imm8", Action: inst.R}, + {Type: "m512", Action: inst.R}, + {Type: "zmm", Action: inst.R}, + {Type: "k", Action: inst.R}, + {Type: "zmm", Action: inst.W}, + }, + EncodingType: inst.EncodingTypeEVEX, + ISA: []string{"AVX512F", "GFNI"}, + }, + { + Operands: []inst.Operand{ + {Type: "imm8", Action: inst.R}, + {Type: "m64", Action: inst.R}, + {Type: "zmm", Action: inst.R}, + {Type: "zmm", Action: inst.W}, + }, + EncodingType: inst.EncodingTypeEVEX, + ISA: []string{"AVX512F", "GFNI"}, + Broadcast: true, + }, + { + Operands: []inst.Operand{ + {Type: "imm8", Action: inst.R}, + {Type: "m64", Action: inst.R}, + {Type: "zmm", Action: inst.R}, + {Type: "k", Action: inst.R}, + {Type: "zmm", Action: inst.W}, + }, + EncodingType: inst.EncodingTypeEVEX, + ISA: []string{"AVX512F", "GFNI"}, + Broadcast: true, + }, + }, + }, + // From https://www.felixcloutier.com/x86/gf2p8mulb + { + Opcode: "GF2P8MULB", + Summary: "Galois Field Multiply Bytes", + Forms: []inst.Form{ + // 66 0F38 CF /r GF2P8MULB xmm1, xmm2/m128 + { + Operands: []inst.Operand{ + {Type: "imm8", Action: inst.R}, + {Type: "xmm", Action: inst.R}, + {Type: "xmm", Action: inst.W}, + }, + EncodingType: inst.EncodingTypeREX, + ISA: []string{"SSE2", "GFNI"}, + }, + { + Operands: []inst.Operand{ + {Type: "imm8", Action: inst.R}, + {Type: "m128", Action: inst.R}, + {Type: "xmm", Action: inst.W}, + }, + EncodingType: inst.EncodingTypeREX, + ISA: []string{"SSE2", "GFNI"}, + }, + }, + }, + { + Opcode: "VGF2P8MULB", + Summary: "Galois Field Multiply Bytes", + Forms: []inst.Form{ + // VEX.128.66.0F38.W0 CF /r VGF2P8MULB xmm1, xmm2, xmm3/m128 + { + Operands: []inst.Operand{ + {Type: "imm8", Action: inst.R}, + {Type: "xmm", Action: inst.R}, + {Type: "xmm", Action: inst.R}, + {Type: "xmm", Action: inst.W}, + }, + EncodingType: inst.EncodingTypeVEX, + ISA: []string{"AVX", "GFNI"}, + }, + { + Operands: []inst.Operand{ + {Type: "imm8", Action: inst.R}, + {Type: "m128", Action: inst.R}, + {Type: "xmm", Action: inst.R}, + {Type: "xmm", Action: inst.W}, + }, + EncodingType: inst.EncodingTypeVEX, + ISA: []string{"AVX", "GFNI"}, + }, + // VEX.256.66.0F38.W0 CF /r VGF2P8MULB ymm1, ymm2, ymm3/m256 + { + Operands: []inst.Operand{ + {Type: "imm8", Action: inst.R}, + {Type: "ymm", Action: inst.R}, + {Type: "ymm", Action: inst.R}, + {Type: "ymm", Action: inst.W}, + }, + EncodingType: inst.EncodingTypeVEX, + ISA: []string{"AVX", "GFNI"}, + }, + { + Operands: []inst.Operand{ + {Type: "imm8", Action: inst.R}, + {Type: "m256", Action: inst.R}, + {Type: "ymm", Action: inst.R}, + {Type: "ymm", Action: inst.W}, + }, + EncodingType: inst.EncodingTypeVEX, + ISA: []string{"AVX", "GFNI"}, + }, + // EVEX.128.66.0F38.W0 CF /r VGF2P8MULB xmm1{k1}{z}, xmm2, xmm3/m128 + { + Operands: []inst.Operand{ + {Type: "imm8", Action: inst.R}, + {Type: "xmm", Action: inst.R}, + {Type: "xmm", Action: inst.R}, + {Type: "xmm", Action: inst.W}, + }, + EncodingType: inst.EncodingTypeEVEX, + ISA: []string{"AVX512VL", "GFNI"}, + }, + { + Operands: []inst.Operand{ + {Type: "imm8", Action: inst.R}, + {Type: "xmm", Action: inst.R}, + {Type: "xmm", Action: inst.R}, + {Type: "k", Action: inst.R}, + {Type: "xmm", Action: inst.W}, + }, + EncodingType: inst.EncodingTypeEVEX, + ISA: []string{"AVX512VL", "GFNI"}, + }, + { + Operands: []inst.Operand{ + {Type: "imm8", Action: inst.R}, + {Type: "m128", Action: inst.R}, + {Type: "xmm", Action: inst.R}, + {Type: "xmm", Action: inst.W}, + }, + EncodingType: inst.EncodingTypeEVEX, + ISA: []string{"AVX512VL", "GFNI"}, + }, + { + Operands: []inst.Operand{ + {Type: "imm8", Action: inst.R}, + {Type: "m128", Action: inst.R}, + {Type: "xmm", Action: inst.R}, + {Type: "k", Action: inst.R}, + {Type: "xmm", Action: inst.W}, + }, + EncodingType: inst.EncodingTypeEVEX, + ISA: []string{"AVX512VL", "GFNI"}, + }, + { + Operands: []inst.Operand{ + {Type: "imm8", Action: inst.R}, + {Type: "m64", Action: inst.R}, + {Type: "xmm", Action: inst.R}, + {Type: "xmm", Action: inst.W}, + }, + EncodingType: inst.EncodingTypeEVEX, + ISA: []string{"AVX512VL", "GFNI"}, + Broadcast: true, + }, + { + Operands: []inst.Operand{ + {Type: "imm8", Action: inst.R}, + {Type: "m64", Action: inst.R}, + {Type: "xmm", Action: inst.R}, + {Type: "k", Action: inst.R}, + {Type: "xmm", Action: inst.W}, + }, + EncodingType: inst.EncodingTypeEVEX, + ISA: []string{"AVX512VL", "GFNI"}, + Broadcast: true, + }, + // EVEX.256.66.0F38.W0 CF /r VGF2P8MULB ymm1{k1}{z}, ymm2, ymm3/m256 + { + Operands: []inst.Operand{ + {Type: "imm8", Action: inst.R}, + {Type: "ymm", Action: inst.R}, + {Type: "ymm", Action: inst.R}, + {Type: "ymm", Action: inst.W}, + }, + EncodingType: inst.EncodingTypeEVEX, + ISA: []string{"AVX512VL", "GFNI"}, + }, + { + Operands: []inst.Operand{ + {Type: "imm8", Action: inst.R}, + {Type: "ymm", Action: inst.R}, + {Type: "ymm", Action: inst.R}, + {Type: "k", Action: inst.R}, + {Type: "ymm", Action: inst.W}, + }, + EncodingType: inst.EncodingTypeEVEX, + ISA: []string{"AVX512VL", "GFNI"}, + }, + { + Operands: []inst.Operand{ + {Type: "imm8", Action: inst.R}, + {Type: "m256", Action: inst.R}, + {Type: "ymm", Action: inst.R}, + {Type: "ymm", Action: inst.W}, + }, + EncodingType: inst.EncodingTypeEVEX, + ISA: []string{"AVX512VL", "GFNI"}, + }, + { + Operands: []inst.Operand{ + {Type: "imm8", Action: inst.R}, + {Type: "m256", Action: inst.R}, + {Type: "ymm", Action: inst.R}, + {Type: "k", Action: inst.R}, + {Type: "ymm", Action: inst.W}, + }, + EncodingType: inst.EncodingTypeEVEX, + ISA: []string{"AVX512VL", "GFNI"}, + }, + { + Operands: []inst.Operand{ + {Type: "imm8", Action: inst.R}, + {Type: "m64", Action: inst.R}, + {Type: "ymm", Action: inst.R}, + {Type: "ymm", Action: inst.W}, + }, + EncodingType: inst.EncodingTypeEVEX, + ISA: []string{"AVX512VL", "GFNI"}, + Broadcast: true, + }, + { + Operands: []inst.Operand{ + {Type: "imm8", Action: inst.R}, + {Type: "m64", Action: inst.R}, + {Type: "ymm", Action: inst.R}, + {Type: "k", Action: inst.R}, + {Type: "ymm", Action: inst.W}, + }, + EncodingType: inst.EncodingTypeEVEX, + ISA: []string{"AVX512VL", "GFNI"}, + Broadcast: true, + }, + // EVEX.512.66.0F38.W0 CF /r VGF2P8MULB zmm1{k1}{z}, zmm2, zmm3/m512 + { + Operands: []inst.Operand{ + {Type: "imm8", Action: inst.R}, + {Type: "zmm", Action: inst.R}, + {Type: "zmm", Action: inst.R}, + {Type: "zmm", Action: inst.W}, + }, + EncodingType: inst.EncodingTypeEVEX, + ISA: []string{"AVX512F", "GFNI"}, + }, + { + Operands: []inst.Operand{ + {Type: "imm8", Action: inst.R}, + {Type: "zmm", Action: inst.R}, + {Type: "zmm", Action: inst.R}, + {Type: "k", Action: inst.R}, + {Type: "zmm", Action: inst.W}, + }, + EncodingType: inst.EncodingTypeEVEX, + ISA: []string{"AVX512F", "GFNI"}, + }, + { + Operands: []inst.Operand{ + {Type: "imm8", Action: inst.R}, + {Type: "m512", Action: inst.R}, + {Type: "zmm", Action: inst.R}, + {Type: "zmm", Action: inst.W}, + }, + EncodingType: inst.EncodingTypeEVEX, + ISA: []string{"AVX512F", "GFNI"}, + }, + { + Operands: []inst.Operand{ + {Type: "imm8", Action: inst.R}, + {Type: "m512", Action: inst.R}, + {Type: "zmm", Action: inst.R}, + {Type: "k", Action: inst.R}, + {Type: "zmm", Action: inst.W}, + }, + EncodingType: inst.EncodingTypeEVEX, + ISA: []string{"AVX512F", "GFNI"}, + }, + { + Operands: []inst.Operand{ + {Type: "imm8", Action: inst.R}, + {Type: "m64", Action: inst.R}, + {Type: "zmm", Action: inst.R}, + {Type: "zmm", Action: inst.W}, + }, + EncodingType: inst.EncodingTypeEVEX, + ISA: []string{"AVX512F", "GFNI"}, + Broadcast: true, + }, + { + Operands: []inst.Operand{ + {Type: "imm8", Action: inst.R}, + {Type: "m64", Action: inst.R}, + {Type: "zmm", Action: inst.R}, + {Type: "k", Action: inst.R}, + {Type: "zmm", Action: inst.W}, + }, + EncodingType: inst.EncodingTypeEVEX, + ISA: []string{"AVX512F", "GFNI"}, + Broadcast: true, + }, + }, + }, +} From ae9209b4d978524f9f39ce7cd91781735ab383e0 Mon Sep 17 00:00:00 2001 From: Michael McLoughlin Date: Sun, 27 Nov 2022 12:21:37 -0800 Subject: [PATCH 02/10] regenerate --- build/zinstructions.go | 291 ++++++ build/zinstructions_test.go | 9 + x86/zctors.go | 132 +++ x86/zctors_test.go | 207 +++++ x86/zoptab.go | 1650 ++++++++++++++++++----------------- 5 files changed, 1507 insertions(+), 782 deletions(-) diff --git a/build/zinstructions.go b/build/zinstructions.go index 5385692a..ce1f469f 100644 --- a/build/zinstructions.go +++ b/build/zinstructions.go @@ -4431,6 +4431,75 @@ func (c *Context) EXTRACTPS(i, x, mr operand.Op) { // Operates on the global context. func EXTRACTPS(i, x, mr operand.Op) { ctx.EXTRACTPS(i, x, mr) } +// GF2P8AFFINEINVQB: Galois Field Affine Transformation Inverse. +// +// Forms: +// +// GF2P8AFFINEINVQB imm8 m128 xmm +// GF2P8AFFINEINVQB imm8 xmm xmm +// +// Construct and append a GF2P8AFFINEINVQB instruction to the active function. +func (c *Context) GF2P8AFFINEINVQB(i, mx, x operand.Op) { + c.addinstruction(x86.GF2P8AFFINEINVQB(i, mx, x)) +} + +// GF2P8AFFINEINVQB: Galois Field Affine Transformation Inverse. +// +// Forms: +// +// GF2P8AFFINEINVQB imm8 m128 xmm +// GF2P8AFFINEINVQB imm8 xmm xmm +// +// Construct and append a GF2P8AFFINEINVQB instruction to the active function. +// Operates on the global context. +func GF2P8AFFINEINVQB(i, mx, x operand.Op) { ctx.GF2P8AFFINEINVQB(i, mx, x) } + +// GF2P8AFFINEQB: Galois Field Affine Transformation. +// +// Forms: +// +// GF2P8AFFINEQB imm8 m128 xmm +// GF2P8AFFINEQB imm8 xmm xmm +// +// Construct and append a GF2P8AFFINEQB instruction to the active function. +func (c *Context) GF2P8AFFINEQB(i, mx, x operand.Op) { + c.addinstruction(x86.GF2P8AFFINEQB(i, mx, x)) +} + +// GF2P8AFFINEQB: Galois Field Affine Transformation. +// +// Forms: +// +// GF2P8AFFINEQB imm8 m128 xmm +// GF2P8AFFINEQB imm8 xmm xmm +// +// Construct and append a GF2P8AFFINEQB instruction to the active function. +// Operates on the global context. +func GF2P8AFFINEQB(i, mx, x operand.Op) { ctx.GF2P8AFFINEQB(i, mx, x) } + +// GF2P8MULB: Galois Field Multiply Bytes. +// +// Forms: +// +// GF2P8MULB imm8 m128 xmm +// GF2P8MULB imm8 xmm xmm +// +// Construct and append a GF2P8MULB instruction to the active function. +func (c *Context) GF2P8MULB(i, mx, x operand.Op) { + c.addinstruction(x86.GF2P8MULB(i, mx, x)) +} + +// GF2P8MULB: Galois Field Multiply Bytes. +// +// Forms: +// +// GF2P8MULB imm8 m128 xmm +// GF2P8MULB imm8 xmm xmm +// +// Construct and append a GF2P8MULB instruction to the active function. +// Operates on the global context. +func GF2P8MULB(i, mx, x operand.Op) { ctx.GF2P8MULB(i, mx, x) } + // HADDPD: Packed Double-FP Horizontal Add. // // Forms: @@ -49989,6 +50058,228 @@ func (c *Context) VGETMANTSS_Z(i, mx, x, k, x1 operand.Op) { // Operates on the global context. func VGETMANTSS_Z(i, mx, x, k, x1 operand.Op) { ctx.VGETMANTSS_Z(i, mx, x, k, x1) } +// VGF2P8AFFINEINVQB: Galois Field Affine Transformation Inverse. +// +// Forms: +// +// VGF2P8AFFINEINVQB imm8 m128 xmm xmm +// VGF2P8AFFINEINVQB imm8 m256 ymm ymm +// VGF2P8AFFINEINVQB imm8 xmm xmm xmm +// VGF2P8AFFINEINVQB imm8 ymm ymm ymm +// VGF2P8AFFINEINVQB imm8 m512 zmm k zmm +// VGF2P8AFFINEINVQB imm8 m512 zmm zmm +// VGF2P8AFFINEINVQB imm8 zmm zmm k zmm +// VGF2P8AFFINEINVQB imm8 zmm zmm zmm +// VGF2P8AFFINEINVQB imm8 m128 xmm k xmm +// VGF2P8AFFINEINVQB imm8 m256 ymm k ymm +// VGF2P8AFFINEINVQB imm8 xmm xmm k xmm +// VGF2P8AFFINEINVQB imm8 ymm ymm k ymm +// +// Construct and append a VGF2P8AFFINEINVQB instruction to the active function. +func (c *Context) VGF2P8AFFINEINVQB(ops ...operand.Op) { + c.addinstruction(x86.VGF2P8AFFINEINVQB(ops...)) +} + +// VGF2P8AFFINEINVQB: Galois Field Affine Transformation Inverse. +// +// Forms: +// +// VGF2P8AFFINEINVQB imm8 m128 xmm xmm +// VGF2P8AFFINEINVQB imm8 m256 ymm ymm +// VGF2P8AFFINEINVQB imm8 xmm xmm xmm +// VGF2P8AFFINEINVQB imm8 ymm ymm ymm +// VGF2P8AFFINEINVQB imm8 m512 zmm k zmm +// VGF2P8AFFINEINVQB imm8 m512 zmm zmm +// VGF2P8AFFINEINVQB imm8 zmm zmm k zmm +// VGF2P8AFFINEINVQB imm8 zmm zmm zmm +// VGF2P8AFFINEINVQB imm8 m128 xmm k xmm +// VGF2P8AFFINEINVQB imm8 m256 ymm k ymm +// VGF2P8AFFINEINVQB imm8 xmm xmm k xmm +// VGF2P8AFFINEINVQB imm8 ymm ymm k ymm +// +// Construct and append a VGF2P8AFFINEINVQB instruction to the active function. +// Operates on the global context. +func VGF2P8AFFINEINVQB(ops ...operand.Op) { ctx.VGF2P8AFFINEINVQB(ops...) } + +// VGF2P8AFFINEINVQB_BCST: Galois Field Affine Transformation Inverse (Broadcast). +// +// Forms: +// +// VGF2P8AFFINEINVQB.BCST imm8 m64 zmm k zmm +// VGF2P8AFFINEINVQB.BCST imm8 m64 zmm zmm +// VGF2P8AFFINEINVQB.BCST imm8 m64 xmm k xmm +// VGF2P8AFFINEINVQB.BCST imm8 m64 xmm xmm +// VGF2P8AFFINEINVQB.BCST imm8 m64 ymm k ymm +// VGF2P8AFFINEINVQB.BCST imm8 m64 ymm ymm +// +// Construct and append a VGF2P8AFFINEINVQB.BCST instruction to the active function. +func (c *Context) VGF2P8AFFINEINVQB_BCST(ops ...operand.Op) { + c.addinstruction(x86.VGF2P8AFFINEINVQB_BCST(ops...)) +} + +// VGF2P8AFFINEINVQB_BCST: Galois Field Affine Transformation Inverse (Broadcast). +// +// Forms: +// +// VGF2P8AFFINEINVQB.BCST imm8 m64 zmm k zmm +// VGF2P8AFFINEINVQB.BCST imm8 m64 zmm zmm +// VGF2P8AFFINEINVQB.BCST imm8 m64 xmm k xmm +// VGF2P8AFFINEINVQB.BCST imm8 m64 xmm xmm +// VGF2P8AFFINEINVQB.BCST imm8 m64 ymm k ymm +// VGF2P8AFFINEINVQB.BCST imm8 m64 ymm ymm +// +// Construct and append a VGF2P8AFFINEINVQB.BCST instruction to the active function. +// Operates on the global context. +func VGF2P8AFFINEINVQB_BCST(ops ...operand.Op) { ctx.VGF2P8AFFINEINVQB_BCST(ops...) } + +// VGF2P8AFFINEQB: Galois Field Affine Transformation. +// +// Forms: +// +// VGF2P8AFFINEQB imm8 m128 xmm xmm +// VGF2P8AFFINEQB imm8 m256 ymm ymm +// VGF2P8AFFINEQB imm8 xmm xmm xmm +// VGF2P8AFFINEQB imm8 ymm ymm ymm +// VGF2P8AFFINEQB imm8 m512 zmm k zmm +// VGF2P8AFFINEQB imm8 m512 zmm zmm +// VGF2P8AFFINEQB imm8 zmm zmm k zmm +// VGF2P8AFFINEQB imm8 zmm zmm zmm +// VGF2P8AFFINEQB imm8 m128 xmm k xmm +// VGF2P8AFFINEQB imm8 m256 ymm k ymm +// VGF2P8AFFINEQB imm8 xmm xmm k xmm +// VGF2P8AFFINEQB imm8 ymm ymm k ymm +// +// Construct and append a VGF2P8AFFINEQB instruction to the active function. +func (c *Context) VGF2P8AFFINEQB(ops ...operand.Op) { + c.addinstruction(x86.VGF2P8AFFINEQB(ops...)) +} + +// VGF2P8AFFINEQB: Galois Field Affine Transformation. +// +// Forms: +// +// VGF2P8AFFINEQB imm8 m128 xmm xmm +// VGF2P8AFFINEQB imm8 m256 ymm ymm +// VGF2P8AFFINEQB imm8 xmm xmm xmm +// VGF2P8AFFINEQB imm8 ymm ymm ymm +// VGF2P8AFFINEQB imm8 m512 zmm k zmm +// VGF2P8AFFINEQB imm8 m512 zmm zmm +// VGF2P8AFFINEQB imm8 zmm zmm k zmm +// VGF2P8AFFINEQB imm8 zmm zmm zmm +// VGF2P8AFFINEQB imm8 m128 xmm k xmm +// VGF2P8AFFINEQB imm8 m256 ymm k ymm +// VGF2P8AFFINEQB imm8 xmm xmm k xmm +// VGF2P8AFFINEQB imm8 ymm ymm k ymm +// +// Construct and append a VGF2P8AFFINEQB instruction to the active function. +// Operates on the global context. +func VGF2P8AFFINEQB(ops ...operand.Op) { ctx.VGF2P8AFFINEQB(ops...) } + +// VGF2P8AFFINEQB_BCST: Galois Field Affine Transformation (Broadcast). +// +// Forms: +// +// VGF2P8AFFINEQB.BCST imm8 m64 zmm k zmm +// VGF2P8AFFINEQB.BCST imm8 m64 zmm zmm +// VGF2P8AFFINEQB.BCST imm8 m64 xmm k xmm +// VGF2P8AFFINEQB.BCST imm8 m64 xmm xmm +// VGF2P8AFFINEQB.BCST imm8 m64 ymm k ymm +// VGF2P8AFFINEQB.BCST imm8 m64 ymm ymm +// +// Construct and append a VGF2P8AFFINEQB.BCST instruction to the active function. +func (c *Context) VGF2P8AFFINEQB_BCST(ops ...operand.Op) { + c.addinstruction(x86.VGF2P8AFFINEQB_BCST(ops...)) +} + +// VGF2P8AFFINEQB_BCST: Galois Field Affine Transformation (Broadcast). +// +// Forms: +// +// VGF2P8AFFINEQB.BCST imm8 m64 zmm k zmm +// VGF2P8AFFINEQB.BCST imm8 m64 zmm zmm +// VGF2P8AFFINEQB.BCST imm8 m64 xmm k xmm +// VGF2P8AFFINEQB.BCST imm8 m64 xmm xmm +// VGF2P8AFFINEQB.BCST imm8 m64 ymm k ymm +// VGF2P8AFFINEQB.BCST imm8 m64 ymm ymm +// +// Construct and append a VGF2P8AFFINEQB.BCST instruction to the active function. +// Operates on the global context. +func VGF2P8AFFINEQB_BCST(ops ...operand.Op) { ctx.VGF2P8AFFINEQB_BCST(ops...) } + +// VGF2P8MULB: Galois Field Multiply Bytes. +// +// Forms: +// +// VGF2P8MULB imm8 m128 xmm xmm +// VGF2P8MULB imm8 m256 ymm ymm +// VGF2P8MULB imm8 xmm xmm xmm +// VGF2P8MULB imm8 ymm ymm ymm +// VGF2P8MULB imm8 m512 zmm k zmm +// VGF2P8MULB imm8 m512 zmm zmm +// VGF2P8MULB imm8 zmm zmm k zmm +// VGF2P8MULB imm8 zmm zmm zmm +// VGF2P8MULB imm8 m128 xmm k xmm +// VGF2P8MULB imm8 m256 ymm k ymm +// VGF2P8MULB imm8 xmm xmm k xmm +// VGF2P8MULB imm8 ymm ymm k ymm +// +// Construct and append a VGF2P8MULB instruction to the active function. +func (c *Context) VGF2P8MULB(ops ...operand.Op) { + c.addinstruction(x86.VGF2P8MULB(ops...)) +} + +// VGF2P8MULB: Galois Field Multiply Bytes. +// +// Forms: +// +// VGF2P8MULB imm8 m128 xmm xmm +// VGF2P8MULB imm8 m256 ymm ymm +// VGF2P8MULB imm8 xmm xmm xmm +// VGF2P8MULB imm8 ymm ymm ymm +// VGF2P8MULB imm8 m512 zmm k zmm +// VGF2P8MULB imm8 m512 zmm zmm +// VGF2P8MULB imm8 zmm zmm k zmm +// VGF2P8MULB imm8 zmm zmm zmm +// VGF2P8MULB imm8 m128 xmm k xmm +// VGF2P8MULB imm8 m256 ymm k ymm +// VGF2P8MULB imm8 xmm xmm k xmm +// VGF2P8MULB imm8 ymm ymm k ymm +// +// Construct and append a VGF2P8MULB instruction to the active function. +// Operates on the global context. +func VGF2P8MULB(ops ...operand.Op) { ctx.VGF2P8MULB(ops...) } + +// VGF2P8MULB_BCST: Galois Field Multiply Bytes (Broadcast). +// +// Forms: +// +// VGF2P8MULB.BCST imm8 m64 zmm k zmm +// VGF2P8MULB.BCST imm8 m64 zmm zmm +// VGF2P8MULB.BCST imm8 m64 xmm k xmm +// VGF2P8MULB.BCST imm8 m64 xmm xmm +// VGF2P8MULB.BCST imm8 m64 ymm k ymm +// VGF2P8MULB.BCST imm8 m64 ymm ymm +// +// Construct and append a VGF2P8MULB.BCST instruction to the active function. +func (c *Context) VGF2P8MULB_BCST(ops ...operand.Op) { + c.addinstruction(x86.VGF2P8MULB_BCST(ops...)) +} + +// VGF2P8MULB_BCST: Galois Field Multiply Bytes (Broadcast). +// +// Forms: +// +// VGF2P8MULB.BCST imm8 m64 zmm k zmm +// VGF2P8MULB.BCST imm8 m64 zmm zmm +// VGF2P8MULB.BCST imm8 m64 xmm k xmm +// VGF2P8MULB.BCST imm8 m64 xmm xmm +// VGF2P8MULB.BCST imm8 m64 ymm k ymm +// VGF2P8MULB.BCST imm8 m64 ymm ymm +// +// Construct and append a VGF2P8MULB.BCST instruction to the active function. +// Operates on the global context. +func VGF2P8MULB_BCST(ops ...operand.Op) { ctx.VGF2P8MULB_BCST(ops...) } + // VHADDPD: Packed Double-FP Horizontal Add. // // Forms: diff --git a/build/zinstructions_test.go b/build/zinstructions_test.go index f937cb1e..bfedd570 100644 --- a/build/zinstructions_test.go +++ b/build/zinstructions_test.go @@ -239,6 +239,9 @@ func TestContextInstructions(t *testing.T) { ctx.DPPD(opimm8, opm128, opxmm) ctx.DPPS(opimm8, opm128, opxmm) ctx.EXTRACTPS(opimm2u, opxmm, opm32) + ctx.GF2P8AFFINEINVQB(opimm8, opm128, opxmm) + ctx.GF2P8AFFINEQB(opimm8, opm128, opxmm) + ctx.GF2P8MULB(opimm8, opm128, opxmm) ctx.HADDPD(opm128, opxmm) ctx.HADDPS(opm128, opxmm) ctx.HSUBPD(opm128, opxmm) @@ -2085,6 +2088,12 @@ func TestContextInstructions(t *testing.T) { ctx.VGETMANTSS_SAE(opimm8, opxmm, opxmm, opk, opxmm) ctx.VGETMANTSS_SAE_Z(opimm8, opxmm, opxmm, opk, opxmm) ctx.VGETMANTSS_Z(opimm8, opm32, opxmm, opk, opxmm) + ctx.VGF2P8AFFINEINVQB(opimm8, opm128, opxmm, opxmm) + ctx.VGF2P8AFFINEINVQB_BCST(opimm8, opm64, opzmm, opk, opzmm) + ctx.VGF2P8AFFINEQB(opimm8, opm128, opxmm, opxmm) + ctx.VGF2P8AFFINEQB_BCST(opimm8, opm64, opzmm, opk, opzmm) + ctx.VGF2P8MULB(opimm8, opm128, opxmm, opxmm) + ctx.VGF2P8MULB_BCST(opimm8, opm64, opzmm, opk, opzmm) ctx.VHADDPD(opm128, opxmm, opxmm) ctx.VHADDPS(opm128, opxmm, opxmm) ctx.VHSUBPD(opm128, opxmm, opxmm) diff --git a/x86/zctors.go b/x86/zctors.go index 93897c20..f5faba69 100644 --- a/x86/zctors.go +++ b/x86/zctors.go @@ -1940,6 +1940,36 @@ func EXTRACTPS(i, x, mr operand.Op) (*intrep.Instruction, error) { return build(opcEXTRACTPS.Forms(), sffxs{}, []operand.Op{i, x, mr}) } +// GF2P8AFFINEINVQB: Galois Field Affine Transformation Inverse. +// +// Forms: +// +// GF2P8AFFINEINVQB imm8 m128 xmm +// GF2P8AFFINEINVQB imm8 xmm xmm +func GF2P8AFFINEINVQB(i, mx, x operand.Op) (*intrep.Instruction, error) { + return build(opcGF2P8AFFINEINVQB.Forms(), sffxs{}, []operand.Op{i, mx, x}) +} + +// GF2P8AFFINEQB: Galois Field Affine Transformation. +// +// Forms: +// +// GF2P8AFFINEQB imm8 m128 xmm +// GF2P8AFFINEQB imm8 xmm xmm +func GF2P8AFFINEQB(i, mx, x operand.Op) (*intrep.Instruction, error) { + return build(opcGF2P8AFFINEQB.Forms(), sffxs{}, []operand.Op{i, mx, x}) +} + +// GF2P8MULB: Galois Field Multiply Bytes. +// +// Forms: +// +// GF2P8MULB imm8 m128 xmm +// GF2P8MULB imm8 xmm xmm +func GF2P8MULB(i, mx, x operand.Op) (*intrep.Instruction, error) { + return build(opcGF2P8MULB.Forms(), sffxs{}, []operand.Op{i, mx, x}) +} + // HADDPD: Packed Double-FP Horizontal Add. // // Forms: @@ -21950,6 +21980,108 @@ func VGETMANTSS_Z(i, mx, x, k, x1 operand.Op) (*intrep.Instruction, error) { return build(opcVGETMANTSS.Forms(), sffxs{sffxZ}, []operand.Op{i, mx, x, k, x1}) } +// VGF2P8AFFINEINVQB: Galois Field Affine Transformation Inverse. +// +// Forms: +// +// VGF2P8AFFINEINVQB imm8 m128 xmm xmm +// VGF2P8AFFINEINVQB imm8 m256 ymm ymm +// VGF2P8AFFINEINVQB imm8 xmm xmm xmm +// VGF2P8AFFINEINVQB imm8 ymm ymm ymm +// VGF2P8AFFINEINVQB imm8 m512 zmm k zmm +// VGF2P8AFFINEINVQB imm8 m512 zmm zmm +// VGF2P8AFFINEINVQB imm8 zmm zmm k zmm +// VGF2P8AFFINEINVQB imm8 zmm zmm zmm +// VGF2P8AFFINEINVQB imm8 m128 xmm k xmm +// VGF2P8AFFINEINVQB imm8 m256 ymm k ymm +// VGF2P8AFFINEINVQB imm8 xmm xmm k xmm +// VGF2P8AFFINEINVQB imm8 ymm ymm k ymm +func VGF2P8AFFINEINVQB(ops ...operand.Op) (*intrep.Instruction, error) { + return build(opcVGF2P8AFFINEINVQB.Forms(), sffxs{}, ops) +} + +// VGF2P8AFFINEINVQB_BCST: Galois Field Affine Transformation Inverse (Broadcast). +// +// Forms: +// +// VGF2P8AFFINEINVQB.BCST imm8 m64 zmm k zmm +// VGF2P8AFFINEINVQB.BCST imm8 m64 zmm zmm +// VGF2P8AFFINEINVQB.BCST imm8 m64 xmm k xmm +// VGF2P8AFFINEINVQB.BCST imm8 m64 xmm xmm +// VGF2P8AFFINEINVQB.BCST imm8 m64 ymm k ymm +// VGF2P8AFFINEINVQB.BCST imm8 m64 ymm ymm +func VGF2P8AFFINEINVQB_BCST(ops ...operand.Op) (*intrep.Instruction, error) { + return build(opcVGF2P8AFFINEINVQB.Forms(), sffxs{sffxBCST}, ops) +} + +// VGF2P8AFFINEQB: Galois Field Affine Transformation. +// +// Forms: +// +// VGF2P8AFFINEQB imm8 m128 xmm xmm +// VGF2P8AFFINEQB imm8 m256 ymm ymm +// VGF2P8AFFINEQB imm8 xmm xmm xmm +// VGF2P8AFFINEQB imm8 ymm ymm ymm +// VGF2P8AFFINEQB imm8 m512 zmm k zmm +// VGF2P8AFFINEQB imm8 m512 zmm zmm +// VGF2P8AFFINEQB imm8 zmm zmm k zmm +// VGF2P8AFFINEQB imm8 zmm zmm zmm +// VGF2P8AFFINEQB imm8 m128 xmm k xmm +// VGF2P8AFFINEQB imm8 m256 ymm k ymm +// VGF2P8AFFINEQB imm8 xmm xmm k xmm +// VGF2P8AFFINEQB imm8 ymm ymm k ymm +func VGF2P8AFFINEQB(ops ...operand.Op) (*intrep.Instruction, error) { + return build(opcVGF2P8AFFINEQB.Forms(), sffxs{}, ops) +} + +// VGF2P8AFFINEQB_BCST: Galois Field Affine Transformation (Broadcast). +// +// Forms: +// +// VGF2P8AFFINEQB.BCST imm8 m64 zmm k zmm +// VGF2P8AFFINEQB.BCST imm8 m64 zmm zmm +// VGF2P8AFFINEQB.BCST imm8 m64 xmm k xmm +// VGF2P8AFFINEQB.BCST imm8 m64 xmm xmm +// VGF2P8AFFINEQB.BCST imm8 m64 ymm k ymm +// VGF2P8AFFINEQB.BCST imm8 m64 ymm ymm +func VGF2P8AFFINEQB_BCST(ops ...operand.Op) (*intrep.Instruction, error) { + return build(opcVGF2P8AFFINEQB.Forms(), sffxs{sffxBCST}, ops) +} + +// VGF2P8MULB: Galois Field Multiply Bytes. +// +// Forms: +// +// VGF2P8MULB imm8 m128 xmm xmm +// VGF2P8MULB imm8 m256 ymm ymm +// VGF2P8MULB imm8 xmm xmm xmm +// VGF2P8MULB imm8 ymm ymm ymm +// VGF2P8MULB imm8 m512 zmm k zmm +// VGF2P8MULB imm8 m512 zmm zmm +// VGF2P8MULB imm8 zmm zmm k zmm +// VGF2P8MULB imm8 zmm zmm zmm +// VGF2P8MULB imm8 m128 xmm k xmm +// VGF2P8MULB imm8 m256 ymm k ymm +// VGF2P8MULB imm8 xmm xmm k xmm +// VGF2P8MULB imm8 ymm ymm k ymm +func VGF2P8MULB(ops ...operand.Op) (*intrep.Instruction, error) { + return build(opcVGF2P8MULB.Forms(), sffxs{}, ops) +} + +// VGF2P8MULB_BCST: Galois Field Multiply Bytes (Broadcast). +// +// Forms: +// +// VGF2P8MULB.BCST imm8 m64 zmm k zmm +// VGF2P8MULB.BCST imm8 m64 zmm zmm +// VGF2P8MULB.BCST imm8 m64 xmm k xmm +// VGF2P8MULB.BCST imm8 m64 xmm xmm +// VGF2P8MULB.BCST imm8 m64 ymm k ymm +// VGF2P8MULB.BCST imm8 m64 ymm ymm +func VGF2P8MULB_BCST(ops ...operand.Op) (*intrep.Instruction, error) { + return build(opcVGF2P8MULB.Forms(), sffxs{sffxBCST}, ops) +} + // VHADDPD: Packed Double-FP Horizontal Add. // // Forms: diff --git a/x86/zctors_test.go b/x86/zctors_test.go index aa169f60..c0edd5a7 100644 --- a/x86/zctors_test.go +++ b/x86/zctors_test.go @@ -2009,6 +2009,33 @@ func TestEXTRACTPSValidFormsNoError(t *testing.T) { } } +func TestGF2P8AFFINEINVQBValidFormsNoError(t *testing.T) { + if _, err := GF2P8AFFINEINVQB(opimm8, opm128, opxmm); err != nil { + t.Fatal(err) + } + if _, err := GF2P8AFFINEINVQB(opimm8, opxmm, opxmm); err != nil { + t.Fatal(err) + } +} + +func TestGF2P8AFFINEQBValidFormsNoError(t *testing.T) { + if _, err := GF2P8AFFINEQB(opimm8, opm128, opxmm); err != nil { + t.Fatal(err) + } + if _, err := GF2P8AFFINEQB(opimm8, opxmm, opxmm); err != nil { + t.Fatal(err) + } +} + +func TestGF2P8MULBValidFormsNoError(t *testing.T) { + if _, err := GF2P8MULB(opimm8, opm128, opxmm); err != nil { + t.Fatal(err) + } + if _, err := GF2P8MULB(opimm8, opxmm, opxmm); err != nil { + t.Fatal(err) + } +} + func TestHADDPDValidFormsNoError(t *testing.T) { if _, err := HADDPD(opm128, opxmm); err != nil { t.Fatal(err) @@ -23273,6 +23300,186 @@ func TestVGETMANTSS_ZValidFormsNoError(t *testing.T) { } } +func TestVGF2P8AFFINEINVQBValidFormsNoError(t *testing.T) { + if _, err := VGF2P8AFFINEINVQB(opimm8, opm128, opxmm, opxmm); err != nil { + t.Fatal(err) + } + if _, err := VGF2P8AFFINEINVQB(opimm8, opm256, opymm, opymm); err != nil { + t.Fatal(err) + } + if _, err := VGF2P8AFFINEINVQB(opimm8, opxmm, opxmm, opxmm); err != nil { + t.Fatal(err) + } + if _, err := VGF2P8AFFINEINVQB(opimm8, opymm, opymm, opymm); err != nil { + t.Fatal(err) + } + if _, err := VGF2P8AFFINEINVQB(opimm8, opm512, opzmm, opk, opzmm); err != nil { + t.Fatal(err) + } + if _, err := VGF2P8AFFINEINVQB(opimm8, opm512, opzmm, opzmm); err != nil { + t.Fatal(err) + } + if _, err := VGF2P8AFFINEINVQB(opimm8, opzmm, opzmm, opk, opzmm); err != nil { + t.Fatal(err) + } + if _, err := VGF2P8AFFINEINVQB(opimm8, opzmm, opzmm, opzmm); err != nil { + t.Fatal(err) + } + if _, err := VGF2P8AFFINEINVQB(opimm8, opm128, opxmm, opk, opxmm); err != nil { + t.Fatal(err) + } + if _, err := VGF2P8AFFINEINVQB(opimm8, opm256, opymm, opk, opymm); err != nil { + t.Fatal(err) + } + if _, err := VGF2P8AFFINEINVQB(opimm8, opxmm, opxmm, opk, opxmm); err != nil { + t.Fatal(err) + } + if _, err := VGF2P8AFFINEINVQB(opimm8, opymm, opymm, opk, opymm); err != nil { + t.Fatal(err) + } +} + +func TestVGF2P8AFFINEINVQB_BCSTValidFormsNoError(t *testing.T) { + if _, err := VGF2P8AFFINEINVQB_BCST(opimm8, opm64, opzmm, opk, opzmm); err != nil { + t.Fatal(err) + } + if _, err := VGF2P8AFFINEINVQB_BCST(opimm8, opm64, opzmm, opzmm); err != nil { + t.Fatal(err) + } + if _, err := VGF2P8AFFINEINVQB_BCST(opimm8, opm64, opxmm, opk, opxmm); err != nil { + t.Fatal(err) + } + if _, err := VGF2P8AFFINEINVQB_BCST(opimm8, opm64, opxmm, opxmm); err != nil { + t.Fatal(err) + } + if _, err := VGF2P8AFFINEINVQB_BCST(opimm8, opm64, opymm, opk, opymm); err != nil { + t.Fatal(err) + } + if _, err := VGF2P8AFFINEINVQB_BCST(opimm8, opm64, opymm, opymm); err != nil { + t.Fatal(err) + } +} + +func TestVGF2P8AFFINEQBValidFormsNoError(t *testing.T) { + if _, err := VGF2P8AFFINEQB(opimm8, opm128, opxmm, opxmm); err != nil { + t.Fatal(err) + } + if _, err := VGF2P8AFFINEQB(opimm8, opm256, opymm, opymm); err != nil { + t.Fatal(err) + } + if _, err := VGF2P8AFFINEQB(opimm8, opxmm, opxmm, opxmm); err != nil { + t.Fatal(err) + } + if _, err := VGF2P8AFFINEQB(opimm8, opymm, opymm, opymm); err != nil { + t.Fatal(err) + } + if _, err := VGF2P8AFFINEQB(opimm8, opm512, opzmm, opk, opzmm); err != nil { + t.Fatal(err) + } + if _, err := VGF2P8AFFINEQB(opimm8, opm512, opzmm, opzmm); err != nil { + t.Fatal(err) + } + if _, err := VGF2P8AFFINEQB(opimm8, opzmm, opzmm, opk, opzmm); err != nil { + t.Fatal(err) + } + if _, err := VGF2P8AFFINEQB(opimm8, opzmm, opzmm, opzmm); err != nil { + t.Fatal(err) + } + if _, err := VGF2P8AFFINEQB(opimm8, opm128, opxmm, opk, opxmm); err != nil { + t.Fatal(err) + } + if _, err := VGF2P8AFFINEQB(opimm8, opm256, opymm, opk, opymm); err != nil { + t.Fatal(err) + } + if _, err := VGF2P8AFFINEQB(opimm8, opxmm, opxmm, opk, opxmm); err != nil { + t.Fatal(err) + } + if _, err := VGF2P8AFFINEQB(opimm8, opymm, opymm, opk, opymm); err != nil { + t.Fatal(err) + } +} + +func TestVGF2P8AFFINEQB_BCSTValidFormsNoError(t *testing.T) { + if _, err := VGF2P8AFFINEQB_BCST(opimm8, opm64, opzmm, opk, opzmm); err != nil { + t.Fatal(err) + } + if _, err := VGF2P8AFFINEQB_BCST(opimm8, opm64, opzmm, opzmm); err != nil { + t.Fatal(err) + } + if _, err := VGF2P8AFFINEQB_BCST(opimm8, opm64, opxmm, opk, opxmm); err != nil { + t.Fatal(err) + } + if _, err := VGF2P8AFFINEQB_BCST(opimm8, opm64, opxmm, opxmm); err != nil { + t.Fatal(err) + } + if _, err := VGF2P8AFFINEQB_BCST(opimm8, opm64, opymm, opk, opymm); err != nil { + t.Fatal(err) + } + if _, err := VGF2P8AFFINEQB_BCST(opimm8, opm64, opymm, opymm); err != nil { + t.Fatal(err) + } +} + +func TestVGF2P8MULBValidFormsNoError(t *testing.T) { + if _, err := VGF2P8MULB(opimm8, opm128, opxmm, opxmm); err != nil { + t.Fatal(err) + } + if _, err := VGF2P8MULB(opimm8, opm256, opymm, opymm); err != nil { + t.Fatal(err) + } + if _, err := VGF2P8MULB(opimm8, opxmm, opxmm, opxmm); err != nil { + t.Fatal(err) + } + if _, err := VGF2P8MULB(opimm8, opymm, opymm, opymm); err != nil { + t.Fatal(err) + } + if _, err := VGF2P8MULB(opimm8, opm512, opzmm, opk, opzmm); err != nil { + t.Fatal(err) + } + if _, err := VGF2P8MULB(opimm8, opm512, opzmm, opzmm); err != nil { + t.Fatal(err) + } + if _, err := VGF2P8MULB(opimm8, opzmm, opzmm, opk, opzmm); err != nil { + t.Fatal(err) + } + if _, err := VGF2P8MULB(opimm8, opzmm, opzmm, opzmm); err != nil { + t.Fatal(err) + } + if _, err := VGF2P8MULB(opimm8, opm128, opxmm, opk, opxmm); err != nil { + t.Fatal(err) + } + if _, err := VGF2P8MULB(opimm8, opm256, opymm, opk, opymm); err != nil { + t.Fatal(err) + } + if _, err := VGF2P8MULB(opimm8, opxmm, opxmm, opk, opxmm); err != nil { + t.Fatal(err) + } + if _, err := VGF2P8MULB(opimm8, opymm, opymm, opk, opymm); err != nil { + t.Fatal(err) + } +} + +func TestVGF2P8MULB_BCSTValidFormsNoError(t *testing.T) { + if _, err := VGF2P8MULB_BCST(opimm8, opm64, opzmm, opk, opzmm); err != nil { + t.Fatal(err) + } + if _, err := VGF2P8MULB_BCST(opimm8, opm64, opzmm, opzmm); err != nil { + t.Fatal(err) + } + if _, err := VGF2P8MULB_BCST(opimm8, opm64, opxmm, opk, opxmm); err != nil { + t.Fatal(err) + } + if _, err := VGF2P8MULB_BCST(opimm8, opm64, opxmm, opxmm); err != nil { + t.Fatal(err) + } + if _, err := VGF2P8MULB_BCST(opimm8, opm64, opymm, opk, opymm); err != nil { + t.Fatal(err) + } + if _, err := VGF2P8MULB_BCST(opimm8, opm64, opymm, opymm); err != nil { + t.Fatal(err) + } +} + func TestVHADDPDValidFormsNoError(t *testing.T) { if _, err := VHADDPD(opm128, opxmm, opxmm); err != nil { t.Fatal(err) diff --git a/x86/zoptab.go b/x86/zoptab.go index bbea9c49..0f14bbb4 100644 --- a/x86/zoptab.go +++ b/x86/zoptab.go @@ -282,6 +282,7 @@ const ( isasCMOV isasCPUID isasSSE42 + isasGFNI_SSE2 isasAVX512DQ isasAVX512BW isasAVX512F @@ -307,6 +308,9 @@ const ( isasAVX512BW_AVX512VL isasAVX512ER isasFMA3 + isasAVX_GFNI + isasAVX512F_GFNI + isasAVX512VL_GFNI isasAVX512CD_AVX512VL isasAVX512CD isasAVX_PCLMULQDQ @@ -341,6 +345,7 @@ var isaslisttable = [][]string{ {"CMOV"}, {"CPUID"}, {"SSE4.2"}, + {"GFNI", "SSE2"}, {"AVX512DQ"}, {"AVX512BW"}, {"AVX512F"}, @@ -366,6 +371,9 @@ var isaslisttable = [][]string{ {"AVX512BW", "AVX512VL"}, {"AVX512ER"}, {"FMA3"}, + {"AVX", "GFNI"}, + {"AVX512F", "GFNI"}, + {"AVX512VL", "GFNI"}, {"AVX512CD", "AVX512VL"}, {"AVX512CD"}, {"AVX", "PCLMULQDQ"}, @@ -564,6 +572,9 @@ const ( opcDPPD opcDPPS opcEXTRACTPS + opcGF2P8AFFINEINVQB + opcGF2P8AFFINEQB + opcGF2P8MULB opcHADDPD opcHADDPS opcHSUBPD @@ -1257,6 +1268,9 @@ const ( opcVGETMANTPS opcVGETMANTSD opcVGETMANTSS + opcVGF2P8AFFINEINVQB + opcVGF2P8AFFINEQB + opcVGF2P8MULB opcVHADDPD opcVHADDPS opcVHSUBPD @@ -1857,6 +1871,9 @@ var opcstringtable = []string{ "DPPD", "DPPS", "EXTRACTPS", + "GF2P8AFFINEINVQB", + "GF2P8AFFINEQB", + "GF2P8MULB", "HADDPD", "HADDPS", "HSUBPD", @@ -2550,6 +2567,9 @@ var opcstringtable = []string{ "VGETMANTPS", "VGETMANTSD", "VGETMANTSS", + "VGF2P8AFFINEINVQB", + "VGF2P8AFFINEQB", + "VGF2P8MULB", "VHADDPD", "VHADDPS", "VHSUBPD", @@ -3428,6 +3448,12 @@ var forms = []form{ {opcDPPS, sffxsclsNIL, 0, isasSSE41, 3, oprnds{{uint8(oprndtypeIMM8), false, actionN}, {uint8(oprndtypeXMM), false, actionR}, {uint8(oprndtypeXMM), false, actionRW}}}, {opcEXTRACTPS, sffxsclsNIL, 0, isasSSE41, 3, oprnds{{uint8(oprndtypeIMM2U), false, actionN}, {uint8(oprndtypeXMM), false, actionR}, {uint8(oprndtypeM32), false, actionW}}}, {opcEXTRACTPS, sffxsclsNIL, 0, isasSSE41, 3, oprnds{{uint8(oprndtypeIMM2U), false, actionN}, {uint8(oprndtypeXMM), false, actionR}, {uint8(oprndtypeR32), false, actionW}}}, + {opcGF2P8AFFINEINVQB, sffxsclsNIL, 0, isasGFNI_SSE2, 3, oprnds{{uint8(oprndtypeIMM8), false, actionR}, {uint8(oprndtypeM128), false, actionR}, {uint8(oprndtypeXMM), false, actionW}}}, + {opcGF2P8AFFINEINVQB, sffxsclsNIL, 0, isasGFNI_SSE2, 3, oprnds{{uint8(oprndtypeIMM8), false, actionR}, {uint8(oprndtypeXMM), false, actionR}, {uint8(oprndtypeXMM), false, actionW}}}, + {opcGF2P8AFFINEQB, sffxsclsNIL, 0, isasGFNI_SSE2, 3, oprnds{{uint8(oprndtypeIMM8), false, actionR}, {uint8(oprndtypeM128), false, actionR}, {uint8(oprndtypeXMM), false, actionW}}}, + {opcGF2P8AFFINEQB, sffxsclsNIL, 0, isasGFNI_SSE2, 3, oprnds{{uint8(oprndtypeIMM8), false, actionR}, {uint8(oprndtypeXMM), false, actionR}, {uint8(oprndtypeXMM), false, actionW}}}, + {opcGF2P8MULB, sffxsclsNIL, 0, isasGFNI_SSE2, 3, oprnds{{uint8(oprndtypeIMM8), false, actionR}, {uint8(oprndtypeM128), false, actionR}, {uint8(oprndtypeXMM), false, actionW}}}, + {opcGF2P8MULB, sffxsclsNIL, 0, isasGFNI_SSE2, 3, oprnds{{uint8(oprndtypeIMM8), false, actionR}, {uint8(oprndtypeXMM), false, actionR}, {uint8(oprndtypeXMM), false, actionW}}}, {opcHADDPD, sffxsclsNIL, 0, isasSSE3, 2, oprnds{{uint8(oprndtypeM128), false, actionR}, {uint8(oprndtypeXMM), false, actionRW}}}, {opcHADDPD, sffxsclsNIL, 0, isasSSE3, 2, oprnds{{uint8(oprndtypeXMM), false, actionR}, {uint8(oprndtypeXMM), false, actionRW}}}, {opcHADDPS, sffxsclsNIL, 0, isasSSE3, 2, oprnds{{uint8(oprndtypeM128), false, actionR}, {uint8(oprndtypeXMM), false, actionRW}}}, @@ -7872,6 +7898,60 @@ var forms = []form{ {opcVGETMANTSS, sffxsclsSAE_Z, 0, isasAVX512F, 5, oprnds{{uint8(oprndtypeIMM8), false, actionN}, {uint8(oprndtypeXMM), false, actionR}, {uint8(oprndtypeXMM), false, actionR}, {uint8(oprndtypeK), false, actionR}, {uint8(oprndtypeXMM), false, actionW}}}, {opcVGETMANTSS, sffxsclsNIL, 0, isasAVX512F, 4, oprnds{{uint8(oprndtypeIMM8), false, actionN}, {uint8(oprndtypeXMM), false, actionR}, {uint8(oprndtypeXMM), false, actionR}, {uint8(oprndtypeXMM), false, actionW}}}, {opcVGETMANTSS, sffxsclsSAE, 0, isasAVX512F, 4, oprnds{{uint8(oprndtypeIMM8), false, actionN}, {uint8(oprndtypeXMM), false, actionR}, {uint8(oprndtypeXMM), false, actionR}, {uint8(oprndtypeXMM), false, actionW}}}, + {opcVGF2P8AFFINEINVQB, sffxsclsNIL, 0, isasAVX_GFNI, 4, oprnds{{uint8(oprndtypeIMM8), false, actionR}, {uint8(oprndtypeM128), false, actionR}, {uint8(oprndtypeXMM), false, actionR}, {uint8(oprndtypeXMM), false, actionW}}}, + {opcVGF2P8AFFINEINVQB, sffxsclsNIL, 0, isasAVX_GFNI, 4, oprnds{{uint8(oprndtypeIMM8), false, actionR}, {uint8(oprndtypeM256), false, actionR}, {uint8(oprndtypeYMM), false, actionR}, {uint8(oprndtypeYMM), false, actionW}}}, + {opcVGF2P8AFFINEINVQB, sffxsclsNIL, 0, isasAVX_GFNI, 4, oprnds{{uint8(oprndtypeIMM8), false, actionR}, {uint8(oprndtypeXMM), false, actionR}, {uint8(oprndtypeXMM), false, actionR}, {uint8(oprndtypeXMM), false, actionW}}}, + {opcVGF2P8AFFINEINVQB, sffxsclsNIL, 0, isasAVX_GFNI, 4, oprnds{{uint8(oprndtypeIMM8), false, actionR}, {uint8(oprndtypeYMM), false, actionR}, {uint8(oprndtypeYMM), false, actionR}, {uint8(oprndtypeYMM), false, actionW}}}, + {opcVGF2P8AFFINEINVQB, sffxsclsNIL, 0, isasAVX512F_GFNI, 5, oprnds{{uint8(oprndtypeIMM8), false, actionR}, {uint8(oprndtypeM512), false, actionR}, {uint8(oprndtypeZMM), false, actionR}, {uint8(oprndtypeK), false, actionR}, {uint8(oprndtypeZMM), false, actionW}}}, + {opcVGF2P8AFFINEINVQB, sffxsclsNIL, 0, isasAVX512F_GFNI, 4, oprnds{{uint8(oprndtypeIMM8), false, actionR}, {uint8(oprndtypeM512), false, actionR}, {uint8(oprndtypeZMM), false, actionR}, {uint8(oprndtypeZMM), false, actionW}}}, + {opcVGF2P8AFFINEINVQB, sffxsclsBCST, 0, isasAVX512F_GFNI, 5, oprnds{{uint8(oprndtypeIMM8), false, actionR}, {uint8(oprndtypeM64), false, actionR}, {uint8(oprndtypeZMM), false, actionR}, {uint8(oprndtypeK), false, actionR}, {uint8(oprndtypeZMM), false, actionW}}}, + {opcVGF2P8AFFINEINVQB, sffxsclsBCST, 0, isasAVX512F_GFNI, 4, oprnds{{uint8(oprndtypeIMM8), false, actionR}, {uint8(oprndtypeM64), false, actionR}, {uint8(oprndtypeZMM), false, actionR}, {uint8(oprndtypeZMM), false, actionW}}}, + {opcVGF2P8AFFINEINVQB, sffxsclsNIL, 0, isasAVX512F_GFNI, 5, oprnds{{uint8(oprndtypeIMM8), false, actionR}, {uint8(oprndtypeZMM), false, actionR}, {uint8(oprndtypeZMM), false, actionR}, {uint8(oprndtypeK), false, actionR}, {uint8(oprndtypeZMM), false, actionW}}}, + {opcVGF2P8AFFINEINVQB, sffxsclsNIL, 0, isasAVX512F_GFNI, 4, oprnds{{uint8(oprndtypeIMM8), false, actionR}, {uint8(oprndtypeZMM), false, actionR}, {uint8(oprndtypeZMM), false, actionR}, {uint8(oprndtypeZMM), false, actionW}}}, + {opcVGF2P8AFFINEINVQB, sffxsclsNIL, 0, isasAVX512VL_GFNI, 5, oprnds{{uint8(oprndtypeIMM8), false, actionR}, {uint8(oprndtypeM128), false, actionR}, {uint8(oprndtypeXMM), false, actionR}, {uint8(oprndtypeK), false, actionR}, {uint8(oprndtypeXMM), false, actionW}}}, + {opcVGF2P8AFFINEINVQB, sffxsclsNIL, 0, isasAVX512VL_GFNI, 5, oprnds{{uint8(oprndtypeIMM8), false, actionR}, {uint8(oprndtypeM256), false, actionR}, {uint8(oprndtypeYMM), false, actionR}, {uint8(oprndtypeK), false, actionR}, {uint8(oprndtypeYMM), false, actionW}}}, + {opcVGF2P8AFFINEINVQB, sffxsclsBCST, 0, isasAVX512VL_GFNI, 5, oprnds{{uint8(oprndtypeIMM8), false, actionR}, {uint8(oprndtypeM64), false, actionR}, {uint8(oprndtypeXMM), false, actionR}, {uint8(oprndtypeK), false, actionR}, {uint8(oprndtypeXMM), false, actionW}}}, + {opcVGF2P8AFFINEINVQB, sffxsclsBCST, 0, isasAVX512VL_GFNI, 4, oprnds{{uint8(oprndtypeIMM8), false, actionR}, {uint8(oprndtypeM64), false, actionR}, {uint8(oprndtypeXMM), false, actionR}, {uint8(oprndtypeXMM), false, actionW}}}, + {opcVGF2P8AFFINEINVQB, sffxsclsBCST, 0, isasAVX512VL_GFNI, 5, oprnds{{uint8(oprndtypeIMM8), false, actionR}, {uint8(oprndtypeM64), false, actionR}, {uint8(oprndtypeYMM), false, actionR}, {uint8(oprndtypeK), false, actionR}, {uint8(oprndtypeYMM), false, actionW}}}, + {opcVGF2P8AFFINEINVQB, sffxsclsBCST, 0, isasAVX512VL_GFNI, 4, oprnds{{uint8(oprndtypeIMM8), false, actionR}, {uint8(oprndtypeM64), false, actionR}, {uint8(oprndtypeYMM), false, actionR}, {uint8(oprndtypeYMM), false, actionW}}}, + {opcVGF2P8AFFINEINVQB, sffxsclsNIL, 0, isasAVX512VL_GFNI, 5, oprnds{{uint8(oprndtypeIMM8), false, actionR}, {uint8(oprndtypeXMM), false, actionR}, {uint8(oprndtypeXMM), false, actionR}, {uint8(oprndtypeK), false, actionR}, {uint8(oprndtypeXMM), false, actionW}}}, + {opcVGF2P8AFFINEINVQB, sffxsclsNIL, 0, isasAVX512VL_GFNI, 5, oprnds{{uint8(oprndtypeIMM8), false, actionR}, {uint8(oprndtypeYMM), false, actionR}, {uint8(oprndtypeYMM), false, actionR}, {uint8(oprndtypeK), false, actionR}, {uint8(oprndtypeYMM), false, actionW}}}, + {opcVGF2P8AFFINEQB, sffxsclsNIL, 0, isasAVX_GFNI, 4, oprnds{{uint8(oprndtypeIMM8), false, actionR}, {uint8(oprndtypeM128), false, actionR}, {uint8(oprndtypeXMM), false, actionR}, {uint8(oprndtypeXMM), false, actionW}}}, + {opcVGF2P8AFFINEQB, sffxsclsNIL, 0, isasAVX_GFNI, 4, oprnds{{uint8(oprndtypeIMM8), false, actionR}, {uint8(oprndtypeM256), false, actionR}, {uint8(oprndtypeYMM), false, actionR}, {uint8(oprndtypeYMM), false, actionW}}}, + {opcVGF2P8AFFINEQB, sffxsclsNIL, 0, isasAVX_GFNI, 4, oprnds{{uint8(oprndtypeIMM8), false, actionR}, {uint8(oprndtypeXMM), false, actionR}, {uint8(oprndtypeXMM), false, actionR}, {uint8(oprndtypeXMM), false, actionW}}}, + {opcVGF2P8AFFINEQB, sffxsclsNIL, 0, isasAVX_GFNI, 4, oprnds{{uint8(oprndtypeIMM8), false, actionR}, {uint8(oprndtypeYMM), false, actionR}, {uint8(oprndtypeYMM), false, actionR}, {uint8(oprndtypeYMM), false, actionW}}}, + {opcVGF2P8AFFINEQB, sffxsclsNIL, 0, isasAVX512F_GFNI, 5, oprnds{{uint8(oprndtypeIMM8), false, actionR}, {uint8(oprndtypeM512), false, actionR}, {uint8(oprndtypeZMM), false, actionR}, {uint8(oprndtypeK), false, actionR}, {uint8(oprndtypeZMM), false, actionW}}}, + {opcVGF2P8AFFINEQB, sffxsclsNIL, 0, isasAVX512F_GFNI, 4, oprnds{{uint8(oprndtypeIMM8), false, actionR}, {uint8(oprndtypeM512), false, actionR}, {uint8(oprndtypeZMM), false, actionR}, {uint8(oprndtypeZMM), false, actionW}}}, + {opcVGF2P8AFFINEQB, sffxsclsBCST, 0, isasAVX512F_GFNI, 5, oprnds{{uint8(oprndtypeIMM8), false, actionR}, {uint8(oprndtypeM64), false, actionR}, {uint8(oprndtypeZMM), false, actionR}, {uint8(oprndtypeK), false, actionR}, {uint8(oprndtypeZMM), false, actionW}}}, + {opcVGF2P8AFFINEQB, sffxsclsBCST, 0, isasAVX512F_GFNI, 4, oprnds{{uint8(oprndtypeIMM8), false, actionR}, {uint8(oprndtypeM64), false, actionR}, {uint8(oprndtypeZMM), false, actionR}, {uint8(oprndtypeZMM), false, actionW}}}, + {opcVGF2P8AFFINEQB, sffxsclsNIL, 0, isasAVX512F_GFNI, 5, oprnds{{uint8(oprndtypeIMM8), false, actionR}, {uint8(oprndtypeZMM), false, actionR}, {uint8(oprndtypeZMM), false, actionR}, {uint8(oprndtypeK), false, actionR}, {uint8(oprndtypeZMM), false, actionW}}}, + {opcVGF2P8AFFINEQB, sffxsclsNIL, 0, isasAVX512F_GFNI, 4, oprnds{{uint8(oprndtypeIMM8), false, actionR}, {uint8(oprndtypeZMM), false, actionR}, {uint8(oprndtypeZMM), false, actionR}, {uint8(oprndtypeZMM), false, actionW}}}, + {opcVGF2P8AFFINEQB, sffxsclsNIL, 0, isasAVX512VL_GFNI, 5, oprnds{{uint8(oprndtypeIMM8), false, actionR}, {uint8(oprndtypeM128), false, actionR}, {uint8(oprndtypeXMM), false, actionR}, {uint8(oprndtypeK), false, actionR}, {uint8(oprndtypeXMM), false, actionW}}}, + {opcVGF2P8AFFINEQB, sffxsclsNIL, 0, isasAVX512VL_GFNI, 5, oprnds{{uint8(oprndtypeIMM8), false, actionR}, {uint8(oprndtypeM256), false, actionR}, {uint8(oprndtypeYMM), false, actionR}, {uint8(oprndtypeK), false, actionR}, {uint8(oprndtypeYMM), false, actionW}}}, + {opcVGF2P8AFFINEQB, sffxsclsBCST, 0, isasAVX512VL_GFNI, 5, oprnds{{uint8(oprndtypeIMM8), false, actionR}, {uint8(oprndtypeM64), false, actionR}, {uint8(oprndtypeXMM), false, actionR}, {uint8(oprndtypeK), false, actionR}, {uint8(oprndtypeXMM), false, actionW}}}, + {opcVGF2P8AFFINEQB, sffxsclsBCST, 0, isasAVX512VL_GFNI, 4, oprnds{{uint8(oprndtypeIMM8), false, actionR}, {uint8(oprndtypeM64), false, actionR}, {uint8(oprndtypeXMM), false, actionR}, {uint8(oprndtypeXMM), false, actionW}}}, + {opcVGF2P8AFFINEQB, sffxsclsBCST, 0, isasAVX512VL_GFNI, 5, oprnds{{uint8(oprndtypeIMM8), false, actionR}, {uint8(oprndtypeM64), false, actionR}, {uint8(oprndtypeYMM), false, actionR}, {uint8(oprndtypeK), false, actionR}, {uint8(oprndtypeYMM), false, actionW}}}, + {opcVGF2P8AFFINEQB, sffxsclsBCST, 0, isasAVX512VL_GFNI, 4, oprnds{{uint8(oprndtypeIMM8), false, actionR}, {uint8(oprndtypeM64), false, actionR}, {uint8(oprndtypeYMM), false, actionR}, {uint8(oprndtypeYMM), false, actionW}}}, + {opcVGF2P8AFFINEQB, sffxsclsNIL, 0, isasAVX512VL_GFNI, 5, oprnds{{uint8(oprndtypeIMM8), false, actionR}, {uint8(oprndtypeXMM), false, actionR}, {uint8(oprndtypeXMM), false, actionR}, {uint8(oprndtypeK), false, actionR}, {uint8(oprndtypeXMM), false, actionW}}}, + {opcVGF2P8AFFINEQB, sffxsclsNIL, 0, isasAVX512VL_GFNI, 5, oprnds{{uint8(oprndtypeIMM8), false, actionR}, {uint8(oprndtypeYMM), false, actionR}, {uint8(oprndtypeYMM), false, actionR}, {uint8(oprndtypeK), false, actionR}, {uint8(oprndtypeYMM), false, actionW}}}, + {opcVGF2P8MULB, sffxsclsNIL, 0, isasAVX_GFNI, 4, oprnds{{uint8(oprndtypeIMM8), false, actionR}, {uint8(oprndtypeM128), false, actionR}, {uint8(oprndtypeXMM), false, actionR}, {uint8(oprndtypeXMM), false, actionW}}}, + {opcVGF2P8MULB, sffxsclsNIL, 0, isasAVX_GFNI, 4, oprnds{{uint8(oprndtypeIMM8), false, actionR}, {uint8(oprndtypeM256), false, actionR}, {uint8(oprndtypeYMM), false, actionR}, {uint8(oprndtypeYMM), false, actionW}}}, + {opcVGF2P8MULB, sffxsclsNIL, 0, isasAVX_GFNI, 4, oprnds{{uint8(oprndtypeIMM8), false, actionR}, {uint8(oprndtypeXMM), false, actionR}, {uint8(oprndtypeXMM), false, actionR}, {uint8(oprndtypeXMM), false, actionW}}}, + {opcVGF2P8MULB, sffxsclsNIL, 0, isasAVX_GFNI, 4, oprnds{{uint8(oprndtypeIMM8), false, actionR}, {uint8(oprndtypeYMM), false, actionR}, {uint8(oprndtypeYMM), false, actionR}, {uint8(oprndtypeYMM), false, actionW}}}, + {opcVGF2P8MULB, sffxsclsNIL, 0, isasAVX512F_GFNI, 5, oprnds{{uint8(oprndtypeIMM8), false, actionR}, {uint8(oprndtypeM512), false, actionR}, {uint8(oprndtypeZMM), false, actionR}, {uint8(oprndtypeK), false, actionR}, {uint8(oprndtypeZMM), false, actionW}}}, + {opcVGF2P8MULB, sffxsclsNIL, 0, isasAVX512F_GFNI, 4, oprnds{{uint8(oprndtypeIMM8), false, actionR}, {uint8(oprndtypeM512), false, actionR}, {uint8(oprndtypeZMM), false, actionR}, {uint8(oprndtypeZMM), false, actionW}}}, + {opcVGF2P8MULB, sffxsclsBCST, 0, isasAVX512F_GFNI, 5, oprnds{{uint8(oprndtypeIMM8), false, actionR}, {uint8(oprndtypeM64), false, actionR}, {uint8(oprndtypeZMM), false, actionR}, {uint8(oprndtypeK), false, actionR}, {uint8(oprndtypeZMM), false, actionW}}}, + {opcVGF2P8MULB, sffxsclsBCST, 0, isasAVX512F_GFNI, 4, oprnds{{uint8(oprndtypeIMM8), false, actionR}, {uint8(oprndtypeM64), false, actionR}, {uint8(oprndtypeZMM), false, actionR}, {uint8(oprndtypeZMM), false, actionW}}}, + {opcVGF2P8MULB, sffxsclsNIL, 0, isasAVX512F_GFNI, 5, oprnds{{uint8(oprndtypeIMM8), false, actionR}, {uint8(oprndtypeZMM), false, actionR}, {uint8(oprndtypeZMM), false, actionR}, {uint8(oprndtypeK), false, actionR}, {uint8(oprndtypeZMM), false, actionW}}}, + {opcVGF2P8MULB, sffxsclsNIL, 0, isasAVX512F_GFNI, 4, oprnds{{uint8(oprndtypeIMM8), false, actionR}, {uint8(oprndtypeZMM), false, actionR}, {uint8(oprndtypeZMM), false, actionR}, {uint8(oprndtypeZMM), false, actionW}}}, + {opcVGF2P8MULB, sffxsclsNIL, 0, isasAVX512VL_GFNI, 5, oprnds{{uint8(oprndtypeIMM8), false, actionR}, {uint8(oprndtypeM128), false, actionR}, {uint8(oprndtypeXMM), false, actionR}, {uint8(oprndtypeK), false, actionR}, {uint8(oprndtypeXMM), false, actionW}}}, + {opcVGF2P8MULB, sffxsclsNIL, 0, isasAVX512VL_GFNI, 5, oprnds{{uint8(oprndtypeIMM8), false, actionR}, {uint8(oprndtypeM256), false, actionR}, {uint8(oprndtypeYMM), false, actionR}, {uint8(oprndtypeK), false, actionR}, {uint8(oprndtypeYMM), false, actionW}}}, + {opcVGF2P8MULB, sffxsclsBCST, 0, isasAVX512VL_GFNI, 5, oprnds{{uint8(oprndtypeIMM8), false, actionR}, {uint8(oprndtypeM64), false, actionR}, {uint8(oprndtypeXMM), false, actionR}, {uint8(oprndtypeK), false, actionR}, {uint8(oprndtypeXMM), false, actionW}}}, + {opcVGF2P8MULB, sffxsclsBCST, 0, isasAVX512VL_GFNI, 4, oprnds{{uint8(oprndtypeIMM8), false, actionR}, {uint8(oprndtypeM64), false, actionR}, {uint8(oprndtypeXMM), false, actionR}, {uint8(oprndtypeXMM), false, actionW}}}, + {opcVGF2P8MULB, sffxsclsBCST, 0, isasAVX512VL_GFNI, 5, oprnds{{uint8(oprndtypeIMM8), false, actionR}, {uint8(oprndtypeM64), false, actionR}, {uint8(oprndtypeYMM), false, actionR}, {uint8(oprndtypeK), false, actionR}, {uint8(oprndtypeYMM), false, actionW}}}, + {opcVGF2P8MULB, sffxsclsBCST, 0, isasAVX512VL_GFNI, 4, oprnds{{uint8(oprndtypeIMM8), false, actionR}, {uint8(oprndtypeM64), false, actionR}, {uint8(oprndtypeYMM), false, actionR}, {uint8(oprndtypeYMM), false, actionW}}}, + {opcVGF2P8MULB, sffxsclsNIL, 0, isasAVX512VL_GFNI, 5, oprnds{{uint8(oprndtypeIMM8), false, actionR}, {uint8(oprndtypeXMM), false, actionR}, {uint8(oprndtypeXMM), false, actionR}, {uint8(oprndtypeK), false, actionR}, {uint8(oprndtypeXMM), false, actionW}}}, + {opcVGF2P8MULB, sffxsclsNIL, 0, isasAVX512VL_GFNI, 5, oprnds{{uint8(oprndtypeIMM8), false, actionR}, {uint8(oprndtypeYMM), false, actionR}, {uint8(oprndtypeYMM), false, actionR}, {uint8(oprndtypeK), false, actionR}, {uint8(oprndtypeYMM), false, actionW}}}, {opcVHADDPD, sffxsclsNIL, 0, isasAVX, 3, oprnds{{uint8(oprndtypeM128), false, actionR}, {uint8(oprndtypeXMM), false, actionR}, {uint8(oprndtypeXMM), false, actionW}}}, {opcVHADDPD, sffxsclsNIL, 0, isasAVX, 3, oprnds{{uint8(oprndtypeM256), false, actionR}, {uint8(oprndtypeYMM), false, actionR}, {uint8(oprndtypeYMM), false, actionW}}}, {opcVHADDPD, sffxsclsNIL, 0, isasAVX, 3, oprnds{{uint8(oprndtypeXMM), false, actionR}, {uint8(oprndtypeXMM), false, actionR}, {uint8(oprndtypeXMM), false, actionW}}}, @@ -14547,16 +14627,16 @@ var opcformstable = [][]form{ forms[479:481], forms[481:483], forms[483:485], - forms[485:489], - forms[489:493], - forms[493:497], - forms[497:499], + forms[485:487], + forms[487:489], + forms[489:491], + forms[491:495], + forms[495:499], forms[499:503], - forms[503:507], - forms[507:511], - forms[511:513], - forms[513:515], - forms[515:517], + forms[503:505], + forms[505:509], + forms[509:513], + forms[513:517], forms[517:519], forms[519:521], forms[521:523], @@ -14567,11 +14647,11 @@ var opcformstable = [][]form{ forms[531:533], forms[533:535], forms[535:537], - forms[537:538], - forms[538:539], + forms[537:539], forms[539:541], forms[541:543], - forms[543:545], + forms[543:544], + forms[544:545], forms[545:547], forms[547:549], forms[549:551], @@ -14582,10 +14662,10 @@ var opcformstable = [][]form{ forms[559:561], forms[561:563], forms[563:565], - forms[565:569], + forms[565:567], + forms[567:569], forms[569:571], - forms[571:573], - forms[573:575], + forms[571:575], forms[575:577], forms[577:579], forms[579:581], @@ -14608,28 +14688,25 @@ var opcformstable = [][]form{ forms[613:615], forms[615:617], forms[617:619], - forms[619:620], - forms[620:621], - forms[621:622], - forms[622:623], - forms[623:624], - forms[624:625], + forms[619:621], + forms[621:623], + forms[623:625], forms[625:626], forms[626:627], forms[627:628], forms[628:629], forms[629:630], forms[630:631], - forms[631:636], - forms[636:641], - forms[641:646], - forms[646:651], - forms[651:652], - forms[652:653], - forms[653:654], - forms[654:655], - forms[655:656], - forms[656:657], + forms[631:632], + forms[632:633], + forms[633:634], + forms[634:635], + forms[635:636], + forms[636:637], + forms[637:642], + forms[642:647], + forms[647:652], + forms[652:657], forms[657:658], forms[658:659], forms[659:660], @@ -14665,68 +14742,71 @@ var opcformstable = [][]form{ forms[689:690], forms[690:691], forms[691:692], - forms[692:694], - forms[694:696], - forms[696:698], - forms[698:699], - forms[699:700], + forms[692:693], + forms[693:694], + forms[694:695], + forms[695:696], + forms[696:697], + forms[697:698], + forms[698:700], forms[700:702], forms[702:704], - forms[704:706], + forms[704:705], + forms[705:706], forms[706:708], - forms[708:709], - forms[709:711], - forms[711:713], - forms[713:715], + forms[708:710], + forms[710:712], + forms[712:714], + forms[714:715], forms[715:717], - forms[717:718], - forms[718:721], - forms[721:724], - forms[724:729], - forms[729:731], - forms[731:733], - forms[733:735], + forms[717:719], + forms[719:721], + forms[721:723], + forms[723:724], + forms[724:727], + forms[727:730], + forms[730:735], forms[735:737], forms[737:739], forms[739:741], forms[741:743], forms[743:745], forms[745:747], - forms[747:762], - forms[762:764], - forms[764:779], - forms[779:780], - forms[780:782], - forms[782:784], - forms[784:789], - forms[789:790], - forms[790:792], - forms[792:794], - forms[794:796], - forms[796:797], - forms[797:798], - forms[798:799], - forms[799:800], - forms[800:801], - forms[801:802], + forms[747:749], + forms[749:751], + forms[751:753], + forms[753:768], + forms[768:770], + forms[770:785], + forms[785:786], + forms[786:788], + forms[788:790], + forms[790:795], + forms[795:796], + forms[796:798], + forms[798:800], + forms[800:802], forms[802:803], forms[803:804], forms[804:805], forms[805:806], - forms[806:809], - forms[809:812], + forms[806:807], + forms[807:808], + forms[808:809], + forms[809:810], + forms[810:811], + forms[811:812], forms[812:815], - forms[815:830], - forms[830:833], - forms[833:835], - forms[835:837], - forms[837:840], - forms[840:843], + forms[815:818], + forms[818:821], + forms[821:836], + forms[836:839], + forms[839:841], + forms[841:843], forms[843:846], - forms[846:851], - forms[851:853], - forms[853:855], - forms[855:857], + forms[846:849], + forms[849:852], + forms[852:857], forms[857:859], forms[859:861], forms[861:863], @@ -14739,25 +14819,25 @@ var opcformstable = [][]form{ forms[875:877], forms[877:879], forms[879:881], - forms[881:882], - forms[882:884], - forms[884:886], - forms[886:888], + forms[881:883], + forms[883:885], + forms[885:887], + forms[887:888], forms[888:890], - forms[890:891], - forms[891:893], - forms[893:895], - forms[895:897], + forms[890:892], + forms[892:894], + forms[894:896], + forms[896:897], forms[897:899], - forms[899:905], - forms[905:913], - forms[913:915], - forms[915:917], - forms[917:925], - forms[925:933], - forms[933:935], - forms[935:937], - forms[937:939], + forms[899:901], + forms[901:903], + forms[903:905], + forms[905:911], + forms[911:919], + forms[919:921], + forms[921:923], + forms[923:931], + forms[931:939], forms[939:941], forms[941:943], forms[943:945], @@ -14774,10 +14854,10 @@ var opcformstable = [][]form{ forms[965:967], forms[967:969], forms[969:971], - forms[971:972], - forms[972:974], - forms[974:976], - forms[976:978], + forms[971:973], + forms[973:975], + forms[975:977], + forms[977:978], forms[978:980], forms[980:982], forms[982:984], @@ -14825,10 +14905,10 @@ var opcformstable = [][]form{ forms[1066:1068], forms[1068:1070], forms[1070:1072], - forms[1072:1073], - forms[1073:1075], - forms[1075:1077], - forms[1077:1079], + forms[1072:1074], + forms[1074:1076], + forms[1076:1078], + forms[1078:1079], forms[1079:1081], forms[1081:1083], forms[1083:1085], @@ -14851,34 +14931,34 @@ var opcformstable = [][]form{ forms[1117:1119], forms[1119:1121], forms[1121:1123], - forms[1123:1124], - forms[1124:1125], - forms[1125:1126], - forms[1126:1127], + forms[1123:1125], + forms[1125:1127], forms[1127:1129], - forms[1129:1131], - forms[1131:1133], + forms[1129:1130], + forms[1130:1131], + forms[1131:1132], + forms[1132:1133], forms[1133:1135], forms[1135:1137], forms[1137:1139], forms[1139:1141], forms[1141:1143], forms[1143:1145], - forms[1145:1146], - forms[1146:1149], - forms[1149:1150], - forms[1150:1153], - forms[1153:1156], + forms[1145:1147], + forms[1147:1149], + forms[1149:1151], + forms[1151:1152], + forms[1152:1155], + forms[1155:1156], forms[1156:1159], forms[1159:1162], - forms[1162:1163], - forms[1163:1166], - forms[1166:1167], - forms[1167:1170], - forms[1170:1173], - forms[1173:1175], - forms[1175:1177], - forms[1177:1179], + forms[1162:1165], + forms[1165:1168], + forms[1168:1169], + forms[1169:1172], + forms[1172:1173], + forms[1173:1176], + forms[1176:1179], forms[1179:1181], forms[1181:1183], forms[1183:1185], @@ -14893,28 +14973,30 @@ var opcformstable = [][]form{ forms[1201:1203], forms[1203:1205], forms[1205:1207], - forms[1207:1211], + forms[1207:1209], + forms[1209:1211], forms[1211:1213], - forms[1213:1215], - forms[1215:1221], + forms[1213:1217], + forms[1217:1219], + forms[1219:1221], forms[1221:1227], forms[1227:1233], forms[1233:1239], - forms[1239:1241], - forms[1241:1243], - forms[1243:1249], + forms[1239:1245], + forms[1245:1247], + forms[1247:1249], forms[1249:1255], forms[1255:1261], forms[1261:1267], - forms[1267:1270], - forms[1270:1273], - forms[1273:1274], - forms[1274:1275], - forms[1275:1276], - forms[1276:1277], - forms[1277:1278], - forms[1278:1279], - forms[1279:1285], + forms[1267:1273], + forms[1273:1276], + forms[1276:1279], + forms[1279:1280], + forms[1280:1281], + forms[1281:1282], + forms[1282:1283], + forms[1283:1284], + forms[1284:1285], forms[1285:1291], forms[1291:1297], forms[1297:1303], @@ -14922,15 +15004,15 @@ var opcformstable = [][]form{ forms[1309:1315], forms[1315:1321], forms[1321:1327], - forms[1327:1329], - forms[1329:1331], - forms[1331:1333], + forms[1327:1333], forms[1333:1335], forms[1335:1337], forms[1337:1339], forms[1339:1341], forms[1341:1343], - forms[1343:1349], + forms[1343:1345], + forms[1345:1347], + forms[1347:1349], forms[1349:1355], forms[1355:1361], forms[1361:1367], @@ -14938,15 +15020,13 @@ var opcformstable = [][]form{ forms[1373:1379], forms[1379:1385], forms[1385:1391], - forms[1391:1393], - forms[1393:1395], - forms[1395:1401], - forms[1401:1409], - forms[1409:1417], - forms[1417:1425], - forms[1425:1427], - forms[1427:1429], - forms[1429:1431], + forms[1391:1397], + forms[1397:1399], + forms[1399:1401], + forms[1401:1407], + forms[1407:1415], + forms[1415:1423], + forms[1423:1431], forms[1431:1433], forms[1433:1435], forms[1435:1437], @@ -14960,682 +15040,688 @@ var opcformstable = [][]form{ forms[1451:1453], forms[1453:1455], forms[1455:1457], - forms[1457:1458], - forms[1458:1460], - forms[1460:1462], - forms[1462:1464], + forms[1457:1459], + forms[1459:1461], + forms[1461:1463], + forms[1463:1464], forms[1464:1466], forms[1466:1468], forms[1468:1470], forms[1470:1472], - forms[1472:1478], - forms[1478:1488], - forms[1488:1498], - forms[1498:1508], - forms[1508:1510], - forms[1510:1512], - forms[1512:1518], - forms[1518:1528], - forms[1528:1538], - forms[1538:1548], - forms[1548:1550], - forms[1550:1552], - forms[1552:1554], + forms[1472:1474], + forms[1474:1476], + forms[1476:1478], + forms[1478:1484], + forms[1484:1494], + forms[1494:1504], + forms[1504:1514], + forms[1514:1516], + forms[1516:1518], + forms[1518:1524], + forms[1524:1534], + forms[1534:1544], + forms[1544:1554], forms[1554:1556], forms[1556:1558], forms[1558:1560], forms[1560:1562], forms[1562:1564], - forms[1564:1565], - forms[1565:1566], - forms[1566:1567], - forms[1567:1573], - forms[1573:1581], - forms[1581:1583], - forms[1583:1585], - forms[1585:1593], - forms[1593:1595], - forms[1595:1597], - forms[1597:1605], - forms[1605:1606], - forms[1606:1611], - forms[1611:1616], - forms[1616:1621], - forms[1621:1626], - forms[1626:1628], - forms[1628:1630], - forms[1630:1632], + forms[1564:1566], + forms[1566:1568], + forms[1568:1570], + forms[1570:1571], + forms[1571:1572], + forms[1572:1573], + forms[1573:1579], + forms[1579:1587], + forms[1587:1589], + forms[1589:1591], + forms[1591:1599], + forms[1599:1601], + forms[1601:1603], + forms[1603:1611], + forms[1611:1612], + forms[1612:1617], + forms[1617:1622], + forms[1622:1627], + forms[1627:1632], forms[1632:1634], forms[1634:1636], - forms[1636:1637], - forms[1637:1639], - forms[1639:1641], - forms[1641:1643], + forms[1636:1638], + forms[1638:1640], + forms[1640:1642], + forms[1642:1643], forms[1643:1645], - forms[1645:1675], - forms[1675:1705], - forms[1705:1714], - forms[1714:1723], - forms[1723:1727], - forms[1727:1731], - forms[1731:1733], - forms[1733:1735], - forms[1735:1737], + forms[1645:1647], + forms[1647:1649], + forms[1649:1651], + forms[1651:1681], + forms[1681:1711], + forms[1711:1720], + forms[1720:1729], + forms[1729:1733], + forms[1733:1737], forms[1737:1739], forms[1739:1741], forms[1741:1743], - forms[1743:1770], - forms[1770:1797], - forms[1797:1824], - forms[1824:1851], - forms[1851:1878], - forms[1878:1905], - forms[1905:1932], - forms[1932:1959], - forms[1959:1963], - forms[1963:1967], - forms[1967:1971], - forms[1971:1975], - forms[1975:1976], - forms[1976:1988], - forms[1988:1994], - forms[1994:1997], - forms[1997:2003], - forms[2003:2006], - forms[2006:2007], - forms[2007:2025], - forms[2025:2031], - forms[2031:2034], - forms[2034:2040], - forms[2040:2043], - forms[2043:2055], - forms[2055:2069], - forms[2069:2093], - forms[2093:2117], - forms[2117:2125], - forms[2125:2133], - forms[2133:2136], - forms[2136:2139], - forms[2139:2157], - forms[2157:2175], - forms[2175:2202], - forms[2202:2232], - forms[2232:2244], - forms[2244:2253], - forms[2253:2262], - forms[2262:2274], - forms[2274:2283], - forms[2283:2292], - forms[2292:2322], - forms[2322:2334], - forms[2334:2343], - forms[2343:2352], - forms[2352:2382], - forms[2382:2403], - forms[2403:2433], - forms[2433:2463], - forms[2463:2484], - forms[2484:2514], - forms[2514:2544], - forms[2544:2574], - forms[2574:2604], - forms[2604:2616], - forms[2616:2625], - forms[2625:2634], - forms[2634:2637], - forms[2637:2640], - forms[2640:2649], - forms[2649:2652], - forms[2652:2655], - forms[2655:2657], - forms[2657:2660], - forms[2660:2663], + forms[1743:1745], + forms[1745:1747], + forms[1747:1749], + forms[1749:1776], + forms[1776:1803], + forms[1803:1830], + forms[1830:1857], + forms[1857:1884], + forms[1884:1911], + forms[1911:1938], + forms[1938:1965], + forms[1965:1969], + forms[1969:1973], + forms[1973:1977], + forms[1977:1981], + forms[1981:1982], + forms[1982:1994], + forms[1994:2000], + forms[2000:2003], + forms[2003:2009], + forms[2009:2012], + forms[2012:2013], + forms[2013:2031], + forms[2031:2037], + forms[2037:2040], + forms[2040:2046], + forms[2046:2049], + forms[2049:2061], + forms[2061:2075], + forms[2075:2099], + forms[2099:2123], + forms[2123:2131], + forms[2131:2139], + forms[2139:2142], + forms[2142:2145], + forms[2145:2163], + forms[2163:2181], + forms[2181:2208], + forms[2208:2238], + forms[2238:2250], + forms[2250:2259], + forms[2259:2268], + forms[2268:2280], + forms[2280:2289], + forms[2289:2298], + forms[2298:2328], + forms[2328:2340], + forms[2340:2349], + forms[2349:2358], + forms[2358:2388], + forms[2388:2409], + forms[2409:2439], + forms[2439:2469], + forms[2469:2490], + forms[2490:2520], + forms[2520:2550], + forms[2550:2580], + forms[2580:2610], + forms[2610:2622], + forms[2622:2631], + forms[2631:2640], + forms[2640:2643], + forms[2643:2646], + forms[2646:2655], + forms[2655:2658], + forms[2658:2661], + forms[2661:2663], forms[2663:2666], - forms[2666:2675], - forms[2675:2678], - forms[2678:2681], + forms[2666:2669], + forms[2669:2672], + forms[2672:2681], forms[2681:2684], forms[2684:2687], - forms[2687:2699], - forms[2699:2708], - forms[2708:2717], - forms[2717:2747], - forms[2747:2759], - forms[2759:2768], - forms[2768:2777], - forms[2777:2807], - forms[2807:2837], - forms[2837:2867], - forms[2867:2897], - forms[2897:2927], - forms[2927:2930], - forms[2930:2933], + forms[2687:2690], + forms[2690:2693], + forms[2693:2705], + forms[2705:2714], + forms[2714:2723], + forms[2723:2753], + forms[2753:2765], + forms[2765:2774], + forms[2774:2783], + forms[2783:2813], + forms[2813:2843], + forms[2843:2873], + forms[2873:2903], + forms[2903:2933], forms[2933:2936], forms[2936:2939], forms[2939:2942], forms[2942:2945], forms[2945:2948], forms[2948:2951], - forms[2951:2978], - forms[2978:3008], - forms[3008:3038], - forms[3038:3050], - forms[3050:3059], - forms[3059:3068], - forms[3068:3070], - forms[3070:3073], - forms[3073:3076], + forms[2951:2954], + forms[2954:2957], + forms[2957:2984], + forms[2984:3014], + forms[3014:3044], + forms[3044:3056], + forms[3056:3065], + forms[3065:3074], + forms[3074:3076], forms[3076:3079], - forms[3079:3097], - forms[3097:3127], - forms[3127:3157], - forms[3157:3166], - forms[3166:3175], - forms[3175:3177], - forms[3177:3181], - forms[3181:3193], - forms[3193:3205], - forms[3205:3223], - forms[3223:3241], - forms[3241:3243], - forms[3243:3255], - forms[3255:3261], - forms[3261:3273], - forms[3273:3279], - forms[3279:3281], - forms[3281:3293], - forms[3293:3299], - forms[3299:3311], - forms[3311:3317], - forms[3317:3319], - forms[3319:3349], - forms[3349:3379], - forms[3379:3388], - forms[3388:3397], - forms[3397:3427], - forms[3427:3457], - forms[3457:3466], - forms[3466:3475], - forms[3475:3505], - forms[3505:3535], - forms[3535:3544], - forms[3544:3553], - forms[3553:3583], - forms[3583:3613], - forms[3613:3622], - forms[3622:3631], - forms[3631:3661], - forms[3661:3691], - forms[3691:3721], - forms[3721:3751], - forms[3751:3781], - forms[3781:3811], - forms[3811:3841], - forms[3841:3871], - forms[3871:3880], - forms[3880:3889], - forms[3889:3919], - forms[3919:3949], - forms[3949:3958], - forms[3958:3967], - forms[3967:3997], - forms[3997:4027], - forms[4027:4036], - forms[4036:4045], - forms[4045:4075], - forms[4075:4105], - forms[4105:4135], - forms[4135:4165], - forms[4165:4195], - forms[4195:4225], - forms[4225:4255], - forms[4255:4285], - forms[4285:4294], - forms[4294:4303], - forms[4303:4333], - forms[4333:4363], - forms[4363:4372], - forms[4372:4381], - forms[4381:4411], - forms[4411:4441], - forms[4441:4450], - forms[4450:4459], - forms[4459:4489], - forms[4489:4519], - forms[4519:4528], - forms[4528:4537], - forms[4537:4567], - forms[4567:4597], - forms[4597:4606], - forms[4606:4615], - forms[4615:4645], - forms[4645:4675], - forms[4675:4684], - forms[4684:4693], - forms[4693:4699], + forms[3079:3082], + forms[3082:3085], + forms[3085:3103], + forms[3103:3133], + forms[3133:3163], + forms[3163:3172], + forms[3172:3181], + forms[3181:3183], + forms[3183:3187], + forms[3187:3199], + forms[3199:3211], + forms[3211:3229], + forms[3229:3247], + forms[3247:3249], + forms[3249:3261], + forms[3261:3267], + forms[3267:3279], + forms[3279:3285], + forms[3285:3287], + forms[3287:3299], + forms[3299:3305], + forms[3305:3317], + forms[3317:3323], + forms[3323:3325], + forms[3325:3355], + forms[3355:3385], + forms[3385:3394], + forms[3394:3403], + forms[3403:3433], + forms[3433:3463], + forms[3463:3472], + forms[3472:3481], + forms[3481:3511], + forms[3511:3541], + forms[3541:3550], + forms[3550:3559], + forms[3559:3589], + forms[3589:3619], + forms[3619:3628], + forms[3628:3637], + forms[3637:3667], + forms[3667:3697], + forms[3697:3727], + forms[3727:3757], + forms[3757:3787], + forms[3787:3817], + forms[3817:3847], + forms[3847:3877], + forms[3877:3886], + forms[3886:3895], + forms[3895:3925], + forms[3925:3955], + forms[3955:3964], + forms[3964:3973], + forms[3973:4003], + forms[4003:4033], + forms[4033:4042], + forms[4042:4051], + forms[4051:4081], + forms[4081:4111], + forms[4111:4141], + forms[4141:4171], + forms[4171:4201], + forms[4201:4231], + forms[4231:4261], + forms[4261:4291], + forms[4291:4300], + forms[4300:4309], + forms[4309:4339], + forms[4339:4369], + forms[4369:4378], + forms[4378:4387], + forms[4387:4417], + forms[4417:4447], + forms[4447:4456], + forms[4456:4465], + forms[4465:4495], + forms[4495:4525], + forms[4525:4534], + forms[4534:4543], + forms[4543:4573], + forms[4573:4603], + forms[4603:4612], + forms[4612:4621], + forms[4621:4651], + forms[4651:4681], + forms[4681:4690], + forms[4690:4699], forms[4699:4705], forms[4705:4711], forms[4711:4717], forms[4717:4723], forms[4723:4729], - forms[4729:4733], - forms[4733:4737], - forms[4737:4742], - forms[4742:4747], - forms[4747:4752], - forms[4752:4757], - forms[4757:4787], - forms[4787:4817], - forms[4817:4826], - forms[4826:4835], - forms[4835:4865], - forms[4865:4895], - forms[4895:4904], - forms[4904:4913], - forms[4913:4917], - forms[4917:4921], - forms[4921:4925], - forms[4925:4929], - forms[4929:4931], - forms[4931:4943], - forms[4943:4949], - forms[4949:4961], - forms[4961:4967], - forms[4967:4969], - forms[4969:4981], - forms[4981:4987], - forms[4987:4999], - forms[4999:5005], - forms[5005:5007], - forms[5007:5009], - forms[5009:5010], - forms[5010:5011], - forms[5011:5015], - forms[5015:5019], - forms[5019:5049], - forms[5049:5079], - forms[5079:5088], - forms[5088:5097], - forms[5097:5127], - forms[5127:5157], - forms[5157:5166], - forms[5166:5175], - forms[5175:5202], - forms[5202:5229], - forms[5229:5233], - forms[5233:5251], - forms[5251:5257], - forms[5257:5284], - forms[5284:5311], + forms[4729:4735], + forms[4735:4739], + forms[4739:4743], + forms[4743:4748], + forms[4748:4753], + forms[4753:4758], + forms[4758:4763], + forms[4763:4793], + forms[4793:4823], + forms[4823:4832], + forms[4832:4841], + forms[4841:4871], + forms[4871:4901], + forms[4901:4910], + forms[4910:4919], + forms[4919:4937], + forms[4937:4955], + forms[4955:4973], + forms[4973:4977], + forms[4977:4981], + forms[4981:4985], + forms[4985:4989], + forms[4989:4991], + forms[4991:5003], + forms[5003:5009], + forms[5009:5021], + forms[5021:5027], + forms[5027:5029], + forms[5029:5041], + forms[5041:5047], + forms[5047:5059], + forms[5059:5065], + forms[5065:5067], + forms[5067:5069], + forms[5069:5070], + forms[5070:5071], + forms[5071:5075], + forms[5075:5079], + forms[5079:5109], + forms[5109:5139], + forms[5139:5148], + forms[5148:5157], + forms[5157:5187], + forms[5187:5217], + forms[5217:5226], + forms[5226:5235], + forms[5235:5262], + forms[5262:5289], + forms[5289:5293], + forms[5293:5311], forms[5311:5317], forms[5317:5344], forms[5344:5371], - forms[5371:5398], - forms[5398:5425], - forms[5425:5426], - forms[5426:5428], - forms[5428:5430], - forms[5430:5431], - forms[5431:5433], - forms[5433:5435], - forms[5435:5437], - forms[5437:5439], - forms[5439:5442], - forms[5442:5445], - forms[5445:5448], - forms[5448:5451], - forms[5451:5456], - forms[5456:5464], - forms[5464:5482], - forms[5482:5500], - forms[5500:5508], - forms[5508:5535], - forms[5535:5562], - forms[5562:5566], - forms[5566:5596], - forms[5596:5626], - forms[5626:5635], - forms[5635:5644], - forms[5644:5671], - forms[5671:5698], - forms[5698:5716], - forms[5716:5743], - forms[5743:5770], - forms[5770:5788], - forms[5788:5815], - forms[5815:5833], - forms[5833:5860], - forms[5860:5878], - forms[5878:5896], - forms[5896:5923], - forms[5923:5950], - forms[5950:5968], - forms[5968:5986], - forms[5986:6004], - forms[6004:6022], - forms[6022:6040], - forms[6040:6058], - forms[6058:6062], - forms[6062:6089], - forms[6089:6093], - forms[6093:6120], - forms[6120:6147], - forms[6147:6174], - forms[6174:6192], - forms[6192:6210], - forms[6210:6214], - forms[6214:6232], - forms[6232:6259], - forms[6259:6286], - forms[6286:6304], - forms[6304:6308], - forms[6308:6312], - forms[6312:6339], - forms[6339:6366], - forms[6366:6369], - forms[6369:6372], + forms[5371:5377], + forms[5377:5404], + forms[5404:5431], + forms[5431:5458], + forms[5458:5485], + forms[5485:5486], + forms[5486:5488], + forms[5488:5490], + forms[5490:5491], + forms[5491:5493], + forms[5493:5495], + forms[5495:5497], + forms[5497:5499], + forms[5499:5502], + forms[5502:5505], + forms[5505:5508], + forms[5508:5511], + forms[5511:5516], + forms[5516:5524], + forms[5524:5542], + forms[5542:5560], + forms[5560:5568], + forms[5568:5595], + forms[5595:5622], + forms[5622:5626], + forms[5626:5656], + forms[5656:5686], + forms[5686:5695], + forms[5695:5704], + forms[5704:5731], + forms[5731:5758], + forms[5758:5776], + forms[5776:5803], + forms[5803:5830], + forms[5830:5848], + forms[5848:5875], + forms[5875:5893], + forms[5893:5920], + forms[5920:5938], + forms[5938:5956], + forms[5956:5983], + forms[5983:6010], + forms[6010:6028], + forms[6028:6046], + forms[6046:6064], + forms[6064:6082], + forms[6082:6100], + forms[6100:6118], + forms[6118:6122], + forms[6122:6149], + forms[6149:6153], + forms[6153:6180], + forms[6180:6207], + forms[6207:6234], + forms[6234:6252], + forms[6252:6270], + forms[6270:6274], + forms[6274:6292], + forms[6292:6319], + forms[6319:6346], + forms[6346:6364], + forms[6364:6368], + forms[6368:6372], forms[6372:6399], forms[6399:6426], - forms[6426:6428], - forms[6428:6440], - forms[6440:6458], - forms[6458:6474], - forms[6474:6496], - forms[6496:6518], + forms[6426:6429], + forms[6429:6432], + forms[6432:6459], + forms[6459:6486], + forms[6486:6488], + forms[6488:6500], + forms[6500:6518], forms[6518:6534], - forms[6534:6536], - forms[6536:6538], - forms[6538:6554], - forms[6554:6576], - forms[6576:6598], + forms[6534:6556], + forms[6556:6578], + forms[6578:6594], + forms[6594:6596], + forms[6596:6598], forms[6598:6614], - forms[6614:6616], - forms[6616:6618], - forms[6618:6636], - forms[6636:6648], - forms[6648:6666], - forms[6666:6684], - forms[6684:6696], + forms[6614:6636], + forms[6636:6658], + forms[6658:6674], + forms[6674:6676], + forms[6676:6678], + forms[6678:6696], forms[6696:6708], forms[6708:6726], forms[6726:6744], - forms[6744:6771], - forms[6771:6798], - forms[6798:6800], - forms[6800:6802], - forms[6802:6820], - forms[6820:6838], - forms[6838:6856], - forms[6856:6883], - forms[6883:6910], - forms[6910:6937], - forms[6937:6964], - forms[6964:6982], - forms[6982:7036], - forms[7036:7090], - forms[7090:7126], - forms[7126:7144], - forms[7144:7180], - forms[7180:7198], - forms[7198:7225], - forms[7225:7252], - forms[7252:7279], - forms[7279:7306], - forms[7306:7324], - forms[7324:7342], - forms[7342:7360], - forms[7360:7378], - forms[7378:7380], - forms[7380:7382], - forms[7382:7384], - forms[7384:7386], - forms[7386:7391], - forms[7391:7396], - forms[7396:7401], - forms[7401:7406], - forms[7406:7410], - forms[7410:7414], - forms[7414:7418], - forms[7418:7420], - forms[7420:7424], - forms[7424:7428], - forms[7428:7432], - forms[7432:7434], - forms[7434:7436], - forms[7436:7438], + forms[6744:6756], + forms[6756:6768], + forms[6768:6786], + forms[6786:6804], + forms[6804:6831], + forms[6831:6858], + forms[6858:6860], + forms[6860:6862], + forms[6862:6880], + forms[6880:6898], + forms[6898:6916], + forms[6916:6943], + forms[6943:6970], + forms[6970:6997], + forms[6997:7024], + forms[7024:7042], + forms[7042:7096], + forms[7096:7150], + forms[7150:7186], + forms[7186:7204], + forms[7204:7240], + forms[7240:7258], + forms[7258:7285], + forms[7285:7312], + forms[7312:7339], + forms[7339:7366], + forms[7366:7384], + forms[7384:7402], + forms[7402:7420], + forms[7420:7438], forms[7438:7440], - forms[7440:7467], - forms[7467:7494], - forms[7494:7521], - forms[7521:7548], - forms[7548:7566], - forms[7566:7584], - forms[7584:7588], - forms[7588:7592], - forms[7592:7610], - forms[7610:7637], - forms[7637:7664], - forms[7664:7682], - forms[7682:7700], - forms[7700:7727], - forms[7727:7754], - forms[7754:7772], - forms[7772:7790], - forms[7790:7817], - forms[7817:7844], - forms[7844:7862], - forms[7862:7880], - forms[7880:7907], - forms[7907:7934], - forms[7934:7952], - forms[7952:7955], - forms[7955:7958], - forms[7958:7976], - forms[7976:7994], - forms[7994:7997], - forms[7997:8000], - forms[8000:8003], - forms[8003:8006], - forms[8006:8008], - forms[8008:8011], - forms[8011:8029], - forms[8029:8047], - forms[8047:8065], - forms[8065:8083], - forms[8083:8101], - forms[8101:8119], - forms[8119:8137], - forms[8137:8155], - forms[8155:8173], - forms[8173:8191], - forms[8191:8209], - forms[8209:8227], - forms[8227:8245], - forms[8245:8263], - forms[8263:8281], - forms[8281:8299], - forms[8299:8317], - forms[8317:8335], - forms[8335:8353], - forms[8353:8371], - forms[8371:8389], - forms[8389:8392], - forms[8392:8410], - forms[8410:8428], - forms[8428:8446], - forms[8446:8464], - forms[8464:8482], - forms[8482:8500], - forms[8500:8518], - forms[8518:8545], - forms[8545:8563], - forms[8563:8581], - forms[8581:8599], - forms[8599:8626], - forms[8626:8653], - forms[8653:8671], - forms[8671:8698], - forms[8698:8725], - forms[8725:8734], - forms[8734:8743], - forms[8743:8747], - forms[8747:8774], - forms[8774:8801], - forms[8801:8828], - forms[8828:8855], - forms[8855:8882], - forms[8882:8909], - forms[8909:8936], - forms[8936:8963], - forms[8963:8990], - forms[8990:9017], - forms[9017:9023], - forms[9023:9026], - forms[9026:9029], - forms[9029:9032], - forms[9032:9035], - forms[9035:9053], - forms[9053:9080], - forms[9080:9098], - forms[9098:9116], - forms[9116:9120], - forms[9120:9124], - forms[9124:9128], - forms[9128:9173], - forms[9173:9179], - forms[9179:9224], - forms[9224:9251], - forms[9251:9278], - forms[9278:9296], - forms[9296:9332], - forms[9332:9377], - forms[9377:9422], - forms[9422:9449], - forms[9449:9476], - forms[9476:9494], - forms[9494:9530], - forms[9530:9575], - forms[9575:9581], - forms[9581:9626], - forms[9626:9653], - forms[9653:9680], - forms[9680:9698], - forms[9698:9734], - forms[9734:9752], - forms[9752:9779], - forms[9779:9806], - forms[9806:9824], - forms[9824:9842], - forms[9842:9860], - forms[9860:9878], - forms[9878:9896], - forms[9896:9923], - forms[9923:9950], - forms[9950:9954], - forms[9954:9966], - forms[9966:9984], - forms[9984:10002], - forms[10002:10014], + forms[7440:7442], + forms[7442:7444], + forms[7444:7446], + forms[7446:7451], + forms[7451:7456], + forms[7456:7461], + forms[7461:7466], + forms[7466:7470], + forms[7470:7474], + forms[7474:7478], + forms[7478:7480], + forms[7480:7484], + forms[7484:7488], + forms[7488:7492], + forms[7492:7494], + forms[7494:7496], + forms[7496:7498], + forms[7498:7500], + forms[7500:7527], + forms[7527:7554], + forms[7554:7581], + forms[7581:7608], + forms[7608:7626], + forms[7626:7644], + forms[7644:7648], + forms[7648:7652], + forms[7652:7670], + forms[7670:7697], + forms[7697:7724], + forms[7724:7742], + forms[7742:7760], + forms[7760:7787], + forms[7787:7814], + forms[7814:7832], + forms[7832:7850], + forms[7850:7877], + forms[7877:7904], + forms[7904:7922], + forms[7922:7940], + forms[7940:7967], + forms[7967:7994], + forms[7994:8012], + forms[8012:8015], + forms[8015:8018], + forms[8018:8036], + forms[8036:8054], + forms[8054:8057], + forms[8057:8060], + forms[8060:8063], + forms[8063:8066], + forms[8066:8068], + forms[8068:8071], + forms[8071:8089], + forms[8089:8107], + forms[8107:8125], + forms[8125:8143], + forms[8143:8161], + forms[8161:8179], + forms[8179:8197], + forms[8197:8215], + forms[8215:8233], + forms[8233:8251], + forms[8251:8269], + forms[8269:8287], + forms[8287:8305], + forms[8305:8323], + forms[8323:8341], + forms[8341:8359], + forms[8359:8377], + forms[8377:8395], + forms[8395:8413], + forms[8413:8431], + forms[8431:8449], + forms[8449:8452], + forms[8452:8470], + forms[8470:8488], + forms[8488:8506], + forms[8506:8524], + forms[8524:8542], + forms[8542:8560], + forms[8560:8578], + forms[8578:8605], + forms[8605:8623], + forms[8623:8641], + forms[8641:8659], + forms[8659:8686], + forms[8686:8713], + forms[8713:8731], + forms[8731:8758], + forms[8758:8785], + forms[8785:8794], + forms[8794:8803], + forms[8803:8807], + forms[8807:8834], + forms[8834:8861], + forms[8861:8888], + forms[8888:8915], + forms[8915:8942], + forms[8942:8969], + forms[8969:8996], + forms[8996:9023], + forms[9023:9050], + forms[9050:9077], + forms[9077:9083], + forms[9083:9086], + forms[9086:9089], + forms[9089:9092], + forms[9092:9095], + forms[9095:9113], + forms[9113:9140], + forms[9140:9158], + forms[9158:9176], + forms[9176:9180], + forms[9180:9184], + forms[9184:9188], + forms[9188:9233], + forms[9233:9239], + forms[9239:9284], + forms[9284:9311], + forms[9311:9338], + forms[9338:9356], + forms[9356:9392], + forms[9392:9437], + forms[9437:9482], + forms[9482:9509], + forms[9509:9536], + forms[9536:9554], + forms[9554:9590], + forms[9590:9635], + forms[9635:9641], + forms[9641:9686], + forms[9686:9713], + forms[9713:9740], + forms[9740:9758], + forms[9758:9794], + forms[9794:9812], + forms[9812:9839], + forms[9839:9866], + forms[9866:9884], + forms[9884:9902], + forms[9902:9920], + forms[9920:9938], + forms[9938:9956], + forms[9956:9983], + forms[9983:10010], + forms[10010:10014], forms[10014:10026], forms[10026:10044], forms[10044:10062], forms[10062:10074], - forms[10074:10092], - forms[10092:10119], - forms[10119:10146], - forms[10146:10164], - forms[10164:10182], - forms[10182:10209], - forms[10209:10236], - forms[10236:10254], - forms[10254:10258], - forms[10258:10285], - forms[10285:10312], - forms[10312:10342], - forms[10342:10372], - forms[10372:10381], - forms[10381:10390], - forms[10390:10417], - forms[10417:10444], - forms[10444:10450], - forms[10450:10456], - forms[10456:10468], - forms[10468:10480], - forms[10480:10489], - forms[10489:10498], - forms[10498:10502], - forms[10502:10504], - forms[10504:10531], - forms[10531:10558], - forms[10558:10564], - forms[10564:10570], - forms[10570:10600], - forms[10600:10630], - forms[10630:10639], - forms[10639:10648], - forms[10648:10652], - forms[10652:10656], - forms[10656:10658], - forms[10658:10660], - forms[10660:10687], - forms[10687:10714], - forms[10714:10720], - forms[10720:10726], - forms[10726:10738], - forms[10738:10750], - forms[10750:10759], - forms[10759:10768], - forms[10768:10772], - forms[10772:10774], - forms[10774:10804], - forms[10804:10834], - forms[10834:10843], - forms[10843:10852], - forms[10852:10855], - forms[10855:10858], - forms[10858:10861], - forms[10861:10864], - forms[10864:10882], - forms[10882:10900], - forms[10900:10918], - forms[10918:10936], - forms[10936:10963], - forms[10963:10990], - forms[10990:11020], - forms[11020:11050], - forms[11050:11059], - forms[11059:11068], - forms[11068:11069], - forms[11069:11099], - forms[11099:11129], - forms[11129:11138], - forms[11138:11147], - forms[11147:11151], - forms[11151:11155], - forms[11155:11158], - forms[11158:11161], - forms[11161:11188], - forms[11188:11215], - forms[11215:11242], - forms[11242:11269], - forms[11269:11296], - forms[11296:11323], - forms[11323:11324], - forms[11324:11325], - forms[11325:11327], - forms[11327:11329], - forms[11329:11331], - forms[11331:11333], - forms[11333:11336], - forms[11336:11341], - forms[11341:11346], - forms[11346:11351], - forms[11351:11352], - forms[11352:11353], - forms[11353:11359], - forms[11359:11367], - forms[11367:11369], - forms[11369:11371], - forms[11371:11379], - forms[11379:11387], + forms[10074:10086], + forms[10086:10104], + forms[10104:10122], + forms[10122:10134], + forms[10134:10152], + forms[10152:10179], + forms[10179:10206], + forms[10206:10224], + forms[10224:10242], + forms[10242:10269], + forms[10269:10296], + forms[10296:10314], + forms[10314:10318], + forms[10318:10345], + forms[10345:10372], + forms[10372:10402], + forms[10402:10432], + forms[10432:10441], + forms[10441:10450], + forms[10450:10477], + forms[10477:10504], + forms[10504:10510], + forms[10510:10516], + forms[10516:10528], + forms[10528:10540], + forms[10540:10549], + forms[10549:10558], + forms[10558:10562], + forms[10562:10564], + forms[10564:10591], + forms[10591:10618], + forms[10618:10624], + forms[10624:10630], + forms[10630:10660], + forms[10660:10690], + forms[10690:10699], + forms[10699:10708], + forms[10708:10712], + forms[10712:10716], + forms[10716:10718], + forms[10718:10720], + forms[10720:10747], + forms[10747:10774], + forms[10774:10780], + forms[10780:10786], + forms[10786:10798], + forms[10798:10810], + forms[10810:10819], + forms[10819:10828], + forms[10828:10832], + forms[10832:10834], + forms[10834:10864], + forms[10864:10894], + forms[10894:10903], + forms[10903:10912], + forms[10912:10915], + forms[10915:10918], + forms[10918:10921], + forms[10921:10924], + forms[10924:10942], + forms[10942:10960], + forms[10960:10978], + forms[10978:10996], + forms[10996:11023], + forms[11023:11050], + forms[11050:11080], + forms[11080:11110], + forms[11110:11119], + forms[11119:11128], + forms[11128:11129], + forms[11129:11159], + forms[11159:11189], + forms[11189:11198], + forms[11198:11207], + forms[11207:11211], + forms[11211:11215], + forms[11215:11218], + forms[11218:11221], + forms[11221:11248], + forms[11248:11275], + forms[11275:11302], + forms[11302:11329], + forms[11329:11356], + forms[11356:11383], + forms[11383:11384], + forms[11384:11385], + forms[11385:11387], + forms[11387:11389], + forms[11389:11391], + forms[11391:11393], + forms[11393:11396], + forms[11396:11401], + forms[11401:11406], + forms[11406:11411], + forms[11411:11412], + forms[11412:11413], + forms[11413:11419], + forms[11419:11427], + forms[11427:11429], + forms[11429:11431], + forms[11431:11439], + forms[11439:11447], } From 8919aa5234fe862697092ff966e9324b91762dd4 Mon Sep 17 00:00:00 2001 From: Michael McLoughlin Date: Sun, 27 Nov 2022 13:55:48 -0800 Subject: [PATCH 03/10] add gfni to extras list --- internal/opcodesextra/instructions.go | 1 + 1 file changed, 1 insertion(+) diff --git a/internal/opcodesextra/instructions.go b/internal/opcodesextra/instructions.go index b25537a9..d4834316 100644 --- a/internal/opcodesextra/instructions.go +++ b/internal/opcodesextra/instructions.go @@ -6,6 +6,7 @@ import "github.com/mmcloughlin/avo/internal/inst" // sets of extra instructions. var sets = [][]*inst.Instruction{ movlqzx, + gfni, } // Instructions returns a list of extras to add to the instructions database. From ef980bd8be822fda2590a92c11c6e8028e80a9ae Mon Sep 17 00:00:00 2001 From: Michael McLoughlin Date: Sun, 27 Nov 2022 14:30:42 -0800 Subject: [PATCH 04/10] remove unsupported forms --- build/zinstructions.go | 69 -- build/zinstructions_test.go | 3 - internal/inst/ztable.go | 72 -- internal/opcodesextra/gfni.go | 78 -- x86/zctors.go | 30 - x86/zctors_test.go | 27 - x86/zoptab.go | 1585 ++++++++++++++++----------------- 7 files changed, 784 insertions(+), 1080 deletions(-) diff --git a/build/zinstructions.go b/build/zinstructions.go index ce1f469f..191842e0 100644 --- a/build/zinstructions.go +++ b/build/zinstructions.go @@ -4431,75 +4431,6 @@ func (c *Context) EXTRACTPS(i, x, mr operand.Op) { // Operates on the global context. func EXTRACTPS(i, x, mr operand.Op) { ctx.EXTRACTPS(i, x, mr) } -// GF2P8AFFINEINVQB: Galois Field Affine Transformation Inverse. -// -// Forms: -// -// GF2P8AFFINEINVQB imm8 m128 xmm -// GF2P8AFFINEINVQB imm8 xmm xmm -// -// Construct and append a GF2P8AFFINEINVQB instruction to the active function. -func (c *Context) GF2P8AFFINEINVQB(i, mx, x operand.Op) { - c.addinstruction(x86.GF2P8AFFINEINVQB(i, mx, x)) -} - -// GF2P8AFFINEINVQB: Galois Field Affine Transformation Inverse. -// -// Forms: -// -// GF2P8AFFINEINVQB imm8 m128 xmm -// GF2P8AFFINEINVQB imm8 xmm xmm -// -// Construct and append a GF2P8AFFINEINVQB instruction to the active function. -// Operates on the global context. -func GF2P8AFFINEINVQB(i, mx, x operand.Op) { ctx.GF2P8AFFINEINVQB(i, mx, x) } - -// GF2P8AFFINEQB: Galois Field Affine Transformation. -// -// Forms: -// -// GF2P8AFFINEQB imm8 m128 xmm -// GF2P8AFFINEQB imm8 xmm xmm -// -// Construct and append a GF2P8AFFINEQB instruction to the active function. -func (c *Context) GF2P8AFFINEQB(i, mx, x operand.Op) { - c.addinstruction(x86.GF2P8AFFINEQB(i, mx, x)) -} - -// GF2P8AFFINEQB: Galois Field Affine Transformation. -// -// Forms: -// -// GF2P8AFFINEQB imm8 m128 xmm -// GF2P8AFFINEQB imm8 xmm xmm -// -// Construct and append a GF2P8AFFINEQB instruction to the active function. -// Operates on the global context. -func GF2P8AFFINEQB(i, mx, x operand.Op) { ctx.GF2P8AFFINEQB(i, mx, x) } - -// GF2P8MULB: Galois Field Multiply Bytes. -// -// Forms: -// -// GF2P8MULB imm8 m128 xmm -// GF2P8MULB imm8 xmm xmm -// -// Construct and append a GF2P8MULB instruction to the active function. -func (c *Context) GF2P8MULB(i, mx, x operand.Op) { - c.addinstruction(x86.GF2P8MULB(i, mx, x)) -} - -// GF2P8MULB: Galois Field Multiply Bytes. -// -// Forms: -// -// GF2P8MULB imm8 m128 xmm -// GF2P8MULB imm8 xmm xmm -// -// Construct and append a GF2P8MULB instruction to the active function. -// Operates on the global context. -func GF2P8MULB(i, mx, x operand.Op) { ctx.GF2P8MULB(i, mx, x) } - // HADDPD: Packed Double-FP Horizontal Add. // // Forms: diff --git a/build/zinstructions_test.go b/build/zinstructions_test.go index bfedd570..ea889967 100644 --- a/build/zinstructions_test.go +++ b/build/zinstructions_test.go @@ -239,9 +239,6 @@ func TestContextInstructions(t *testing.T) { ctx.DPPD(opimm8, opm128, opxmm) ctx.DPPS(opimm8, opm128, opxmm) ctx.EXTRACTPS(opimm2u, opxmm, opm32) - ctx.GF2P8AFFINEINVQB(opimm8, opm128, opxmm) - ctx.GF2P8AFFINEQB(opimm8, opm128, opxmm) - ctx.GF2P8MULB(opimm8, opm128, opxmm) ctx.HADDPD(opm128, opxmm) ctx.HADDPS(opm128, opxmm) ctx.HSUBPD(opm128, opxmm) diff --git a/internal/inst/ztable.go b/internal/inst/ztable.go index b9460240..1e75dd8e 100644 --- a/internal/inst/ztable.go +++ b/internal/inst/ztable.go @@ -4698,78 +4698,6 @@ var Instructions = []Instruction{ }, }, }, - { - Opcode: "GF2P8AFFINEINVQB", - Summary: "Galois Field Affine Transformation Inverse", - Forms: []Form{ - { - ISA: []string{"SSE2", "GFNI"}, - Operands: []Operand{ - {Type: "imm8", Action: 0x1}, - {Type: "m128", Action: 0x1}, - {Type: "xmm", Action: 0x2}, - }, - EncodingType: 0x2, - }, - { - ISA: []string{"SSE2", "GFNI"}, - Operands: []Operand{ - {Type: "imm8", Action: 0x1}, - {Type: "xmm", Action: 0x1}, - {Type: "xmm", Action: 0x2}, - }, - EncodingType: 0x2, - }, - }, - }, - { - Opcode: "GF2P8AFFINEQB", - Summary: "Galois Field Affine Transformation", - Forms: []Form{ - { - ISA: []string{"SSE2", "GFNI"}, - Operands: []Operand{ - {Type: "imm8", Action: 0x1}, - {Type: "m128", Action: 0x1}, - {Type: "xmm", Action: 0x2}, - }, - EncodingType: 0x2, - }, - { - ISA: []string{"SSE2", "GFNI"}, - Operands: []Operand{ - {Type: "imm8", Action: 0x1}, - {Type: "xmm", Action: 0x1}, - {Type: "xmm", Action: 0x2}, - }, - EncodingType: 0x2, - }, - }, - }, - { - Opcode: "GF2P8MULB", - Summary: "Galois Field Multiply Bytes", - Forms: []Form{ - { - ISA: []string{"SSE2", "GFNI"}, - Operands: []Operand{ - {Type: "imm8", Action: 0x1}, - {Type: "m128", Action: 0x1}, - {Type: "xmm", Action: 0x2}, - }, - EncodingType: 0x2, - }, - { - ISA: []string{"SSE2", "GFNI"}, - Operands: []Operand{ - {Type: "imm8", Action: 0x1}, - {Type: "xmm", Action: 0x1}, - {Type: "xmm", Action: 0x2}, - }, - EncodingType: 0x2, - }, - }, - }, { Opcode: "HADDPD", Summary: "Packed Double-FP Horizontal Add", diff --git a/internal/opcodesextra/gfni.go b/internal/opcodesextra/gfni.go index 210aff13..9c9a6ec2 100644 --- a/internal/opcodesextra/gfni.go +++ b/internal/opcodesextra/gfni.go @@ -3,32 +3,6 @@ package opcodesextra import "github.com/mmcloughlin/avo/internal/inst" var gfni = []*inst.Instruction{ - // From https://www.felixcloutier.com/x86/gf2p8affineqb - { - Opcode: "GF2P8AFFINEQB", - Summary: "Galois Field Affine Transformation", - Forms: []inst.Form{ - // 66 0F3A CE /r /ib GF2P8AFFINEQB xmm1, xmm2/m128, imm8 - { - Operands: []inst.Operand{ - {Type: "imm8", Action: inst.R}, - {Type: "xmm", Action: inst.R}, - {Type: "xmm", Action: inst.W}, - }, - EncodingType: inst.EncodingTypeREX, - ISA: []string{"SSE2", "GFNI"}, - }, - { - Operands: []inst.Operand{ - {Type: "imm8", Action: inst.R}, - {Type: "m128", Action: inst.R}, - {Type: "xmm", Action: inst.W}, - }, - EncodingType: inst.EncodingTypeREX, - ISA: []string{"SSE2", "GFNI"}, - }, - }, - }, { Opcode: "VGF2P8AFFINEQB", Summary: "Galois Field Affine Transformation", @@ -275,32 +249,6 @@ var gfni = []*inst.Instruction{ }, }, }, - // From https://www.felixcloutier.com/x86/gf2p8affineinvqb - { - Opcode: "GF2P8AFFINEINVQB", - Summary: "Galois Field Affine Transformation Inverse", - Forms: []inst.Form{ - // 66 0F3A CF /r /ib GF2P8AFFINEINVQB xmm1, xmm2/m128, imm8 - { - Operands: []inst.Operand{ - {Type: "imm8", Action: inst.R}, - {Type: "xmm", Action: inst.R}, - {Type: "xmm", Action: inst.W}, - }, - EncodingType: inst.EncodingTypeREX, - ISA: []string{"SSE2", "GFNI"}, - }, - { - Operands: []inst.Operand{ - {Type: "imm8", Action: inst.R}, - {Type: "m128", Action: inst.R}, - {Type: "xmm", Action: inst.W}, - }, - EncodingType: inst.EncodingTypeREX, - ISA: []string{"SSE2", "GFNI"}, - }, - }, - }, { Opcode: "VGF2P8AFFINEINVQB", Summary: "Galois Field Affine Transformation Inverse", @@ -547,32 +495,6 @@ var gfni = []*inst.Instruction{ }, }, }, - // From https://www.felixcloutier.com/x86/gf2p8mulb - { - Opcode: "GF2P8MULB", - Summary: "Galois Field Multiply Bytes", - Forms: []inst.Form{ - // 66 0F38 CF /r GF2P8MULB xmm1, xmm2/m128 - { - Operands: []inst.Operand{ - {Type: "imm8", Action: inst.R}, - {Type: "xmm", Action: inst.R}, - {Type: "xmm", Action: inst.W}, - }, - EncodingType: inst.EncodingTypeREX, - ISA: []string{"SSE2", "GFNI"}, - }, - { - Operands: []inst.Operand{ - {Type: "imm8", Action: inst.R}, - {Type: "m128", Action: inst.R}, - {Type: "xmm", Action: inst.W}, - }, - EncodingType: inst.EncodingTypeREX, - ISA: []string{"SSE2", "GFNI"}, - }, - }, - }, { Opcode: "VGF2P8MULB", Summary: "Galois Field Multiply Bytes", diff --git a/x86/zctors.go b/x86/zctors.go index f5faba69..ae8d2c31 100644 --- a/x86/zctors.go +++ b/x86/zctors.go @@ -1940,36 +1940,6 @@ func EXTRACTPS(i, x, mr operand.Op) (*intrep.Instruction, error) { return build(opcEXTRACTPS.Forms(), sffxs{}, []operand.Op{i, x, mr}) } -// GF2P8AFFINEINVQB: Galois Field Affine Transformation Inverse. -// -// Forms: -// -// GF2P8AFFINEINVQB imm8 m128 xmm -// GF2P8AFFINEINVQB imm8 xmm xmm -func GF2P8AFFINEINVQB(i, mx, x operand.Op) (*intrep.Instruction, error) { - return build(opcGF2P8AFFINEINVQB.Forms(), sffxs{}, []operand.Op{i, mx, x}) -} - -// GF2P8AFFINEQB: Galois Field Affine Transformation. -// -// Forms: -// -// GF2P8AFFINEQB imm8 m128 xmm -// GF2P8AFFINEQB imm8 xmm xmm -func GF2P8AFFINEQB(i, mx, x operand.Op) (*intrep.Instruction, error) { - return build(opcGF2P8AFFINEQB.Forms(), sffxs{}, []operand.Op{i, mx, x}) -} - -// GF2P8MULB: Galois Field Multiply Bytes. -// -// Forms: -// -// GF2P8MULB imm8 m128 xmm -// GF2P8MULB imm8 xmm xmm -func GF2P8MULB(i, mx, x operand.Op) (*intrep.Instruction, error) { - return build(opcGF2P8MULB.Forms(), sffxs{}, []operand.Op{i, mx, x}) -} - // HADDPD: Packed Double-FP Horizontal Add. // // Forms: diff --git a/x86/zctors_test.go b/x86/zctors_test.go index c0edd5a7..3ec923e2 100644 --- a/x86/zctors_test.go +++ b/x86/zctors_test.go @@ -2009,33 +2009,6 @@ func TestEXTRACTPSValidFormsNoError(t *testing.T) { } } -func TestGF2P8AFFINEINVQBValidFormsNoError(t *testing.T) { - if _, err := GF2P8AFFINEINVQB(opimm8, opm128, opxmm); err != nil { - t.Fatal(err) - } - if _, err := GF2P8AFFINEINVQB(opimm8, opxmm, opxmm); err != nil { - t.Fatal(err) - } -} - -func TestGF2P8AFFINEQBValidFormsNoError(t *testing.T) { - if _, err := GF2P8AFFINEQB(opimm8, opm128, opxmm); err != nil { - t.Fatal(err) - } - if _, err := GF2P8AFFINEQB(opimm8, opxmm, opxmm); err != nil { - t.Fatal(err) - } -} - -func TestGF2P8MULBValidFormsNoError(t *testing.T) { - if _, err := GF2P8MULB(opimm8, opm128, opxmm); err != nil { - t.Fatal(err) - } - if _, err := GF2P8MULB(opimm8, opxmm, opxmm); err != nil { - t.Fatal(err) - } -} - func TestHADDPDValidFormsNoError(t *testing.T) { if _, err := HADDPD(opm128, opxmm); err != nil { t.Fatal(err) diff --git a/x86/zoptab.go b/x86/zoptab.go index 0f14bbb4..f472ffeb 100644 --- a/x86/zoptab.go +++ b/x86/zoptab.go @@ -282,7 +282,6 @@ const ( isasCMOV isasCPUID isasSSE42 - isasGFNI_SSE2 isasAVX512DQ isasAVX512BW isasAVX512F @@ -345,7 +344,6 @@ var isaslisttable = [][]string{ {"CMOV"}, {"CPUID"}, {"SSE4.2"}, - {"GFNI", "SSE2"}, {"AVX512DQ"}, {"AVX512BW"}, {"AVX512F"}, @@ -572,9 +570,6 @@ const ( opcDPPD opcDPPS opcEXTRACTPS - opcGF2P8AFFINEINVQB - opcGF2P8AFFINEQB - opcGF2P8MULB opcHADDPD opcHADDPS opcHSUBPD @@ -1871,9 +1866,6 @@ var opcstringtable = []string{ "DPPD", "DPPS", "EXTRACTPS", - "GF2P8AFFINEINVQB", - "GF2P8AFFINEQB", - "GF2P8MULB", "HADDPD", "HADDPS", "HSUBPD", @@ -3448,12 +3440,6 @@ var forms = []form{ {opcDPPS, sffxsclsNIL, 0, isasSSE41, 3, oprnds{{uint8(oprndtypeIMM8), false, actionN}, {uint8(oprndtypeXMM), false, actionR}, {uint8(oprndtypeXMM), false, actionRW}}}, {opcEXTRACTPS, sffxsclsNIL, 0, isasSSE41, 3, oprnds{{uint8(oprndtypeIMM2U), false, actionN}, {uint8(oprndtypeXMM), false, actionR}, {uint8(oprndtypeM32), false, actionW}}}, {opcEXTRACTPS, sffxsclsNIL, 0, isasSSE41, 3, oprnds{{uint8(oprndtypeIMM2U), false, actionN}, {uint8(oprndtypeXMM), false, actionR}, {uint8(oprndtypeR32), false, actionW}}}, - {opcGF2P8AFFINEINVQB, sffxsclsNIL, 0, isasGFNI_SSE2, 3, oprnds{{uint8(oprndtypeIMM8), false, actionR}, {uint8(oprndtypeM128), false, actionR}, {uint8(oprndtypeXMM), false, actionW}}}, - {opcGF2P8AFFINEINVQB, sffxsclsNIL, 0, isasGFNI_SSE2, 3, oprnds{{uint8(oprndtypeIMM8), false, actionR}, {uint8(oprndtypeXMM), false, actionR}, {uint8(oprndtypeXMM), false, actionW}}}, - {opcGF2P8AFFINEQB, sffxsclsNIL, 0, isasGFNI_SSE2, 3, oprnds{{uint8(oprndtypeIMM8), false, actionR}, {uint8(oprndtypeM128), false, actionR}, {uint8(oprndtypeXMM), false, actionW}}}, - {opcGF2P8AFFINEQB, sffxsclsNIL, 0, isasGFNI_SSE2, 3, oprnds{{uint8(oprndtypeIMM8), false, actionR}, {uint8(oprndtypeXMM), false, actionR}, {uint8(oprndtypeXMM), false, actionW}}}, - {opcGF2P8MULB, sffxsclsNIL, 0, isasGFNI_SSE2, 3, oprnds{{uint8(oprndtypeIMM8), false, actionR}, {uint8(oprndtypeM128), false, actionR}, {uint8(oprndtypeXMM), false, actionW}}}, - {opcGF2P8MULB, sffxsclsNIL, 0, isasGFNI_SSE2, 3, oprnds{{uint8(oprndtypeIMM8), false, actionR}, {uint8(oprndtypeXMM), false, actionR}, {uint8(oprndtypeXMM), false, actionW}}}, {opcHADDPD, sffxsclsNIL, 0, isasSSE3, 2, oprnds{{uint8(oprndtypeM128), false, actionR}, {uint8(oprndtypeXMM), false, actionRW}}}, {opcHADDPD, sffxsclsNIL, 0, isasSSE3, 2, oprnds{{uint8(oprndtypeXMM), false, actionR}, {uint8(oprndtypeXMM), false, actionRW}}}, {opcHADDPS, sffxsclsNIL, 0, isasSSE3, 2, oprnds{{uint8(oprndtypeM128), false, actionR}, {uint8(oprndtypeXMM), false, actionRW}}}, @@ -14627,16 +14613,16 @@ var opcformstable = [][]form{ forms[479:481], forms[481:483], forms[483:485], - forms[485:487], - forms[487:489], - forms[489:491], - forms[491:495], - forms[495:499], + forms[485:489], + forms[489:493], + forms[493:497], + forms[497:499], forms[499:503], - forms[503:505], - forms[505:509], - forms[509:513], - forms[513:517], + forms[503:507], + forms[507:511], + forms[511:513], + forms[513:515], + forms[515:517], forms[517:519], forms[519:521], forms[521:523], @@ -14647,11 +14633,11 @@ var opcformstable = [][]form{ forms[531:533], forms[533:535], forms[535:537], - forms[537:539], + forms[537:538], + forms[538:539], forms[539:541], forms[541:543], - forms[543:544], - forms[544:545], + forms[543:545], forms[545:547], forms[547:549], forms[549:551], @@ -14662,10 +14648,10 @@ var opcformstable = [][]form{ forms[559:561], forms[561:563], forms[563:565], - forms[565:567], - forms[567:569], + forms[565:569], forms[569:571], - forms[571:575], + forms[571:573], + forms[573:575], forms[575:577], forms[577:579], forms[579:581], @@ -14688,25 +14674,28 @@ var opcformstable = [][]form{ forms[613:615], forms[615:617], forms[617:619], - forms[619:621], - forms[621:623], - forms[623:625], + forms[619:620], + forms[620:621], + forms[621:622], + forms[622:623], + forms[623:624], + forms[624:625], forms[625:626], forms[626:627], forms[627:628], forms[628:629], forms[629:630], forms[630:631], - forms[631:632], - forms[632:633], - forms[633:634], - forms[634:635], - forms[635:636], - forms[636:637], - forms[637:642], - forms[642:647], - forms[647:652], - forms[652:657], + forms[631:636], + forms[636:641], + forms[641:646], + forms[646:651], + forms[651:652], + forms[652:653], + forms[653:654], + forms[654:655], + forms[655:656], + forms[656:657], forms[657:658], forms[658:659], forms[659:660], @@ -14742,71 +14731,68 @@ var opcformstable = [][]form{ forms[689:690], forms[690:691], forms[691:692], - forms[692:693], - forms[693:694], - forms[694:695], - forms[695:696], - forms[696:697], - forms[697:698], - forms[698:700], + forms[692:694], + forms[694:696], + forms[696:698], + forms[698:699], + forms[699:700], forms[700:702], forms[702:704], - forms[704:705], - forms[705:706], + forms[704:706], forms[706:708], - forms[708:710], - forms[710:712], - forms[712:714], - forms[714:715], + forms[708:709], + forms[709:711], + forms[711:713], + forms[713:715], forms[715:717], - forms[717:719], - forms[719:721], - forms[721:723], - forms[723:724], - forms[724:727], - forms[727:730], - forms[730:735], + forms[717:718], + forms[718:721], + forms[721:724], + forms[724:729], + forms[729:731], + forms[731:733], + forms[733:735], forms[735:737], forms[737:739], forms[739:741], forms[741:743], forms[743:745], forms[745:747], - forms[747:749], - forms[749:751], - forms[751:753], - forms[753:768], - forms[768:770], - forms[770:785], - forms[785:786], - forms[786:788], - forms[788:790], - forms[790:795], - forms[795:796], - forms[796:798], - forms[798:800], - forms[800:802], + forms[747:762], + forms[762:764], + forms[764:779], + forms[779:780], + forms[780:782], + forms[782:784], + forms[784:789], + forms[789:790], + forms[790:792], + forms[792:794], + forms[794:796], + forms[796:797], + forms[797:798], + forms[798:799], + forms[799:800], + forms[800:801], + forms[801:802], forms[802:803], forms[803:804], forms[804:805], forms[805:806], - forms[806:807], - forms[807:808], - forms[808:809], - forms[809:810], - forms[810:811], - forms[811:812], + forms[806:809], + forms[809:812], forms[812:815], - forms[815:818], - forms[818:821], - forms[821:836], - forms[836:839], - forms[839:841], - forms[841:843], + forms[815:830], + forms[830:833], + forms[833:835], + forms[835:837], + forms[837:840], + forms[840:843], forms[843:846], - forms[846:849], - forms[849:852], - forms[852:857], + forms[846:851], + forms[851:853], + forms[853:855], + forms[855:857], forms[857:859], forms[859:861], forms[861:863], @@ -14819,25 +14805,25 @@ var opcformstable = [][]form{ forms[875:877], forms[877:879], forms[879:881], - forms[881:883], - forms[883:885], - forms[885:887], - forms[887:888], + forms[881:882], + forms[882:884], + forms[884:886], + forms[886:888], forms[888:890], - forms[890:892], - forms[892:894], - forms[894:896], - forms[896:897], + forms[890:891], + forms[891:893], + forms[893:895], + forms[895:897], forms[897:899], - forms[899:901], - forms[901:903], - forms[903:905], - forms[905:911], - forms[911:919], - forms[919:921], - forms[921:923], - forms[923:931], - forms[931:939], + forms[899:905], + forms[905:913], + forms[913:915], + forms[915:917], + forms[917:925], + forms[925:933], + forms[933:935], + forms[935:937], + forms[937:939], forms[939:941], forms[941:943], forms[943:945], @@ -14854,10 +14840,10 @@ var opcformstable = [][]form{ forms[965:967], forms[967:969], forms[969:971], - forms[971:973], - forms[973:975], - forms[975:977], - forms[977:978], + forms[971:972], + forms[972:974], + forms[974:976], + forms[976:978], forms[978:980], forms[980:982], forms[982:984], @@ -14905,10 +14891,10 @@ var opcformstable = [][]form{ forms[1066:1068], forms[1068:1070], forms[1070:1072], - forms[1072:1074], - forms[1074:1076], - forms[1076:1078], - forms[1078:1079], + forms[1072:1073], + forms[1073:1075], + forms[1075:1077], + forms[1077:1079], forms[1079:1081], forms[1081:1083], forms[1083:1085], @@ -14931,34 +14917,34 @@ var opcformstable = [][]form{ forms[1117:1119], forms[1119:1121], forms[1121:1123], - forms[1123:1125], - forms[1125:1127], + forms[1123:1124], + forms[1124:1125], + forms[1125:1126], + forms[1126:1127], forms[1127:1129], - forms[1129:1130], - forms[1130:1131], - forms[1131:1132], - forms[1132:1133], + forms[1129:1131], + forms[1131:1133], forms[1133:1135], forms[1135:1137], forms[1137:1139], forms[1139:1141], forms[1141:1143], forms[1143:1145], - forms[1145:1147], - forms[1147:1149], - forms[1149:1151], - forms[1151:1152], - forms[1152:1155], - forms[1155:1156], + forms[1145:1146], + forms[1146:1149], + forms[1149:1150], + forms[1150:1153], + forms[1153:1156], forms[1156:1159], forms[1159:1162], - forms[1162:1165], - forms[1165:1168], - forms[1168:1169], - forms[1169:1172], - forms[1172:1173], - forms[1173:1176], - forms[1176:1179], + forms[1162:1163], + forms[1163:1166], + forms[1166:1167], + forms[1167:1170], + forms[1170:1173], + forms[1173:1175], + forms[1175:1177], + forms[1177:1179], forms[1179:1181], forms[1181:1183], forms[1183:1185], @@ -14973,30 +14959,28 @@ var opcformstable = [][]form{ forms[1201:1203], forms[1203:1205], forms[1205:1207], - forms[1207:1209], - forms[1209:1211], + forms[1207:1211], forms[1211:1213], - forms[1213:1217], - forms[1217:1219], - forms[1219:1221], + forms[1213:1215], + forms[1215:1221], forms[1221:1227], forms[1227:1233], forms[1233:1239], - forms[1239:1245], - forms[1245:1247], - forms[1247:1249], + forms[1239:1241], + forms[1241:1243], + forms[1243:1249], forms[1249:1255], forms[1255:1261], forms[1261:1267], - forms[1267:1273], - forms[1273:1276], - forms[1276:1279], - forms[1279:1280], - forms[1280:1281], - forms[1281:1282], - forms[1282:1283], - forms[1283:1284], - forms[1284:1285], + forms[1267:1270], + forms[1270:1273], + forms[1273:1274], + forms[1274:1275], + forms[1275:1276], + forms[1276:1277], + forms[1277:1278], + forms[1278:1279], + forms[1279:1285], forms[1285:1291], forms[1291:1297], forms[1297:1303], @@ -15004,15 +14988,15 @@ var opcformstable = [][]form{ forms[1309:1315], forms[1315:1321], forms[1321:1327], - forms[1327:1333], + forms[1327:1329], + forms[1329:1331], + forms[1331:1333], forms[1333:1335], forms[1335:1337], forms[1337:1339], forms[1339:1341], forms[1341:1343], - forms[1343:1345], - forms[1345:1347], - forms[1347:1349], + forms[1343:1349], forms[1349:1355], forms[1355:1361], forms[1361:1367], @@ -15020,13 +15004,15 @@ var opcformstable = [][]form{ forms[1373:1379], forms[1379:1385], forms[1385:1391], - forms[1391:1397], - forms[1397:1399], - forms[1399:1401], - forms[1401:1407], - forms[1407:1415], - forms[1415:1423], - forms[1423:1431], + forms[1391:1393], + forms[1393:1395], + forms[1395:1401], + forms[1401:1409], + forms[1409:1417], + forms[1417:1425], + forms[1425:1427], + forms[1427:1429], + forms[1429:1431], forms[1431:1433], forms[1433:1435], forms[1435:1437], @@ -15040,688 +15026,685 @@ var opcformstable = [][]form{ forms[1451:1453], forms[1453:1455], forms[1455:1457], - forms[1457:1459], - forms[1459:1461], - forms[1461:1463], - forms[1463:1464], + forms[1457:1458], + forms[1458:1460], + forms[1460:1462], + forms[1462:1464], forms[1464:1466], forms[1466:1468], forms[1468:1470], forms[1470:1472], - forms[1472:1474], - forms[1474:1476], - forms[1476:1478], - forms[1478:1484], - forms[1484:1494], - forms[1494:1504], - forms[1504:1514], - forms[1514:1516], - forms[1516:1518], - forms[1518:1524], - forms[1524:1534], - forms[1534:1544], - forms[1544:1554], + forms[1472:1478], + forms[1478:1488], + forms[1488:1498], + forms[1498:1508], + forms[1508:1510], + forms[1510:1512], + forms[1512:1518], + forms[1518:1528], + forms[1528:1538], + forms[1538:1548], + forms[1548:1550], + forms[1550:1552], + forms[1552:1554], forms[1554:1556], forms[1556:1558], forms[1558:1560], forms[1560:1562], forms[1562:1564], - forms[1564:1566], - forms[1566:1568], - forms[1568:1570], - forms[1570:1571], - forms[1571:1572], - forms[1572:1573], - forms[1573:1579], - forms[1579:1587], - forms[1587:1589], - forms[1589:1591], - forms[1591:1599], - forms[1599:1601], - forms[1601:1603], - forms[1603:1611], - forms[1611:1612], - forms[1612:1617], - forms[1617:1622], - forms[1622:1627], - forms[1627:1632], + forms[1564:1565], + forms[1565:1566], + forms[1566:1567], + forms[1567:1573], + forms[1573:1581], + forms[1581:1583], + forms[1583:1585], + forms[1585:1593], + forms[1593:1595], + forms[1595:1597], + forms[1597:1605], + forms[1605:1606], + forms[1606:1611], + forms[1611:1616], + forms[1616:1621], + forms[1621:1626], + forms[1626:1628], + forms[1628:1630], + forms[1630:1632], forms[1632:1634], forms[1634:1636], - forms[1636:1638], - forms[1638:1640], - forms[1640:1642], - forms[1642:1643], + forms[1636:1637], + forms[1637:1639], + forms[1639:1641], + forms[1641:1643], forms[1643:1645], - forms[1645:1647], - forms[1647:1649], - forms[1649:1651], - forms[1651:1681], - forms[1681:1711], - forms[1711:1720], - forms[1720:1729], - forms[1729:1733], - forms[1733:1737], + forms[1645:1675], + forms[1675:1705], + forms[1705:1714], + forms[1714:1723], + forms[1723:1727], + forms[1727:1731], + forms[1731:1733], + forms[1733:1735], + forms[1735:1737], forms[1737:1739], forms[1739:1741], forms[1741:1743], - forms[1743:1745], - forms[1745:1747], - forms[1747:1749], - forms[1749:1776], - forms[1776:1803], - forms[1803:1830], - forms[1830:1857], - forms[1857:1884], - forms[1884:1911], - forms[1911:1938], - forms[1938:1965], - forms[1965:1969], - forms[1969:1973], - forms[1973:1977], - forms[1977:1981], - forms[1981:1982], - forms[1982:1994], - forms[1994:2000], - forms[2000:2003], - forms[2003:2009], - forms[2009:2012], - forms[2012:2013], - forms[2013:2031], - forms[2031:2037], - forms[2037:2040], - forms[2040:2046], - forms[2046:2049], - forms[2049:2061], - forms[2061:2075], - forms[2075:2099], - forms[2099:2123], - forms[2123:2131], - forms[2131:2139], - forms[2139:2142], - forms[2142:2145], - forms[2145:2163], - forms[2163:2181], - forms[2181:2208], - forms[2208:2238], - forms[2238:2250], - forms[2250:2259], - forms[2259:2268], - forms[2268:2280], - forms[2280:2289], - forms[2289:2298], - forms[2298:2328], - forms[2328:2340], - forms[2340:2349], - forms[2349:2358], - forms[2358:2388], - forms[2388:2409], - forms[2409:2439], - forms[2439:2469], - forms[2469:2490], - forms[2490:2520], - forms[2520:2550], - forms[2550:2580], - forms[2580:2610], - forms[2610:2622], - forms[2622:2631], - forms[2631:2640], - forms[2640:2643], - forms[2643:2646], - forms[2646:2655], - forms[2655:2658], - forms[2658:2661], - forms[2661:2663], + forms[1743:1770], + forms[1770:1797], + forms[1797:1824], + forms[1824:1851], + forms[1851:1878], + forms[1878:1905], + forms[1905:1932], + forms[1932:1959], + forms[1959:1963], + forms[1963:1967], + forms[1967:1971], + forms[1971:1975], + forms[1975:1976], + forms[1976:1988], + forms[1988:1994], + forms[1994:1997], + forms[1997:2003], + forms[2003:2006], + forms[2006:2007], + forms[2007:2025], + forms[2025:2031], + forms[2031:2034], + forms[2034:2040], + forms[2040:2043], + forms[2043:2055], + forms[2055:2069], + forms[2069:2093], + forms[2093:2117], + forms[2117:2125], + forms[2125:2133], + forms[2133:2136], + forms[2136:2139], + forms[2139:2157], + forms[2157:2175], + forms[2175:2202], + forms[2202:2232], + forms[2232:2244], + forms[2244:2253], + forms[2253:2262], + forms[2262:2274], + forms[2274:2283], + forms[2283:2292], + forms[2292:2322], + forms[2322:2334], + forms[2334:2343], + forms[2343:2352], + forms[2352:2382], + forms[2382:2403], + forms[2403:2433], + forms[2433:2463], + forms[2463:2484], + forms[2484:2514], + forms[2514:2544], + forms[2544:2574], + forms[2574:2604], + forms[2604:2616], + forms[2616:2625], + forms[2625:2634], + forms[2634:2637], + forms[2637:2640], + forms[2640:2649], + forms[2649:2652], + forms[2652:2655], + forms[2655:2657], + forms[2657:2660], + forms[2660:2663], forms[2663:2666], - forms[2666:2669], - forms[2669:2672], - forms[2672:2681], + forms[2666:2675], + forms[2675:2678], + forms[2678:2681], forms[2681:2684], forms[2684:2687], - forms[2687:2690], - forms[2690:2693], - forms[2693:2705], - forms[2705:2714], - forms[2714:2723], - forms[2723:2753], - forms[2753:2765], - forms[2765:2774], - forms[2774:2783], - forms[2783:2813], - forms[2813:2843], - forms[2843:2873], - forms[2873:2903], - forms[2903:2933], + forms[2687:2699], + forms[2699:2708], + forms[2708:2717], + forms[2717:2747], + forms[2747:2759], + forms[2759:2768], + forms[2768:2777], + forms[2777:2807], + forms[2807:2837], + forms[2837:2867], + forms[2867:2897], + forms[2897:2927], + forms[2927:2930], + forms[2930:2933], forms[2933:2936], forms[2936:2939], forms[2939:2942], forms[2942:2945], forms[2945:2948], forms[2948:2951], - forms[2951:2954], - forms[2954:2957], - forms[2957:2984], - forms[2984:3014], - forms[3014:3044], - forms[3044:3056], - forms[3056:3065], - forms[3065:3074], - forms[3074:3076], + forms[2951:2978], + forms[2978:3008], + forms[3008:3038], + forms[3038:3050], + forms[3050:3059], + forms[3059:3068], + forms[3068:3070], + forms[3070:3073], + forms[3073:3076], forms[3076:3079], - forms[3079:3082], - forms[3082:3085], - forms[3085:3103], - forms[3103:3133], - forms[3133:3163], - forms[3163:3172], - forms[3172:3181], - forms[3181:3183], - forms[3183:3187], - forms[3187:3199], - forms[3199:3211], - forms[3211:3229], - forms[3229:3247], - forms[3247:3249], - forms[3249:3261], - forms[3261:3267], - forms[3267:3279], - forms[3279:3285], - forms[3285:3287], - forms[3287:3299], - forms[3299:3305], - forms[3305:3317], - forms[3317:3323], - forms[3323:3325], - forms[3325:3355], - forms[3355:3385], - forms[3385:3394], - forms[3394:3403], - forms[3403:3433], - forms[3433:3463], - forms[3463:3472], - forms[3472:3481], - forms[3481:3511], - forms[3511:3541], - forms[3541:3550], - forms[3550:3559], - forms[3559:3589], - forms[3589:3619], - forms[3619:3628], - forms[3628:3637], - forms[3637:3667], - forms[3667:3697], - forms[3697:3727], - forms[3727:3757], - forms[3757:3787], - forms[3787:3817], - forms[3817:3847], - forms[3847:3877], - forms[3877:3886], - forms[3886:3895], - forms[3895:3925], - forms[3925:3955], - forms[3955:3964], - forms[3964:3973], - forms[3973:4003], - forms[4003:4033], - forms[4033:4042], - forms[4042:4051], - forms[4051:4081], - forms[4081:4111], - forms[4111:4141], - forms[4141:4171], - forms[4171:4201], - forms[4201:4231], - forms[4231:4261], - forms[4261:4291], - forms[4291:4300], - forms[4300:4309], - forms[4309:4339], - forms[4339:4369], - forms[4369:4378], - forms[4378:4387], - forms[4387:4417], - forms[4417:4447], - forms[4447:4456], - forms[4456:4465], - forms[4465:4495], - forms[4495:4525], - forms[4525:4534], - forms[4534:4543], - forms[4543:4573], - forms[4573:4603], - forms[4603:4612], - forms[4612:4621], - forms[4621:4651], - forms[4651:4681], - forms[4681:4690], - forms[4690:4699], + forms[3079:3097], + forms[3097:3127], + forms[3127:3157], + forms[3157:3166], + forms[3166:3175], + forms[3175:3177], + forms[3177:3181], + forms[3181:3193], + forms[3193:3205], + forms[3205:3223], + forms[3223:3241], + forms[3241:3243], + forms[3243:3255], + forms[3255:3261], + forms[3261:3273], + forms[3273:3279], + forms[3279:3281], + forms[3281:3293], + forms[3293:3299], + forms[3299:3311], + forms[3311:3317], + forms[3317:3319], + forms[3319:3349], + forms[3349:3379], + forms[3379:3388], + forms[3388:3397], + forms[3397:3427], + forms[3427:3457], + forms[3457:3466], + forms[3466:3475], + forms[3475:3505], + forms[3505:3535], + forms[3535:3544], + forms[3544:3553], + forms[3553:3583], + forms[3583:3613], + forms[3613:3622], + forms[3622:3631], + forms[3631:3661], + forms[3661:3691], + forms[3691:3721], + forms[3721:3751], + forms[3751:3781], + forms[3781:3811], + forms[3811:3841], + forms[3841:3871], + forms[3871:3880], + forms[3880:3889], + forms[3889:3919], + forms[3919:3949], + forms[3949:3958], + forms[3958:3967], + forms[3967:3997], + forms[3997:4027], + forms[4027:4036], + forms[4036:4045], + forms[4045:4075], + forms[4075:4105], + forms[4105:4135], + forms[4135:4165], + forms[4165:4195], + forms[4195:4225], + forms[4225:4255], + forms[4255:4285], + forms[4285:4294], + forms[4294:4303], + forms[4303:4333], + forms[4333:4363], + forms[4363:4372], + forms[4372:4381], + forms[4381:4411], + forms[4411:4441], + forms[4441:4450], + forms[4450:4459], + forms[4459:4489], + forms[4489:4519], + forms[4519:4528], + forms[4528:4537], + forms[4537:4567], + forms[4567:4597], + forms[4597:4606], + forms[4606:4615], + forms[4615:4645], + forms[4645:4675], + forms[4675:4684], + forms[4684:4693], + forms[4693:4699], forms[4699:4705], forms[4705:4711], forms[4711:4717], forms[4717:4723], forms[4723:4729], - forms[4729:4735], - forms[4735:4739], - forms[4739:4743], - forms[4743:4748], - forms[4748:4753], - forms[4753:4758], - forms[4758:4763], - forms[4763:4793], - forms[4793:4823], - forms[4823:4832], - forms[4832:4841], - forms[4841:4871], - forms[4871:4901], - forms[4901:4910], - forms[4910:4919], - forms[4919:4937], - forms[4937:4955], - forms[4955:4973], - forms[4973:4977], - forms[4977:4981], - forms[4981:4985], - forms[4985:4989], - forms[4989:4991], - forms[4991:5003], - forms[5003:5009], - forms[5009:5021], - forms[5021:5027], - forms[5027:5029], - forms[5029:5041], - forms[5041:5047], - forms[5047:5059], - forms[5059:5065], - forms[5065:5067], - forms[5067:5069], - forms[5069:5070], - forms[5070:5071], - forms[5071:5075], - forms[5075:5079], - forms[5079:5109], - forms[5109:5139], - forms[5139:5148], - forms[5148:5157], - forms[5157:5187], - forms[5187:5217], - forms[5217:5226], - forms[5226:5235], - forms[5235:5262], - forms[5262:5289], - forms[5289:5293], - forms[5293:5311], - forms[5311:5317], - forms[5317:5344], - forms[5344:5371], - forms[5371:5377], - forms[5377:5404], - forms[5404:5431], - forms[5431:5458], - forms[5458:5485], - forms[5485:5486], - forms[5486:5488], - forms[5488:5490], - forms[5490:5491], + forms[4729:4733], + forms[4733:4737], + forms[4737:4742], + forms[4742:4747], + forms[4747:4752], + forms[4752:4757], + forms[4757:4787], + forms[4787:4817], + forms[4817:4826], + forms[4826:4835], + forms[4835:4865], + forms[4865:4895], + forms[4895:4904], + forms[4904:4913], + forms[4913:4931], + forms[4931:4949], + forms[4949:4967], + forms[4967:4971], + forms[4971:4975], + forms[4975:4979], + forms[4979:4983], + forms[4983:4985], + forms[4985:4997], + forms[4997:5003], + forms[5003:5015], + forms[5015:5021], + forms[5021:5023], + forms[5023:5035], + forms[5035:5041], + forms[5041:5053], + forms[5053:5059], + forms[5059:5061], + forms[5061:5063], + forms[5063:5064], + forms[5064:5065], + forms[5065:5069], + forms[5069:5073], + forms[5073:5103], + forms[5103:5133], + forms[5133:5142], + forms[5142:5151], + forms[5151:5181], + forms[5181:5211], + forms[5211:5220], + forms[5220:5229], + forms[5229:5256], + forms[5256:5283], + forms[5283:5287], + forms[5287:5305], + forms[5305:5311], + forms[5311:5338], + forms[5338:5365], + forms[5365:5371], + forms[5371:5398], + forms[5398:5425], + forms[5425:5452], + forms[5452:5479], + forms[5479:5480], + forms[5480:5482], + forms[5482:5484], + forms[5484:5485], + forms[5485:5487], + forms[5487:5489], + forms[5489:5491], forms[5491:5493], - forms[5493:5495], - forms[5495:5497], - forms[5497:5499], + forms[5493:5496], + forms[5496:5499], forms[5499:5502], forms[5502:5505], - forms[5505:5508], - forms[5508:5511], - forms[5511:5516], - forms[5516:5524], - forms[5524:5542], - forms[5542:5560], - forms[5560:5568], - forms[5568:5595], - forms[5595:5622], - forms[5622:5626], - forms[5626:5656], - forms[5656:5686], - forms[5686:5695], - forms[5695:5704], - forms[5704:5731], - forms[5731:5758], - forms[5758:5776], - forms[5776:5803], - forms[5803:5830], - forms[5830:5848], - forms[5848:5875], - forms[5875:5893], - forms[5893:5920], - forms[5920:5938], - forms[5938:5956], - forms[5956:5983], - forms[5983:6010], - forms[6010:6028], - forms[6028:6046], - forms[6046:6064], - forms[6064:6082], - forms[6082:6100], - forms[6100:6118], - forms[6118:6122], - forms[6122:6149], - forms[6149:6153], - forms[6153:6180], - forms[6180:6207], - forms[6207:6234], - forms[6234:6252], - forms[6252:6270], - forms[6270:6274], - forms[6274:6292], - forms[6292:6319], - forms[6319:6346], - forms[6346:6364], - forms[6364:6368], - forms[6368:6372], - forms[6372:6399], - forms[6399:6426], - forms[6426:6429], - forms[6429:6432], - forms[6432:6459], - forms[6459:6486], - forms[6486:6488], - forms[6488:6500], - forms[6500:6518], - forms[6518:6534], - forms[6534:6556], - forms[6556:6578], - forms[6578:6594], - forms[6594:6596], - forms[6596:6598], - forms[6598:6614], - forms[6614:6636], - forms[6636:6658], - forms[6658:6674], - forms[6674:6676], - forms[6676:6678], - forms[6678:6696], - forms[6696:6708], - forms[6708:6726], - forms[6726:6744], - forms[6744:6756], - forms[6756:6768], - forms[6768:6786], - forms[6786:6804], - forms[6804:6831], - forms[6831:6858], - forms[6858:6860], - forms[6860:6862], - forms[6862:6880], - forms[6880:6898], - forms[6898:6916], - forms[6916:6943], - forms[6943:6970], - forms[6970:6997], - forms[6997:7024], - forms[7024:7042], - forms[7042:7096], - forms[7096:7150], - forms[7150:7186], - forms[7186:7204], - forms[7204:7240], - forms[7240:7258], - forms[7258:7285], - forms[7285:7312], - forms[7312:7339], - forms[7339:7366], - forms[7366:7384], - forms[7384:7402], - forms[7402:7420], - forms[7420:7438], + forms[5505:5510], + forms[5510:5518], + forms[5518:5536], + forms[5536:5554], + forms[5554:5562], + forms[5562:5589], + forms[5589:5616], + forms[5616:5620], + forms[5620:5650], + forms[5650:5680], + forms[5680:5689], + forms[5689:5698], + forms[5698:5725], + forms[5725:5752], + forms[5752:5770], + forms[5770:5797], + forms[5797:5824], + forms[5824:5842], + forms[5842:5869], + forms[5869:5887], + forms[5887:5914], + forms[5914:5932], + forms[5932:5950], + forms[5950:5977], + forms[5977:6004], + forms[6004:6022], + forms[6022:6040], + forms[6040:6058], + forms[6058:6076], + forms[6076:6094], + forms[6094:6112], + forms[6112:6116], + forms[6116:6143], + forms[6143:6147], + forms[6147:6174], + forms[6174:6201], + forms[6201:6228], + forms[6228:6246], + forms[6246:6264], + forms[6264:6268], + forms[6268:6286], + forms[6286:6313], + forms[6313:6340], + forms[6340:6358], + forms[6358:6362], + forms[6362:6366], + forms[6366:6393], + forms[6393:6420], + forms[6420:6423], + forms[6423:6426], + forms[6426:6453], + forms[6453:6480], + forms[6480:6482], + forms[6482:6494], + forms[6494:6512], + forms[6512:6528], + forms[6528:6550], + forms[6550:6572], + forms[6572:6588], + forms[6588:6590], + forms[6590:6592], + forms[6592:6608], + forms[6608:6630], + forms[6630:6652], + forms[6652:6668], + forms[6668:6670], + forms[6670:6672], + forms[6672:6690], + forms[6690:6702], + forms[6702:6720], + forms[6720:6738], + forms[6738:6750], + forms[6750:6762], + forms[6762:6780], + forms[6780:6798], + forms[6798:6825], + forms[6825:6852], + forms[6852:6854], + forms[6854:6856], + forms[6856:6874], + forms[6874:6892], + forms[6892:6910], + forms[6910:6937], + forms[6937:6964], + forms[6964:6991], + forms[6991:7018], + forms[7018:7036], + forms[7036:7090], + forms[7090:7144], + forms[7144:7180], + forms[7180:7198], + forms[7198:7234], + forms[7234:7252], + forms[7252:7279], + forms[7279:7306], + forms[7306:7333], + forms[7333:7360], + forms[7360:7378], + forms[7378:7396], + forms[7396:7414], + forms[7414:7432], + forms[7432:7434], + forms[7434:7436], + forms[7436:7438], forms[7438:7440], - forms[7440:7442], - forms[7442:7444], - forms[7444:7446], - forms[7446:7451], - forms[7451:7456], - forms[7456:7461], - forms[7461:7466], - forms[7466:7470], - forms[7470:7474], + forms[7440:7445], + forms[7445:7450], + forms[7450:7455], + forms[7455:7460], + forms[7460:7464], + forms[7464:7468], + forms[7468:7472], + forms[7472:7474], forms[7474:7478], - forms[7478:7480], - forms[7480:7484], - forms[7484:7488], - forms[7488:7492], + forms[7478:7482], + forms[7482:7486], + forms[7486:7488], + forms[7488:7490], + forms[7490:7492], forms[7492:7494], - forms[7494:7496], - forms[7496:7498], - forms[7498:7500], - forms[7500:7527], - forms[7527:7554], - forms[7554:7581], - forms[7581:7608], - forms[7608:7626], - forms[7626:7644], - forms[7644:7648], - forms[7648:7652], - forms[7652:7670], - forms[7670:7697], - forms[7697:7724], - forms[7724:7742], - forms[7742:7760], - forms[7760:7787], - forms[7787:7814], - forms[7814:7832], - forms[7832:7850], - forms[7850:7877], - forms[7877:7904], - forms[7904:7922], - forms[7922:7940], - forms[7940:7967], - forms[7967:7994], - forms[7994:8012], - forms[8012:8015], - forms[8015:8018], - forms[8018:8036], - forms[8036:8054], + forms[7494:7521], + forms[7521:7548], + forms[7548:7575], + forms[7575:7602], + forms[7602:7620], + forms[7620:7638], + forms[7638:7642], + forms[7642:7646], + forms[7646:7664], + forms[7664:7691], + forms[7691:7718], + forms[7718:7736], + forms[7736:7754], + forms[7754:7781], + forms[7781:7808], + forms[7808:7826], + forms[7826:7844], + forms[7844:7871], + forms[7871:7898], + forms[7898:7916], + forms[7916:7934], + forms[7934:7961], + forms[7961:7988], + forms[7988:8006], + forms[8006:8009], + forms[8009:8012], + forms[8012:8030], + forms[8030:8048], + forms[8048:8051], + forms[8051:8054], forms[8054:8057], forms[8057:8060], - forms[8060:8063], - forms[8063:8066], - forms[8066:8068], - forms[8068:8071], - forms[8071:8089], - forms[8089:8107], - forms[8107:8125], - forms[8125:8143], - forms[8143:8161], - forms[8161:8179], - forms[8179:8197], - forms[8197:8215], - forms[8215:8233], - forms[8233:8251], - forms[8251:8269], - forms[8269:8287], - forms[8287:8305], - forms[8305:8323], - forms[8323:8341], - forms[8341:8359], - forms[8359:8377], - forms[8377:8395], - forms[8395:8413], - forms[8413:8431], - forms[8431:8449], - forms[8449:8452], - forms[8452:8470], - forms[8470:8488], - forms[8488:8506], - forms[8506:8524], - forms[8524:8542], - forms[8542:8560], - forms[8560:8578], - forms[8578:8605], - forms[8605:8623], - forms[8623:8641], - forms[8641:8659], - forms[8659:8686], - forms[8686:8713], - forms[8713:8731], - forms[8731:8758], - forms[8758:8785], - forms[8785:8794], - forms[8794:8803], - forms[8803:8807], - forms[8807:8834], - forms[8834:8861], - forms[8861:8888], - forms[8888:8915], - forms[8915:8942], - forms[8942:8969], - forms[8969:8996], - forms[8996:9023], - forms[9023:9050], - forms[9050:9077], - forms[9077:9083], + forms[8060:8062], + forms[8062:8065], + forms[8065:8083], + forms[8083:8101], + forms[8101:8119], + forms[8119:8137], + forms[8137:8155], + forms[8155:8173], + forms[8173:8191], + forms[8191:8209], + forms[8209:8227], + forms[8227:8245], + forms[8245:8263], + forms[8263:8281], + forms[8281:8299], + forms[8299:8317], + forms[8317:8335], + forms[8335:8353], + forms[8353:8371], + forms[8371:8389], + forms[8389:8407], + forms[8407:8425], + forms[8425:8443], + forms[8443:8446], + forms[8446:8464], + forms[8464:8482], + forms[8482:8500], + forms[8500:8518], + forms[8518:8536], + forms[8536:8554], + forms[8554:8572], + forms[8572:8599], + forms[8599:8617], + forms[8617:8635], + forms[8635:8653], + forms[8653:8680], + forms[8680:8707], + forms[8707:8725], + forms[8725:8752], + forms[8752:8779], + forms[8779:8788], + forms[8788:8797], + forms[8797:8801], + forms[8801:8828], + forms[8828:8855], + forms[8855:8882], + forms[8882:8909], + forms[8909:8936], + forms[8936:8963], + forms[8963:8990], + forms[8990:9017], + forms[9017:9044], + forms[9044:9071], + forms[9071:9077], + forms[9077:9080], + forms[9080:9083], forms[9083:9086], forms[9086:9089], - forms[9089:9092], - forms[9092:9095], - forms[9095:9113], - forms[9113:9140], - forms[9140:9158], - forms[9158:9176], - forms[9176:9180], - forms[9180:9184], - forms[9184:9188], - forms[9188:9233], - forms[9233:9239], - forms[9239:9284], - forms[9284:9311], - forms[9311:9338], - forms[9338:9356], - forms[9356:9392], - forms[9392:9437], - forms[9437:9482], - forms[9482:9509], - forms[9509:9536], - forms[9536:9554], - forms[9554:9590], - forms[9590:9635], - forms[9635:9641], - forms[9641:9686], - forms[9686:9713], - forms[9713:9740], - forms[9740:9758], - forms[9758:9794], - forms[9794:9812], - forms[9812:9839], - forms[9839:9866], - forms[9866:9884], - forms[9884:9902], - forms[9902:9920], - forms[9920:9938], - forms[9938:9956], - forms[9956:9983], - forms[9983:10010], - forms[10010:10014], - forms[10014:10026], - forms[10026:10044], - forms[10044:10062], - forms[10062:10074], - forms[10074:10086], - forms[10086:10104], - forms[10104:10122], - forms[10122:10134], - forms[10134:10152], - forms[10152:10179], - forms[10179:10206], - forms[10206:10224], - forms[10224:10242], - forms[10242:10269], - forms[10269:10296], - forms[10296:10314], - forms[10314:10318], - forms[10318:10345], - forms[10345:10372], - forms[10372:10402], - forms[10402:10432], - forms[10432:10441], - forms[10441:10450], - forms[10450:10477], - forms[10477:10504], + forms[9089:9107], + forms[9107:9134], + forms[9134:9152], + forms[9152:9170], + forms[9170:9174], + forms[9174:9178], + forms[9178:9182], + forms[9182:9227], + forms[9227:9233], + forms[9233:9278], + forms[9278:9305], + forms[9305:9332], + forms[9332:9350], + forms[9350:9386], + forms[9386:9431], + forms[9431:9476], + forms[9476:9503], + forms[9503:9530], + forms[9530:9548], + forms[9548:9584], + forms[9584:9629], + forms[9629:9635], + forms[9635:9680], + forms[9680:9707], + forms[9707:9734], + forms[9734:9752], + forms[9752:9788], + forms[9788:9806], + forms[9806:9833], + forms[9833:9860], + forms[9860:9878], + forms[9878:9896], + forms[9896:9914], + forms[9914:9932], + forms[9932:9950], + forms[9950:9977], + forms[9977:10004], + forms[10004:10008], + forms[10008:10020], + forms[10020:10038], + forms[10038:10056], + forms[10056:10068], + forms[10068:10080], + forms[10080:10098], + forms[10098:10116], + forms[10116:10128], + forms[10128:10146], + forms[10146:10173], + forms[10173:10200], + forms[10200:10218], + forms[10218:10236], + forms[10236:10263], + forms[10263:10290], + forms[10290:10308], + forms[10308:10312], + forms[10312:10339], + forms[10339:10366], + forms[10366:10396], + forms[10396:10426], + forms[10426:10435], + forms[10435:10444], + forms[10444:10471], + forms[10471:10498], + forms[10498:10504], forms[10504:10510], - forms[10510:10516], - forms[10516:10528], - forms[10528:10540], - forms[10540:10549], - forms[10549:10558], - forms[10558:10562], - forms[10562:10564], - forms[10564:10591], - forms[10591:10618], + forms[10510:10522], + forms[10522:10534], + forms[10534:10543], + forms[10543:10552], + forms[10552:10556], + forms[10556:10558], + forms[10558:10585], + forms[10585:10612], + forms[10612:10618], forms[10618:10624], - forms[10624:10630], - forms[10630:10660], - forms[10660:10690], - forms[10690:10699], - forms[10699:10708], - forms[10708:10712], - forms[10712:10716], - forms[10716:10718], - forms[10718:10720], - forms[10720:10747], - forms[10747:10774], + forms[10624:10654], + forms[10654:10684], + forms[10684:10693], + forms[10693:10702], + forms[10702:10706], + forms[10706:10710], + forms[10710:10712], + forms[10712:10714], + forms[10714:10741], + forms[10741:10768], + forms[10768:10774], forms[10774:10780], - forms[10780:10786], - forms[10786:10798], - forms[10798:10810], - forms[10810:10819], - forms[10819:10828], - forms[10828:10832], - forms[10832:10834], - forms[10834:10864], - forms[10864:10894], - forms[10894:10903], - forms[10903:10912], + forms[10780:10792], + forms[10792:10804], + forms[10804:10813], + forms[10813:10822], + forms[10822:10826], + forms[10826:10828], + forms[10828:10858], + forms[10858:10888], + forms[10888:10897], + forms[10897:10906], + forms[10906:10909], + forms[10909:10912], forms[10912:10915], forms[10915:10918], - forms[10918:10921], - forms[10921:10924], - forms[10924:10942], - forms[10942:10960], - forms[10960:10978], - forms[10978:10996], - forms[10996:11023], - forms[11023:11050], - forms[11050:11080], - forms[11080:11110], - forms[11110:11119], - forms[11119:11128], - forms[11128:11129], - forms[11129:11159], - forms[11159:11189], - forms[11189:11198], - forms[11198:11207], - forms[11207:11211], - forms[11211:11215], - forms[11215:11218], - forms[11218:11221], - forms[11221:11248], - forms[11248:11275], - forms[11275:11302], - forms[11302:11329], - forms[11329:11356], - forms[11356:11383], - forms[11383:11384], - forms[11384:11385], + forms[10918:10936], + forms[10936:10954], + forms[10954:10972], + forms[10972:10990], + forms[10990:11017], + forms[11017:11044], + forms[11044:11074], + forms[11074:11104], + forms[11104:11113], + forms[11113:11122], + forms[11122:11123], + forms[11123:11153], + forms[11153:11183], + forms[11183:11192], + forms[11192:11201], + forms[11201:11205], + forms[11205:11209], + forms[11209:11212], + forms[11212:11215], + forms[11215:11242], + forms[11242:11269], + forms[11269:11296], + forms[11296:11323], + forms[11323:11350], + forms[11350:11377], + forms[11377:11378], + forms[11378:11379], + forms[11379:11381], + forms[11381:11383], + forms[11383:11385], forms[11385:11387], - forms[11387:11389], - forms[11389:11391], - forms[11391:11393], - forms[11393:11396], - forms[11396:11401], - forms[11401:11406], - forms[11406:11411], - forms[11411:11412], - forms[11412:11413], - forms[11413:11419], - forms[11419:11427], - forms[11427:11429], - forms[11429:11431], - forms[11431:11439], - forms[11439:11447], + forms[11387:11390], + forms[11390:11395], + forms[11395:11400], + forms[11400:11405], + forms[11405:11406], + forms[11406:11407], + forms[11407:11413], + forms[11413:11421], + forms[11421:11423], + forms[11423:11425], + forms[11425:11433], + forms[11433:11441], } From 739bbc790b7fdb81eea8a8a47bdad6a71bfcbcc4 Mon Sep 17 00:00:00 2001 From: Michael McLoughlin Date: Sun, 27 Nov 2022 14:39:57 -0800 Subject: [PATCH 05/10] split out forms --- internal/opcodesextra/gfni.go | 1264 ++++++++++++++------------------- 1 file changed, 539 insertions(+), 725 deletions(-) diff --git a/internal/opcodesextra/gfni.go b/internal/opcodesextra/gfni.go index 9c9a6ec2..2f54eb4f 100644 --- a/internal/opcodesextra/gfni.go +++ b/internal/opcodesextra/gfni.go @@ -2,743 +2,557 @@ package opcodesextra import "github.com/mmcloughlin/avo/internal/inst" +// gfni is the "Galois Field New Instructions" instruction set. var gfni = []*inst.Instruction{ + // Reference: https://github.com/golang/go/blob/go1.19.3/src/cmd/internal/obj/x86/avx_optabs.go#L2250-L2269 + // + // {as: AVGF2P8AFFINEINVQB, ytab: _yvgf2p8affineinvqb, prefix: Pavx, op: opBytes{ + // avxEscape | vex128 | vex66 | vex0F3A | vexW1, 0xCF, + // avxEscape | vex256 | vex66 | vex0F3A | vexW1, 0xCF, + // avxEscape | evex128 | evex66 | evex0F3A | evexW1, evexN16 | evexBcstN8 | evexZeroingEnabled, 0xCF, + // avxEscape | evex256 | evex66 | evex0F3A | evexW1, evexN32 | evexBcstN8 | evexZeroingEnabled, 0xCF, + // avxEscape | evex512 | evex66 | evex0F3A | evexW1, evexN64 | evexBcstN8 | evexZeroingEnabled, 0xCF, + // }}, + // {as: AVGF2P8AFFINEQB, ytab: _yvgf2p8affineinvqb, prefix: Pavx, op: opBytes{ + // avxEscape | vex128 | vex66 | vex0F3A | vexW1, 0xCE, + // avxEscape | vex256 | vex66 | vex0F3A | vexW1, 0xCE, + // avxEscape | evex128 | evex66 | evex0F3A | evexW1, evexN16 | evexBcstN8 | evexZeroingEnabled, 0xCE, + // avxEscape | evex256 | evex66 | evex0F3A | evexW1, evexN32 | evexBcstN8 | evexZeroingEnabled, 0xCE, + // avxEscape | evex512 | evex66 | evex0F3A | evexW1, evexN64 | evexBcstN8 | evexZeroingEnabled, 0xCE, + // }}, + // {as: AVGF2P8MULB, ytab: _yvandnpd, prefix: Pavx, op: opBytes{ + // avxEscape | vex128 | vex66 | vex0F38 | vexW0, 0xCF, + // avxEscape | vex256 | vex66 | vex0F38 | vexW0, 0xCF, + // avxEscape | evex128 | evex66 | evex0F38 | evexW0, evexN16 | evexZeroingEnabled, 0xCF, + // avxEscape | evex256 | evex66 | evex0F38 | evexW0, evexN32 | evexZeroingEnabled, 0xCF, + // avxEscape | evex512 | evex66 | evex0F38 | evexW0, evexN64 | evexZeroingEnabled, 0xCF, + // { Opcode: "VGF2P8AFFINEQB", Summary: "Galois Field Affine Transformation", - Forms: []inst.Form{ - // VEX.128.66.0F3A.W1 CE /r /ib VGF2P8AFFINEQB xmm1, xmm2, xmm3/m128, imm8 - { - Operands: []inst.Operand{ - {Type: "imm8", Action: inst.R}, - {Type: "xmm", Action: inst.R}, - {Type: "xmm", Action: inst.R}, - {Type: "xmm", Action: inst.W}, - }, - EncodingType: inst.EncodingTypeVEX, - ISA: []string{"AVX", "GFNI"}, - }, - { - Operands: []inst.Operand{ - {Type: "imm8", Action: inst.R}, - {Type: "m128", Action: inst.R}, - {Type: "xmm", Action: inst.R}, - {Type: "xmm", Action: inst.W}, - }, - EncodingType: inst.EncodingTypeVEX, - ISA: []string{"AVX", "GFNI"}, - }, - // VEX.256.66.0F3A.W1 CE /r /ib VGF2P8AFFINEQB ymm1, ymm2, ymm3/m256, imm8 - { - Operands: []inst.Operand{ - {Type: "imm8", Action: inst.R}, - {Type: "ymm", Action: inst.R}, - {Type: "ymm", Action: inst.R}, - {Type: "ymm", Action: inst.W}, - }, - EncodingType: inst.EncodingTypeVEX, - ISA: []string{"AVX", "GFNI"}, - }, - { - Operands: []inst.Operand{ - {Type: "imm8", Action: inst.R}, - {Type: "m256", Action: inst.R}, - {Type: "ymm", Action: inst.R}, - {Type: "ymm", Action: inst.W}, - }, - EncodingType: inst.EncodingTypeVEX, - ISA: []string{"AVX", "GFNI"}, - }, - // EVEX.128.66.0F3A.W1 CE /r /ib VGF2P8AFFINEQB xmm1{k1}{z}, xmm2, xmm3/m128/m64bcst, imm8 - { - Operands: []inst.Operand{ - {Type: "imm8", Action: inst.R}, - {Type: "xmm", Action: inst.R}, - {Type: "xmm", Action: inst.R}, - {Type: "xmm", Action: inst.W}, - }, - EncodingType: inst.EncodingTypeEVEX, - ISA: []string{"AVX512VL", "GFNI"}, - }, - { - Operands: []inst.Operand{ - {Type: "imm8", Action: inst.R}, - {Type: "xmm", Action: inst.R}, - {Type: "xmm", Action: inst.R}, - {Type: "k", Action: inst.R}, - {Type: "xmm", Action: inst.W}, - }, - EncodingType: inst.EncodingTypeEVEX, - ISA: []string{"AVX512VL", "GFNI"}, - }, - { - Operands: []inst.Operand{ - {Type: "imm8", Action: inst.R}, - {Type: "m128", Action: inst.R}, - {Type: "xmm", Action: inst.R}, - {Type: "xmm", Action: inst.W}, - }, - EncodingType: inst.EncodingTypeEVEX, - ISA: []string{"AVX512VL", "GFNI"}, - }, - { - Operands: []inst.Operand{ - {Type: "imm8", Action: inst.R}, - {Type: "m128", Action: inst.R}, - {Type: "xmm", Action: inst.R}, - {Type: "k", Action: inst.R}, - {Type: "xmm", Action: inst.W}, - }, - EncodingType: inst.EncodingTypeEVEX, - ISA: []string{"AVX512VL", "GFNI"}, - }, - { - Operands: []inst.Operand{ - {Type: "imm8", Action: inst.R}, - {Type: "m64", Action: inst.R}, - {Type: "xmm", Action: inst.R}, - {Type: "xmm", Action: inst.W}, - }, - EncodingType: inst.EncodingTypeEVEX, - ISA: []string{"AVX512VL", "GFNI"}, - Broadcast: true, - }, - { - Operands: []inst.Operand{ - {Type: "imm8", Action: inst.R}, - {Type: "m64", Action: inst.R}, - {Type: "xmm", Action: inst.R}, - {Type: "k", Action: inst.R}, - {Type: "xmm", Action: inst.W}, - }, - EncodingType: inst.EncodingTypeEVEX, - ISA: []string{"AVX512VL", "GFNI"}, - Broadcast: true, - }, - // EVEX.256.66.0F3A.W1 CE /r /ib VGF2P8AFFINEQB ymm1{k1}{z}, ymm2, ymm3/m256/m64bcst, imm8 - { - Operands: []inst.Operand{ - {Type: "imm8", Action: inst.R}, - {Type: "ymm", Action: inst.R}, - {Type: "ymm", Action: inst.R}, - {Type: "ymm", Action: inst.W}, - }, - EncodingType: inst.EncodingTypeEVEX, - ISA: []string{"AVX512VL", "GFNI"}, - }, - { - Operands: []inst.Operand{ - {Type: "imm8", Action: inst.R}, - {Type: "ymm", Action: inst.R}, - {Type: "ymm", Action: inst.R}, - {Type: "k", Action: inst.R}, - {Type: "ymm", Action: inst.W}, - }, - EncodingType: inst.EncodingTypeEVEX, - ISA: []string{"AVX512VL", "GFNI"}, - }, - { - Operands: []inst.Operand{ - {Type: "imm8", Action: inst.R}, - {Type: "m256", Action: inst.R}, - {Type: "ymm", Action: inst.R}, - {Type: "ymm", Action: inst.W}, - }, - EncodingType: inst.EncodingTypeEVEX, - ISA: []string{"AVX512VL", "GFNI"}, - }, - { - Operands: []inst.Operand{ - {Type: "imm8", Action: inst.R}, - {Type: "m256", Action: inst.R}, - {Type: "ymm", Action: inst.R}, - {Type: "k", Action: inst.R}, - {Type: "ymm", Action: inst.W}, - }, - EncodingType: inst.EncodingTypeEVEX, - ISA: []string{"AVX512VL", "GFNI"}, - }, - { - Operands: []inst.Operand{ - {Type: "imm8", Action: inst.R}, - {Type: "m64", Action: inst.R}, - {Type: "ymm", Action: inst.R}, - {Type: "ymm", Action: inst.W}, - }, - EncodingType: inst.EncodingTypeEVEX, - ISA: []string{"AVX512VL", "GFNI"}, - Broadcast: true, - }, - { - Operands: []inst.Operand{ - {Type: "imm8", Action: inst.R}, - {Type: "m64", Action: inst.R}, - {Type: "ymm", Action: inst.R}, - {Type: "k", Action: inst.R}, - {Type: "ymm", Action: inst.W}, - }, - EncodingType: inst.EncodingTypeEVEX, - ISA: []string{"AVX512VL", "GFNI"}, - Broadcast: true, - }, - // EVEX.512.66.0F3A.W1 CE /r /ib VGF2P8AFFINEQB zmm1{k1}{z}, zmm2, zmm3/m512/m64bcst, imm8 - { - Operands: []inst.Operand{ - {Type: "imm8", Action: inst.R}, - {Type: "zmm", Action: inst.R}, - {Type: "zmm", Action: inst.R}, - {Type: "zmm", Action: inst.W}, - }, - EncodingType: inst.EncodingTypeEVEX, - ISA: []string{"AVX512F", "GFNI"}, - }, - { - Operands: []inst.Operand{ - {Type: "imm8", Action: inst.R}, - {Type: "zmm", Action: inst.R}, - {Type: "zmm", Action: inst.R}, - {Type: "k", Action: inst.R}, - {Type: "zmm", Action: inst.W}, - }, - EncodingType: inst.EncodingTypeEVEX, - ISA: []string{"AVX512F", "GFNI"}, - }, - { - Operands: []inst.Operand{ - {Type: "imm8", Action: inst.R}, - {Type: "m512", Action: inst.R}, - {Type: "zmm", Action: inst.R}, - {Type: "zmm", Action: inst.W}, - }, - EncodingType: inst.EncodingTypeEVEX, - ISA: []string{"AVX512F", "GFNI"}, - }, - { - Operands: []inst.Operand{ - {Type: "imm8", Action: inst.R}, - {Type: "m512", Action: inst.R}, - {Type: "zmm", Action: inst.R}, - {Type: "k", Action: inst.R}, - {Type: "zmm", Action: inst.W}, - }, - EncodingType: inst.EncodingTypeEVEX, - ISA: []string{"AVX512F", "GFNI"}, - }, - { - Operands: []inst.Operand{ - {Type: "imm8", Action: inst.R}, - {Type: "m64", Action: inst.R}, - {Type: "zmm", Action: inst.R}, - {Type: "zmm", Action: inst.W}, - }, - EncodingType: inst.EncodingTypeEVEX, - ISA: []string{"AVX512F", "GFNI"}, - Broadcast: true, - }, - { - Operands: []inst.Operand{ - {Type: "imm8", Action: inst.R}, - {Type: "m64", Action: inst.R}, - {Type: "zmm", Action: inst.R}, - {Type: "k", Action: inst.R}, - {Type: "zmm", Action: inst.W}, - }, - EncodingType: inst.EncodingTypeEVEX, - ISA: []string{"AVX512F", "GFNI"}, - Broadcast: true, - }, - }, + Forms: vgf2p8affineqb, }, { Opcode: "VGF2P8AFFINEINVQB", Summary: "Galois Field Affine Transformation Inverse", - Forms: []inst.Form{ - // VEX.128.66.0F3A.W1 CF /r /ib VGF2P8AFFINEINVQB xmm1, xmm2, xmm3/m128, imm8 - { - Operands: []inst.Operand{ - {Type: "imm8", Action: inst.R}, - {Type: "xmm", Action: inst.R}, - {Type: "xmm", Action: inst.R}, - {Type: "xmm", Action: inst.W}, - }, - EncodingType: inst.EncodingTypeVEX, - ISA: []string{"AVX", "GFNI"}, - }, - { - Operands: []inst.Operand{ - {Type: "imm8", Action: inst.R}, - {Type: "m128", Action: inst.R}, - {Type: "xmm", Action: inst.R}, - {Type: "xmm", Action: inst.W}, - }, - EncodingType: inst.EncodingTypeVEX, - ISA: []string{"AVX", "GFNI"}, - }, - // VEX.256.66.0F3A.W1 CF /r /ib VGF2P8AFFINEINVQB ymm1, ymm2, ymm3/m256, imm8 - { - Operands: []inst.Operand{ - {Type: "imm8", Action: inst.R}, - {Type: "ymm", Action: inst.R}, - {Type: "ymm", Action: inst.R}, - {Type: "ymm", Action: inst.W}, - }, - EncodingType: inst.EncodingTypeVEX, - ISA: []string{"AVX", "GFNI"}, - }, - { - Operands: []inst.Operand{ - {Type: "imm8", Action: inst.R}, - {Type: "m256", Action: inst.R}, - {Type: "ymm", Action: inst.R}, - {Type: "ymm", Action: inst.W}, - }, - EncodingType: inst.EncodingTypeVEX, - ISA: []string{"AVX", "GFNI"}, - }, - // EVEX.128.66.0F3A.W1 CF /r /ib VGF2P8AFFINEINVQB xmm1{k1}{z}, xmm2, xmm3/m128/m64bcst, imm8 - { - Operands: []inst.Operand{ - {Type: "imm8", Action: inst.R}, - {Type: "xmm", Action: inst.R}, - {Type: "xmm", Action: inst.R}, - {Type: "xmm", Action: inst.W}, - }, - EncodingType: inst.EncodingTypeEVEX, - ISA: []string{"AVX512VL", "GFNI"}, - }, - { - Operands: []inst.Operand{ - {Type: "imm8", Action: inst.R}, - {Type: "xmm", Action: inst.R}, - {Type: "xmm", Action: inst.R}, - {Type: "k", Action: inst.R}, - {Type: "xmm", Action: inst.W}, - }, - EncodingType: inst.EncodingTypeEVEX, - ISA: []string{"AVX512VL", "GFNI"}, - }, - { - Operands: []inst.Operand{ - {Type: "imm8", Action: inst.R}, - {Type: "m128", Action: inst.R}, - {Type: "xmm", Action: inst.R}, - {Type: "xmm", Action: inst.W}, - }, - EncodingType: inst.EncodingTypeEVEX, - ISA: []string{"AVX512VL", "GFNI"}, - }, - { - Operands: []inst.Operand{ - {Type: "imm8", Action: inst.R}, - {Type: "m128", Action: inst.R}, - {Type: "xmm", Action: inst.R}, - {Type: "k", Action: inst.R}, - {Type: "xmm", Action: inst.W}, - }, - EncodingType: inst.EncodingTypeEVEX, - ISA: []string{"AVX512VL", "GFNI"}, - }, - { - Operands: []inst.Operand{ - {Type: "imm8", Action: inst.R}, - {Type: "m64", Action: inst.R}, - {Type: "xmm", Action: inst.R}, - {Type: "xmm", Action: inst.W}, - }, - EncodingType: inst.EncodingTypeEVEX, - ISA: []string{"AVX512VL", "GFNI"}, - Broadcast: true, - }, - { - Operands: []inst.Operand{ - {Type: "imm8", Action: inst.R}, - {Type: "m64", Action: inst.R}, - {Type: "xmm", Action: inst.R}, - {Type: "k", Action: inst.R}, - {Type: "xmm", Action: inst.W}, - }, - EncodingType: inst.EncodingTypeEVEX, - ISA: []string{"AVX512VL", "GFNI"}, - Broadcast: true, - }, - // EVEX.256.66.0F3A.W1 CF /r /ib VGF2P8AFFINEINVQB ymm1{k1}{z}, ymm2, ymm3/m256/m64bcst, imm8 - { - Operands: []inst.Operand{ - {Type: "imm8", Action: inst.R}, - {Type: "ymm", Action: inst.R}, - {Type: "ymm", Action: inst.R}, - {Type: "ymm", Action: inst.W}, - }, - EncodingType: inst.EncodingTypeEVEX, - ISA: []string{"AVX512VL", "GFNI"}, - }, - { - Operands: []inst.Operand{ - {Type: "imm8", Action: inst.R}, - {Type: "ymm", Action: inst.R}, - {Type: "ymm", Action: inst.R}, - {Type: "k", Action: inst.R}, - {Type: "ymm", Action: inst.W}, - }, - EncodingType: inst.EncodingTypeEVEX, - ISA: []string{"AVX512VL", "GFNI"}, - }, - { - Operands: []inst.Operand{ - {Type: "imm8", Action: inst.R}, - {Type: "m256", Action: inst.R}, - {Type: "ymm", Action: inst.R}, - {Type: "ymm", Action: inst.W}, - }, - EncodingType: inst.EncodingTypeEVEX, - ISA: []string{"AVX512VL", "GFNI"}, - }, - { - Operands: []inst.Operand{ - {Type: "imm8", Action: inst.R}, - {Type: "m256", Action: inst.R}, - {Type: "ymm", Action: inst.R}, - {Type: "k", Action: inst.R}, - {Type: "ymm", Action: inst.W}, - }, - EncodingType: inst.EncodingTypeEVEX, - ISA: []string{"AVX512VL", "GFNI"}, - }, - { - Operands: []inst.Operand{ - {Type: "imm8", Action: inst.R}, - {Type: "m64", Action: inst.R}, - {Type: "ymm", Action: inst.R}, - {Type: "ymm", Action: inst.W}, - }, - EncodingType: inst.EncodingTypeEVEX, - ISA: []string{"AVX512VL", "GFNI"}, - Broadcast: true, - }, - { - Operands: []inst.Operand{ - {Type: "imm8", Action: inst.R}, - {Type: "m64", Action: inst.R}, - {Type: "ymm", Action: inst.R}, - {Type: "k", Action: inst.R}, - {Type: "ymm", Action: inst.W}, - }, - EncodingType: inst.EncodingTypeEVEX, - ISA: []string{"AVX512VL", "GFNI"}, - Broadcast: true, - }, - // EVEX.512.66.0F3A.W1 CF /r /ib VGF2P8AFFINEINVQB zmm1{k1}{z}, zmm2, zmm3/m512/m64bcst, imm8 - { - Operands: []inst.Operand{ - {Type: "imm8", Action: inst.R}, - {Type: "zmm", Action: inst.R}, - {Type: "zmm", Action: inst.R}, - {Type: "zmm", Action: inst.W}, - }, - EncodingType: inst.EncodingTypeEVEX, - ISA: []string{"AVX512F", "GFNI"}, - }, - { - Operands: []inst.Operand{ - {Type: "imm8", Action: inst.R}, - {Type: "zmm", Action: inst.R}, - {Type: "zmm", Action: inst.R}, - {Type: "k", Action: inst.R}, - {Type: "zmm", Action: inst.W}, - }, - EncodingType: inst.EncodingTypeEVEX, - ISA: []string{"AVX512F", "GFNI"}, - }, - { - Operands: []inst.Operand{ - {Type: "imm8", Action: inst.R}, - {Type: "m512", Action: inst.R}, - {Type: "zmm", Action: inst.R}, - {Type: "zmm", Action: inst.W}, - }, - EncodingType: inst.EncodingTypeEVEX, - ISA: []string{"AVX512F", "GFNI"}, - }, - { - Operands: []inst.Operand{ - {Type: "imm8", Action: inst.R}, - {Type: "m512", Action: inst.R}, - {Type: "zmm", Action: inst.R}, - {Type: "k", Action: inst.R}, - {Type: "zmm", Action: inst.W}, - }, - EncodingType: inst.EncodingTypeEVEX, - ISA: []string{"AVX512F", "GFNI"}, - }, - { - Operands: []inst.Operand{ - {Type: "imm8", Action: inst.R}, - {Type: "m64", Action: inst.R}, - {Type: "zmm", Action: inst.R}, - {Type: "zmm", Action: inst.W}, - }, - EncodingType: inst.EncodingTypeEVEX, - ISA: []string{"AVX512F", "GFNI"}, - Broadcast: true, - }, - { - Operands: []inst.Operand{ - {Type: "imm8", Action: inst.R}, - {Type: "m64", Action: inst.R}, - {Type: "zmm", Action: inst.R}, - {Type: "k", Action: inst.R}, - {Type: "zmm", Action: inst.W}, - }, - EncodingType: inst.EncodingTypeEVEX, - ISA: []string{"AVX512F", "GFNI"}, - Broadcast: true, - }, - }, + Forms: vgf2p8affineqb, }, + { Opcode: "VGF2P8MULB", Summary: "Galois Field Multiply Bytes", - Forms: []inst.Form{ - // VEX.128.66.0F38.W0 CF /r VGF2P8MULB xmm1, xmm2, xmm3/m128 - { - Operands: []inst.Operand{ - {Type: "imm8", Action: inst.R}, - {Type: "xmm", Action: inst.R}, - {Type: "xmm", Action: inst.R}, - {Type: "xmm", Action: inst.W}, - }, - EncodingType: inst.EncodingTypeVEX, - ISA: []string{"AVX", "GFNI"}, - }, - { - Operands: []inst.Operand{ - {Type: "imm8", Action: inst.R}, - {Type: "m128", Action: inst.R}, - {Type: "xmm", Action: inst.R}, - {Type: "xmm", Action: inst.W}, - }, - EncodingType: inst.EncodingTypeVEX, - ISA: []string{"AVX", "GFNI"}, - }, - // VEX.256.66.0F38.W0 CF /r VGF2P8MULB ymm1, ymm2, ymm3/m256 - { - Operands: []inst.Operand{ - {Type: "imm8", Action: inst.R}, - {Type: "ymm", Action: inst.R}, - {Type: "ymm", Action: inst.R}, - {Type: "ymm", Action: inst.W}, - }, - EncodingType: inst.EncodingTypeVEX, - ISA: []string{"AVX", "GFNI"}, - }, - { - Operands: []inst.Operand{ - {Type: "imm8", Action: inst.R}, - {Type: "m256", Action: inst.R}, - {Type: "ymm", Action: inst.R}, - {Type: "ymm", Action: inst.W}, - }, - EncodingType: inst.EncodingTypeVEX, - ISA: []string{"AVX", "GFNI"}, - }, - // EVEX.128.66.0F38.W0 CF /r VGF2P8MULB xmm1{k1}{z}, xmm2, xmm3/m128 - { - Operands: []inst.Operand{ - {Type: "imm8", Action: inst.R}, - {Type: "xmm", Action: inst.R}, - {Type: "xmm", Action: inst.R}, - {Type: "xmm", Action: inst.W}, - }, - EncodingType: inst.EncodingTypeEVEX, - ISA: []string{"AVX512VL", "GFNI"}, - }, - { - Operands: []inst.Operand{ - {Type: "imm8", Action: inst.R}, - {Type: "xmm", Action: inst.R}, - {Type: "xmm", Action: inst.R}, - {Type: "k", Action: inst.R}, - {Type: "xmm", Action: inst.W}, - }, - EncodingType: inst.EncodingTypeEVEX, - ISA: []string{"AVX512VL", "GFNI"}, - }, - { - Operands: []inst.Operand{ - {Type: "imm8", Action: inst.R}, - {Type: "m128", Action: inst.R}, - {Type: "xmm", Action: inst.R}, - {Type: "xmm", Action: inst.W}, - }, - EncodingType: inst.EncodingTypeEVEX, - ISA: []string{"AVX512VL", "GFNI"}, - }, - { - Operands: []inst.Operand{ - {Type: "imm8", Action: inst.R}, - {Type: "m128", Action: inst.R}, - {Type: "xmm", Action: inst.R}, - {Type: "k", Action: inst.R}, - {Type: "xmm", Action: inst.W}, - }, - EncodingType: inst.EncodingTypeEVEX, - ISA: []string{"AVX512VL", "GFNI"}, - }, - { - Operands: []inst.Operand{ - {Type: "imm8", Action: inst.R}, - {Type: "m64", Action: inst.R}, - {Type: "xmm", Action: inst.R}, - {Type: "xmm", Action: inst.W}, - }, - EncodingType: inst.EncodingTypeEVEX, - ISA: []string{"AVX512VL", "GFNI"}, - Broadcast: true, - }, - { - Operands: []inst.Operand{ - {Type: "imm8", Action: inst.R}, - {Type: "m64", Action: inst.R}, - {Type: "xmm", Action: inst.R}, - {Type: "k", Action: inst.R}, - {Type: "xmm", Action: inst.W}, - }, - EncodingType: inst.EncodingTypeEVEX, - ISA: []string{"AVX512VL", "GFNI"}, - Broadcast: true, - }, - // EVEX.256.66.0F38.W0 CF /r VGF2P8MULB ymm1{k1}{z}, ymm2, ymm3/m256 - { - Operands: []inst.Operand{ - {Type: "imm8", Action: inst.R}, - {Type: "ymm", Action: inst.R}, - {Type: "ymm", Action: inst.R}, - {Type: "ymm", Action: inst.W}, - }, - EncodingType: inst.EncodingTypeEVEX, - ISA: []string{"AVX512VL", "GFNI"}, - }, - { - Operands: []inst.Operand{ - {Type: "imm8", Action: inst.R}, - {Type: "ymm", Action: inst.R}, - {Type: "ymm", Action: inst.R}, - {Type: "k", Action: inst.R}, - {Type: "ymm", Action: inst.W}, - }, - EncodingType: inst.EncodingTypeEVEX, - ISA: []string{"AVX512VL", "GFNI"}, - }, - { - Operands: []inst.Operand{ - {Type: "imm8", Action: inst.R}, - {Type: "m256", Action: inst.R}, - {Type: "ymm", Action: inst.R}, - {Type: "ymm", Action: inst.W}, - }, - EncodingType: inst.EncodingTypeEVEX, - ISA: []string{"AVX512VL", "GFNI"}, - }, - { - Operands: []inst.Operand{ - {Type: "imm8", Action: inst.R}, - {Type: "m256", Action: inst.R}, - {Type: "ymm", Action: inst.R}, - {Type: "k", Action: inst.R}, - {Type: "ymm", Action: inst.W}, - }, - EncodingType: inst.EncodingTypeEVEX, - ISA: []string{"AVX512VL", "GFNI"}, - }, - { - Operands: []inst.Operand{ - {Type: "imm8", Action: inst.R}, - {Type: "m64", Action: inst.R}, - {Type: "ymm", Action: inst.R}, - {Type: "ymm", Action: inst.W}, - }, - EncodingType: inst.EncodingTypeEVEX, - ISA: []string{"AVX512VL", "GFNI"}, - Broadcast: true, - }, - { - Operands: []inst.Operand{ - {Type: "imm8", Action: inst.R}, - {Type: "m64", Action: inst.R}, - {Type: "ymm", Action: inst.R}, - {Type: "k", Action: inst.R}, - {Type: "ymm", Action: inst.W}, - }, - EncodingType: inst.EncodingTypeEVEX, - ISA: []string{"AVX512VL", "GFNI"}, - Broadcast: true, - }, - // EVEX.512.66.0F38.W0 CF /r VGF2P8MULB zmm1{k1}{z}, zmm2, zmm3/m512 - { - Operands: []inst.Operand{ - {Type: "imm8", Action: inst.R}, - {Type: "zmm", Action: inst.R}, - {Type: "zmm", Action: inst.R}, - {Type: "zmm", Action: inst.W}, - }, - EncodingType: inst.EncodingTypeEVEX, - ISA: []string{"AVX512F", "GFNI"}, - }, - { - Operands: []inst.Operand{ - {Type: "imm8", Action: inst.R}, - {Type: "zmm", Action: inst.R}, - {Type: "zmm", Action: inst.R}, - {Type: "k", Action: inst.R}, - {Type: "zmm", Action: inst.W}, - }, - EncodingType: inst.EncodingTypeEVEX, - ISA: []string{"AVX512F", "GFNI"}, - }, - { - Operands: []inst.Operand{ - {Type: "imm8", Action: inst.R}, - {Type: "m512", Action: inst.R}, - {Type: "zmm", Action: inst.R}, - {Type: "zmm", Action: inst.W}, - }, - EncodingType: inst.EncodingTypeEVEX, - ISA: []string{"AVX512F", "GFNI"}, - }, - { - Operands: []inst.Operand{ - {Type: "imm8", Action: inst.R}, - {Type: "m512", Action: inst.R}, - {Type: "zmm", Action: inst.R}, - {Type: "k", Action: inst.R}, - {Type: "zmm", Action: inst.W}, - }, - EncodingType: inst.EncodingTypeEVEX, - ISA: []string{"AVX512F", "GFNI"}, - }, - { - Operands: []inst.Operand{ - {Type: "imm8", Action: inst.R}, - {Type: "m64", Action: inst.R}, - {Type: "zmm", Action: inst.R}, - {Type: "zmm", Action: inst.W}, - }, - EncodingType: inst.EncodingTypeEVEX, - ISA: []string{"AVX512F", "GFNI"}, - Broadcast: true, - }, - { - Operands: []inst.Operand{ - {Type: "imm8", Action: inst.R}, - {Type: "m64", Action: inst.R}, - {Type: "zmm", Action: inst.R}, - {Type: "k", Action: inst.R}, - {Type: "zmm", Action: inst.W}, - }, - EncodingType: inst.EncodingTypeEVEX, - ISA: []string{"AVX512F", "GFNI"}, - Broadcast: true, - }, + Forms: vgf2p8mulb, + }, +} + +// Reference: https://github.com/golang/go/blob/go1.19.3/src/cmd/internal/obj/x86/avx_optabs.go#L483-L492 +// +// var _yvgf2p8affineinvqb = []ytab{ +// {zcase: Zvex_i_rm_v_r, zoffset: 2, args: argList{Yu8, Yxm, Yxr, Yxr}}, +// {zcase: Zvex_i_rm_v_r, zoffset: 2, args: argList{Yu8, Yym, Yyr, Yyr}}, +// {zcase: Zevex_i_rm_v_r, zoffset: 0, args: argList{Yu8, YxmEvex, YxrEvex, YxrEvex}}, +// {zcase: Zevex_i_rm_v_k_r, zoffset: 3, args: argList{Yu8, YxmEvex, YxrEvex, Yknot0, YxrEvex}}, +// {zcase: Zevex_i_rm_v_r, zoffset: 0, args: argList{Yu8, YymEvex, YyrEvex, YyrEvex}}, +// {zcase: Zevex_i_rm_v_k_r, zoffset: 3, args: argList{Yu8, YymEvex, YyrEvex, Yknot0, YyrEvex}}, +// {zcase: Zevex_i_rm_v_r, zoffset: 0, args: argList{Yu8, Yzm, Yzr, Yzr}}, +// {zcase: Zevex_i_rm_v_k_r, zoffset: 3, args: argList{Yu8, Yzm, Yzr, Yknot0, Yzr}}, +// } +// +var vgf2p8affineqb = inst.Forms{ + // VEX.128.66.0F3A.W1 CE /r /ib VGF2P8AFFINEQB xmm1, xmm2, xmm3/m128, imm8 + { + Operands: []inst.Operand{ + {Type: "imm8", Action: inst.R}, + {Type: "xmm", Action: inst.R}, + {Type: "xmm", Action: inst.R}, + {Type: "xmm", Action: inst.W}, + }, + EncodingType: inst.EncodingTypeVEX, + ISA: []string{"AVX", "GFNI"}, + }, + { + Operands: []inst.Operand{ + {Type: "imm8", Action: inst.R}, + {Type: "m128", Action: inst.R}, + {Type: "xmm", Action: inst.R}, + {Type: "xmm", Action: inst.W}, + }, + EncodingType: inst.EncodingTypeVEX, + ISA: []string{"AVX", "GFNI"}, + }, + // VEX.256.66.0F3A.W1 CE /r /ib VGF2P8AFFINEQB ymm1, ymm2, ymm3/m256, imm8 + { + Operands: []inst.Operand{ + {Type: "imm8", Action: inst.R}, + {Type: "ymm", Action: inst.R}, + {Type: "ymm", Action: inst.R}, + {Type: "ymm", Action: inst.W}, + }, + EncodingType: inst.EncodingTypeVEX, + ISA: []string{"AVX", "GFNI"}, + }, + { + Operands: []inst.Operand{ + {Type: "imm8", Action: inst.R}, + {Type: "m256", Action: inst.R}, + {Type: "ymm", Action: inst.R}, + {Type: "ymm", Action: inst.W}, + }, + EncodingType: inst.EncodingTypeVEX, + ISA: []string{"AVX", "GFNI"}, + }, + // EVEX.128.66.0F3A.W1 CE /r /ib VGF2P8AFFINEQB xmm1{k1}{z}, xmm2, xmm3/m128/m64bcst, imm8 + { + Operands: []inst.Operand{ + {Type: "imm8", Action: inst.R}, + {Type: "xmm", Action: inst.R}, + {Type: "xmm", Action: inst.R}, + {Type: "xmm", Action: inst.W}, + }, + EncodingType: inst.EncodingTypeEVEX, + ISA: []string{"AVX512VL", "GFNI"}, + }, + { + Operands: []inst.Operand{ + {Type: "imm8", Action: inst.R}, + {Type: "xmm", Action: inst.R}, + {Type: "xmm", Action: inst.R}, + {Type: "k", Action: inst.R}, + {Type: "xmm", Action: inst.W}, + }, + EncodingType: inst.EncodingTypeEVEX, + ISA: []string{"AVX512VL", "GFNI"}, + }, + { + Operands: []inst.Operand{ + {Type: "imm8", Action: inst.R}, + {Type: "m128", Action: inst.R}, + {Type: "xmm", Action: inst.R}, + {Type: "xmm", Action: inst.W}, + }, + EncodingType: inst.EncodingTypeEVEX, + ISA: []string{"AVX512VL", "GFNI"}, + }, + { + Operands: []inst.Operand{ + {Type: "imm8", Action: inst.R}, + {Type: "m128", Action: inst.R}, + {Type: "xmm", Action: inst.R}, + {Type: "k", Action: inst.R}, + {Type: "xmm", Action: inst.W}, + }, + EncodingType: inst.EncodingTypeEVEX, + ISA: []string{"AVX512VL", "GFNI"}, + }, + { + Operands: []inst.Operand{ + {Type: "imm8", Action: inst.R}, + {Type: "m64", Action: inst.R}, + {Type: "xmm", Action: inst.R}, + {Type: "xmm", Action: inst.W}, + }, + EncodingType: inst.EncodingTypeEVEX, + ISA: []string{"AVX512VL", "GFNI"}, + Broadcast: true, + }, + { + Operands: []inst.Operand{ + {Type: "imm8", Action: inst.R}, + {Type: "m64", Action: inst.R}, + {Type: "xmm", Action: inst.R}, + {Type: "k", Action: inst.R}, + {Type: "xmm", Action: inst.W}, + }, + EncodingType: inst.EncodingTypeEVEX, + ISA: []string{"AVX512VL", "GFNI"}, + Broadcast: true, + }, + // EVEX.256.66.0F3A.W1 CE /r /ib VGF2P8AFFINEQB ymm1{k1}{z}, ymm2, ymm3/m256/m64bcst, imm8 + { + Operands: []inst.Operand{ + {Type: "imm8", Action: inst.R}, + {Type: "ymm", Action: inst.R}, + {Type: "ymm", Action: inst.R}, + {Type: "ymm", Action: inst.W}, + }, + EncodingType: inst.EncodingTypeEVEX, + ISA: []string{"AVX512VL", "GFNI"}, + }, + { + Operands: []inst.Operand{ + {Type: "imm8", Action: inst.R}, + {Type: "ymm", Action: inst.R}, + {Type: "ymm", Action: inst.R}, + {Type: "k", Action: inst.R}, + {Type: "ymm", Action: inst.W}, + }, + EncodingType: inst.EncodingTypeEVEX, + ISA: []string{"AVX512VL", "GFNI"}, + }, + { + Operands: []inst.Operand{ + {Type: "imm8", Action: inst.R}, + {Type: "m256", Action: inst.R}, + {Type: "ymm", Action: inst.R}, + {Type: "ymm", Action: inst.W}, + }, + EncodingType: inst.EncodingTypeEVEX, + ISA: []string{"AVX512VL", "GFNI"}, + }, + { + Operands: []inst.Operand{ + {Type: "imm8", Action: inst.R}, + {Type: "m256", Action: inst.R}, + {Type: "ymm", Action: inst.R}, + {Type: "k", Action: inst.R}, + {Type: "ymm", Action: inst.W}, + }, + EncodingType: inst.EncodingTypeEVEX, + ISA: []string{"AVX512VL", "GFNI"}, + }, + { + Operands: []inst.Operand{ + {Type: "imm8", Action: inst.R}, + {Type: "m64", Action: inst.R}, + {Type: "ymm", Action: inst.R}, + {Type: "ymm", Action: inst.W}, + }, + EncodingType: inst.EncodingTypeEVEX, + ISA: []string{"AVX512VL", "GFNI"}, + Broadcast: true, + }, + { + Operands: []inst.Operand{ + {Type: "imm8", Action: inst.R}, + {Type: "m64", Action: inst.R}, + {Type: "ymm", Action: inst.R}, + {Type: "k", Action: inst.R}, + {Type: "ymm", Action: inst.W}, + }, + EncodingType: inst.EncodingTypeEVEX, + ISA: []string{"AVX512VL", "GFNI"}, + Broadcast: true, + }, + // EVEX.512.66.0F3A.W1 CE /r /ib VGF2P8AFFINEQB zmm1{k1}{z}, zmm2, zmm3/m512/m64bcst, imm8 + { + Operands: []inst.Operand{ + {Type: "imm8", Action: inst.R}, + {Type: "zmm", Action: inst.R}, + {Type: "zmm", Action: inst.R}, + {Type: "zmm", Action: inst.W}, + }, + EncodingType: inst.EncodingTypeEVEX, + ISA: []string{"AVX512F", "GFNI"}, + }, + { + Operands: []inst.Operand{ + {Type: "imm8", Action: inst.R}, + {Type: "zmm", Action: inst.R}, + {Type: "zmm", Action: inst.R}, + {Type: "k", Action: inst.R}, + {Type: "zmm", Action: inst.W}, + }, + EncodingType: inst.EncodingTypeEVEX, + ISA: []string{"AVX512F", "GFNI"}, + }, + { + Operands: []inst.Operand{ + {Type: "imm8", Action: inst.R}, + {Type: "m512", Action: inst.R}, + {Type: "zmm", Action: inst.R}, + {Type: "zmm", Action: inst.W}, + }, + EncodingType: inst.EncodingTypeEVEX, + ISA: []string{"AVX512F", "GFNI"}, + }, + { + Operands: []inst.Operand{ + {Type: "imm8", Action: inst.R}, + {Type: "m512", Action: inst.R}, + {Type: "zmm", Action: inst.R}, + {Type: "k", Action: inst.R}, + {Type: "zmm", Action: inst.W}, + }, + EncodingType: inst.EncodingTypeEVEX, + ISA: []string{"AVX512F", "GFNI"}, + }, + { + Operands: []inst.Operand{ + {Type: "imm8", Action: inst.R}, + {Type: "m64", Action: inst.R}, + {Type: "zmm", Action: inst.R}, + {Type: "zmm", Action: inst.W}, + }, + EncodingType: inst.EncodingTypeEVEX, + ISA: []string{"AVX512F", "GFNI"}, + Broadcast: true, + }, + { + Operands: []inst.Operand{ + {Type: "imm8", Action: inst.R}, + {Type: "m64", Action: inst.R}, + {Type: "zmm", Action: inst.R}, + {Type: "k", Action: inst.R}, + {Type: "zmm", Action: inst.W}, + }, + EncodingType: inst.EncodingTypeEVEX, + ISA: []string{"AVX512F", "GFNI"}, + Broadcast: true, + }, +} + +// Reference: https://github.com/golang/go/blob/go1.19.3/src/cmd/internal/obj/x86/avx_optabs.go#L137-L146 +// +// var _yvandnpd = []ytab{ +// {zcase: Zvex_rm_v_r, zoffset: 2, args: argList{Yxm, Yxr, Yxr}}, +// {zcase: Zvex_rm_v_r, zoffset: 2, args: argList{Yym, Yyr, Yyr}}, +// {zcase: Zevex_rm_v_r, zoffset: 0, args: argList{YxmEvex, YxrEvex, YxrEvex}}, +// {zcase: Zevex_rm_v_k_r, zoffset: 3, args: argList{YxmEvex, YxrEvex, Yknot0, YxrEvex}}, +// {zcase: Zevex_rm_v_r, zoffset: 0, args: argList{YymEvex, YyrEvex, YyrEvex}}, +// {zcase: Zevex_rm_v_k_r, zoffset: 3, args: argList{YymEvex, YyrEvex, Yknot0, YyrEvex}}, +// {zcase: Zevex_rm_v_r, zoffset: 0, args: argList{Yzm, Yzr, Yzr}}, +// {zcase: Zevex_rm_v_k_r, zoffset: 3, args: argList{Yzm, Yzr, Yknot0, Yzr}}, +// } +// +var vgf2p8mulb = inst.Forms{ + // VEX.128.66.0F38.W0 CF /r VGF2P8MULB xmm1, xmm2, xmm3/m128 + { + Operands: []inst.Operand{ + {Type: "imm8", Action: inst.R}, + {Type: "xmm", Action: inst.R}, + {Type: "xmm", Action: inst.R}, + {Type: "xmm", Action: inst.W}, + }, + EncodingType: inst.EncodingTypeVEX, + ISA: []string{"AVX", "GFNI"}, + }, + { + Operands: []inst.Operand{ + {Type: "imm8", Action: inst.R}, + {Type: "m128", Action: inst.R}, + {Type: "xmm", Action: inst.R}, + {Type: "xmm", Action: inst.W}, + }, + EncodingType: inst.EncodingTypeVEX, + ISA: []string{"AVX", "GFNI"}, + }, + // VEX.256.66.0F38.W0 CF /r VGF2P8MULB ymm1, ymm2, ymm3/m256 + { + Operands: []inst.Operand{ + {Type: "imm8", Action: inst.R}, + {Type: "ymm", Action: inst.R}, + {Type: "ymm", Action: inst.R}, + {Type: "ymm", Action: inst.W}, + }, + EncodingType: inst.EncodingTypeVEX, + ISA: []string{"AVX", "GFNI"}, + }, + { + Operands: []inst.Operand{ + {Type: "imm8", Action: inst.R}, + {Type: "m256", Action: inst.R}, + {Type: "ymm", Action: inst.R}, + {Type: "ymm", Action: inst.W}, + }, + EncodingType: inst.EncodingTypeVEX, + ISA: []string{"AVX", "GFNI"}, + }, + // EVEX.128.66.0F38.W0 CF /r VGF2P8MULB xmm1{k1}{z}, xmm2, xmm3/m128 + { + Operands: []inst.Operand{ + {Type: "imm8", Action: inst.R}, + {Type: "xmm", Action: inst.R}, + {Type: "xmm", Action: inst.R}, + {Type: "xmm", Action: inst.W}, + }, + EncodingType: inst.EncodingTypeEVEX, + ISA: []string{"AVX512VL", "GFNI"}, + }, + { + Operands: []inst.Operand{ + {Type: "imm8", Action: inst.R}, + {Type: "xmm", Action: inst.R}, + {Type: "xmm", Action: inst.R}, + {Type: "k", Action: inst.R}, + {Type: "xmm", Action: inst.W}, + }, + EncodingType: inst.EncodingTypeEVEX, + ISA: []string{"AVX512VL", "GFNI"}, + }, + { + Operands: []inst.Operand{ + {Type: "imm8", Action: inst.R}, + {Type: "m128", Action: inst.R}, + {Type: "xmm", Action: inst.R}, + {Type: "xmm", Action: inst.W}, + }, + EncodingType: inst.EncodingTypeEVEX, + ISA: []string{"AVX512VL", "GFNI"}, + }, + { + Operands: []inst.Operand{ + {Type: "imm8", Action: inst.R}, + {Type: "m128", Action: inst.R}, + {Type: "xmm", Action: inst.R}, + {Type: "k", Action: inst.R}, + {Type: "xmm", Action: inst.W}, + }, + EncodingType: inst.EncodingTypeEVEX, + ISA: []string{"AVX512VL", "GFNI"}, + }, + { + Operands: []inst.Operand{ + {Type: "imm8", Action: inst.R}, + {Type: "m64", Action: inst.R}, + {Type: "xmm", Action: inst.R}, + {Type: "xmm", Action: inst.W}, + }, + EncodingType: inst.EncodingTypeEVEX, + ISA: []string{"AVX512VL", "GFNI"}, + Broadcast: true, + }, + { + Operands: []inst.Operand{ + {Type: "imm8", Action: inst.R}, + {Type: "m64", Action: inst.R}, + {Type: "xmm", Action: inst.R}, + {Type: "k", Action: inst.R}, + {Type: "xmm", Action: inst.W}, + }, + EncodingType: inst.EncodingTypeEVEX, + ISA: []string{"AVX512VL", "GFNI"}, + Broadcast: true, + }, + // EVEX.256.66.0F38.W0 CF /r VGF2P8MULB ymm1{k1}{z}, ymm2, ymm3/m256 + { + Operands: []inst.Operand{ + {Type: "imm8", Action: inst.R}, + {Type: "ymm", Action: inst.R}, + {Type: "ymm", Action: inst.R}, + {Type: "ymm", Action: inst.W}, + }, + EncodingType: inst.EncodingTypeEVEX, + ISA: []string{"AVX512VL", "GFNI"}, + }, + { + Operands: []inst.Operand{ + {Type: "imm8", Action: inst.R}, + {Type: "ymm", Action: inst.R}, + {Type: "ymm", Action: inst.R}, + {Type: "k", Action: inst.R}, + {Type: "ymm", Action: inst.W}, + }, + EncodingType: inst.EncodingTypeEVEX, + ISA: []string{"AVX512VL", "GFNI"}, + }, + { + Operands: []inst.Operand{ + {Type: "imm8", Action: inst.R}, + {Type: "m256", Action: inst.R}, + {Type: "ymm", Action: inst.R}, + {Type: "ymm", Action: inst.W}, + }, + EncodingType: inst.EncodingTypeEVEX, + ISA: []string{"AVX512VL", "GFNI"}, + }, + { + Operands: []inst.Operand{ + {Type: "imm8", Action: inst.R}, + {Type: "m256", Action: inst.R}, + {Type: "ymm", Action: inst.R}, + {Type: "k", Action: inst.R}, + {Type: "ymm", Action: inst.W}, + }, + EncodingType: inst.EncodingTypeEVEX, + ISA: []string{"AVX512VL", "GFNI"}, + }, + { + Operands: []inst.Operand{ + {Type: "imm8", Action: inst.R}, + {Type: "m64", Action: inst.R}, + {Type: "ymm", Action: inst.R}, + {Type: "ymm", Action: inst.W}, + }, + EncodingType: inst.EncodingTypeEVEX, + ISA: []string{"AVX512VL", "GFNI"}, + Broadcast: true, + }, + { + Operands: []inst.Operand{ + {Type: "imm8", Action: inst.R}, + {Type: "m64", Action: inst.R}, + {Type: "ymm", Action: inst.R}, + {Type: "k", Action: inst.R}, + {Type: "ymm", Action: inst.W}, + }, + EncodingType: inst.EncodingTypeEVEX, + ISA: []string{"AVX512VL", "GFNI"}, + Broadcast: true, + }, + // EVEX.512.66.0F38.W0 CF /r VGF2P8MULB zmm1{k1}{z}, zmm2, zmm3/m512 + { + Operands: []inst.Operand{ + {Type: "imm8", Action: inst.R}, + {Type: "zmm", Action: inst.R}, + {Type: "zmm", Action: inst.R}, + {Type: "zmm", Action: inst.W}, + }, + EncodingType: inst.EncodingTypeEVEX, + ISA: []string{"AVX512F", "GFNI"}, + }, + { + Operands: []inst.Operand{ + {Type: "imm8", Action: inst.R}, + {Type: "zmm", Action: inst.R}, + {Type: "zmm", Action: inst.R}, + {Type: "k", Action: inst.R}, + {Type: "zmm", Action: inst.W}, + }, + EncodingType: inst.EncodingTypeEVEX, + ISA: []string{"AVX512F", "GFNI"}, + }, + { + Operands: []inst.Operand{ + {Type: "imm8", Action: inst.R}, + {Type: "m512", Action: inst.R}, + {Type: "zmm", Action: inst.R}, + {Type: "zmm", Action: inst.W}, + }, + EncodingType: inst.EncodingTypeEVEX, + ISA: []string{"AVX512F", "GFNI"}, + }, + { + Operands: []inst.Operand{ + {Type: "imm8", Action: inst.R}, + {Type: "m512", Action: inst.R}, + {Type: "zmm", Action: inst.R}, + {Type: "k", Action: inst.R}, + {Type: "zmm", Action: inst.W}, + }, + EncodingType: inst.EncodingTypeEVEX, + ISA: []string{"AVX512F", "GFNI"}, + }, + { + Operands: []inst.Operand{ + {Type: "imm8", Action: inst.R}, + {Type: "m64", Action: inst.R}, + {Type: "zmm", Action: inst.R}, + {Type: "zmm", Action: inst.W}, + }, + EncodingType: inst.EncodingTypeEVEX, + ISA: []string{"AVX512F", "GFNI"}, + Broadcast: true, + }, + { + Operands: []inst.Operand{ + {Type: "imm8", Action: inst.R}, + {Type: "m64", Action: inst.R}, + {Type: "zmm", Action: inst.R}, + {Type: "k", Action: inst.R}, + {Type: "zmm", Action: inst.W}, }, + EncodingType: inst.EncodingTypeEVEX, + ISA: []string{"AVX512F", "GFNI"}, + Broadcast: true, }, } From f11765d2415494a3a95babdde224b211d9971d0e Mon Sep 17 00:00:00 2001 From: Michael McLoughlin Date: Sun, 27 Nov 2022 15:00:38 -0800 Subject: [PATCH 06/10] process AVX-512 forms after extras --- internal/load/load.go | 57 +++++++++++++++++++++++++------------------ 1 file changed, 33 insertions(+), 24 deletions(-) diff --git a/internal/load/load.go b/internal/load/load.go index 3c3aa31b..1274106b 100644 --- a/internal/load/load.go +++ b/internal/load/load.go @@ -80,8 +80,7 @@ func (l *Loader) Load() ([]inst.Instruction, error) { Summary: i.Summary, } } - forms := l.forms(opcode, f) - im[opcode].Forms = append(im[opcode].Forms, forms...) + im[opcode].Forms = append(im[opcode].Forms, l.form(opcode, f)) } } } @@ -91,6 +90,11 @@ func (l *Loader) Load() ([]inst.Instruction, error) { im[e.Opcode] = e } + // Generate additional AVX-512 forms. + for _, i := range im { + i.Forms = avx512forms(i.Opcode, i.Forms) + } + // Merge aliased forms. This is primarily for MOVQ (issue #50). for _, a := range aliases { if existing, found := im[a.From]; found { @@ -309,7 +313,7 @@ func (l Loader) gonames(f opcodesxml.Form) []string { return []string{n} } -func (l Loader) forms(opcode string, f opcodesxml.Form) []inst.Form { +func (l Loader) form(opcode string, f opcodesxml.Form) inst.Form { // Map operands to avo format and ensure correct order. ops := operands(f.Operands) @@ -366,15 +370,39 @@ func (l Loader) forms(opcode string, f opcodesxml.Form) []inst.Form { } sort.Strings(isas) - // Initialize form. - form := inst.Form{ + // Build form. + return inst.Form{ ISA: isas, Operands: ops, ImplicitOperands: implicits, EncodingType: enctype(f), CancellingInputs: f.CancellingInputs, } +} +// operands maps Opcodes XML operands to avo format. Returned in Intel order. +func operands(ops []opcodesxml.Operand) []inst.Operand { + n := len(ops) + r := make([]inst.Operand, n) + for i, op := range ops { + r[i] = operand(op) + } + return r +} + +// operand maps an Opcodes XML operand to avo format. +func operand(op opcodesxml.Operand) inst.Operand { + return inst.Operand{ + Type: op.Type, + Action: inst.ActionFromReadWrite(op.Input, op.Output), + } +} + +// avx512forms processes AVX-512 operands and expands them into additional +// instruction forms as expected by the Go assembler. +// +// See: https://go.dev/wiki/AVX512 +func avx512forms(opcode string, forms []inst.Form) []inst.Form { // Apply modification stages to produce final list of forms. stages := []func(string, inst.Form) []inst.Form{ avx512rounding, @@ -384,7 +412,6 @@ func (l Loader) forms(opcode string, f opcodesxml.Form) []inst.Form { avx512zeroing, } - forms := []inst.Form{form} for _, stage := range stages { var next []inst.Form for _, f := range forms { @@ -396,24 +423,6 @@ func (l Loader) forms(opcode string, f opcodesxml.Form) []inst.Form { return forms } -// operands maps Opcodes XML operands to avo format. Returned in Intel order. -func operands(ops []opcodesxml.Operand) []inst.Operand { - n := len(ops) - r := make([]inst.Operand, n) - for i, op := range ops { - r[i] = operand(op) - } - return r -} - -// operand maps an Opcodes XML operand to avo format. -func operand(op opcodesxml.Operand) inst.Operand { - return inst.Operand{ - Type: op.Type, - Action: inst.ActionFromReadWrite(op.Input, op.Output), - } -} - // avx512rounding handles AVX-512 embedded rounding. Opcodes database represents // these as {er} operands, whereas Go uses instruction suffixes. Remove the // operand if present and set the corresponding flag. From 3459ffeaec00882929601185fe13ce2e7f563b7b Mon Sep 17 00:00:00 2001 From: Michael McLoughlin Date: Sun, 27 Nov 2022 15:06:40 -0800 Subject: [PATCH 07/10] fix fmt --- internal/opcodesextra/gfni.go | 2 -- 1 file changed, 2 deletions(-) diff --git a/internal/opcodesextra/gfni.go b/internal/opcodesextra/gfni.go index 2f54eb4f..d192ad32 100644 --- a/internal/opcodesextra/gfni.go +++ b/internal/opcodesextra/gfni.go @@ -57,7 +57,6 @@ var gfni = []*inst.Instruction{ // {zcase: Zevex_i_rm_v_r, zoffset: 0, args: argList{Yu8, Yzm, Yzr, Yzr}}, // {zcase: Zevex_i_rm_v_k_r, zoffset: 3, args: argList{Yu8, Yzm, Yzr, Yknot0, Yzr}}, // } -// var vgf2p8affineqb = inst.Forms{ // VEX.128.66.0F3A.W1 CE /r /ib VGF2P8AFFINEQB xmm1, xmm2, xmm3/m128, imm8 { @@ -313,7 +312,6 @@ var vgf2p8affineqb = inst.Forms{ // {zcase: Zevex_rm_v_r, zoffset: 0, args: argList{Yzm, Yzr, Yzr}}, // {zcase: Zevex_rm_v_k_r, zoffset: 3, args: argList{Yzm, Yzr, Yknot0, Yzr}}, // } -// var vgf2p8mulb = inst.Forms{ // VEX.128.66.0F38.W0 CF /r VGF2P8MULB xmm1, xmm2, xmm3/m128 { From 70ce15f6c47d83b9782bbef8a2ed2a76b706708f Mon Sep 17 00:00:00 2001 From: Michael McLoughlin Date: Sun, 27 Nov 2022 15:36:16 -0800 Subject: [PATCH 08/10] refine gfni forms lists --- build/zinstructions.go | 202 ++++++-- build/zinstructions_test.go | 8 +- internal/inst/ztable.go | 260 +++++++--- internal/opcodesextra/gfni.go | 319 +----------- x86/zctors.go | 92 +++- x86/zctors_test.go | 104 ++-- x86/zoptab.go | 890 +++++++++++++++++----------------- 7 files changed, 976 insertions(+), 899 deletions(-) diff --git a/build/zinstructions.go b/build/zinstructions.go index 191842e0..1251500b 100644 --- a/build/zinstructions.go +++ b/build/zinstructions.go @@ -49999,12 +49999,9 @@ func VGETMANTSS_Z(i, mx, x, k, x1 operand.Op) { ctx.VGETMANTSS_Z(i, mx, x, k, x1 // VGF2P8AFFINEINVQB imm8 ymm ymm ymm // VGF2P8AFFINEINVQB imm8 m512 zmm k zmm // VGF2P8AFFINEINVQB imm8 m512 zmm zmm -// VGF2P8AFFINEINVQB imm8 zmm zmm k zmm // VGF2P8AFFINEINVQB imm8 zmm zmm zmm // VGF2P8AFFINEINVQB imm8 m128 xmm k xmm // VGF2P8AFFINEINVQB imm8 m256 ymm k ymm -// VGF2P8AFFINEINVQB imm8 xmm xmm k xmm -// VGF2P8AFFINEINVQB imm8 ymm ymm k ymm // // Construct and append a VGF2P8AFFINEINVQB instruction to the active function. func (c *Context) VGF2P8AFFINEINVQB(ops ...operand.Op) { @@ -50021,12 +50018,9 @@ func (c *Context) VGF2P8AFFINEINVQB(ops ...operand.Op) { // VGF2P8AFFINEINVQB imm8 ymm ymm ymm // VGF2P8AFFINEINVQB imm8 m512 zmm k zmm // VGF2P8AFFINEINVQB imm8 m512 zmm zmm -// VGF2P8AFFINEINVQB imm8 zmm zmm k zmm // VGF2P8AFFINEINVQB imm8 zmm zmm zmm // VGF2P8AFFINEINVQB imm8 m128 xmm k xmm // VGF2P8AFFINEINVQB imm8 m256 ymm k ymm -// VGF2P8AFFINEINVQB imm8 xmm xmm k xmm -// VGF2P8AFFINEINVQB imm8 ymm ymm k ymm // // Construct and append a VGF2P8AFFINEINVQB instruction to the active function. // Operates on the global context. @@ -50063,6 +50057,58 @@ func (c *Context) VGF2P8AFFINEINVQB_BCST(ops ...operand.Op) { // Operates on the global context. func VGF2P8AFFINEINVQB_BCST(ops ...operand.Op) { ctx.VGF2P8AFFINEINVQB_BCST(ops...) } +// VGF2P8AFFINEINVQB_BCST_Z: Galois Field Affine Transformation Inverse (Broadcast, Zeroing Masking). +// +// Forms: +// +// VGF2P8AFFINEINVQB.BCST.Z imm8 m64 zmm k zmm +// VGF2P8AFFINEINVQB.BCST.Z imm8 m64 xmm k xmm +// VGF2P8AFFINEINVQB.BCST.Z imm8 m64 ymm k ymm +// +// Construct and append a VGF2P8AFFINEINVQB.BCST.Z instruction to the active function. +func (c *Context) VGF2P8AFFINEINVQB_BCST_Z(i, m, xyz, k, xyz1 operand.Op) { + c.addinstruction(x86.VGF2P8AFFINEINVQB_BCST_Z(i, m, xyz, k, xyz1)) +} + +// VGF2P8AFFINEINVQB_BCST_Z: Galois Field Affine Transformation Inverse (Broadcast, Zeroing Masking). +// +// Forms: +// +// VGF2P8AFFINEINVQB.BCST.Z imm8 m64 zmm k zmm +// VGF2P8AFFINEINVQB.BCST.Z imm8 m64 xmm k xmm +// VGF2P8AFFINEINVQB.BCST.Z imm8 m64 ymm k ymm +// +// Construct and append a VGF2P8AFFINEINVQB.BCST.Z instruction to the active function. +// Operates on the global context. +func VGF2P8AFFINEINVQB_BCST_Z(i, m, xyz, k, xyz1 operand.Op) { + ctx.VGF2P8AFFINEINVQB_BCST_Z(i, m, xyz, k, xyz1) +} + +// VGF2P8AFFINEINVQB_Z: Galois Field Affine Transformation Inverse (Zeroing Masking). +// +// Forms: +// +// VGF2P8AFFINEINVQB.Z imm8 m512 zmm k zmm +// VGF2P8AFFINEINVQB.Z imm8 m128 xmm k xmm +// VGF2P8AFFINEINVQB.Z imm8 m256 ymm k ymm +// +// Construct and append a VGF2P8AFFINEINVQB.Z instruction to the active function. +func (c *Context) VGF2P8AFFINEINVQB_Z(i, m, xyz, k, xyz1 operand.Op) { + c.addinstruction(x86.VGF2P8AFFINEINVQB_Z(i, m, xyz, k, xyz1)) +} + +// VGF2P8AFFINEINVQB_Z: Galois Field Affine Transformation Inverse (Zeroing Masking). +// +// Forms: +// +// VGF2P8AFFINEINVQB.Z imm8 m512 zmm k zmm +// VGF2P8AFFINEINVQB.Z imm8 m128 xmm k xmm +// VGF2P8AFFINEINVQB.Z imm8 m256 ymm k ymm +// +// Construct and append a VGF2P8AFFINEINVQB.Z instruction to the active function. +// Operates on the global context. +func VGF2P8AFFINEINVQB_Z(i, m, xyz, k, xyz1 operand.Op) { ctx.VGF2P8AFFINEINVQB_Z(i, m, xyz, k, xyz1) } + // VGF2P8AFFINEQB: Galois Field Affine Transformation. // // Forms: @@ -50137,22 +50183,80 @@ func (c *Context) VGF2P8AFFINEQB_BCST(ops ...operand.Op) { // Operates on the global context. func VGF2P8AFFINEQB_BCST(ops ...operand.Op) { ctx.VGF2P8AFFINEQB_BCST(ops...) } +// VGF2P8AFFINEQB_BCST_Z: Galois Field Affine Transformation (Broadcast, Zeroing Masking). +// +// Forms: +// +// VGF2P8AFFINEQB.BCST.Z imm8 m64 zmm k zmm +// VGF2P8AFFINEQB.BCST.Z imm8 m64 xmm k xmm +// VGF2P8AFFINEQB.BCST.Z imm8 m64 ymm k ymm +// +// Construct and append a VGF2P8AFFINEQB.BCST.Z instruction to the active function. +func (c *Context) VGF2P8AFFINEQB_BCST_Z(i, m, xyz, k, xyz1 operand.Op) { + c.addinstruction(x86.VGF2P8AFFINEQB_BCST_Z(i, m, xyz, k, xyz1)) +} + +// VGF2P8AFFINEQB_BCST_Z: Galois Field Affine Transformation (Broadcast, Zeroing Masking). +// +// Forms: +// +// VGF2P8AFFINEQB.BCST.Z imm8 m64 zmm k zmm +// VGF2P8AFFINEQB.BCST.Z imm8 m64 xmm k xmm +// VGF2P8AFFINEQB.BCST.Z imm8 m64 ymm k ymm +// +// Construct and append a VGF2P8AFFINEQB.BCST.Z instruction to the active function. +// Operates on the global context. +func VGF2P8AFFINEQB_BCST_Z(i, m, xyz, k, xyz1 operand.Op) { + ctx.VGF2P8AFFINEQB_BCST_Z(i, m, xyz, k, xyz1) +} + +// VGF2P8AFFINEQB_Z: Galois Field Affine Transformation (Zeroing Masking). +// +// Forms: +// +// VGF2P8AFFINEQB.Z imm8 m512 zmm k zmm +// VGF2P8AFFINEQB.Z imm8 zmm zmm k zmm +// VGF2P8AFFINEQB.Z imm8 m128 xmm k xmm +// VGF2P8AFFINEQB.Z imm8 m256 ymm k ymm +// VGF2P8AFFINEQB.Z imm8 xmm xmm k xmm +// VGF2P8AFFINEQB.Z imm8 ymm ymm k ymm +// +// Construct and append a VGF2P8AFFINEQB.Z instruction to the active function. +func (c *Context) VGF2P8AFFINEQB_Z(i, mxyz, xyz, k, xyz1 operand.Op) { + c.addinstruction(x86.VGF2P8AFFINEQB_Z(i, mxyz, xyz, k, xyz1)) +} + +// VGF2P8AFFINEQB_Z: Galois Field Affine Transformation (Zeroing Masking). +// +// Forms: +// +// VGF2P8AFFINEQB.Z imm8 m512 zmm k zmm +// VGF2P8AFFINEQB.Z imm8 zmm zmm k zmm +// VGF2P8AFFINEQB.Z imm8 m128 xmm k xmm +// VGF2P8AFFINEQB.Z imm8 m256 ymm k ymm +// VGF2P8AFFINEQB.Z imm8 xmm xmm k xmm +// VGF2P8AFFINEQB.Z imm8 ymm ymm k ymm +// +// Construct and append a VGF2P8AFFINEQB.Z instruction to the active function. +// Operates on the global context. +func VGF2P8AFFINEQB_Z(i, mxyz, xyz, k, xyz1 operand.Op) { ctx.VGF2P8AFFINEQB_Z(i, mxyz, xyz, k, xyz1) } + // VGF2P8MULB: Galois Field Multiply Bytes. // // Forms: // -// VGF2P8MULB imm8 m128 xmm xmm -// VGF2P8MULB imm8 m256 ymm ymm -// VGF2P8MULB imm8 xmm xmm xmm -// VGF2P8MULB imm8 ymm ymm ymm -// VGF2P8MULB imm8 m512 zmm k zmm -// VGF2P8MULB imm8 m512 zmm zmm -// VGF2P8MULB imm8 zmm zmm k zmm -// VGF2P8MULB imm8 zmm zmm zmm -// VGF2P8MULB imm8 m128 xmm k xmm -// VGF2P8MULB imm8 m256 ymm k ymm -// VGF2P8MULB imm8 xmm xmm k xmm -// VGF2P8MULB imm8 ymm ymm k ymm +// VGF2P8MULB m128 xmm xmm +// VGF2P8MULB m256 ymm ymm +// VGF2P8MULB xmm xmm xmm +// VGF2P8MULB ymm ymm ymm +// VGF2P8MULB m512 zmm k zmm +// VGF2P8MULB m512 zmm zmm +// VGF2P8MULB zmm zmm k zmm +// VGF2P8MULB zmm zmm zmm +// VGF2P8MULB m128 xmm k xmm +// VGF2P8MULB m256 ymm k ymm +// VGF2P8MULB xmm xmm k xmm +// VGF2P8MULB ymm ymm k ymm // // Construct and append a VGF2P8MULB instruction to the active function. func (c *Context) VGF2P8MULB(ops ...operand.Op) { @@ -50163,53 +50267,53 @@ func (c *Context) VGF2P8MULB(ops ...operand.Op) { // // Forms: // -// VGF2P8MULB imm8 m128 xmm xmm -// VGF2P8MULB imm8 m256 ymm ymm -// VGF2P8MULB imm8 xmm xmm xmm -// VGF2P8MULB imm8 ymm ymm ymm -// VGF2P8MULB imm8 m512 zmm k zmm -// VGF2P8MULB imm8 m512 zmm zmm -// VGF2P8MULB imm8 zmm zmm k zmm -// VGF2P8MULB imm8 zmm zmm zmm -// VGF2P8MULB imm8 m128 xmm k xmm -// VGF2P8MULB imm8 m256 ymm k ymm -// VGF2P8MULB imm8 xmm xmm k xmm -// VGF2P8MULB imm8 ymm ymm k ymm +// VGF2P8MULB m128 xmm xmm +// VGF2P8MULB m256 ymm ymm +// VGF2P8MULB xmm xmm xmm +// VGF2P8MULB ymm ymm ymm +// VGF2P8MULB m512 zmm k zmm +// VGF2P8MULB m512 zmm zmm +// VGF2P8MULB zmm zmm k zmm +// VGF2P8MULB zmm zmm zmm +// VGF2P8MULB m128 xmm k xmm +// VGF2P8MULB m256 ymm k ymm +// VGF2P8MULB xmm xmm k xmm +// VGF2P8MULB ymm ymm k ymm // // Construct and append a VGF2P8MULB instruction to the active function. // Operates on the global context. func VGF2P8MULB(ops ...operand.Op) { ctx.VGF2P8MULB(ops...) } -// VGF2P8MULB_BCST: Galois Field Multiply Bytes (Broadcast). +// VGF2P8MULB_Z: Galois Field Multiply Bytes (Zeroing Masking). // // Forms: // -// VGF2P8MULB.BCST imm8 m64 zmm k zmm -// VGF2P8MULB.BCST imm8 m64 zmm zmm -// VGF2P8MULB.BCST imm8 m64 xmm k xmm -// VGF2P8MULB.BCST imm8 m64 xmm xmm -// VGF2P8MULB.BCST imm8 m64 ymm k ymm -// VGF2P8MULB.BCST imm8 m64 ymm ymm +// VGF2P8MULB.Z m512 zmm k zmm +// VGF2P8MULB.Z zmm zmm k zmm +// VGF2P8MULB.Z m128 xmm k xmm +// VGF2P8MULB.Z m256 ymm k ymm +// VGF2P8MULB.Z xmm xmm k xmm +// VGF2P8MULB.Z ymm ymm k ymm // -// Construct and append a VGF2P8MULB.BCST instruction to the active function. -func (c *Context) VGF2P8MULB_BCST(ops ...operand.Op) { - c.addinstruction(x86.VGF2P8MULB_BCST(ops...)) +// Construct and append a VGF2P8MULB.Z instruction to the active function. +func (c *Context) VGF2P8MULB_Z(mxyz, xyz, k, xyz1 operand.Op) { + c.addinstruction(x86.VGF2P8MULB_Z(mxyz, xyz, k, xyz1)) } -// VGF2P8MULB_BCST: Galois Field Multiply Bytes (Broadcast). +// VGF2P8MULB_Z: Galois Field Multiply Bytes (Zeroing Masking). // // Forms: // -// VGF2P8MULB.BCST imm8 m64 zmm k zmm -// VGF2P8MULB.BCST imm8 m64 zmm zmm -// VGF2P8MULB.BCST imm8 m64 xmm k xmm -// VGF2P8MULB.BCST imm8 m64 xmm xmm -// VGF2P8MULB.BCST imm8 m64 ymm k ymm -// VGF2P8MULB.BCST imm8 m64 ymm ymm +// VGF2P8MULB.Z m512 zmm k zmm +// VGF2P8MULB.Z zmm zmm k zmm +// VGF2P8MULB.Z m128 xmm k xmm +// VGF2P8MULB.Z m256 ymm k ymm +// VGF2P8MULB.Z xmm xmm k xmm +// VGF2P8MULB.Z ymm ymm k ymm // -// Construct and append a VGF2P8MULB.BCST instruction to the active function. +// Construct and append a VGF2P8MULB.Z instruction to the active function. // Operates on the global context. -func VGF2P8MULB_BCST(ops ...operand.Op) { ctx.VGF2P8MULB_BCST(ops...) } +func VGF2P8MULB_Z(mxyz, xyz, k, xyz1 operand.Op) { ctx.VGF2P8MULB_Z(mxyz, xyz, k, xyz1) } // VHADDPD: Packed Double-FP Horizontal Add. // diff --git a/build/zinstructions_test.go b/build/zinstructions_test.go index ea889967..db18d2a9 100644 --- a/build/zinstructions_test.go +++ b/build/zinstructions_test.go @@ -2087,10 +2087,14 @@ func TestContextInstructions(t *testing.T) { ctx.VGETMANTSS_Z(opimm8, opm32, opxmm, opk, opxmm) ctx.VGF2P8AFFINEINVQB(opimm8, opm128, opxmm, opxmm) ctx.VGF2P8AFFINEINVQB_BCST(opimm8, opm64, opzmm, opk, opzmm) + ctx.VGF2P8AFFINEINVQB_BCST_Z(opimm8, opm64, opzmm, opk, opzmm) + ctx.VGF2P8AFFINEINVQB_Z(opimm8, opm512, opzmm, opk, opzmm) ctx.VGF2P8AFFINEQB(opimm8, opm128, opxmm, opxmm) ctx.VGF2P8AFFINEQB_BCST(opimm8, opm64, opzmm, opk, opzmm) - ctx.VGF2P8MULB(opimm8, opm128, opxmm, opxmm) - ctx.VGF2P8MULB_BCST(opimm8, opm64, opzmm, opk, opzmm) + ctx.VGF2P8AFFINEQB_BCST_Z(opimm8, opm64, opzmm, opk, opzmm) + ctx.VGF2P8AFFINEQB_Z(opimm8, opm512, opzmm, opk, opzmm) + ctx.VGF2P8MULB(opm128, opxmm, opxmm) + ctx.VGF2P8MULB_Z(opm512, opzmm, opk, opzmm) ctx.VHADDPD(opm128, opxmm, opxmm) ctx.VHADDPS(opm128, opxmm, opxmm) ctx.VHSUBPD(opm128, opxmm, opxmm) diff --git a/internal/inst/ztable.go b/internal/inst/ztable.go index 1e75dd8e..86333d80 100644 --- a/internal/inst/ztable.go +++ b/internal/inst/ztable.go @@ -50616,6 +50616,17 @@ var Instructions = []Instruction{ }, EncodingType: 0x3, }, + { + ISA: []string{"AVX512F", "GFNI"}, + Operands: []Operand{ + {Type: "imm8", Action: 0x1}, + {Type: "m512", Action: 0x1}, + {Type: "zmm", Action: 0x1}, + {Type: "k", Action: 0x1}, + {Type: "zmm", Action: 0x3}, + }, + EncodingType: 0x4, + }, { ISA: []string{"AVX512F", "GFNI"}, Operands: []Operand{ @@ -50626,6 +50637,7 @@ var Instructions = []Instruction{ {Type: "zmm", Action: 0x2}, }, EncodingType: 0x4, + Zeroing: true, }, { ISA: []string{"AVX512F", "GFNI"}, @@ -50644,7 +50656,7 @@ var Instructions = []Instruction{ {Type: "m64", Action: 0x1}, {Type: "zmm", Action: 0x1}, {Type: "k", Action: 0x1}, - {Type: "zmm", Action: 0x2}, + {Type: "zmm", Action: 0x3}, }, EncodingType: 0x4, Broadcast: true, @@ -50655,21 +50667,23 @@ var Instructions = []Instruction{ {Type: "imm8", Action: 0x1}, {Type: "m64", Action: 0x1}, {Type: "zmm", Action: 0x1}, + {Type: "k", Action: 0x1}, {Type: "zmm", Action: 0x2}, }, EncodingType: 0x4, + Zeroing: true, Broadcast: true, }, { ISA: []string{"AVX512F", "GFNI"}, Operands: []Operand{ {Type: "imm8", Action: 0x1}, + {Type: "m64", Action: 0x1}, {Type: "zmm", Action: 0x1}, - {Type: "zmm", Action: 0x1}, - {Type: "k", Action: 0x1}, {Type: "zmm", Action: 0x2}, }, EncodingType: 0x4, + Broadcast: true, }, { ISA: []string{"AVX512F", "GFNI"}, @@ -50681,6 +50695,17 @@ var Instructions = []Instruction{ }, EncodingType: 0x4, }, + { + ISA: []string{"AVX512VL", "GFNI"}, + Operands: []Operand{ + {Type: "imm8", Action: 0x1}, + {Type: "m128", Action: 0x1}, + {Type: "xmm", Action: 0x1}, + {Type: "k", Action: 0x1}, + {Type: "xmm", Action: 0x3}, + }, + EncodingType: 0x4, + }, { ISA: []string{"AVX512VL", "GFNI"}, Operands: []Operand{ @@ -50691,6 +50716,18 @@ var Instructions = []Instruction{ {Type: "xmm", Action: 0x2}, }, EncodingType: 0x4, + Zeroing: true, + }, + { + ISA: []string{"AVX512VL", "GFNI"}, + Operands: []Operand{ + {Type: "imm8", Action: 0x1}, + {Type: "m256", Action: 0x1}, + {Type: "ymm", Action: 0x1}, + {Type: "k", Action: 0x1}, + {Type: "ymm", Action: 0x3}, + }, + EncodingType: 0x4, }, { ISA: []string{"AVX512VL", "GFNI"}, @@ -50702,6 +50739,7 @@ var Instructions = []Instruction{ {Type: "ymm", Action: 0x2}, }, EncodingType: 0x4, + Zeroing: true, }, { ISA: []string{"AVX512VL", "GFNI"}, @@ -50710,7 +50748,7 @@ var Instructions = []Instruction{ {Type: "m64", Action: 0x1}, {Type: "xmm", Action: 0x1}, {Type: "k", Action: 0x1}, - {Type: "xmm", Action: 0x2}, + {Type: "xmm", Action: 0x3}, }, EncodingType: 0x4, Broadcast: true, @@ -50721,9 +50759,11 @@ var Instructions = []Instruction{ {Type: "imm8", Action: 0x1}, {Type: "m64", Action: 0x1}, {Type: "xmm", Action: 0x1}, + {Type: "k", Action: 0x1}, {Type: "xmm", Action: 0x2}, }, EncodingType: 0x4, + Zeroing: true, Broadcast: true, }, { @@ -50731,9 +50771,8 @@ var Instructions = []Instruction{ Operands: []Operand{ {Type: "imm8", Action: 0x1}, {Type: "m64", Action: 0x1}, - {Type: "ymm", Action: 0x1}, - {Type: "k", Action: 0x1}, - {Type: "ymm", Action: 0x2}, + {Type: "xmm", Action: 0x1}, + {Type: "xmm", Action: 0x2}, }, EncodingType: 0x4, Broadcast: true, @@ -50744,7 +50783,8 @@ var Instructions = []Instruction{ {Type: "imm8", Action: 0x1}, {Type: "m64", Action: 0x1}, {Type: "ymm", Action: 0x1}, - {Type: "ymm", Action: 0x2}, + {Type: "k", Action: 0x1}, + {Type: "ymm", Action: 0x3}, }, EncodingType: 0x4, Broadcast: true, @@ -50753,23 +50793,25 @@ var Instructions = []Instruction{ ISA: []string{"AVX512VL", "GFNI"}, Operands: []Operand{ {Type: "imm8", Action: 0x1}, - {Type: "xmm", Action: 0x1}, - {Type: "xmm", Action: 0x1}, + {Type: "m64", Action: 0x1}, + {Type: "ymm", Action: 0x1}, {Type: "k", Action: 0x1}, - {Type: "xmm", Action: 0x2}, + {Type: "ymm", Action: 0x2}, }, EncodingType: 0x4, + Zeroing: true, + Broadcast: true, }, { ISA: []string{"AVX512VL", "GFNI"}, Operands: []Operand{ {Type: "imm8", Action: 0x1}, + {Type: "m64", Action: 0x1}, {Type: "ymm", Action: 0x1}, - {Type: "ymm", Action: 0x1}, - {Type: "k", Action: 0x1}, {Type: "ymm", Action: 0x2}, }, EncodingType: 0x4, + Broadcast: true, }, }, }, @@ -50817,6 +50859,17 @@ var Instructions = []Instruction{ }, EncodingType: 0x3, }, + { + ISA: []string{"AVX512F", "GFNI"}, + Operands: []Operand{ + {Type: "imm8", Action: 0x1}, + {Type: "m512", Action: 0x1}, + {Type: "zmm", Action: 0x1}, + {Type: "k", Action: 0x1}, + {Type: "zmm", Action: 0x3}, + }, + EncodingType: 0x4, + }, { ISA: []string{"AVX512F", "GFNI"}, Operands: []Operand{ @@ -50827,6 +50880,7 @@ var Instructions = []Instruction{ {Type: "zmm", Action: 0x2}, }, EncodingType: 0x4, + Zeroing: true, }, { ISA: []string{"AVX512F", "GFNI"}, @@ -50838,6 +50892,18 @@ var Instructions = []Instruction{ }, EncodingType: 0x4, }, + { + ISA: []string{"AVX512F", "GFNI"}, + Operands: []Operand{ + {Type: "imm8", Action: 0x1}, + {Type: "m64", Action: 0x1}, + {Type: "zmm", Action: 0x1}, + {Type: "k", Action: 0x1}, + {Type: "zmm", Action: 0x3}, + }, + EncodingType: 0x4, + Broadcast: true, + }, { ISA: []string{"AVX512F", "GFNI"}, Operands: []Operand{ @@ -50848,6 +50914,7 @@ var Instructions = []Instruction{ {Type: "zmm", Action: 0x2}, }, EncodingType: 0x4, + Zeroing: true, Broadcast: true, }, { @@ -50861,6 +50928,17 @@ var Instructions = []Instruction{ EncodingType: 0x4, Broadcast: true, }, + { + ISA: []string{"AVX512F", "GFNI"}, + Operands: []Operand{ + {Type: "imm8", Action: 0x1}, + {Type: "zmm", Action: 0x1}, + {Type: "zmm", Action: 0x1}, + {Type: "k", Action: 0x1}, + {Type: "zmm", Action: 0x3}, + }, + EncodingType: 0x4, + }, { ISA: []string{"AVX512F", "GFNI"}, Operands: []Operand{ @@ -50871,6 +50949,7 @@ var Instructions = []Instruction{ {Type: "zmm", Action: 0x2}, }, EncodingType: 0x4, + Zeroing: true, }, { ISA: []string{"AVX512F", "GFNI"}, @@ -50882,6 +50961,17 @@ var Instructions = []Instruction{ }, EncodingType: 0x4, }, + { + ISA: []string{"AVX512VL", "GFNI"}, + Operands: []Operand{ + {Type: "imm8", Action: 0x1}, + {Type: "m128", Action: 0x1}, + {Type: "xmm", Action: 0x1}, + {Type: "k", Action: 0x1}, + {Type: "xmm", Action: 0x3}, + }, + EncodingType: 0x4, + }, { ISA: []string{"AVX512VL", "GFNI"}, Operands: []Operand{ @@ -50892,6 +50982,18 @@ var Instructions = []Instruction{ {Type: "xmm", Action: 0x2}, }, EncodingType: 0x4, + Zeroing: true, + }, + { + ISA: []string{"AVX512VL", "GFNI"}, + Operands: []Operand{ + {Type: "imm8", Action: 0x1}, + {Type: "m256", Action: 0x1}, + {Type: "ymm", Action: 0x1}, + {Type: "k", Action: 0x1}, + {Type: "ymm", Action: 0x3}, + }, + EncodingType: 0x4, }, { ISA: []string{"AVX512VL", "GFNI"}, @@ -50903,6 +51005,19 @@ var Instructions = []Instruction{ {Type: "ymm", Action: 0x2}, }, EncodingType: 0x4, + Zeroing: true, + }, + { + ISA: []string{"AVX512VL", "GFNI"}, + Operands: []Operand{ + {Type: "imm8", Action: 0x1}, + {Type: "m64", Action: 0x1}, + {Type: "xmm", Action: 0x1}, + {Type: "k", Action: 0x1}, + {Type: "xmm", Action: 0x3}, + }, + EncodingType: 0x4, + Broadcast: true, }, { ISA: []string{"AVX512VL", "GFNI"}, @@ -50914,6 +51029,7 @@ var Instructions = []Instruction{ {Type: "xmm", Action: 0x2}, }, EncodingType: 0x4, + Zeroing: true, Broadcast: true, }, { @@ -50927,6 +51043,18 @@ var Instructions = []Instruction{ EncodingType: 0x4, Broadcast: true, }, + { + ISA: []string{"AVX512VL", "GFNI"}, + Operands: []Operand{ + {Type: "imm8", Action: 0x1}, + {Type: "m64", Action: 0x1}, + {Type: "ymm", Action: 0x1}, + {Type: "k", Action: 0x1}, + {Type: "ymm", Action: 0x3}, + }, + EncodingType: 0x4, + Broadcast: true, + }, { ISA: []string{"AVX512VL", "GFNI"}, Operands: []Operand{ @@ -50937,6 +51065,7 @@ var Instructions = []Instruction{ {Type: "ymm", Action: 0x2}, }, EncodingType: 0x4, + Zeroing: true, Broadcast: true, }, { @@ -50950,6 +51079,17 @@ var Instructions = []Instruction{ EncodingType: 0x4, Broadcast: true, }, + { + ISA: []string{"AVX512VL", "GFNI"}, + Operands: []Operand{ + {Type: "imm8", Action: 0x1}, + {Type: "xmm", Action: 0x1}, + {Type: "xmm", Action: 0x1}, + {Type: "k", Action: 0x1}, + {Type: "xmm", Action: 0x3}, + }, + EncodingType: 0x4, + }, { ISA: []string{"AVX512VL", "GFNI"}, Operands: []Operand{ @@ -50960,6 +51100,18 @@ var Instructions = []Instruction{ {Type: "xmm", Action: 0x2}, }, EncodingType: 0x4, + Zeroing: true, + }, + { + ISA: []string{"AVX512VL", "GFNI"}, + Operands: []Operand{ + {Type: "imm8", Action: 0x1}, + {Type: "ymm", Action: 0x1}, + {Type: "ymm", Action: 0x1}, + {Type: "k", Action: 0x1}, + {Type: "ymm", Action: 0x3}, + }, + EncodingType: 0x4, }, { ISA: []string{"AVX512VL", "GFNI"}, @@ -50971,6 +51123,7 @@ var Instructions = []Instruction{ {Type: "ymm", Action: 0x2}, }, EncodingType: 0x4, + Zeroing: true, }, }, }, @@ -50981,7 +51134,6 @@ var Instructions = []Instruction{ { ISA: []string{"AVX", "GFNI"}, Operands: []Operand{ - {Type: "imm8", Action: 0x1}, {Type: "m128", Action: 0x1}, {Type: "xmm", Action: 0x1}, {Type: "xmm", Action: 0x2}, @@ -50991,7 +51143,6 @@ var Instructions = []Instruction{ { ISA: []string{"AVX", "GFNI"}, Operands: []Operand{ - {Type: "imm8", Action: 0x1}, {Type: "m256", Action: 0x1}, {Type: "ymm", Action: 0x1}, {Type: "ymm", Action: 0x2}, @@ -51001,7 +51152,6 @@ var Instructions = []Instruction{ { ISA: []string{"AVX", "GFNI"}, Operands: []Operand{ - {Type: "imm8", Action: 0x1}, {Type: "xmm", Action: 0x1}, {Type: "xmm", Action: 0x1}, {Type: "xmm", Action: 0x2}, @@ -51011,7 +51161,6 @@ var Instructions = []Instruction{ { ISA: []string{"AVX", "GFNI"}, Operands: []Operand{ - {Type: "imm8", Action: 0x1}, {Type: "ymm", Action: 0x1}, {Type: "ymm", Action: 0x1}, {Type: "ymm", Action: 0x2}, @@ -51021,62 +51170,57 @@ var Instructions = []Instruction{ { ISA: []string{"AVX512F", "GFNI"}, Operands: []Operand{ - {Type: "imm8", Action: 0x1}, {Type: "m512", Action: 0x1}, {Type: "zmm", Action: 0x1}, {Type: "k", Action: 0x1}, - {Type: "zmm", Action: 0x2}, + {Type: "zmm", Action: 0x3}, }, EncodingType: 0x4, }, { ISA: []string{"AVX512F", "GFNI"}, Operands: []Operand{ - {Type: "imm8", Action: 0x1}, {Type: "m512", Action: 0x1}, {Type: "zmm", Action: 0x1}, + {Type: "k", Action: 0x1}, {Type: "zmm", Action: 0x2}, }, EncodingType: 0x4, + Zeroing: true, }, { ISA: []string{"AVX512F", "GFNI"}, Operands: []Operand{ - {Type: "imm8", Action: 0x1}, - {Type: "m64", Action: 0x1}, + {Type: "m512", Action: 0x1}, {Type: "zmm", Action: 0x1}, - {Type: "k", Action: 0x1}, {Type: "zmm", Action: 0x2}, }, EncodingType: 0x4, - Broadcast: true, }, { ISA: []string{"AVX512F", "GFNI"}, Operands: []Operand{ - {Type: "imm8", Action: 0x1}, - {Type: "m64", Action: 0x1}, {Type: "zmm", Action: 0x1}, - {Type: "zmm", Action: 0x2}, + {Type: "zmm", Action: 0x1}, + {Type: "k", Action: 0x1}, + {Type: "zmm", Action: 0x3}, }, EncodingType: 0x4, - Broadcast: true, }, { ISA: []string{"AVX512F", "GFNI"}, Operands: []Operand{ - {Type: "imm8", Action: 0x1}, {Type: "zmm", Action: 0x1}, {Type: "zmm", Action: 0x1}, {Type: "k", Action: 0x1}, {Type: "zmm", Action: 0x2}, }, EncodingType: 0x4, + Zeroing: true, }, { ISA: []string{"AVX512F", "GFNI"}, Operands: []Operand{ - {Type: "imm8", Action: 0x1}, {Type: "zmm", Action: 0x1}, {Type: "zmm", Action: 0x1}, {Type: "zmm", Action: 0x2}, @@ -51086,92 +51230,86 @@ var Instructions = []Instruction{ { ISA: []string{"AVX512VL", "GFNI"}, Operands: []Operand{ - {Type: "imm8", Action: 0x1}, {Type: "m128", Action: 0x1}, {Type: "xmm", Action: 0x1}, {Type: "k", Action: 0x1}, - {Type: "xmm", Action: 0x2}, - }, - EncodingType: 0x4, - }, - { - ISA: []string{"AVX512VL", "GFNI"}, - Operands: []Operand{ - {Type: "imm8", Action: 0x1}, - {Type: "m256", Action: 0x1}, - {Type: "ymm", Action: 0x1}, - {Type: "k", Action: 0x1}, - {Type: "ymm", Action: 0x2}, + {Type: "xmm", Action: 0x3}, }, EncodingType: 0x4, }, { ISA: []string{"AVX512VL", "GFNI"}, Operands: []Operand{ - {Type: "imm8", Action: 0x1}, - {Type: "m64", Action: 0x1}, + {Type: "m128", Action: 0x1}, {Type: "xmm", Action: 0x1}, {Type: "k", Action: 0x1}, {Type: "xmm", Action: 0x2}, }, EncodingType: 0x4, - Broadcast: true, + Zeroing: true, }, { ISA: []string{"AVX512VL", "GFNI"}, Operands: []Operand{ - {Type: "imm8", Action: 0x1}, - {Type: "m64", Action: 0x1}, - {Type: "xmm", Action: 0x1}, - {Type: "xmm", Action: 0x2}, + {Type: "m256", Action: 0x1}, + {Type: "ymm", Action: 0x1}, + {Type: "k", Action: 0x1}, + {Type: "ymm", Action: 0x3}, }, EncodingType: 0x4, - Broadcast: true, }, { ISA: []string{"AVX512VL", "GFNI"}, Operands: []Operand{ - {Type: "imm8", Action: 0x1}, - {Type: "m64", Action: 0x1}, + {Type: "m256", Action: 0x1}, {Type: "ymm", Action: 0x1}, {Type: "k", Action: 0x1}, {Type: "ymm", Action: 0x2}, }, EncodingType: 0x4, - Broadcast: true, + Zeroing: true, }, { ISA: []string{"AVX512VL", "GFNI"}, Operands: []Operand{ - {Type: "imm8", Action: 0x1}, - {Type: "m64", Action: 0x1}, - {Type: "ymm", Action: 0x1}, - {Type: "ymm", Action: 0x2}, + {Type: "xmm", Action: 0x1}, + {Type: "xmm", Action: 0x1}, + {Type: "k", Action: 0x1}, + {Type: "xmm", Action: 0x3}, }, EncodingType: 0x4, - Broadcast: true, }, { ISA: []string{"AVX512VL", "GFNI"}, Operands: []Operand{ - {Type: "imm8", Action: 0x1}, {Type: "xmm", Action: 0x1}, {Type: "xmm", Action: 0x1}, {Type: "k", Action: 0x1}, {Type: "xmm", Action: 0x2}, }, EncodingType: 0x4, + Zeroing: true, + }, + { + ISA: []string{"AVX512VL", "GFNI"}, + Operands: []Operand{ + {Type: "ymm", Action: 0x1}, + {Type: "ymm", Action: 0x1}, + {Type: "k", Action: 0x1}, + {Type: "ymm", Action: 0x3}, + }, + EncodingType: 0x4, }, { ISA: []string{"AVX512VL", "GFNI"}, Operands: []Operand{ - {Type: "imm8", Action: 0x1}, {Type: "ymm", Action: 0x1}, {Type: "ymm", Action: 0x1}, {Type: "k", Action: 0x1}, {Type: "ymm", Action: 0x2}, }, EncodingType: 0x4, + Zeroing: true, }, }, }, diff --git a/internal/opcodesextra/gfni.go b/internal/opcodesextra/gfni.go index d192ad32..353ec45b 100644 --- a/internal/opcodesextra/gfni.go +++ b/internal/opcodesextra/gfni.go @@ -37,7 +37,6 @@ var gfni = []*inst.Instruction{ Summary: "Galois Field Affine Transformation Inverse", Forms: vgf2p8affineqb, }, - { Opcode: "VGF2P8MULB", Summary: "Galois Field Multiply Bytes", @@ -45,6 +44,10 @@ var gfni = []*inst.Instruction{ }, } +// VGF2P8AFFINEQB and VGF2P8AFFINEINVQB forms. +// +// See: https://www.felixcloutier.com/x86/gf2p8affineqb +// // Reference: https://github.com/golang/go/blob/go1.19.3/src/cmd/internal/obj/x86/avx_optabs.go#L483-L492 // // var _yvgf2p8affineinvqb = []ytab{ @@ -106,65 +109,20 @@ var vgf2p8affineqb = inst.Forms{ {Type: "imm8", Action: inst.R}, {Type: "xmm", Action: inst.R}, {Type: "xmm", Action: inst.R}, - {Type: "xmm", Action: inst.W}, - }, - EncodingType: inst.EncodingTypeEVEX, - ISA: []string{"AVX512VL", "GFNI"}, - }, - { - Operands: []inst.Operand{ - {Type: "imm8", Action: inst.R}, - {Type: "xmm", Action: inst.R}, - {Type: "xmm", Action: inst.R}, - {Type: "k", Action: inst.R}, - {Type: "xmm", Action: inst.W}, - }, - EncodingType: inst.EncodingTypeEVEX, - ISA: []string{"AVX512VL", "GFNI"}, - }, - { - Operands: []inst.Operand{ - {Type: "imm8", Action: inst.R}, - {Type: "m128", Action: inst.R}, - {Type: "xmm", Action: inst.R}, - {Type: "xmm", Action: inst.W}, - }, - EncodingType: inst.EncodingTypeEVEX, - ISA: []string{"AVX512VL", "GFNI"}, - }, - { - Operands: []inst.Operand{ - {Type: "imm8", Action: inst.R}, - {Type: "m128", Action: inst.R}, - {Type: "xmm", Action: inst.R}, - {Type: "k", Action: inst.R}, - {Type: "xmm", Action: inst.W}, - }, - EncodingType: inst.EncodingTypeEVEX, - ISA: []string{"AVX512VL", "GFNI"}, - }, - { - Operands: []inst.Operand{ - {Type: "imm8", Action: inst.R}, - {Type: "m64", Action: inst.R}, - {Type: "xmm", Action: inst.R}, - {Type: "xmm", Action: inst.W}, + {Type: "xmm{k}{z}", Action: inst.W}, }, EncodingType: inst.EncodingTypeEVEX, ISA: []string{"AVX512VL", "GFNI"}, - Broadcast: true, }, { Operands: []inst.Operand{ {Type: "imm8", Action: inst.R}, - {Type: "m64", Action: inst.R}, + {Type: "m128/m64bcst", Action: inst.R}, {Type: "xmm", Action: inst.R}, - {Type: "k", Action: inst.R}, - {Type: "xmm", Action: inst.W}, + {Type: "xmm{k}{z}", Action: inst.W}, }, EncodingType: inst.EncodingTypeEVEX, ISA: []string{"AVX512VL", "GFNI"}, - Broadcast: true, }, // EVEX.256.66.0F3A.W1 CE /r /ib VGF2P8AFFINEQB ymm1{k1}{z}, ymm2, ymm3/m256/m64bcst, imm8 { @@ -172,7 +130,7 @@ var vgf2p8affineqb = inst.Forms{ {Type: "imm8", Action: inst.R}, {Type: "ymm", Action: inst.R}, {Type: "ymm", Action: inst.R}, - {Type: "ymm", Action: inst.W}, + {Type: "ymm{k}{z}", Action: inst.W}, }, EncodingType: inst.EncodingTypeEVEX, ISA: []string{"AVX512VL", "GFNI"}, @@ -180,65 +138,20 @@ var vgf2p8affineqb = inst.Forms{ { Operands: []inst.Operand{ {Type: "imm8", Action: inst.R}, + {Type: "m256/m64bcst", Action: inst.R}, {Type: "ymm", Action: inst.R}, - {Type: "ymm", Action: inst.R}, - {Type: "k", Action: inst.R}, - {Type: "ymm", Action: inst.W}, + {Type: "ymm{k}{z}", Action: inst.W}, }, EncodingType: inst.EncodingTypeEVEX, ISA: []string{"AVX512VL", "GFNI"}, }, - { - Operands: []inst.Operand{ - {Type: "imm8", Action: inst.R}, - {Type: "m256", Action: inst.R}, - {Type: "ymm", Action: inst.R}, - {Type: "ymm", Action: inst.W}, - }, - EncodingType: inst.EncodingTypeEVEX, - ISA: []string{"AVX512VL", "GFNI"}, - }, - { - Operands: []inst.Operand{ - {Type: "imm8", Action: inst.R}, - {Type: "m256", Action: inst.R}, - {Type: "ymm", Action: inst.R}, - {Type: "k", Action: inst.R}, - {Type: "ymm", Action: inst.W}, - }, - EncodingType: inst.EncodingTypeEVEX, - ISA: []string{"AVX512VL", "GFNI"}, - }, - { - Operands: []inst.Operand{ - {Type: "imm8", Action: inst.R}, - {Type: "m64", Action: inst.R}, - {Type: "ymm", Action: inst.R}, - {Type: "ymm", Action: inst.W}, - }, - EncodingType: inst.EncodingTypeEVEX, - ISA: []string{"AVX512VL", "GFNI"}, - Broadcast: true, - }, - { - Operands: []inst.Operand{ - {Type: "imm8", Action: inst.R}, - {Type: "m64", Action: inst.R}, - {Type: "ymm", Action: inst.R}, - {Type: "k", Action: inst.R}, - {Type: "ymm", Action: inst.W}, - }, - EncodingType: inst.EncodingTypeEVEX, - ISA: []string{"AVX512VL", "GFNI"}, - Broadcast: true, - }, // EVEX.512.66.0F3A.W1 CE /r /ib VGF2P8AFFINEQB zmm1{k1}{z}, zmm2, zmm3/m512/m64bcst, imm8 { Operands: []inst.Operand{ {Type: "imm8", Action: inst.R}, {Type: "zmm", Action: inst.R}, {Type: "zmm", Action: inst.R}, - {Type: "zmm", Action: inst.W}, + {Type: "zmm{k}{z}", Action: inst.W}, }, EncodingType: inst.EncodingTypeEVEX, ISA: []string{"AVX512F", "GFNI"}, @@ -246,60 +159,19 @@ var vgf2p8affineqb = inst.Forms{ { Operands: []inst.Operand{ {Type: "imm8", Action: inst.R}, + {Type: "m512/m64bcst", Action: inst.R}, {Type: "zmm", Action: inst.R}, - {Type: "zmm", Action: inst.R}, - {Type: "k", Action: inst.R}, - {Type: "zmm", Action: inst.W}, + {Type: "zmm{k}{z}", Action: inst.W}, }, EncodingType: inst.EncodingTypeEVEX, ISA: []string{"AVX512F", "GFNI"}, }, - { - Operands: []inst.Operand{ - {Type: "imm8", Action: inst.R}, - {Type: "m512", Action: inst.R}, - {Type: "zmm", Action: inst.R}, - {Type: "zmm", Action: inst.W}, - }, - EncodingType: inst.EncodingTypeEVEX, - ISA: []string{"AVX512F", "GFNI"}, - }, - { - Operands: []inst.Operand{ - {Type: "imm8", Action: inst.R}, - {Type: "m512", Action: inst.R}, - {Type: "zmm", Action: inst.R}, - {Type: "k", Action: inst.R}, - {Type: "zmm", Action: inst.W}, - }, - EncodingType: inst.EncodingTypeEVEX, - ISA: []string{"AVX512F", "GFNI"}, - }, - { - Operands: []inst.Operand{ - {Type: "imm8", Action: inst.R}, - {Type: "m64", Action: inst.R}, - {Type: "zmm", Action: inst.R}, - {Type: "zmm", Action: inst.W}, - }, - EncodingType: inst.EncodingTypeEVEX, - ISA: []string{"AVX512F", "GFNI"}, - Broadcast: true, - }, - { - Operands: []inst.Operand{ - {Type: "imm8", Action: inst.R}, - {Type: "m64", Action: inst.R}, - {Type: "zmm", Action: inst.R}, - {Type: "k", Action: inst.R}, - {Type: "zmm", Action: inst.W}, - }, - EncodingType: inst.EncodingTypeEVEX, - ISA: []string{"AVX512F", "GFNI"}, - Broadcast: true, - }, } +// VGF2P8MULB forms. +// +// See: https://www.felixcloutier.com/x86/gf2p8mulb +// // Reference: https://github.com/golang/go/blob/go1.19.3/src/cmd/internal/obj/x86/avx_optabs.go#L137-L146 // // var _yvandnpd = []ytab{ @@ -316,7 +188,6 @@ var vgf2p8mulb = inst.Forms{ // VEX.128.66.0F38.W0 CF /r VGF2P8MULB xmm1, xmm2, xmm3/m128 { Operands: []inst.Operand{ - {Type: "imm8", Action: inst.R}, {Type: "xmm", Action: inst.R}, {Type: "xmm", Action: inst.R}, {Type: "xmm", Action: inst.W}, @@ -326,7 +197,6 @@ var vgf2p8mulb = inst.Forms{ }, { Operands: []inst.Operand{ - {Type: "imm8", Action: inst.R}, {Type: "m128", Action: inst.R}, {Type: "xmm", Action: inst.R}, {Type: "xmm", Action: inst.W}, @@ -337,7 +207,6 @@ var vgf2p8mulb = inst.Forms{ // VEX.256.66.0F38.W0 CF /r VGF2P8MULB ymm1, ymm2, ymm3/m256 { Operands: []inst.Operand{ - {Type: "imm8", Action: inst.R}, {Type: "ymm", Action: inst.R}, {Type: "ymm", Action: inst.R}, {Type: "ymm", Action: inst.W}, @@ -347,7 +216,6 @@ var vgf2p8mulb = inst.Forms{ }, { Operands: []inst.Operand{ - {Type: "imm8", Action: inst.R}, {Type: "m256", Action: inst.R}, {Type: "ymm", Action: inst.R}, {Type: "ymm", Action: inst.W}, @@ -358,199 +226,58 @@ var vgf2p8mulb = inst.Forms{ // EVEX.128.66.0F38.W0 CF /r VGF2P8MULB xmm1{k1}{z}, xmm2, xmm3/m128 { Operands: []inst.Operand{ - {Type: "imm8", Action: inst.R}, - {Type: "xmm", Action: inst.R}, - {Type: "xmm", Action: inst.R}, - {Type: "xmm", Action: inst.W}, - }, - EncodingType: inst.EncodingTypeEVEX, - ISA: []string{"AVX512VL", "GFNI"}, - }, - { - Operands: []inst.Operand{ - {Type: "imm8", Action: inst.R}, {Type: "xmm", Action: inst.R}, {Type: "xmm", Action: inst.R}, - {Type: "k", Action: inst.R}, - {Type: "xmm", Action: inst.W}, + {Type: "xmm{k}{z}", Action: inst.W}, }, EncodingType: inst.EncodingTypeEVEX, ISA: []string{"AVX512VL", "GFNI"}, }, { Operands: []inst.Operand{ - {Type: "imm8", Action: inst.R}, {Type: "m128", Action: inst.R}, {Type: "xmm", Action: inst.R}, - {Type: "xmm", Action: inst.W}, - }, - EncodingType: inst.EncodingTypeEVEX, - ISA: []string{"AVX512VL", "GFNI"}, - }, - { - Operands: []inst.Operand{ - {Type: "imm8", Action: inst.R}, - {Type: "m128", Action: inst.R}, - {Type: "xmm", Action: inst.R}, - {Type: "k", Action: inst.R}, - {Type: "xmm", Action: inst.W}, - }, - EncodingType: inst.EncodingTypeEVEX, - ISA: []string{"AVX512VL", "GFNI"}, - }, - { - Operands: []inst.Operand{ - {Type: "imm8", Action: inst.R}, - {Type: "m64", Action: inst.R}, - {Type: "xmm", Action: inst.R}, - {Type: "xmm", Action: inst.W}, - }, - EncodingType: inst.EncodingTypeEVEX, - ISA: []string{"AVX512VL", "GFNI"}, - Broadcast: true, - }, - { - Operands: []inst.Operand{ - {Type: "imm8", Action: inst.R}, - {Type: "m64", Action: inst.R}, - {Type: "xmm", Action: inst.R}, - {Type: "k", Action: inst.R}, - {Type: "xmm", Action: inst.W}, + {Type: "xmm{k}{z}", Action: inst.W}, }, EncodingType: inst.EncodingTypeEVEX, ISA: []string{"AVX512VL", "GFNI"}, - Broadcast: true, }, // EVEX.256.66.0F38.W0 CF /r VGF2P8MULB ymm1{k1}{z}, ymm2, ymm3/m256 { Operands: []inst.Operand{ - {Type: "imm8", Action: inst.R}, {Type: "ymm", Action: inst.R}, {Type: "ymm", Action: inst.R}, - {Type: "ymm", Action: inst.W}, + {Type: "ymm{k}{z}", Action: inst.W}, }, EncodingType: inst.EncodingTypeEVEX, ISA: []string{"AVX512VL", "GFNI"}, }, { Operands: []inst.Operand{ - {Type: "imm8", Action: inst.R}, - {Type: "ymm", Action: inst.R}, - {Type: "ymm", Action: inst.R}, - {Type: "k", Action: inst.R}, - {Type: "ymm", Action: inst.W}, - }, - EncodingType: inst.EncodingTypeEVEX, - ISA: []string{"AVX512VL", "GFNI"}, - }, - { - Operands: []inst.Operand{ - {Type: "imm8", Action: inst.R}, {Type: "m256", Action: inst.R}, {Type: "ymm", Action: inst.R}, - {Type: "ymm", Action: inst.W}, + {Type: "ymm{k}{z}", Action: inst.W}, }, EncodingType: inst.EncodingTypeEVEX, ISA: []string{"AVX512VL", "GFNI"}, }, - { - Operands: []inst.Operand{ - {Type: "imm8", Action: inst.R}, - {Type: "m256", Action: inst.R}, - {Type: "ymm", Action: inst.R}, - {Type: "k", Action: inst.R}, - {Type: "ymm", Action: inst.W}, - }, - EncodingType: inst.EncodingTypeEVEX, - ISA: []string{"AVX512VL", "GFNI"}, - }, - { - Operands: []inst.Operand{ - {Type: "imm8", Action: inst.R}, - {Type: "m64", Action: inst.R}, - {Type: "ymm", Action: inst.R}, - {Type: "ymm", Action: inst.W}, - }, - EncodingType: inst.EncodingTypeEVEX, - ISA: []string{"AVX512VL", "GFNI"}, - Broadcast: true, - }, - { - Operands: []inst.Operand{ - {Type: "imm8", Action: inst.R}, - {Type: "m64", Action: inst.R}, - {Type: "ymm", Action: inst.R}, - {Type: "k", Action: inst.R}, - {Type: "ymm", Action: inst.W}, - }, - EncodingType: inst.EncodingTypeEVEX, - ISA: []string{"AVX512VL", "GFNI"}, - Broadcast: true, - }, // EVEX.512.66.0F38.W0 CF /r VGF2P8MULB zmm1{k1}{z}, zmm2, zmm3/m512 { Operands: []inst.Operand{ - {Type: "imm8", Action: inst.R}, {Type: "zmm", Action: inst.R}, {Type: "zmm", Action: inst.R}, - {Type: "zmm", Action: inst.W}, + {Type: "zmm{k}{z}", Action: inst.W}, }, EncodingType: inst.EncodingTypeEVEX, ISA: []string{"AVX512F", "GFNI"}, }, { Operands: []inst.Operand{ - {Type: "imm8", Action: inst.R}, - {Type: "zmm", Action: inst.R}, - {Type: "zmm", Action: inst.R}, - {Type: "k", Action: inst.R}, - {Type: "zmm", Action: inst.W}, - }, - EncodingType: inst.EncodingTypeEVEX, - ISA: []string{"AVX512F", "GFNI"}, - }, - { - Operands: []inst.Operand{ - {Type: "imm8", Action: inst.R}, {Type: "m512", Action: inst.R}, {Type: "zmm", Action: inst.R}, - {Type: "zmm", Action: inst.W}, - }, - EncodingType: inst.EncodingTypeEVEX, - ISA: []string{"AVX512F", "GFNI"}, - }, - { - Operands: []inst.Operand{ - {Type: "imm8", Action: inst.R}, - {Type: "m512", Action: inst.R}, - {Type: "zmm", Action: inst.R}, - {Type: "k", Action: inst.R}, - {Type: "zmm", Action: inst.W}, - }, - EncodingType: inst.EncodingTypeEVEX, - ISA: []string{"AVX512F", "GFNI"}, - }, - { - Operands: []inst.Operand{ - {Type: "imm8", Action: inst.R}, - {Type: "m64", Action: inst.R}, - {Type: "zmm", Action: inst.R}, - {Type: "zmm", Action: inst.W}, - }, - EncodingType: inst.EncodingTypeEVEX, - ISA: []string{"AVX512F", "GFNI"}, - Broadcast: true, - }, - { - Operands: []inst.Operand{ - {Type: "imm8", Action: inst.R}, - {Type: "m64", Action: inst.R}, - {Type: "zmm", Action: inst.R}, - {Type: "k", Action: inst.R}, - {Type: "zmm", Action: inst.W}, + {Type: "zmm{k}{z}", Action: inst.W}, }, EncodingType: inst.EncodingTypeEVEX, ISA: []string{"AVX512F", "GFNI"}, - Broadcast: true, }, } diff --git a/x86/zctors.go b/x86/zctors.go index ae8d2c31..74b36f1d 100644 --- a/x86/zctors.go +++ b/x86/zctors.go @@ -21960,12 +21960,9 @@ func VGETMANTSS_Z(i, mx, x, k, x1 operand.Op) (*intrep.Instruction, error) { // VGF2P8AFFINEINVQB imm8 ymm ymm ymm // VGF2P8AFFINEINVQB imm8 m512 zmm k zmm // VGF2P8AFFINEINVQB imm8 m512 zmm zmm -// VGF2P8AFFINEINVQB imm8 zmm zmm k zmm // VGF2P8AFFINEINVQB imm8 zmm zmm zmm // VGF2P8AFFINEINVQB imm8 m128 xmm k xmm // VGF2P8AFFINEINVQB imm8 m256 ymm k ymm -// VGF2P8AFFINEINVQB imm8 xmm xmm k xmm -// VGF2P8AFFINEINVQB imm8 ymm ymm k ymm func VGF2P8AFFINEINVQB(ops ...operand.Op) (*intrep.Instruction, error) { return build(opcVGF2P8AFFINEINVQB.Forms(), sffxs{}, ops) } @@ -21984,6 +21981,28 @@ func VGF2P8AFFINEINVQB_BCST(ops ...operand.Op) (*intrep.Instruction, error) { return build(opcVGF2P8AFFINEINVQB.Forms(), sffxs{sffxBCST}, ops) } +// VGF2P8AFFINEINVQB_BCST_Z: Galois Field Affine Transformation Inverse (Broadcast, Zeroing Masking). +// +// Forms: +// +// VGF2P8AFFINEINVQB.BCST.Z imm8 m64 zmm k zmm +// VGF2P8AFFINEINVQB.BCST.Z imm8 m64 xmm k xmm +// VGF2P8AFFINEINVQB.BCST.Z imm8 m64 ymm k ymm +func VGF2P8AFFINEINVQB_BCST_Z(i, m, xyz, k, xyz1 operand.Op) (*intrep.Instruction, error) { + return build(opcVGF2P8AFFINEINVQB.Forms(), sffxs{sffxBCST, sffxZ}, []operand.Op{i, m, xyz, k, xyz1}) +} + +// VGF2P8AFFINEINVQB_Z: Galois Field Affine Transformation Inverse (Zeroing Masking). +// +// Forms: +// +// VGF2P8AFFINEINVQB.Z imm8 m512 zmm k zmm +// VGF2P8AFFINEINVQB.Z imm8 m128 xmm k xmm +// VGF2P8AFFINEINVQB.Z imm8 m256 ymm k ymm +func VGF2P8AFFINEINVQB_Z(i, m, xyz, k, xyz1 operand.Op) (*intrep.Instruction, error) { + return build(opcVGF2P8AFFINEINVQB.Forms(), sffxs{sffxZ}, []operand.Op{i, m, xyz, k, xyz1}) +} + // VGF2P8AFFINEQB: Galois Field Affine Transformation. // // Forms: @@ -22018,38 +22037,63 @@ func VGF2P8AFFINEQB_BCST(ops ...operand.Op) (*intrep.Instruction, error) { return build(opcVGF2P8AFFINEQB.Forms(), sffxs{sffxBCST}, ops) } +// VGF2P8AFFINEQB_BCST_Z: Galois Field Affine Transformation (Broadcast, Zeroing Masking). +// +// Forms: +// +// VGF2P8AFFINEQB.BCST.Z imm8 m64 zmm k zmm +// VGF2P8AFFINEQB.BCST.Z imm8 m64 xmm k xmm +// VGF2P8AFFINEQB.BCST.Z imm8 m64 ymm k ymm +func VGF2P8AFFINEQB_BCST_Z(i, m, xyz, k, xyz1 operand.Op) (*intrep.Instruction, error) { + return build(opcVGF2P8AFFINEQB.Forms(), sffxs{sffxBCST, sffxZ}, []operand.Op{i, m, xyz, k, xyz1}) +} + +// VGF2P8AFFINEQB_Z: Galois Field Affine Transformation (Zeroing Masking). +// +// Forms: +// +// VGF2P8AFFINEQB.Z imm8 m512 zmm k zmm +// VGF2P8AFFINEQB.Z imm8 zmm zmm k zmm +// VGF2P8AFFINEQB.Z imm8 m128 xmm k xmm +// VGF2P8AFFINEQB.Z imm8 m256 ymm k ymm +// VGF2P8AFFINEQB.Z imm8 xmm xmm k xmm +// VGF2P8AFFINEQB.Z imm8 ymm ymm k ymm +func VGF2P8AFFINEQB_Z(i, mxyz, xyz, k, xyz1 operand.Op) (*intrep.Instruction, error) { + return build(opcVGF2P8AFFINEQB.Forms(), sffxs{sffxZ}, []operand.Op{i, mxyz, xyz, k, xyz1}) +} + // VGF2P8MULB: Galois Field Multiply Bytes. // // Forms: // -// VGF2P8MULB imm8 m128 xmm xmm -// VGF2P8MULB imm8 m256 ymm ymm -// VGF2P8MULB imm8 xmm xmm xmm -// VGF2P8MULB imm8 ymm ymm ymm -// VGF2P8MULB imm8 m512 zmm k zmm -// VGF2P8MULB imm8 m512 zmm zmm -// VGF2P8MULB imm8 zmm zmm k zmm -// VGF2P8MULB imm8 zmm zmm zmm -// VGF2P8MULB imm8 m128 xmm k xmm -// VGF2P8MULB imm8 m256 ymm k ymm -// VGF2P8MULB imm8 xmm xmm k xmm -// VGF2P8MULB imm8 ymm ymm k ymm +// VGF2P8MULB m128 xmm xmm +// VGF2P8MULB m256 ymm ymm +// VGF2P8MULB xmm xmm xmm +// VGF2P8MULB ymm ymm ymm +// VGF2P8MULB m512 zmm k zmm +// VGF2P8MULB m512 zmm zmm +// VGF2P8MULB zmm zmm k zmm +// VGF2P8MULB zmm zmm zmm +// VGF2P8MULB m128 xmm k xmm +// VGF2P8MULB m256 ymm k ymm +// VGF2P8MULB xmm xmm k xmm +// VGF2P8MULB ymm ymm k ymm func VGF2P8MULB(ops ...operand.Op) (*intrep.Instruction, error) { return build(opcVGF2P8MULB.Forms(), sffxs{}, ops) } -// VGF2P8MULB_BCST: Galois Field Multiply Bytes (Broadcast). +// VGF2P8MULB_Z: Galois Field Multiply Bytes (Zeroing Masking). // // Forms: // -// VGF2P8MULB.BCST imm8 m64 zmm k zmm -// VGF2P8MULB.BCST imm8 m64 zmm zmm -// VGF2P8MULB.BCST imm8 m64 xmm k xmm -// VGF2P8MULB.BCST imm8 m64 xmm xmm -// VGF2P8MULB.BCST imm8 m64 ymm k ymm -// VGF2P8MULB.BCST imm8 m64 ymm ymm -func VGF2P8MULB_BCST(ops ...operand.Op) (*intrep.Instruction, error) { - return build(opcVGF2P8MULB.Forms(), sffxs{sffxBCST}, ops) +// VGF2P8MULB.Z m512 zmm k zmm +// VGF2P8MULB.Z zmm zmm k zmm +// VGF2P8MULB.Z m128 xmm k xmm +// VGF2P8MULB.Z m256 ymm k ymm +// VGF2P8MULB.Z xmm xmm k xmm +// VGF2P8MULB.Z ymm ymm k ymm +func VGF2P8MULB_Z(mxyz, xyz, k, xyz1 operand.Op) (*intrep.Instruction, error) { + return build(opcVGF2P8MULB.Forms(), sffxs{sffxZ}, []operand.Op{mxyz, xyz, k, xyz1}) } // VHADDPD: Packed Double-FP Horizontal Add. diff --git a/x86/zctors_test.go b/x86/zctors_test.go index 3ec923e2..d4cf4cee 100644 --- a/x86/zctors_test.go +++ b/x86/zctors_test.go @@ -23292,9 +23292,6 @@ func TestVGF2P8AFFINEINVQBValidFormsNoError(t *testing.T) { if _, err := VGF2P8AFFINEINVQB(opimm8, opm512, opzmm, opzmm); err != nil { t.Fatal(err) } - if _, err := VGF2P8AFFINEINVQB(opimm8, opzmm, opzmm, opk, opzmm); err != nil { - t.Fatal(err) - } if _, err := VGF2P8AFFINEINVQB(opimm8, opzmm, opzmm, opzmm); err != nil { t.Fatal(err) } @@ -23304,12 +23301,6 @@ func TestVGF2P8AFFINEINVQBValidFormsNoError(t *testing.T) { if _, err := VGF2P8AFFINEINVQB(opimm8, opm256, opymm, opk, opymm); err != nil { t.Fatal(err) } - if _, err := VGF2P8AFFINEINVQB(opimm8, opxmm, opxmm, opk, opxmm); err != nil { - t.Fatal(err) - } - if _, err := VGF2P8AFFINEINVQB(opimm8, opymm, opymm, opk, opymm); err != nil { - t.Fatal(err) - } } func TestVGF2P8AFFINEINVQB_BCSTValidFormsNoError(t *testing.T) { @@ -23333,6 +23324,30 @@ func TestVGF2P8AFFINEINVQB_BCSTValidFormsNoError(t *testing.T) { } } +func TestVGF2P8AFFINEINVQB_BCST_ZValidFormsNoError(t *testing.T) { + if _, err := VGF2P8AFFINEINVQB_BCST_Z(opimm8, opm64, opzmm, opk, opzmm); err != nil { + t.Fatal(err) + } + if _, err := VGF2P8AFFINEINVQB_BCST_Z(opimm8, opm64, opxmm, opk, opxmm); err != nil { + t.Fatal(err) + } + if _, err := VGF2P8AFFINEINVQB_BCST_Z(opimm8, opm64, opymm, opk, opymm); err != nil { + t.Fatal(err) + } +} + +func TestVGF2P8AFFINEINVQB_ZValidFormsNoError(t *testing.T) { + if _, err := VGF2P8AFFINEINVQB_Z(opimm8, opm512, opzmm, opk, opzmm); err != nil { + t.Fatal(err) + } + if _, err := VGF2P8AFFINEINVQB_Z(opimm8, opm128, opxmm, opk, opxmm); err != nil { + t.Fatal(err) + } + if _, err := VGF2P8AFFINEINVQB_Z(opimm8, opm256, opymm, opk, opymm); err != nil { + t.Fatal(err) + } +} + func TestVGF2P8AFFINEQBValidFormsNoError(t *testing.T) { if _, err := VGF2P8AFFINEQB(opimm8, opm128, opxmm, opxmm); err != nil { t.Fatal(err) @@ -23393,62 +23408,95 @@ func TestVGF2P8AFFINEQB_BCSTValidFormsNoError(t *testing.T) { } } +func TestVGF2P8AFFINEQB_BCST_ZValidFormsNoError(t *testing.T) { + if _, err := VGF2P8AFFINEQB_BCST_Z(opimm8, opm64, opzmm, opk, opzmm); err != nil { + t.Fatal(err) + } + if _, err := VGF2P8AFFINEQB_BCST_Z(opimm8, opm64, opxmm, opk, opxmm); err != nil { + t.Fatal(err) + } + if _, err := VGF2P8AFFINEQB_BCST_Z(opimm8, opm64, opymm, opk, opymm); err != nil { + t.Fatal(err) + } +} + +func TestVGF2P8AFFINEQB_ZValidFormsNoError(t *testing.T) { + if _, err := VGF2P8AFFINEQB_Z(opimm8, opm512, opzmm, opk, opzmm); err != nil { + t.Fatal(err) + } + if _, err := VGF2P8AFFINEQB_Z(opimm8, opzmm, opzmm, opk, opzmm); err != nil { + t.Fatal(err) + } + if _, err := VGF2P8AFFINEQB_Z(opimm8, opm128, opxmm, opk, opxmm); err != nil { + t.Fatal(err) + } + if _, err := VGF2P8AFFINEQB_Z(opimm8, opm256, opymm, opk, opymm); err != nil { + t.Fatal(err) + } + if _, err := VGF2P8AFFINEQB_Z(opimm8, opxmm, opxmm, opk, opxmm); err != nil { + t.Fatal(err) + } + if _, err := VGF2P8AFFINEQB_Z(opimm8, opymm, opymm, opk, opymm); err != nil { + t.Fatal(err) + } +} + func TestVGF2P8MULBValidFormsNoError(t *testing.T) { - if _, err := VGF2P8MULB(opimm8, opm128, opxmm, opxmm); err != nil { + if _, err := VGF2P8MULB(opm128, opxmm, opxmm); err != nil { t.Fatal(err) } - if _, err := VGF2P8MULB(opimm8, opm256, opymm, opymm); err != nil { + if _, err := VGF2P8MULB(opm256, opymm, opymm); err != nil { t.Fatal(err) } - if _, err := VGF2P8MULB(opimm8, opxmm, opxmm, opxmm); err != nil { + if _, err := VGF2P8MULB(opxmm, opxmm, opxmm); err != nil { t.Fatal(err) } - if _, err := VGF2P8MULB(opimm8, opymm, opymm, opymm); err != nil { + if _, err := VGF2P8MULB(opymm, opymm, opymm); err != nil { t.Fatal(err) } - if _, err := VGF2P8MULB(opimm8, opm512, opzmm, opk, opzmm); err != nil { + if _, err := VGF2P8MULB(opm512, opzmm, opk, opzmm); err != nil { t.Fatal(err) } - if _, err := VGF2P8MULB(opimm8, opm512, opzmm, opzmm); err != nil { + if _, err := VGF2P8MULB(opm512, opzmm, opzmm); err != nil { t.Fatal(err) } - if _, err := VGF2P8MULB(opimm8, opzmm, opzmm, opk, opzmm); err != nil { + if _, err := VGF2P8MULB(opzmm, opzmm, opk, opzmm); err != nil { t.Fatal(err) } - if _, err := VGF2P8MULB(opimm8, opzmm, opzmm, opzmm); err != nil { + if _, err := VGF2P8MULB(opzmm, opzmm, opzmm); err != nil { t.Fatal(err) } - if _, err := VGF2P8MULB(opimm8, opm128, opxmm, opk, opxmm); err != nil { + if _, err := VGF2P8MULB(opm128, opxmm, opk, opxmm); err != nil { t.Fatal(err) } - if _, err := VGF2P8MULB(opimm8, opm256, opymm, opk, opymm); err != nil { + if _, err := VGF2P8MULB(opm256, opymm, opk, opymm); err != nil { t.Fatal(err) } - if _, err := VGF2P8MULB(opimm8, opxmm, opxmm, opk, opxmm); err != nil { + if _, err := VGF2P8MULB(opxmm, opxmm, opk, opxmm); err != nil { t.Fatal(err) } - if _, err := VGF2P8MULB(opimm8, opymm, opymm, opk, opymm); err != nil { + if _, err := VGF2P8MULB(opymm, opymm, opk, opymm); err != nil { t.Fatal(err) } } -func TestVGF2P8MULB_BCSTValidFormsNoError(t *testing.T) { - if _, err := VGF2P8MULB_BCST(opimm8, opm64, opzmm, opk, opzmm); err != nil { +func TestVGF2P8MULB_ZValidFormsNoError(t *testing.T) { + if _, err := VGF2P8MULB_Z(opm512, opzmm, opk, opzmm); err != nil { t.Fatal(err) } - if _, err := VGF2P8MULB_BCST(opimm8, opm64, opzmm, opzmm); err != nil { + if _, err := VGF2P8MULB_Z(opzmm, opzmm, opk, opzmm); err != nil { t.Fatal(err) } - if _, err := VGF2P8MULB_BCST(opimm8, opm64, opxmm, opk, opxmm); err != nil { + if _, err := VGF2P8MULB_Z(opm128, opxmm, opk, opxmm); err != nil { t.Fatal(err) } - if _, err := VGF2P8MULB_BCST(opimm8, opm64, opxmm, opxmm); err != nil { + if _, err := VGF2P8MULB_Z(opm256, opymm, opk, opymm); err != nil { t.Fatal(err) } - if _, err := VGF2P8MULB_BCST(opimm8, opm64, opymm, opk, opymm); err != nil { + if _, err := VGF2P8MULB_Z(opxmm, opxmm, opk, opxmm); err != nil { t.Fatal(err) } - if _, err := VGF2P8MULB_BCST(opimm8, opm64, opymm, opymm); err != nil { + if _, err := VGF2P8MULB_Z(opymm, opymm, opk, opymm); err != nil { t.Fatal(err) } } diff --git a/x86/zoptab.go b/x86/zoptab.go index f472ffeb..d61f5e62 100644 --- a/x86/zoptab.go +++ b/x86/zoptab.go @@ -7888,56 +7888,68 @@ var forms = []form{ {opcVGF2P8AFFINEINVQB, sffxsclsNIL, 0, isasAVX_GFNI, 4, oprnds{{uint8(oprndtypeIMM8), false, actionR}, {uint8(oprndtypeM256), false, actionR}, {uint8(oprndtypeYMM), false, actionR}, {uint8(oprndtypeYMM), false, actionW}}}, {opcVGF2P8AFFINEINVQB, sffxsclsNIL, 0, isasAVX_GFNI, 4, oprnds{{uint8(oprndtypeIMM8), false, actionR}, {uint8(oprndtypeXMM), false, actionR}, {uint8(oprndtypeXMM), false, actionR}, {uint8(oprndtypeXMM), false, actionW}}}, {opcVGF2P8AFFINEINVQB, sffxsclsNIL, 0, isasAVX_GFNI, 4, oprnds{{uint8(oprndtypeIMM8), false, actionR}, {uint8(oprndtypeYMM), false, actionR}, {uint8(oprndtypeYMM), false, actionR}, {uint8(oprndtypeYMM), false, actionW}}}, - {opcVGF2P8AFFINEINVQB, sffxsclsNIL, 0, isasAVX512F_GFNI, 5, oprnds{{uint8(oprndtypeIMM8), false, actionR}, {uint8(oprndtypeM512), false, actionR}, {uint8(oprndtypeZMM), false, actionR}, {uint8(oprndtypeK), false, actionR}, {uint8(oprndtypeZMM), false, actionW}}}, + {opcVGF2P8AFFINEINVQB, sffxsclsNIL, 0, isasAVX512F_GFNI, 5, oprnds{{uint8(oprndtypeIMM8), false, actionR}, {uint8(oprndtypeM512), false, actionR}, {uint8(oprndtypeZMM), false, actionR}, {uint8(oprndtypeK), false, actionR}, {uint8(oprndtypeZMM), false, actionRW}}}, + {opcVGF2P8AFFINEINVQB, sffxsclsZ, 0, isasAVX512F_GFNI, 5, oprnds{{uint8(oprndtypeIMM8), false, actionR}, {uint8(oprndtypeM512), false, actionR}, {uint8(oprndtypeZMM), false, actionR}, {uint8(oprndtypeK), false, actionR}, {uint8(oprndtypeZMM), false, actionW}}}, {opcVGF2P8AFFINEINVQB, sffxsclsNIL, 0, isasAVX512F_GFNI, 4, oprnds{{uint8(oprndtypeIMM8), false, actionR}, {uint8(oprndtypeM512), false, actionR}, {uint8(oprndtypeZMM), false, actionR}, {uint8(oprndtypeZMM), false, actionW}}}, - {opcVGF2P8AFFINEINVQB, sffxsclsBCST, 0, isasAVX512F_GFNI, 5, oprnds{{uint8(oprndtypeIMM8), false, actionR}, {uint8(oprndtypeM64), false, actionR}, {uint8(oprndtypeZMM), false, actionR}, {uint8(oprndtypeK), false, actionR}, {uint8(oprndtypeZMM), false, actionW}}}, + {opcVGF2P8AFFINEINVQB, sffxsclsBCST, 0, isasAVX512F_GFNI, 5, oprnds{{uint8(oprndtypeIMM8), false, actionR}, {uint8(oprndtypeM64), false, actionR}, {uint8(oprndtypeZMM), false, actionR}, {uint8(oprndtypeK), false, actionR}, {uint8(oprndtypeZMM), false, actionRW}}}, + {opcVGF2P8AFFINEINVQB, sffxsclsBCST_Z, 0, isasAVX512F_GFNI, 5, oprnds{{uint8(oprndtypeIMM8), false, actionR}, {uint8(oprndtypeM64), false, actionR}, {uint8(oprndtypeZMM), false, actionR}, {uint8(oprndtypeK), false, actionR}, {uint8(oprndtypeZMM), false, actionW}}}, {opcVGF2P8AFFINEINVQB, sffxsclsBCST, 0, isasAVX512F_GFNI, 4, oprnds{{uint8(oprndtypeIMM8), false, actionR}, {uint8(oprndtypeM64), false, actionR}, {uint8(oprndtypeZMM), false, actionR}, {uint8(oprndtypeZMM), false, actionW}}}, - {opcVGF2P8AFFINEINVQB, sffxsclsNIL, 0, isasAVX512F_GFNI, 5, oprnds{{uint8(oprndtypeIMM8), false, actionR}, {uint8(oprndtypeZMM), false, actionR}, {uint8(oprndtypeZMM), false, actionR}, {uint8(oprndtypeK), false, actionR}, {uint8(oprndtypeZMM), false, actionW}}}, {opcVGF2P8AFFINEINVQB, sffxsclsNIL, 0, isasAVX512F_GFNI, 4, oprnds{{uint8(oprndtypeIMM8), false, actionR}, {uint8(oprndtypeZMM), false, actionR}, {uint8(oprndtypeZMM), false, actionR}, {uint8(oprndtypeZMM), false, actionW}}}, - {opcVGF2P8AFFINEINVQB, sffxsclsNIL, 0, isasAVX512VL_GFNI, 5, oprnds{{uint8(oprndtypeIMM8), false, actionR}, {uint8(oprndtypeM128), false, actionR}, {uint8(oprndtypeXMM), false, actionR}, {uint8(oprndtypeK), false, actionR}, {uint8(oprndtypeXMM), false, actionW}}}, - {opcVGF2P8AFFINEINVQB, sffxsclsNIL, 0, isasAVX512VL_GFNI, 5, oprnds{{uint8(oprndtypeIMM8), false, actionR}, {uint8(oprndtypeM256), false, actionR}, {uint8(oprndtypeYMM), false, actionR}, {uint8(oprndtypeK), false, actionR}, {uint8(oprndtypeYMM), false, actionW}}}, - {opcVGF2P8AFFINEINVQB, sffxsclsBCST, 0, isasAVX512VL_GFNI, 5, oprnds{{uint8(oprndtypeIMM8), false, actionR}, {uint8(oprndtypeM64), false, actionR}, {uint8(oprndtypeXMM), false, actionR}, {uint8(oprndtypeK), false, actionR}, {uint8(oprndtypeXMM), false, actionW}}}, + {opcVGF2P8AFFINEINVQB, sffxsclsNIL, 0, isasAVX512VL_GFNI, 5, oprnds{{uint8(oprndtypeIMM8), false, actionR}, {uint8(oprndtypeM128), false, actionR}, {uint8(oprndtypeXMM), false, actionR}, {uint8(oprndtypeK), false, actionR}, {uint8(oprndtypeXMM), false, actionRW}}}, + {opcVGF2P8AFFINEINVQB, sffxsclsZ, 0, isasAVX512VL_GFNI, 5, oprnds{{uint8(oprndtypeIMM8), false, actionR}, {uint8(oprndtypeM128), false, actionR}, {uint8(oprndtypeXMM), false, actionR}, {uint8(oprndtypeK), false, actionR}, {uint8(oprndtypeXMM), false, actionW}}}, + {opcVGF2P8AFFINEINVQB, sffxsclsNIL, 0, isasAVX512VL_GFNI, 5, oprnds{{uint8(oprndtypeIMM8), false, actionR}, {uint8(oprndtypeM256), false, actionR}, {uint8(oprndtypeYMM), false, actionR}, {uint8(oprndtypeK), false, actionR}, {uint8(oprndtypeYMM), false, actionRW}}}, + {opcVGF2P8AFFINEINVQB, sffxsclsZ, 0, isasAVX512VL_GFNI, 5, oprnds{{uint8(oprndtypeIMM8), false, actionR}, {uint8(oprndtypeM256), false, actionR}, {uint8(oprndtypeYMM), false, actionR}, {uint8(oprndtypeK), false, actionR}, {uint8(oprndtypeYMM), false, actionW}}}, + {opcVGF2P8AFFINEINVQB, sffxsclsBCST, 0, isasAVX512VL_GFNI, 5, oprnds{{uint8(oprndtypeIMM8), false, actionR}, {uint8(oprndtypeM64), false, actionR}, {uint8(oprndtypeXMM), false, actionR}, {uint8(oprndtypeK), false, actionR}, {uint8(oprndtypeXMM), false, actionRW}}}, + {opcVGF2P8AFFINEINVQB, sffxsclsBCST_Z, 0, isasAVX512VL_GFNI, 5, oprnds{{uint8(oprndtypeIMM8), false, actionR}, {uint8(oprndtypeM64), false, actionR}, {uint8(oprndtypeXMM), false, actionR}, {uint8(oprndtypeK), false, actionR}, {uint8(oprndtypeXMM), false, actionW}}}, {opcVGF2P8AFFINEINVQB, sffxsclsBCST, 0, isasAVX512VL_GFNI, 4, oprnds{{uint8(oprndtypeIMM8), false, actionR}, {uint8(oprndtypeM64), false, actionR}, {uint8(oprndtypeXMM), false, actionR}, {uint8(oprndtypeXMM), false, actionW}}}, - {opcVGF2P8AFFINEINVQB, sffxsclsBCST, 0, isasAVX512VL_GFNI, 5, oprnds{{uint8(oprndtypeIMM8), false, actionR}, {uint8(oprndtypeM64), false, actionR}, {uint8(oprndtypeYMM), false, actionR}, {uint8(oprndtypeK), false, actionR}, {uint8(oprndtypeYMM), false, actionW}}}, + {opcVGF2P8AFFINEINVQB, sffxsclsBCST, 0, isasAVX512VL_GFNI, 5, oprnds{{uint8(oprndtypeIMM8), false, actionR}, {uint8(oprndtypeM64), false, actionR}, {uint8(oprndtypeYMM), false, actionR}, {uint8(oprndtypeK), false, actionR}, {uint8(oprndtypeYMM), false, actionRW}}}, + {opcVGF2P8AFFINEINVQB, sffxsclsBCST_Z, 0, isasAVX512VL_GFNI, 5, oprnds{{uint8(oprndtypeIMM8), false, actionR}, {uint8(oprndtypeM64), false, actionR}, {uint8(oprndtypeYMM), false, actionR}, {uint8(oprndtypeK), false, actionR}, {uint8(oprndtypeYMM), false, actionW}}}, {opcVGF2P8AFFINEINVQB, sffxsclsBCST, 0, isasAVX512VL_GFNI, 4, oprnds{{uint8(oprndtypeIMM8), false, actionR}, {uint8(oprndtypeM64), false, actionR}, {uint8(oprndtypeYMM), false, actionR}, {uint8(oprndtypeYMM), false, actionW}}}, - {opcVGF2P8AFFINEINVQB, sffxsclsNIL, 0, isasAVX512VL_GFNI, 5, oprnds{{uint8(oprndtypeIMM8), false, actionR}, {uint8(oprndtypeXMM), false, actionR}, {uint8(oprndtypeXMM), false, actionR}, {uint8(oprndtypeK), false, actionR}, {uint8(oprndtypeXMM), false, actionW}}}, - {opcVGF2P8AFFINEINVQB, sffxsclsNIL, 0, isasAVX512VL_GFNI, 5, oprnds{{uint8(oprndtypeIMM8), false, actionR}, {uint8(oprndtypeYMM), false, actionR}, {uint8(oprndtypeYMM), false, actionR}, {uint8(oprndtypeK), false, actionR}, {uint8(oprndtypeYMM), false, actionW}}}, {opcVGF2P8AFFINEQB, sffxsclsNIL, 0, isasAVX_GFNI, 4, oprnds{{uint8(oprndtypeIMM8), false, actionR}, {uint8(oprndtypeM128), false, actionR}, {uint8(oprndtypeXMM), false, actionR}, {uint8(oprndtypeXMM), false, actionW}}}, {opcVGF2P8AFFINEQB, sffxsclsNIL, 0, isasAVX_GFNI, 4, oprnds{{uint8(oprndtypeIMM8), false, actionR}, {uint8(oprndtypeM256), false, actionR}, {uint8(oprndtypeYMM), false, actionR}, {uint8(oprndtypeYMM), false, actionW}}}, {opcVGF2P8AFFINEQB, sffxsclsNIL, 0, isasAVX_GFNI, 4, oprnds{{uint8(oprndtypeIMM8), false, actionR}, {uint8(oprndtypeXMM), false, actionR}, {uint8(oprndtypeXMM), false, actionR}, {uint8(oprndtypeXMM), false, actionW}}}, {opcVGF2P8AFFINEQB, sffxsclsNIL, 0, isasAVX_GFNI, 4, oprnds{{uint8(oprndtypeIMM8), false, actionR}, {uint8(oprndtypeYMM), false, actionR}, {uint8(oprndtypeYMM), false, actionR}, {uint8(oprndtypeYMM), false, actionW}}}, - {opcVGF2P8AFFINEQB, sffxsclsNIL, 0, isasAVX512F_GFNI, 5, oprnds{{uint8(oprndtypeIMM8), false, actionR}, {uint8(oprndtypeM512), false, actionR}, {uint8(oprndtypeZMM), false, actionR}, {uint8(oprndtypeK), false, actionR}, {uint8(oprndtypeZMM), false, actionW}}}, + {opcVGF2P8AFFINEQB, sffxsclsNIL, 0, isasAVX512F_GFNI, 5, oprnds{{uint8(oprndtypeIMM8), false, actionR}, {uint8(oprndtypeM512), false, actionR}, {uint8(oprndtypeZMM), false, actionR}, {uint8(oprndtypeK), false, actionR}, {uint8(oprndtypeZMM), false, actionRW}}}, + {opcVGF2P8AFFINEQB, sffxsclsZ, 0, isasAVX512F_GFNI, 5, oprnds{{uint8(oprndtypeIMM8), false, actionR}, {uint8(oprndtypeM512), false, actionR}, {uint8(oprndtypeZMM), false, actionR}, {uint8(oprndtypeK), false, actionR}, {uint8(oprndtypeZMM), false, actionW}}}, {opcVGF2P8AFFINEQB, sffxsclsNIL, 0, isasAVX512F_GFNI, 4, oprnds{{uint8(oprndtypeIMM8), false, actionR}, {uint8(oprndtypeM512), false, actionR}, {uint8(oprndtypeZMM), false, actionR}, {uint8(oprndtypeZMM), false, actionW}}}, - {opcVGF2P8AFFINEQB, sffxsclsBCST, 0, isasAVX512F_GFNI, 5, oprnds{{uint8(oprndtypeIMM8), false, actionR}, {uint8(oprndtypeM64), false, actionR}, {uint8(oprndtypeZMM), false, actionR}, {uint8(oprndtypeK), false, actionR}, {uint8(oprndtypeZMM), false, actionW}}}, + {opcVGF2P8AFFINEQB, sffxsclsBCST, 0, isasAVX512F_GFNI, 5, oprnds{{uint8(oprndtypeIMM8), false, actionR}, {uint8(oprndtypeM64), false, actionR}, {uint8(oprndtypeZMM), false, actionR}, {uint8(oprndtypeK), false, actionR}, {uint8(oprndtypeZMM), false, actionRW}}}, + {opcVGF2P8AFFINEQB, sffxsclsBCST_Z, 0, isasAVX512F_GFNI, 5, oprnds{{uint8(oprndtypeIMM8), false, actionR}, {uint8(oprndtypeM64), false, actionR}, {uint8(oprndtypeZMM), false, actionR}, {uint8(oprndtypeK), false, actionR}, {uint8(oprndtypeZMM), false, actionW}}}, {opcVGF2P8AFFINEQB, sffxsclsBCST, 0, isasAVX512F_GFNI, 4, oprnds{{uint8(oprndtypeIMM8), false, actionR}, {uint8(oprndtypeM64), false, actionR}, {uint8(oprndtypeZMM), false, actionR}, {uint8(oprndtypeZMM), false, actionW}}}, - {opcVGF2P8AFFINEQB, sffxsclsNIL, 0, isasAVX512F_GFNI, 5, oprnds{{uint8(oprndtypeIMM8), false, actionR}, {uint8(oprndtypeZMM), false, actionR}, {uint8(oprndtypeZMM), false, actionR}, {uint8(oprndtypeK), false, actionR}, {uint8(oprndtypeZMM), false, actionW}}}, + {opcVGF2P8AFFINEQB, sffxsclsNIL, 0, isasAVX512F_GFNI, 5, oprnds{{uint8(oprndtypeIMM8), false, actionR}, {uint8(oprndtypeZMM), false, actionR}, {uint8(oprndtypeZMM), false, actionR}, {uint8(oprndtypeK), false, actionR}, {uint8(oprndtypeZMM), false, actionRW}}}, + {opcVGF2P8AFFINEQB, sffxsclsZ, 0, isasAVX512F_GFNI, 5, oprnds{{uint8(oprndtypeIMM8), false, actionR}, {uint8(oprndtypeZMM), false, actionR}, {uint8(oprndtypeZMM), false, actionR}, {uint8(oprndtypeK), false, actionR}, {uint8(oprndtypeZMM), false, actionW}}}, {opcVGF2P8AFFINEQB, sffxsclsNIL, 0, isasAVX512F_GFNI, 4, oprnds{{uint8(oprndtypeIMM8), false, actionR}, {uint8(oprndtypeZMM), false, actionR}, {uint8(oprndtypeZMM), false, actionR}, {uint8(oprndtypeZMM), false, actionW}}}, - {opcVGF2P8AFFINEQB, sffxsclsNIL, 0, isasAVX512VL_GFNI, 5, oprnds{{uint8(oprndtypeIMM8), false, actionR}, {uint8(oprndtypeM128), false, actionR}, {uint8(oprndtypeXMM), false, actionR}, {uint8(oprndtypeK), false, actionR}, {uint8(oprndtypeXMM), false, actionW}}}, - {opcVGF2P8AFFINEQB, sffxsclsNIL, 0, isasAVX512VL_GFNI, 5, oprnds{{uint8(oprndtypeIMM8), false, actionR}, {uint8(oprndtypeM256), false, actionR}, {uint8(oprndtypeYMM), false, actionR}, {uint8(oprndtypeK), false, actionR}, {uint8(oprndtypeYMM), false, actionW}}}, - {opcVGF2P8AFFINEQB, sffxsclsBCST, 0, isasAVX512VL_GFNI, 5, oprnds{{uint8(oprndtypeIMM8), false, actionR}, {uint8(oprndtypeM64), false, actionR}, {uint8(oprndtypeXMM), false, actionR}, {uint8(oprndtypeK), false, actionR}, {uint8(oprndtypeXMM), false, actionW}}}, + {opcVGF2P8AFFINEQB, sffxsclsNIL, 0, isasAVX512VL_GFNI, 5, oprnds{{uint8(oprndtypeIMM8), false, actionR}, {uint8(oprndtypeM128), false, actionR}, {uint8(oprndtypeXMM), false, actionR}, {uint8(oprndtypeK), false, actionR}, {uint8(oprndtypeXMM), false, actionRW}}}, + {opcVGF2P8AFFINEQB, sffxsclsZ, 0, isasAVX512VL_GFNI, 5, oprnds{{uint8(oprndtypeIMM8), false, actionR}, {uint8(oprndtypeM128), false, actionR}, {uint8(oprndtypeXMM), false, actionR}, {uint8(oprndtypeK), false, actionR}, {uint8(oprndtypeXMM), false, actionW}}}, + {opcVGF2P8AFFINEQB, sffxsclsNIL, 0, isasAVX512VL_GFNI, 5, oprnds{{uint8(oprndtypeIMM8), false, actionR}, {uint8(oprndtypeM256), false, actionR}, {uint8(oprndtypeYMM), false, actionR}, {uint8(oprndtypeK), false, actionR}, {uint8(oprndtypeYMM), false, actionRW}}}, + {opcVGF2P8AFFINEQB, sffxsclsZ, 0, isasAVX512VL_GFNI, 5, oprnds{{uint8(oprndtypeIMM8), false, actionR}, {uint8(oprndtypeM256), false, actionR}, {uint8(oprndtypeYMM), false, actionR}, {uint8(oprndtypeK), false, actionR}, {uint8(oprndtypeYMM), false, actionW}}}, + {opcVGF2P8AFFINEQB, sffxsclsBCST, 0, isasAVX512VL_GFNI, 5, oprnds{{uint8(oprndtypeIMM8), false, actionR}, {uint8(oprndtypeM64), false, actionR}, {uint8(oprndtypeXMM), false, actionR}, {uint8(oprndtypeK), false, actionR}, {uint8(oprndtypeXMM), false, actionRW}}}, + {opcVGF2P8AFFINEQB, sffxsclsBCST_Z, 0, isasAVX512VL_GFNI, 5, oprnds{{uint8(oprndtypeIMM8), false, actionR}, {uint8(oprndtypeM64), false, actionR}, {uint8(oprndtypeXMM), false, actionR}, {uint8(oprndtypeK), false, actionR}, {uint8(oprndtypeXMM), false, actionW}}}, {opcVGF2P8AFFINEQB, sffxsclsBCST, 0, isasAVX512VL_GFNI, 4, oprnds{{uint8(oprndtypeIMM8), false, actionR}, {uint8(oprndtypeM64), false, actionR}, {uint8(oprndtypeXMM), false, actionR}, {uint8(oprndtypeXMM), false, actionW}}}, - {opcVGF2P8AFFINEQB, sffxsclsBCST, 0, isasAVX512VL_GFNI, 5, oprnds{{uint8(oprndtypeIMM8), false, actionR}, {uint8(oprndtypeM64), false, actionR}, {uint8(oprndtypeYMM), false, actionR}, {uint8(oprndtypeK), false, actionR}, {uint8(oprndtypeYMM), false, actionW}}}, + {opcVGF2P8AFFINEQB, sffxsclsBCST, 0, isasAVX512VL_GFNI, 5, oprnds{{uint8(oprndtypeIMM8), false, actionR}, {uint8(oprndtypeM64), false, actionR}, {uint8(oprndtypeYMM), false, actionR}, {uint8(oprndtypeK), false, actionR}, {uint8(oprndtypeYMM), false, actionRW}}}, + {opcVGF2P8AFFINEQB, sffxsclsBCST_Z, 0, isasAVX512VL_GFNI, 5, oprnds{{uint8(oprndtypeIMM8), false, actionR}, {uint8(oprndtypeM64), false, actionR}, {uint8(oprndtypeYMM), false, actionR}, {uint8(oprndtypeK), false, actionR}, {uint8(oprndtypeYMM), false, actionW}}}, {opcVGF2P8AFFINEQB, sffxsclsBCST, 0, isasAVX512VL_GFNI, 4, oprnds{{uint8(oprndtypeIMM8), false, actionR}, {uint8(oprndtypeM64), false, actionR}, {uint8(oprndtypeYMM), false, actionR}, {uint8(oprndtypeYMM), false, actionW}}}, - {opcVGF2P8AFFINEQB, sffxsclsNIL, 0, isasAVX512VL_GFNI, 5, oprnds{{uint8(oprndtypeIMM8), false, actionR}, {uint8(oprndtypeXMM), false, actionR}, {uint8(oprndtypeXMM), false, actionR}, {uint8(oprndtypeK), false, actionR}, {uint8(oprndtypeXMM), false, actionW}}}, - {opcVGF2P8AFFINEQB, sffxsclsNIL, 0, isasAVX512VL_GFNI, 5, oprnds{{uint8(oprndtypeIMM8), false, actionR}, {uint8(oprndtypeYMM), false, actionR}, {uint8(oprndtypeYMM), false, actionR}, {uint8(oprndtypeK), false, actionR}, {uint8(oprndtypeYMM), false, actionW}}}, - {opcVGF2P8MULB, sffxsclsNIL, 0, isasAVX_GFNI, 4, oprnds{{uint8(oprndtypeIMM8), false, actionR}, {uint8(oprndtypeM128), false, actionR}, {uint8(oprndtypeXMM), false, actionR}, {uint8(oprndtypeXMM), false, actionW}}}, - {opcVGF2P8MULB, sffxsclsNIL, 0, isasAVX_GFNI, 4, oprnds{{uint8(oprndtypeIMM8), false, actionR}, {uint8(oprndtypeM256), false, actionR}, {uint8(oprndtypeYMM), false, actionR}, {uint8(oprndtypeYMM), false, actionW}}}, - {opcVGF2P8MULB, sffxsclsNIL, 0, isasAVX_GFNI, 4, oprnds{{uint8(oprndtypeIMM8), false, actionR}, {uint8(oprndtypeXMM), false, actionR}, {uint8(oprndtypeXMM), false, actionR}, {uint8(oprndtypeXMM), false, actionW}}}, - {opcVGF2P8MULB, sffxsclsNIL, 0, isasAVX_GFNI, 4, oprnds{{uint8(oprndtypeIMM8), false, actionR}, {uint8(oprndtypeYMM), false, actionR}, {uint8(oprndtypeYMM), false, actionR}, {uint8(oprndtypeYMM), false, actionW}}}, - {opcVGF2P8MULB, sffxsclsNIL, 0, isasAVX512F_GFNI, 5, oprnds{{uint8(oprndtypeIMM8), false, actionR}, {uint8(oprndtypeM512), false, actionR}, {uint8(oprndtypeZMM), false, actionR}, {uint8(oprndtypeK), false, actionR}, {uint8(oprndtypeZMM), false, actionW}}}, - {opcVGF2P8MULB, sffxsclsNIL, 0, isasAVX512F_GFNI, 4, oprnds{{uint8(oprndtypeIMM8), false, actionR}, {uint8(oprndtypeM512), false, actionR}, {uint8(oprndtypeZMM), false, actionR}, {uint8(oprndtypeZMM), false, actionW}}}, - {opcVGF2P8MULB, sffxsclsBCST, 0, isasAVX512F_GFNI, 5, oprnds{{uint8(oprndtypeIMM8), false, actionR}, {uint8(oprndtypeM64), false, actionR}, {uint8(oprndtypeZMM), false, actionR}, {uint8(oprndtypeK), false, actionR}, {uint8(oprndtypeZMM), false, actionW}}}, - {opcVGF2P8MULB, sffxsclsBCST, 0, isasAVX512F_GFNI, 4, oprnds{{uint8(oprndtypeIMM8), false, actionR}, {uint8(oprndtypeM64), false, actionR}, {uint8(oprndtypeZMM), false, actionR}, {uint8(oprndtypeZMM), false, actionW}}}, - {opcVGF2P8MULB, sffxsclsNIL, 0, isasAVX512F_GFNI, 5, oprnds{{uint8(oprndtypeIMM8), false, actionR}, {uint8(oprndtypeZMM), false, actionR}, {uint8(oprndtypeZMM), false, actionR}, {uint8(oprndtypeK), false, actionR}, {uint8(oprndtypeZMM), false, actionW}}}, - {opcVGF2P8MULB, sffxsclsNIL, 0, isasAVX512F_GFNI, 4, oprnds{{uint8(oprndtypeIMM8), false, actionR}, {uint8(oprndtypeZMM), false, actionR}, {uint8(oprndtypeZMM), false, actionR}, {uint8(oprndtypeZMM), false, actionW}}}, - {opcVGF2P8MULB, sffxsclsNIL, 0, isasAVX512VL_GFNI, 5, oprnds{{uint8(oprndtypeIMM8), false, actionR}, {uint8(oprndtypeM128), false, actionR}, {uint8(oprndtypeXMM), false, actionR}, {uint8(oprndtypeK), false, actionR}, {uint8(oprndtypeXMM), false, actionW}}}, - {opcVGF2P8MULB, sffxsclsNIL, 0, isasAVX512VL_GFNI, 5, oprnds{{uint8(oprndtypeIMM8), false, actionR}, {uint8(oprndtypeM256), false, actionR}, {uint8(oprndtypeYMM), false, actionR}, {uint8(oprndtypeK), false, actionR}, {uint8(oprndtypeYMM), false, actionW}}}, - {opcVGF2P8MULB, sffxsclsBCST, 0, isasAVX512VL_GFNI, 5, oprnds{{uint8(oprndtypeIMM8), false, actionR}, {uint8(oprndtypeM64), false, actionR}, {uint8(oprndtypeXMM), false, actionR}, {uint8(oprndtypeK), false, actionR}, {uint8(oprndtypeXMM), false, actionW}}}, - {opcVGF2P8MULB, sffxsclsBCST, 0, isasAVX512VL_GFNI, 4, oprnds{{uint8(oprndtypeIMM8), false, actionR}, {uint8(oprndtypeM64), false, actionR}, {uint8(oprndtypeXMM), false, actionR}, {uint8(oprndtypeXMM), false, actionW}}}, - {opcVGF2P8MULB, sffxsclsBCST, 0, isasAVX512VL_GFNI, 5, oprnds{{uint8(oprndtypeIMM8), false, actionR}, {uint8(oprndtypeM64), false, actionR}, {uint8(oprndtypeYMM), false, actionR}, {uint8(oprndtypeK), false, actionR}, {uint8(oprndtypeYMM), false, actionW}}}, - {opcVGF2P8MULB, sffxsclsBCST, 0, isasAVX512VL_GFNI, 4, oprnds{{uint8(oprndtypeIMM8), false, actionR}, {uint8(oprndtypeM64), false, actionR}, {uint8(oprndtypeYMM), false, actionR}, {uint8(oprndtypeYMM), false, actionW}}}, - {opcVGF2P8MULB, sffxsclsNIL, 0, isasAVX512VL_GFNI, 5, oprnds{{uint8(oprndtypeIMM8), false, actionR}, {uint8(oprndtypeXMM), false, actionR}, {uint8(oprndtypeXMM), false, actionR}, {uint8(oprndtypeK), false, actionR}, {uint8(oprndtypeXMM), false, actionW}}}, - {opcVGF2P8MULB, sffxsclsNIL, 0, isasAVX512VL_GFNI, 5, oprnds{{uint8(oprndtypeIMM8), false, actionR}, {uint8(oprndtypeYMM), false, actionR}, {uint8(oprndtypeYMM), false, actionR}, {uint8(oprndtypeK), false, actionR}, {uint8(oprndtypeYMM), false, actionW}}}, + {opcVGF2P8AFFINEQB, sffxsclsNIL, 0, isasAVX512VL_GFNI, 5, oprnds{{uint8(oprndtypeIMM8), false, actionR}, {uint8(oprndtypeXMM), false, actionR}, {uint8(oprndtypeXMM), false, actionR}, {uint8(oprndtypeK), false, actionR}, {uint8(oprndtypeXMM), false, actionRW}}}, + {opcVGF2P8AFFINEQB, sffxsclsZ, 0, isasAVX512VL_GFNI, 5, oprnds{{uint8(oprndtypeIMM8), false, actionR}, {uint8(oprndtypeXMM), false, actionR}, {uint8(oprndtypeXMM), false, actionR}, {uint8(oprndtypeK), false, actionR}, {uint8(oprndtypeXMM), false, actionW}}}, + {opcVGF2P8AFFINEQB, sffxsclsNIL, 0, isasAVX512VL_GFNI, 5, oprnds{{uint8(oprndtypeIMM8), false, actionR}, {uint8(oprndtypeYMM), false, actionR}, {uint8(oprndtypeYMM), false, actionR}, {uint8(oprndtypeK), false, actionR}, {uint8(oprndtypeYMM), false, actionRW}}}, + {opcVGF2P8AFFINEQB, sffxsclsZ, 0, isasAVX512VL_GFNI, 5, oprnds{{uint8(oprndtypeIMM8), false, actionR}, {uint8(oprndtypeYMM), false, actionR}, {uint8(oprndtypeYMM), false, actionR}, {uint8(oprndtypeK), false, actionR}, {uint8(oprndtypeYMM), false, actionW}}}, + {opcVGF2P8MULB, sffxsclsNIL, 0, isasAVX_GFNI, 3, oprnds{{uint8(oprndtypeM128), false, actionR}, {uint8(oprndtypeXMM), false, actionR}, {uint8(oprndtypeXMM), false, actionW}}}, + {opcVGF2P8MULB, sffxsclsNIL, 0, isasAVX_GFNI, 3, oprnds{{uint8(oprndtypeM256), false, actionR}, {uint8(oprndtypeYMM), false, actionR}, {uint8(oprndtypeYMM), false, actionW}}}, + {opcVGF2P8MULB, sffxsclsNIL, 0, isasAVX_GFNI, 3, oprnds{{uint8(oprndtypeXMM), false, actionR}, {uint8(oprndtypeXMM), false, actionR}, {uint8(oprndtypeXMM), false, actionW}}}, + {opcVGF2P8MULB, sffxsclsNIL, 0, isasAVX_GFNI, 3, oprnds{{uint8(oprndtypeYMM), false, actionR}, {uint8(oprndtypeYMM), false, actionR}, {uint8(oprndtypeYMM), false, actionW}}}, + {opcVGF2P8MULB, sffxsclsNIL, 0, isasAVX512F_GFNI, 4, oprnds{{uint8(oprndtypeM512), false, actionR}, {uint8(oprndtypeZMM), false, actionR}, {uint8(oprndtypeK), false, actionR}, {uint8(oprndtypeZMM), false, actionRW}}}, + {opcVGF2P8MULB, sffxsclsZ, 0, isasAVX512F_GFNI, 4, oprnds{{uint8(oprndtypeM512), false, actionR}, {uint8(oprndtypeZMM), false, actionR}, {uint8(oprndtypeK), false, actionR}, {uint8(oprndtypeZMM), false, actionW}}}, + {opcVGF2P8MULB, sffxsclsNIL, 0, isasAVX512F_GFNI, 3, oprnds{{uint8(oprndtypeM512), false, actionR}, {uint8(oprndtypeZMM), false, actionR}, {uint8(oprndtypeZMM), false, actionW}}}, + {opcVGF2P8MULB, sffxsclsNIL, 0, isasAVX512F_GFNI, 4, oprnds{{uint8(oprndtypeZMM), false, actionR}, {uint8(oprndtypeZMM), false, actionR}, {uint8(oprndtypeK), false, actionR}, {uint8(oprndtypeZMM), false, actionRW}}}, + {opcVGF2P8MULB, sffxsclsZ, 0, isasAVX512F_GFNI, 4, oprnds{{uint8(oprndtypeZMM), false, actionR}, {uint8(oprndtypeZMM), false, actionR}, {uint8(oprndtypeK), false, actionR}, {uint8(oprndtypeZMM), false, actionW}}}, + {opcVGF2P8MULB, sffxsclsNIL, 0, isasAVX512F_GFNI, 3, oprnds{{uint8(oprndtypeZMM), false, actionR}, {uint8(oprndtypeZMM), false, actionR}, {uint8(oprndtypeZMM), false, actionW}}}, + {opcVGF2P8MULB, sffxsclsNIL, 0, isasAVX512VL_GFNI, 4, oprnds{{uint8(oprndtypeM128), false, actionR}, {uint8(oprndtypeXMM), false, actionR}, {uint8(oprndtypeK), false, actionR}, {uint8(oprndtypeXMM), false, actionRW}}}, + {opcVGF2P8MULB, sffxsclsZ, 0, isasAVX512VL_GFNI, 4, oprnds{{uint8(oprndtypeM128), false, actionR}, {uint8(oprndtypeXMM), false, actionR}, {uint8(oprndtypeK), false, actionR}, {uint8(oprndtypeXMM), false, actionW}}}, + {opcVGF2P8MULB, sffxsclsNIL, 0, isasAVX512VL_GFNI, 4, oprnds{{uint8(oprndtypeM256), false, actionR}, {uint8(oprndtypeYMM), false, actionR}, {uint8(oprndtypeK), false, actionR}, {uint8(oprndtypeYMM), false, actionRW}}}, + {opcVGF2P8MULB, sffxsclsZ, 0, isasAVX512VL_GFNI, 4, oprnds{{uint8(oprndtypeM256), false, actionR}, {uint8(oprndtypeYMM), false, actionR}, {uint8(oprndtypeK), false, actionR}, {uint8(oprndtypeYMM), false, actionW}}}, + {opcVGF2P8MULB, sffxsclsNIL, 0, isasAVX512VL_GFNI, 4, oprnds{{uint8(oprndtypeXMM), false, actionR}, {uint8(oprndtypeXMM), false, actionR}, {uint8(oprndtypeK), false, actionR}, {uint8(oprndtypeXMM), false, actionRW}}}, + {opcVGF2P8MULB, sffxsclsZ, 0, isasAVX512VL_GFNI, 4, oprnds{{uint8(oprndtypeXMM), false, actionR}, {uint8(oprndtypeXMM), false, actionR}, {uint8(oprndtypeK), false, actionR}, {uint8(oprndtypeXMM), false, actionW}}}, + {opcVGF2P8MULB, sffxsclsNIL, 0, isasAVX512VL_GFNI, 4, oprnds{{uint8(oprndtypeYMM), false, actionR}, {uint8(oprndtypeYMM), false, actionR}, {uint8(oprndtypeK), false, actionR}, {uint8(oprndtypeYMM), false, actionRW}}}, + {opcVGF2P8MULB, sffxsclsZ, 0, isasAVX512VL_GFNI, 4, oprnds{{uint8(oprndtypeYMM), false, actionR}, {uint8(oprndtypeYMM), false, actionR}, {uint8(oprndtypeK), false, actionR}, {uint8(oprndtypeYMM), false, actionW}}}, {opcVHADDPD, sffxsclsNIL, 0, isasAVX, 3, oprnds{{uint8(oprndtypeM128), false, actionR}, {uint8(oprndtypeXMM), false, actionR}, {uint8(oprndtypeXMM), false, actionW}}}, {opcVHADDPD, sffxsclsNIL, 0, isasAVX, 3, oprnds{{uint8(oprndtypeM256), false, actionR}, {uint8(oprndtypeYMM), false, actionR}, {uint8(oprndtypeYMM), false, actionW}}}, {opcVHADDPD, sffxsclsNIL, 0, isasAVX, 3, oprnds{{uint8(oprndtypeXMM), false, actionR}, {uint8(oprndtypeXMM), false, actionR}, {uint8(oprndtypeXMM), false, actionW}}}, @@ -15298,413 +15310,413 @@ var opcformstable = [][]form{ forms[4865:4895], forms[4895:4904], forms[4904:4913], - forms[4913:4931], - forms[4931:4949], - forms[4949:4967], - forms[4967:4971], - forms[4971:4975], - forms[4975:4979], + forms[4913:4934], + forms[4934:4961], + forms[4961:4979], forms[4979:4983], - forms[4983:4985], - forms[4985:4997], - forms[4997:5003], - forms[5003:5015], - forms[5015:5021], - forms[5021:5023], - forms[5023:5035], - forms[5035:5041], - forms[5041:5053], - forms[5053:5059], - forms[5059:5061], - forms[5061:5063], - forms[5063:5064], - forms[5064:5065], - forms[5065:5069], - forms[5069:5073], - forms[5073:5103], - forms[5103:5133], - forms[5133:5142], - forms[5142:5151], - forms[5151:5181], - forms[5181:5211], - forms[5211:5220], - forms[5220:5229], - forms[5229:5256], - forms[5256:5283], - forms[5283:5287], - forms[5287:5305], - forms[5305:5311], - forms[5311:5338], - forms[5338:5365], - forms[5365:5371], - forms[5371:5398], - forms[5398:5425], - forms[5425:5452], - forms[5452:5479], - forms[5479:5480], - forms[5480:5482], - forms[5482:5484], - forms[5484:5485], - forms[5485:5487], - forms[5487:5489], - forms[5489:5491], - forms[5491:5493], - forms[5493:5496], - forms[5496:5499], - forms[5499:5502], - forms[5502:5505], - forms[5505:5510], - forms[5510:5518], - forms[5518:5536], - forms[5536:5554], - forms[5554:5562], - forms[5562:5589], - forms[5589:5616], - forms[5616:5620], - forms[5620:5650], - forms[5650:5680], - forms[5680:5689], - forms[5689:5698], - forms[5698:5725], - forms[5725:5752], - forms[5752:5770], - forms[5770:5797], - forms[5797:5824], - forms[5824:5842], - forms[5842:5869], - forms[5869:5887], - forms[5887:5914], - forms[5914:5932], - forms[5932:5950], - forms[5950:5977], - forms[5977:6004], - forms[6004:6022], - forms[6022:6040], - forms[6040:6058], - forms[6058:6076], - forms[6076:6094], - forms[6094:6112], - forms[6112:6116], - forms[6116:6143], - forms[6143:6147], - forms[6147:6174], - forms[6174:6201], - forms[6201:6228], - forms[6228:6246], - forms[6246:6264], - forms[6264:6268], - forms[6268:6286], - forms[6286:6313], - forms[6313:6340], - forms[6340:6358], - forms[6358:6362], - forms[6362:6366], - forms[6366:6393], - forms[6393:6420], - forms[6420:6423], - forms[6423:6426], - forms[6426:6453], - forms[6453:6480], - forms[6480:6482], - forms[6482:6494], - forms[6494:6512], - forms[6512:6528], - forms[6528:6550], - forms[6550:6572], - forms[6572:6588], - forms[6588:6590], - forms[6590:6592], - forms[6592:6608], - forms[6608:6630], - forms[6630:6652], - forms[6652:6668], - forms[6668:6670], - forms[6670:6672], - forms[6672:6690], - forms[6690:6702], - forms[6702:6720], - forms[6720:6738], - forms[6738:6750], + forms[4983:4987], + forms[4987:4991], + forms[4991:4995], + forms[4995:4997], + forms[4997:5009], + forms[5009:5015], + forms[5015:5027], + forms[5027:5033], + forms[5033:5035], + forms[5035:5047], + forms[5047:5053], + forms[5053:5065], + forms[5065:5071], + forms[5071:5073], + forms[5073:5075], + forms[5075:5076], + forms[5076:5077], + forms[5077:5081], + forms[5081:5085], + forms[5085:5115], + forms[5115:5145], + forms[5145:5154], + forms[5154:5163], + forms[5163:5193], + forms[5193:5223], + forms[5223:5232], + forms[5232:5241], + forms[5241:5268], + forms[5268:5295], + forms[5295:5299], + forms[5299:5317], + forms[5317:5323], + forms[5323:5350], + forms[5350:5377], + forms[5377:5383], + forms[5383:5410], + forms[5410:5437], + forms[5437:5464], + forms[5464:5491], + forms[5491:5492], + forms[5492:5494], + forms[5494:5496], + forms[5496:5497], + forms[5497:5499], + forms[5499:5501], + forms[5501:5503], + forms[5503:5505], + forms[5505:5508], + forms[5508:5511], + forms[5511:5514], + forms[5514:5517], + forms[5517:5522], + forms[5522:5530], + forms[5530:5548], + forms[5548:5566], + forms[5566:5574], + forms[5574:5601], + forms[5601:5628], + forms[5628:5632], + forms[5632:5662], + forms[5662:5692], + forms[5692:5701], + forms[5701:5710], + forms[5710:5737], + forms[5737:5764], + forms[5764:5782], + forms[5782:5809], + forms[5809:5836], + forms[5836:5854], + forms[5854:5881], + forms[5881:5899], + forms[5899:5926], + forms[5926:5944], + forms[5944:5962], + forms[5962:5989], + forms[5989:6016], + forms[6016:6034], + forms[6034:6052], + forms[6052:6070], + forms[6070:6088], + forms[6088:6106], + forms[6106:6124], + forms[6124:6128], + forms[6128:6155], + forms[6155:6159], + forms[6159:6186], + forms[6186:6213], + forms[6213:6240], + forms[6240:6258], + forms[6258:6276], + forms[6276:6280], + forms[6280:6298], + forms[6298:6325], + forms[6325:6352], + forms[6352:6370], + forms[6370:6374], + forms[6374:6378], + forms[6378:6405], + forms[6405:6432], + forms[6432:6435], + forms[6435:6438], + forms[6438:6465], + forms[6465:6492], + forms[6492:6494], + forms[6494:6506], + forms[6506:6524], + forms[6524:6540], + forms[6540:6562], + forms[6562:6584], + forms[6584:6600], + forms[6600:6602], + forms[6602:6604], + forms[6604:6620], + forms[6620:6642], + forms[6642:6664], + forms[6664:6680], + forms[6680:6682], + forms[6682:6684], + forms[6684:6702], + forms[6702:6714], + forms[6714:6732], + forms[6732:6750], forms[6750:6762], - forms[6762:6780], - forms[6780:6798], - forms[6798:6825], - forms[6825:6852], - forms[6852:6854], - forms[6854:6856], - forms[6856:6874], - forms[6874:6892], - forms[6892:6910], - forms[6910:6937], - forms[6937:6964], - forms[6964:6991], - forms[6991:7018], - forms[7018:7036], - forms[7036:7090], - forms[7090:7144], - forms[7144:7180], - forms[7180:7198], - forms[7198:7234], - forms[7234:7252], - forms[7252:7279], - forms[7279:7306], - forms[7306:7333], - forms[7333:7360], - forms[7360:7378], - forms[7378:7396], - forms[7396:7414], - forms[7414:7432], - forms[7432:7434], - forms[7434:7436], - forms[7436:7438], - forms[7438:7440], - forms[7440:7445], - forms[7445:7450], - forms[7450:7455], - forms[7455:7460], - forms[7460:7464], - forms[7464:7468], - forms[7468:7472], - forms[7472:7474], - forms[7474:7478], - forms[7478:7482], - forms[7482:7486], - forms[7486:7488], - forms[7488:7490], - forms[7490:7492], - forms[7492:7494], - forms[7494:7521], - forms[7521:7548], - forms[7548:7575], - forms[7575:7602], - forms[7602:7620], - forms[7620:7638], - forms[7638:7642], - forms[7642:7646], - forms[7646:7664], - forms[7664:7691], - forms[7691:7718], - forms[7718:7736], - forms[7736:7754], - forms[7754:7781], - forms[7781:7808], - forms[7808:7826], - forms[7826:7844], - forms[7844:7871], - forms[7871:7898], - forms[7898:7916], - forms[7916:7934], - forms[7934:7961], - forms[7961:7988], - forms[7988:8006], - forms[8006:8009], - forms[8009:8012], - forms[8012:8030], - forms[8030:8048], - forms[8048:8051], - forms[8051:8054], - forms[8054:8057], - forms[8057:8060], - forms[8060:8062], - forms[8062:8065], - forms[8065:8083], - forms[8083:8101], - forms[8101:8119], - forms[8119:8137], - forms[8137:8155], - forms[8155:8173], - forms[8173:8191], - forms[8191:8209], - forms[8209:8227], - forms[8227:8245], - forms[8245:8263], - forms[8263:8281], - forms[8281:8299], - forms[8299:8317], - forms[8317:8335], - forms[8335:8353], - forms[8353:8371], - forms[8371:8389], - forms[8389:8407], - forms[8407:8425], - forms[8425:8443], - forms[8443:8446], - forms[8446:8464], - forms[8464:8482], - forms[8482:8500], - forms[8500:8518], - forms[8518:8536], - forms[8536:8554], - forms[8554:8572], - forms[8572:8599], - forms[8599:8617], - forms[8617:8635], - forms[8635:8653], - forms[8653:8680], - forms[8680:8707], - forms[8707:8725], - forms[8725:8752], - forms[8752:8779], - forms[8779:8788], - forms[8788:8797], - forms[8797:8801], - forms[8801:8828], - forms[8828:8855], - forms[8855:8882], - forms[8882:8909], - forms[8909:8936], - forms[8936:8963], - forms[8963:8990], - forms[8990:9017], - forms[9017:9044], - forms[9044:9071], - forms[9071:9077], - forms[9077:9080], - forms[9080:9083], - forms[9083:9086], - forms[9086:9089], - forms[9089:9107], - forms[9107:9134], - forms[9134:9152], - forms[9152:9170], - forms[9170:9174], - forms[9174:9178], - forms[9178:9182], - forms[9182:9227], - forms[9227:9233], - forms[9233:9278], - forms[9278:9305], - forms[9305:9332], - forms[9332:9350], - forms[9350:9386], - forms[9386:9431], - forms[9431:9476], - forms[9476:9503], - forms[9503:9530], - forms[9530:9548], - forms[9548:9584], - forms[9584:9629], - forms[9629:9635], - forms[9635:9680], - forms[9680:9707], - forms[9707:9734], - forms[9734:9752], - forms[9752:9788], - forms[9788:9806], - forms[9806:9833], - forms[9833:9860], - forms[9860:9878], - forms[9878:9896], - forms[9896:9914], - forms[9914:9932], - forms[9932:9950], - forms[9950:9977], - forms[9977:10004], - forms[10004:10008], - forms[10008:10020], - forms[10020:10038], - forms[10038:10056], - forms[10056:10068], + forms[6762:6774], + forms[6774:6792], + forms[6792:6810], + forms[6810:6837], + forms[6837:6864], + forms[6864:6866], + forms[6866:6868], + forms[6868:6886], + forms[6886:6904], + forms[6904:6922], + forms[6922:6949], + forms[6949:6976], + forms[6976:7003], + forms[7003:7030], + forms[7030:7048], + forms[7048:7102], + forms[7102:7156], + forms[7156:7192], + forms[7192:7210], + forms[7210:7246], + forms[7246:7264], + forms[7264:7291], + forms[7291:7318], + forms[7318:7345], + forms[7345:7372], + forms[7372:7390], + forms[7390:7408], + forms[7408:7426], + forms[7426:7444], + forms[7444:7446], + forms[7446:7448], + forms[7448:7450], + forms[7450:7452], + forms[7452:7457], + forms[7457:7462], + forms[7462:7467], + forms[7467:7472], + forms[7472:7476], + forms[7476:7480], + forms[7480:7484], + forms[7484:7486], + forms[7486:7490], + forms[7490:7494], + forms[7494:7498], + forms[7498:7500], + forms[7500:7502], + forms[7502:7504], + forms[7504:7506], + forms[7506:7533], + forms[7533:7560], + forms[7560:7587], + forms[7587:7614], + forms[7614:7632], + forms[7632:7650], + forms[7650:7654], + forms[7654:7658], + forms[7658:7676], + forms[7676:7703], + forms[7703:7730], + forms[7730:7748], + forms[7748:7766], + forms[7766:7793], + forms[7793:7820], + forms[7820:7838], + forms[7838:7856], + forms[7856:7883], + forms[7883:7910], + forms[7910:7928], + forms[7928:7946], + forms[7946:7973], + forms[7973:8000], + forms[8000:8018], + forms[8018:8021], + forms[8021:8024], + forms[8024:8042], + forms[8042:8060], + forms[8060:8063], + forms[8063:8066], + forms[8066:8069], + forms[8069:8072], + forms[8072:8074], + forms[8074:8077], + forms[8077:8095], + forms[8095:8113], + forms[8113:8131], + forms[8131:8149], + forms[8149:8167], + forms[8167:8185], + forms[8185:8203], + forms[8203:8221], + forms[8221:8239], + forms[8239:8257], + forms[8257:8275], + forms[8275:8293], + forms[8293:8311], + forms[8311:8329], + forms[8329:8347], + forms[8347:8365], + forms[8365:8383], + forms[8383:8401], + forms[8401:8419], + forms[8419:8437], + forms[8437:8455], + forms[8455:8458], + forms[8458:8476], + forms[8476:8494], + forms[8494:8512], + forms[8512:8530], + forms[8530:8548], + forms[8548:8566], + forms[8566:8584], + forms[8584:8611], + forms[8611:8629], + forms[8629:8647], + forms[8647:8665], + forms[8665:8692], + forms[8692:8719], + forms[8719:8737], + forms[8737:8764], + forms[8764:8791], + forms[8791:8800], + forms[8800:8809], + forms[8809:8813], + forms[8813:8840], + forms[8840:8867], + forms[8867:8894], + forms[8894:8921], + forms[8921:8948], + forms[8948:8975], + forms[8975:9002], + forms[9002:9029], + forms[9029:9056], + forms[9056:9083], + forms[9083:9089], + forms[9089:9092], + forms[9092:9095], + forms[9095:9098], + forms[9098:9101], + forms[9101:9119], + forms[9119:9146], + forms[9146:9164], + forms[9164:9182], + forms[9182:9186], + forms[9186:9190], + forms[9190:9194], + forms[9194:9239], + forms[9239:9245], + forms[9245:9290], + forms[9290:9317], + forms[9317:9344], + forms[9344:9362], + forms[9362:9398], + forms[9398:9443], + forms[9443:9488], + forms[9488:9515], + forms[9515:9542], + forms[9542:9560], + forms[9560:9596], + forms[9596:9641], + forms[9641:9647], + forms[9647:9692], + forms[9692:9719], + forms[9719:9746], + forms[9746:9764], + forms[9764:9800], + forms[9800:9818], + forms[9818:9845], + forms[9845:9872], + forms[9872:9890], + forms[9890:9908], + forms[9908:9926], + forms[9926:9944], + forms[9944:9962], + forms[9962:9989], + forms[9989:10016], + forms[10016:10020], + forms[10020:10032], + forms[10032:10050], + forms[10050:10068], forms[10068:10080], - forms[10080:10098], - forms[10098:10116], - forms[10116:10128], - forms[10128:10146], - forms[10146:10173], - forms[10173:10200], - forms[10200:10218], - forms[10218:10236], - forms[10236:10263], - forms[10263:10290], - forms[10290:10308], - forms[10308:10312], - forms[10312:10339], - forms[10339:10366], - forms[10366:10396], - forms[10396:10426], - forms[10426:10435], - forms[10435:10444], - forms[10444:10471], - forms[10471:10498], - forms[10498:10504], - forms[10504:10510], - forms[10510:10522], + forms[10080:10092], + forms[10092:10110], + forms[10110:10128], + forms[10128:10140], + forms[10140:10158], + forms[10158:10185], + forms[10185:10212], + forms[10212:10230], + forms[10230:10248], + forms[10248:10275], + forms[10275:10302], + forms[10302:10320], + forms[10320:10324], + forms[10324:10351], + forms[10351:10378], + forms[10378:10408], + forms[10408:10438], + forms[10438:10447], + forms[10447:10456], + forms[10456:10483], + forms[10483:10510], + forms[10510:10516], + forms[10516:10522], forms[10522:10534], - forms[10534:10543], - forms[10543:10552], - forms[10552:10556], - forms[10556:10558], - forms[10558:10585], - forms[10585:10612], - forms[10612:10618], - forms[10618:10624], - forms[10624:10654], - forms[10654:10684], - forms[10684:10693], - forms[10693:10702], - forms[10702:10706], - forms[10706:10710], - forms[10710:10712], - forms[10712:10714], - forms[10714:10741], - forms[10741:10768], - forms[10768:10774], - forms[10774:10780], - forms[10780:10792], + forms[10534:10546], + forms[10546:10555], + forms[10555:10564], + forms[10564:10568], + forms[10568:10570], + forms[10570:10597], + forms[10597:10624], + forms[10624:10630], + forms[10630:10636], + forms[10636:10666], + forms[10666:10696], + forms[10696:10705], + forms[10705:10714], + forms[10714:10718], + forms[10718:10722], + forms[10722:10724], + forms[10724:10726], + forms[10726:10753], + forms[10753:10780], + forms[10780:10786], + forms[10786:10792], forms[10792:10804], - forms[10804:10813], - forms[10813:10822], - forms[10822:10826], - forms[10826:10828], - forms[10828:10858], - forms[10858:10888], - forms[10888:10897], - forms[10897:10906], - forms[10906:10909], - forms[10909:10912], - forms[10912:10915], - forms[10915:10918], - forms[10918:10936], - forms[10936:10954], - forms[10954:10972], - forms[10972:10990], - forms[10990:11017], - forms[11017:11044], - forms[11044:11074], - forms[11074:11104], - forms[11104:11113], - forms[11113:11122], - forms[11122:11123], - forms[11123:11153], - forms[11153:11183], - forms[11183:11192], - forms[11192:11201], - forms[11201:11205], - forms[11205:11209], - forms[11209:11212], - forms[11212:11215], - forms[11215:11242], - forms[11242:11269], - forms[11269:11296], - forms[11296:11323], - forms[11323:11350], - forms[11350:11377], - forms[11377:11378], - forms[11378:11379], - forms[11379:11381], - forms[11381:11383], - forms[11383:11385], - forms[11385:11387], - forms[11387:11390], - forms[11390:11395], - forms[11395:11400], - forms[11400:11405], - forms[11405:11406], - forms[11406:11407], - forms[11407:11413], - forms[11413:11421], - forms[11421:11423], - forms[11423:11425], + forms[10804:10816], + forms[10816:10825], + forms[10825:10834], + forms[10834:10838], + forms[10838:10840], + forms[10840:10870], + forms[10870:10900], + forms[10900:10909], + forms[10909:10918], + forms[10918:10921], + forms[10921:10924], + forms[10924:10927], + forms[10927:10930], + forms[10930:10948], + forms[10948:10966], + forms[10966:10984], + forms[10984:11002], + forms[11002:11029], + forms[11029:11056], + forms[11056:11086], + forms[11086:11116], + forms[11116:11125], + forms[11125:11134], + forms[11134:11135], + forms[11135:11165], + forms[11165:11195], + forms[11195:11204], + forms[11204:11213], + forms[11213:11217], + forms[11217:11221], + forms[11221:11224], + forms[11224:11227], + forms[11227:11254], + forms[11254:11281], + forms[11281:11308], + forms[11308:11335], + forms[11335:11362], + forms[11362:11389], + forms[11389:11390], + forms[11390:11391], + forms[11391:11393], + forms[11393:11395], + forms[11395:11397], + forms[11397:11399], + forms[11399:11402], + forms[11402:11407], + forms[11407:11412], + forms[11412:11417], + forms[11417:11418], + forms[11418:11419], + forms[11419:11425], forms[11425:11433], - forms[11433:11441], + forms[11433:11435], + forms[11435:11437], + forms[11437:11445], + forms[11445:11453], } From c9b438f7df1dc92d63dbc115322c7fa2f9ba1955 Mon Sep 17 00:00:00 2001 From: Michael McLoughlin Date: Sun, 27 Nov 2022 15:39:31 -0800 Subject: [PATCH 09/10] fix reproducibility bug and regenerate --- build/zinstructions.go | 20 +- internal/inst/types.go | 16 + internal/inst/ztable.go | 69 +++ internal/load/load.go | 6 +- internal/opcodesextra/instructions.go | 9 +- x86/zctors.go | 10 +- x86/zctors_test.go | 18 + x86/zoptab.go | 792 +++++++++++++------------- 8 files changed, 536 insertions(+), 404 deletions(-) diff --git a/build/zinstructions.go b/build/zinstructions.go index 1251500b..a0cffd79 100644 --- a/build/zinstructions.go +++ b/build/zinstructions.go @@ -49999,9 +49999,12 @@ func VGETMANTSS_Z(i, mx, x, k, x1 operand.Op) { ctx.VGETMANTSS_Z(i, mx, x, k, x1 // VGF2P8AFFINEINVQB imm8 ymm ymm ymm // VGF2P8AFFINEINVQB imm8 m512 zmm k zmm // VGF2P8AFFINEINVQB imm8 m512 zmm zmm +// VGF2P8AFFINEINVQB imm8 zmm zmm k zmm // VGF2P8AFFINEINVQB imm8 zmm zmm zmm // VGF2P8AFFINEINVQB imm8 m128 xmm k xmm // VGF2P8AFFINEINVQB imm8 m256 ymm k ymm +// VGF2P8AFFINEINVQB imm8 xmm xmm k xmm +// VGF2P8AFFINEINVQB imm8 ymm ymm k ymm // // Construct and append a VGF2P8AFFINEINVQB instruction to the active function. func (c *Context) VGF2P8AFFINEINVQB(ops ...operand.Op) { @@ -50018,9 +50021,12 @@ func (c *Context) VGF2P8AFFINEINVQB(ops ...operand.Op) { // VGF2P8AFFINEINVQB imm8 ymm ymm ymm // VGF2P8AFFINEINVQB imm8 m512 zmm k zmm // VGF2P8AFFINEINVQB imm8 m512 zmm zmm +// VGF2P8AFFINEINVQB imm8 zmm zmm k zmm // VGF2P8AFFINEINVQB imm8 zmm zmm zmm // VGF2P8AFFINEINVQB imm8 m128 xmm k xmm // VGF2P8AFFINEINVQB imm8 m256 ymm k ymm +// VGF2P8AFFINEINVQB imm8 xmm xmm k xmm +// VGF2P8AFFINEINVQB imm8 ymm ymm k ymm // // Construct and append a VGF2P8AFFINEINVQB instruction to the active function. // Operates on the global context. @@ -50089,12 +50095,15 @@ func VGF2P8AFFINEINVQB_BCST_Z(i, m, xyz, k, xyz1 operand.Op) { // Forms: // // VGF2P8AFFINEINVQB.Z imm8 m512 zmm k zmm +// VGF2P8AFFINEINVQB.Z imm8 zmm zmm k zmm // VGF2P8AFFINEINVQB.Z imm8 m128 xmm k xmm // VGF2P8AFFINEINVQB.Z imm8 m256 ymm k ymm +// VGF2P8AFFINEINVQB.Z imm8 xmm xmm k xmm +// VGF2P8AFFINEINVQB.Z imm8 ymm ymm k ymm // // Construct and append a VGF2P8AFFINEINVQB.Z instruction to the active function. -func (c *Context) VGF2P8AFFINEINVQB_Z(i, m, xyz, k, xyz1 operand.Op) { - c.addinstruction(x86.VGF2P8AFFINEINVQB_Z(i, m, xyz, k, xyz1)) +func (c *Context) VGF2P8AFFINEINVQB_Z(i, mxyz, xyz, k, xyz1 operand.Op) { + c.addinstruction(x86.VGF2P8AFFINEINVQB_Z(i, mxyz, xyz, k, xyz1)) } // VGF2P8AFFINEINVQB_Z: Galois Field Affine Transformation Inverse (Zeroing Masking). @@ -50102,12 +50111,17 @@ func (c *Context) VGF2P8AFFINEINVQB_Z(i, m, xyz, k, xyz1 operand.Op) { // Forms: // // VGF2P8AFFINEINVQB.Z imm8 m512 zmm k zmm +// VGF2P8AFFINEINVQB.Z imm8 zmm zmm k zmm // VGF2P8AFFINEINVQB.Z imm8 m128 xmm k xmm // VGF2P8AFFINEINVQB.Z imm8 m256 ymm k ymm +// VGF2P8AFFINEINVQB.Z imm8 xmm xmm k xmm +// VGF2P8AFFINEINVQB.Z imm8 ymm ymm k ymm // // Construct and append a VGF2P8AFFINEINVQB.Z instruction to the active function. // Operates on the global context. -func VGF2P8AFFINEINVQB_Z(i, m, xyz, k, xyz1 operand.Op) { ctx.VGF2P8AFFINEINVQB_Z(i, m, xyz, k, xyz1) } +func VGF2P8AFFINEINVQB_Z(i, mxyz, xyz, k, xyz1 operand.Op) { + ctx.VGF2P8AFFINEINVQB_Z(i, mxyz, xyz, k, xyz1) +} // VGF2P8AFFINEQB: Galois Field Affine Transformation. // diff --git a/internal/inst/types.go b/internal/inst/types.go index 0d65b96c..8d591c91 100644 --- a/internal/inst/types.go +++ b/internal/inst/types.go @@ -40,6 +40,13 @@ func (i Instruction) IsConditionalBranch() bool { return i.IsBranch() && i.Opcode != "JMP" } +// Clone the instruction. +func (i Instruction) Clone() Instruction { + c := i + c.Forms = i.Forms.Clone() + return c +} + // Forms is a collection of instruction forms. type Forms []Form @@ -78,6 +85,15 @@ func (fs Forms) IsNiladic() bool { return len(a) == 1 && a[0] == 0 } +// Clone the instruction forms. +func (fs Forms) Clone() Forms { + cs := make(Forms, 0, len(fs)) + for _, f := range fs { + cs = append(cs, f.Clone()) + } + return cs +} + // Form specifies one accepted set of operands for an instruction. type Form struct { // Instruction sets this instruction form requires. diff --git a/internal/inst/ztable.go b/internal/inst/ztable.go index 86333d80..bfb50fac 100644 --- a/internal/inst/ztable.go +++ b/internal/inst/ztable.go @@ -50685,6 +50685,29 @@ var Instructions = []Instruction{ EncodingType: 0x4, Broadcast: true, }, + { + ISA: []string{"AVX512F", "GFNI"}, + Operands: []Operand{ + {Type: "imm8", Action: 0x1}, + {Type: "zmm", Action: 0x1}, + {Type: "zmm", Action: 0x1}, + {Type: "k", Action: 0x1}, + {Type: "zmm", Action: 0x3}, + }, + EncodingType: 0x4, + }, + { + ISA: []string{"AVX512F", "GFNI"}, + Operands: []Operand{ + {Type: "imm8", Action: 0x1}, + {Type: "zmm", Action: 0x1}, + {Type: "zmm", Action: 0x1}, + {Type: "k", Action: 0x1}, + {Type: "zmm", Action: 0x2}, + }, + EncodingType: 0x4, + Zeroing: true, + }, { ISA: []string{"AVX512F", "GFNI"}, Operands: []Operand{ @@ -50813,6 +50836,52 @@ var Instructions = []Instruction{ EncodingType: 0x4, Broadcast: true, }, + { + ISA: []string{"AVX512VL", "GFNI"}, + Operands: []Operand{ + {Type: "imm8", Action: 0x1}, + {Type: "xmm", Action: 0x1}, + {Type: "xmm", Action: 0x1}, + {Type: "k", Action: 0x1}, + {Type: "xmm", Action: 0x3}, + }, + EncodingType: 0x4, + }, + { + ISA: []string{"AVX512VL", "GFNI"}, + Operands: []Operand{ + {Type: "imm8", Action: 0x1}, + {Type: "xmm", Action: 0x1}, + {Type: "xmm", Action: 0x1}, + {Type: "k", Action: 0x1}, + {Type: "xmm", Action: 0x2}, + }, + EncodingType: 0x4, + Zeroing: true, + }, + { + ISA: []string{"AVX512VL", "GFNI"}, + Operands: []Operand{ + {Type: "imm8", Action: 0x1}, + {Type: "ymm", Action: 0x1}, + {Type: "ymm", Action: 0x1}, + {Type: "k", Action: 0x1}, + {Type: "ymm", Action: 0x3}, + }, + EncodingType: 0x4, + }, + { + ISA: []string{"AVX512VL", "GFNI"}, + Operands: []Operand{ + {Type: "imm8", Action: 0x1}, + {Type: "ymm", Action: 0x1}, + {Type: "ymm", Action: 0x1}, + {Type: "k", Action: 0x1}, + {Type: "ymm", Action: 0x2}, + }, + EncodingType: 0x4, + Zeroing: true, + }, }, }, { diff --git a/internal/load/load.go b/internal/load/load.go index 1274106b..0cdb6743 100644 --- a/internal/load/load.go +++ b/internal/load/load.go @@ -126,6 +126,7 @@ func (l *Loader) Load() ([]inst.Instruction, error) { // Convert to a slice. Sort instructions and forms for reproducibility. is := make([]inst.Instruction, 0, len(im)) for _, i := range im { + sortforms(i.Forms) is = append(is, *i) } @@ -133,10 +134,6 @@ func (l *Loader) Load() ([]inst.Instruction, error) { return is[i].Opcode < is[j].Opcode }) - for _, i := range im { - sortforms(i.Forms) - } - return is, nil } @@ -834,7 +831,6 @@ func vexevex(fs []inst.Form) ([]inst.Form, error) { } if group[0].EncodingType != inst.EncodingTypeVEX || group[1].EncodingType != inst.EncodingTypeEVEX { - fmt.Println(group) return nil, errors.New("expected pair of VEX/EVEX encoded forms") } diff --git a/internal/opcodesextra/instructions.go b/internal/opcodesextra/instructions.go index d4834316..b4916e80 100644 --- a/internal/opcodesextra/instructions.go +++ b/internal/opcodesextra/instructions.go @@ -11,9 +11,16 @@ var sets = [][]*inst.Instruction{ // Instructions returns a list of extras to add to the instructions database. func Instructions() []*inst.Instruction { + // Concatenate and clone the instruction lists. It can be convenient for + // forms lists and other data structures to be shared in the curated lists, + // but we want to return distinct copies here to avoid subtle bugs in + // consumers. var is []*inst.Instruction for _, set := range sets { - is = append(is, set...) + for _, i := range set { + c := i.Clone() + is = append(is, &c) + } } return is } diff --git a/x86/zctors.go b/x86/zctors.go index 74b36f1d..85a2ee6a 100644 --- a/x86/zctors.go +++ b/x86/zctors.go @@ -21960,9 +21960,12 @@ func VGETMANTSS_Z(i, mx, x, k, x1 operand.Op) (*intrep.Instruction, error) { // VGF2P8AFFINEINVQB imm8 ymm ymm ymm // VGF2P8AFFINEINVQB imm8 m512 zmm k zmm // VGF2P8AFFINEINVQB imm8 m512 zmm zmm +// VGF2P8AFFINEINVQB imm8 zmm zmm k zmm // VGF2P8AFFINEINVQB imm8 zmm zmm zmm // VGF2P8AFFINEINVQB imm8 m128 xmm k xmm // VGF2P8AFFINEINVQB imm8 m256 ymm k ymm +// VGF2P8AFFINEINVQB imm8 xmm xmm k xmm +// VGF2P8AFFINEINVQB imm8 ymm ymm k ymm func VGF2P8AFFINEINVQB(ops ...operand.Op) (*intrep.Instruction, error) { return build(opcVGF2P8AFFINEINVQB.Forms(), sffxs{}, ops) } @@ -21997,10 +22000,13 @@ func VGF2P8AFFINEINVQB_BCST_Z(i, m, xyz, k, xyz1 operand.Op) (*intrep.Instructio // Forms: // // VGF2P8AFFINEINVQB.Z imm8 m512 zmm k zmm +// VGF2P8AFFINEINVQB.Z imm8 zmm zmm k zmm // VGF2P8AFFINEINVQB.Z imm8 m128 xmm k xmm // VGF2P8AFFINEINVQB.Z imm8 m256 ymm k ymm -func VGF2P8AFFINEINVQB_Z(i, m, xyz, k, xyz1 operand.Op) (*intrep.Instruction, error) { - return build(opcVGF2P8AFFINEINVQB.Forms(), sffxs{sffxZ}, []operand.Op{i, m, xyz, k, xyz1}) +// VGF2P8AFFINEINVQB.Z imm8 xmm xmm k xmm +// VGF2P8AFFINEINVQB.Z imm8 ymm ymm k ymm +func VGF2P8AFFINEINVQB_Z(i, mxyz, xyz, k, xyz1 operand.Op) (*intrep.Instruction, error) { + return build(opcVGF2P8AFFINEINVQB.Forms(), sffxs{sffxZ}, []operand.Op{i, mxyz, xyz, k, xyz1}) } // VGF2P8AFFINEQB: Galois Field Affine Transformation. diff --git a/x86/zctors_test.go b/x86/zctors_test.go index d4cf4cee..c7b707f2 100644 --- a/x86/zctors_test.go +++ b/x86/zctors_test.go @@ -23292,6 +23292,9 @@ func TestVGF2P8AFFINEINVQBValidFormsNoError(t *testing.T) { if _, err := VGF2P8AFFINEINVQB(opimm8, opm512, opzmm, opzmm); err != nil { t.Fatal(err) } + if _, err := VGF2P8AFFINEINVQB(opimm8, opzmm, opzmm, opk, opzmm); err != nil { + t.Fatal(err) + } if _, err := VGF2P8AFFINEINVQB(opimm8, opzmm, opzmm, opzmm); err != nil { t.Fatal(err) } @@ -23301,6 +23304,12 @@ func TestVGF2P8AFFINEINVQBValidFormsNoError(t *testing.T) { if _, err := VGF2P8AFFINEINVQB(opimm8, opm256, opymm, opk, opymm); err != nil { t.Fatal(err) } + if _, err := VGF2P8AFFINEINVQB(opimm8, opxmm, opxmm, opk, opxmm); err != nil { + t.Fatal(err) + } + if _, err := VGF2P8AFFINEINVQB(opimm8, opymm, opymm, opk, opymm); err != nil { + t.Fatal(err) + } } func TestVGF2P8AFFINEINVQB_BCSTValidFormsNoError(t *testing.T) { @@ -23340,12 +23349,21 @@ func TestVGF2P8AFFINEINVQB_ZValidFormsNoError(t *testing.T) { if _, err := VGF2P8AFFINEINVQB_Z(opimm8, opm512, opzmm, opk, opzmm); err != nil { t.Fatal(err) } + if _, err := VGF2P8AFFINEINVQB_Z(opimm8, opzmm, opzmm, opk, opzmm); err != nil { + t.Fatal(err) + } if _, err := VGF2P8AFFINEINVQB_Z(opimm8, opm128, opxmm, opk, opxmm); err != nil { t.Fatal(err) } if _, err := VGF2P8AFFINEINVQB_Z(opimm8, opm256, opymm, opk, opymm); err != nil { t.Fatal(err) } + if _, err := VGF2P8AFFINEINVQB_Z(opimm8, opxmm, opxmm, opk, opxmm); err != nil { + t.Fatal(err) + } + if _, err := VGF2P8AFFINEINVQB_Z(opimm8, opymm, opymm, opk, opymm); err != nil { + t.Fatal(err) + } } func TestVGF2P8AFFINEQBValidFormsNoError(t *testing.T) { diff --git a/x86/zoptab.go b/x86/zoptab.go index d61f5e62..34608a4f 100644 --- a/x86/zoptab.go +++ b/x86/zoptab.go @@ -7894,6 +7894,8 @@ var forms = []form{ {opcVGF2P8AFFINEINVQB, sffxsclsBCST, 0, isasAVX512F_GFNI, 5, oprnds{{uint8(oprndtypeIMM8), false, actionR}, {uint8(oprndtypeM64), false, actionR}, {uint8(oprndtypeZMM), false, actionR}, {uint8(oprndtypeK), false, actionR}, {uint8(oprndtypeZMM), false, actionRW}}}, {opcVGF2P8AFFINEINVQB, sffxsclsBCST_Z, 0, isasAVX512F_GFNI, 5, oprnds{{uint8(oprndtypeIMM8), false, actionR}, {uint8(oprndtypeM64), false, actionR}, {uint8(oprndtypeZMM), false, actionR}, {uint8(oprndtypeK), false, actionR}, {uint8(oprndtypeZMM), false, actionW}}}, {opcVGF2P8AFFINEINVQB, sffxsclsBCST, 0, isasAVX512F_GFNI, 4, oprnds{{uint8(oprndtypeIMM8), false, actionR}, {uint8(oprndtypeM64), false, actionR}, {uint8(oprndtypeZMM), false, actionR}, {uint8(oprndtypeZMM), false, actionW}}}, + {opcVGF2P8AFFINEINVQB, sffxsclsNIL, 0, isasAVX512F_GFNI, 5, oprnds{{uint8(oprndtypeIMM8), false, actionR}, {uint8(oprndtypeZMM), false, actionR}, {uint8(oprndtypeZMM), false, actionR}, {uint8(oprndtypeK), false, actionR}, {uint8(oprndtypeZMM), false, actionRW}}}, + {opcVGF2P8AFFINEINVQB, sffxsclsZ, 0, isasAVX512F_GFNI, 5, oprnds{{uint8(oprndtypeIMM8), false, actionR}, {uint8(oprndtypeZMM), false, actionR}, {uint8(oprndtypeZMM), false, actionR}, {uint8(oprndtypeK), false, actionR}, {uint8(oprndtypeZMM), false, actionW}}}, {opcVGF2P8AFFINEINVQB, sffxsclsNIL, 0, isasAVX512F_GFNI, 4, oprnds{{uint8(oprndtypeIMM8), false, actionR}, {uint8(oprndtypeZMM), false, actionR}, {uint8(oprndtypeZMM), false, actionR}, {uint8(oprndtypeZMM), false, actionW}}}, {opcVGF2P8AFFINEINVQB, sffxsclsNIL, 0, isasAVX512VL_GFNI, 5, oprnds{{uint8(oprndtypeIMM8), false, actionR}, {uint8(oprndtypeM128), false, actionR}, {uint8(oprndtypeXMM), false, actionR}, {uint8(oprndtypeK), false, actionR}, {uint8(oprndtypeXMM), false, actionRW}}}, {opcVGF2P8AFFINEINVQB, sffxsclsZ, 0, isasAVX512VL_GFNI, 5, oprnds{{uint8(oprndtypeIMM8), false, actionR}, {uint8(oprndtypeM128), false, actionR}, {uint8(oprndtypeXMM), false, actionR}, {uint8(oprndtypeK), false, actionR}, {uint8(oprndtypeXMM), false, actionW}}}, @@ -7905,6 +7907,10 @@ var forms = []form{ {opcVGF2P8AFFINEINVQB, sffxsclsBCST, 0, isasAVX512VL_GFNI, 5, oprnds{{uint8(oprndtypeIMM8), false, actionR}, {uint8(oprndtypeM64), false, actionR}, {uint8(oprndtypeYMM), false, actionR}, {uint8(oprndtypeK), false, actionR}, {uint8(oprndtypeYMM), false, actionRW}}}, {opcVGF2P8AFFINEINVQB, sffxsclsBCST_Z, 0, isasAVX512VL_GFNI, 5, oprnds{{uint8(oprndtypeIMM8), false, actionR}, {uint8(oprndtypeM64), false, actionR}, {uint8(oprndtypeYMM), false, actionR}, {uint8(oprndtypeK), false, actionR}, {uint8(oprndtypeYMM), false, actionW}}}, {opcVGF2P8AFFINEINVQB, sffxsclsBCST, 0, isasAVX512VL_GFNI, 4, oprnds{{uint8(oprndtypeIMM8), false, actionR}, {uint8(oprndtypeM64), false, actionR}, {uint8(oprndtypeYMM), false, actionR}, {uint8(oprndtypeYMM), false, actionW}}}, + {opcVGF2P8AFFINEINVQB, sffxsclsNIL, 0, isasAVX512VL_GFNI, 5, oprnds{{uint8(oprndtypeIMM8), false, actionR}, {uint8(oprndtypeXMM), false, actionR}, {uint8(oprndtypeXMM), false, actionR}, {uint8(oprndtypeK), false, actionR}, {uint8(oprndtypeXMM), false, actionRW}}}, + {opcVGF2P8AFFINEINVQB, sffxsclsZ, 0, isasAVX512VL_GFNI, 5, oprnds{{uint8(oprndtypeIMM8), false, actionR}, {uint8(oprndtypeXMM), false, actionR}, {uint8(oprndtypeXMM), false, actionR}, {uint8(oprndtypeK), false, actionR}, {uint8(oprndtypeXMM), false, actionW}}}, + {opcVGF2P8AFFINEINVQB, sffxsclsNIL, 0, isasAVX512VL_GFNI, 5, oprnds{{uint8(oprndtypeIMM8), false, actionR}, {uint8(oprndtypeYMM), false, actionR}, {uint8(oprndtypeYMM), false, actionR}, {uint8(oprndtypeK), false, actionR}, {uint8(oprndtypeYMM), false, actionRW}}}, + {opcVGF2P8AFFINEINVQB, sffxsclsZ, 0, isasAVX512VL_GFNI, 5, oprnds{{uint8(oprndtypeIMM8), false, actionR}, {uint8(oprndtypeYMM), false, actionR}, {uint8(oprndtypeYMM), false, actionR}, {uint8(oprndtypeK), false, actionR}, {uint8(oprndtypeYMM), false, actionW}}}, {opcVGF2P8AFFINEQB, sffxsclsNIL, 0, isasAVX_GFNI, 4, oprnds{{uint8(oprndtypeIMM8), false, actionR}, {uint8(oprndtypeM128), false, actionR}, {uint8(oprndtypeXMM), false, actionR}, {uint8(oprndtypeXMM), false, actionW}}}, {opcVGF2P8AFFINEQB, sffxsclsNIL, 0, isasAVX_GFNI, 4, oprnds{{uint8(oprndtypeIMM8), false, actionR}, {uint8(oprndtypeM256), false, actionR}, {uint8(oprndtypeYMM), false, actionR}, {uint8(oprndtypeYMM), false, actionW}}}, {opcVGF2P8AFFINEQB, sffxsclsNIL, 0, isasAVX_GFNI, 4, oprnds{{uint8(oprndtypeIMM8), false, actionR}, {uint8(oprndtypeXMM), false, actionR}, {uint8(oprndtypeXMM), false, actionR}, {uint8(oprndtypeXMM), false, actionW}}}, @@ -15310,413 +15316,413 @@ var opcformstable = [][]form{ forms[4865:4895], forms[4895:4904], forms[4904:4913], - forms[4913:4934], - forms[4934:4961], - forms[4961:4979], - forms[4979:4983], - forms[4983:4987], - forms[4987:4991], - forms[4991:4995], - forms[4995:4997], - forms[4997:5009], - forms[5009:5015], - forms[5015:5027], - forms[5027:5033], - forms[5033:5035], - forms[5035:5047], - forms[5047:5053], - forms[5053:5065], - forms[5065:5071], - forms[5071:5073], - forms[5073:5075], - forms[5075:5076], - forms[5076:5077], - forms[5077:5081], - forms[5081:5085], - forms[5085:5115], - forms[5115:5145], - forms[5145:5154], - forms[5154:5163], - forms[5163:5193], - forms[5193:5223], - forms[5223:5232], - forms[5232:5241], - forms[5241:5268], - forms[5268:5295], - forms[5295:5299], - forms[5299:5317], - forms[5317:5323], - forms[5323:5350], - forms[5350:5377], - forms[5377:5383], - forms[5383:5410], - forms[5410:5437], - forms[5437:5464], - forms[5464:5491], - forms[5491:5492], - forms[5492:5494], - forms[5494:5496], - forms[5496:5497], - forms[5497:5499], - forms[5499:5501], - forms[5501:5503], + forms[4913:4940], + forms[4940:4967], + forms[4967:4985], + forms[4985:4989], + forms[4989:4993], + forms[4993:4997], + forms[4997:5001], + forms[5001:5003], + forms[5003:5015], + forms[5015:5021], + forms[5021:5033], + forms[5033:5039], + forms[5039:5041], + forms[5041:5053], + forms[5053:5059], + forms[5059:5071], + forms[5071:5077], + forms[5077:5079], + forms[5079:5081], + forms[5081:5082], + forms[5082:5083], + forms[5083:5087], + forms[5087:5091], + forms[5091:5121], + forms[5121:5151], + forms[5151:5160], + forms[5160:5169], + forms[5169:5199], + forms[5199:5229], + forms[5229:5238], + forms[5238:5247], + forms[5247:5274], + forms[5274:5301], + forms[5301:5305], + forms[5305:5323], + forms[5323:5329], + forms[5329:5356], + forms[5356:5383], + forms[5383:5389], + forms[5389:5416], + forms[5416:5443], + forms[5443:5470], + forms[5470:5497], + forms[5497:5498], + forms[5498:5500], + forms[5500:5502], + forms[5502:5503], forms[5503:5505], - forms[5505:5508], - forms[5508:5511], + forms[5505:5507], + forms[5507:5509], + forms[5509:5511], forms[5511:5514], forms[5514:5517], - forms[5517:5522], - forms[5522:5530], - forms[5530:5548], - forms[5548:5566], - forms[5566:5574], - forms[5574:5601], - forms[5601:5628], - forms[5628:5632], - forms[5632:5662], - forms[5662:5692], - forms[5692:5701], - forms[5701:5710], - forms[5710:5737], - forms[5737:5764], - forms[5764:5782], - forms[5782:5809], - forms[5809:5836], - forms[5836:5854], - forms[5854:5881], - forms[5881:5899], - forms[5899:5926], - forms[5926:5944], - forms[5944:5962], - forms[5962:5989], - forms[5989:6016], - forms[6016:6034], - forms[6034:6052], - forms[6052:6070], - forms[6070:6088], - forms[6088:6106], - forms[6106:6124], - forms[6124:6128], - forms[6128:6155], - forms[6155:6159], - forms[6159:6186], - forms[6186:6213], - forms[6213:6240], - forms[6240:6258], - forms[6258:6276], - forms[6276:6280], - forms[6280:6298], - forms[6298:6325], - forms[6325:6352], - forms[6352:6370], - forms[6370:6374], - forms[6374:6378], - forms[6378:6405], - forms[6405:6432], - forms[6432:6435], - forms[6435:6438], - forms[6438:6465], - forms[6465:6492], - forms[6492:6494], - forms[6494:6506], - forms[6506:6524], - forms[6524:6540], - forms[6540:6562], - forms[6562:6584], - forms[6584:6600], - forms[6600:6602], - forms[6602:6604], - forms[6604:6620], - forms[6620:6642], - forms[6642:6664], - forms[6664:6680], - forms[6680:6682], - forms[6682:6684], - forms[6684:6702], - forms[6702:6714], - forms[6714:6732], - forms[6732:6750], - forms[6750:6762], - forms[6762:6774], - forms[6774:6792], - forms[6792:6810], - forms[6810:6837], - forms[6837:6864], - forms[6864:6866], - forms[6866:6868], - forms[6868:6886], - forms[6886:6904], - forms[6904:6922], - forms[6922:6949], - forms[6949:6976], - forms[6976:7003], - forms[7003:7030], - forms[7030:7048], - forms[7048:7102], - forms[7102:7156], - forms[7156:7192], - forms[7192:7210], - forms[7210:7246], - forms[7246:7264], - forms[7264:7291], - forms[7291:7318], - forms[7318:7345], - forms[7345:7372], - forms[7372:7390], - forms[7390:7408], - forms[7408:7426], - forms[7426:7444], - forms[7444:7446], - forms[7446:7448], - forms[7448:7450], + forms[5517:5520], + forms[5520:5523], + forms[5523:5528], + forms[5528:5536], + forms[5536:5554], + forms[5554:5572], + forms[5572:5580], + forms[5580:5607], + forms[5607:5634], + forms[5634:5638], + forms[5638:5668], + forms[5668:5698], + forms[5698:5707], + forms[5707:5716], + forms[5716:5743], + forms[5743:5770], + forms[5770:5788], + forms[5788:5815], + forms[5815:5842], + forms[5842:5860], + forms[5860:5887], + forms[5887:5905], + forms[5905:5932], + forms[5932:5950], + forms[5950:5968], + forms[5968:5995], + forms[5995:6022], + forms[6022:6040], + forms[6040:6058], + forms[6058:6076], + forms[6076:6094], + forms[6094:6112], + forms[6112:6130], + forms[6130:6134], + forms[6134:6161], + forms[6161:6165], + forms[6165:6192], + forms[6192:6219], + forms[6219:6246], + forms[6246:6264], + forms[6264:6282], + forms[6282:6286], + forms[6286:6304], + forms[6304:6331], + forms[6331:6358], + forms[6358:6376], + forms[6376:6380], + forms[6380:6384], + forms[6384:6411], + forms[6411:6438], + forms[6438:6441], + forms[6441:6444], + forms[6444:6471], + forms[6471:6498], + forms[6498:6500], + forms[6500:6512], + forms[6512:6530], + forms[6530:6546], + forms[6546:6568], + forms[6568:6590], + forms[6590:6606], + forms[6606:6608], + forms[6608:6610], + forms[6610:6626], + forms[6626:6648], + forms[6648:6670], + forms[6670:6686], + forms[6686:6688], + forms[6688:6690], + forms[6690:6708], + forms[6708:6720], + forms[6720:6738], + forms[6738:6756], + forms[6756:6768], + forms[6768:6780], + forms[6780:6798], + forms[6798:6816], + forms[6816:6843], + forms[6843:6870], + forms[6870:6872], + forms[6872:6874], + forms[6874:6892], + forms[6892:6910], + forms[6910:6928], + forms[6928:6955], + forms[6955:6982], + forms[6982:7009], + forms[7009:7036], + forms[7036:7054], + forms[7054:7108], + forms[7108:7162], + forms[7162:7198], + forms[7198:7216], + forms[7216:7252], + forms[7252:7270], + forms[7270:7297], + forms[7297:7324], + forms[7324:7351], + forms[7351:7378], + forms[7378:7396], + forms[7396:7414], + forms[7414:7432], + forms[7432:7450], forms[7450:7452], - forms[7452:7457], - forms[7457:7462], - forms[7462:7467], - forms[7467:7472], - forms[7472:7476], - forms[7476:7480], - forms[7480:7484], - forms[7484:7486], + forms[7452:7454], + forms[7454:7456], + forms[7456:7458], + forms[7458:7463], + forms[7463:7468], + forms[7468:7473], + forms[7473:7478], + forms[7478:7482], + forms[7482:7486], forms[7486:7490], - forms[7490:7494], - forms[7494:7498], - forms[7498:7500], - forms[7500:7502], - forms[7502:7504], + forms[7490:7492], + forms[7492:7496], + forms[7496:7500], + forms[7500:7504], forms[7504:7506], - forms[7506:7533], - forms[7533:7560], - forms[7560:7587], - forms[7587:7614], - forms[7614:7632], - forms[7632:7650], - forms[7650:7654], - forms[7654:7658], - forms[7658:7676], - forms[7676:7703], - forms[7703:7730], - forms[7730:7748], - forms[7748:7766], - forms[7766:7793], - forms[7793:7820], - forms[7820:7838], - forms[7838:7856], - forms[7856:7883], - forms[7883:7910], - forms[7910:7928], - forms[7928:7946], - forms[7946:7973], - forms[7973:8000], - forms[8000:8018], - forms[8018:8021], - forms[8021:8024], - forms[8024:8042], - forms[8042:8060], - forms[8060:8063], - forms[8063:8066], + forms[7506:7508], + forms[7508:7510], + forms[7510:7512], + forms[7512:7539], + forms[7539:7566], + forms[7566:7593], + forms[7593:7620], + forms[7620:7638], + forms[7638:7656], + forms[7656:7660], + forms[7660:7664], + forms[7664:7682], + forms[7682:7709], + forms[7709:7736], + forms[7736:7754], + forms[7754:7772], + forms[7772:7799], + forms[7799:7826], + forms[7826:7844], + forms[7844:7862], + forms[7862:7889], + forms[7889:7916], + forms[7916:7934], + forms[7934:7952], + forms[7952:7979], + forms[7979:8006], + forms[8006:8024], + forms[8024:8027], + forms[8027:8030], + forms[8030:8048], + forms[8048:8066], forms[8066:8069], forms[8069:8072], - forms[8072:8074], - forms[8074:8077], - forms[8077:8095], - forms[8095:8113], - forms[8113:8131], - forms[8131:8149], - forms[8149:8167], - forms[8167:8185], - forms[8185:8203], - forms[8203:8221], - forms[8221:8239], - forms[8239:8257], - forms[8257:8275], - forms[8275:8293], - forms[8293:8311], - forms[8311:8329], - forms[8329:8347], - forms[8347:8365], - forms[8365:8383], - forms[8383:8401], - forms[8401:8419], - forms[8419:8437], - forms[8437:8455], - forms[8455:8458], - forms[8458:8476], - forms[8476:8494], - forms[8494:8512], - forms[8512:8530], - forms[8530:8548], - forms[8548:8566], - forms[8566:8584], - forms[8584:8611], - forms[8611:8629], - forms[8629:8647], - forms[8647:8665], - forms[8665:8692], - forms[8692:8719], - forms[8719:8737], - forms[8737:8764], - forms[8764:8791], - forms[8791:8800], - forms[8800:8809], - forms[8809:8813], - forms[8813:8840], - forms[8840:8867], - forms[8867:8894], - forms[8894:8921], - forms[8921:8948], - forms[8948:8975], - forms[8975:9002], - forms[9002:9029], - forms[9029:9056], - forms[9056:9083], - forms[9083:9089], - forms[9089:9092], - forms[9092:9095], + forms[8072:8075], + forms[8075:8078], + forms[8078:8080], + forms[8080:8083], + forms[8083:8101], + forms[8101:8119], + forms[8119:8137], + forms[8137:8155], + forms[8155:8173], + forms[8173:8191], + forms[8191:8209], + forms[8209:8227], + forms[8227:8245], + forms[8245:8263], + forms[8263:8281], + forms[8281:8299], + forms[8299:8317], + forms[8317:8335], + forms[8335:8353], + forms[8353:8371], + forms[8371:8389], + forms[8389:8407], + forms[8407:8425], + forms[8425:8443], + forms[8443:8461], + forms[8461:8464], + forms[8464:8482], + forms[8482:8500], + forms[8500:8518], + forms[8518:8536], + forms[8536:8554], + forms[8554:8572], + forms[8572:8590], + forms[8590:8617], + forms[8617:8635], + forms[8635:8653], + forms[8653:8671], + forms[8671:8698], + forms[8698:8725], + forms[8725:8743], + forms[8743:8770], + forms[8770:8797], + forms[8797:8806], + forms[8806:8815], + forms[8815:8819], + forms[8819:8846], + forms[8846:8873], + forms[8873:8900], + forms[8900:8927], + forms[8927:8954], + forms[8954:8981], + forms[8981:9008], + forms[9008:9035], + forms[9035:9062], + forms[9062:9089], + forms[9089:9095], forms[9095:9098], forms[9098:9101], - forms[9101:9119], - forms[9119:9146], - forms[9146:9164], - forms[9164:9182], - forms[9182:9186], - forms[9186:9190], - forms[9190:9194], - forms[9194:9239], - forms[9239:9245], - forms[9245:9290], - forms[9290:9317], - forms[9317:9344], - forms[9344:9362], - forms[9362:9398], - forms[9398:9443], - forms[9443:9488], - forms[9488:9515], - forms[9515:9542], - forms[9542:9560], - forms[9560:9596], - forms[9596:9641], - forms[9641:9647], - forms[9647:9692], - forms[9692:9719], - forms[9719:9746], - forms[9746:9764], - forms[9764:9800], - forms[9800:9818], - forms[9818:9845], - forms[9845:9872], - forms[9872:9890], - forms[9890:9908], - forms[9908:9926], - forms[9926:9944], - forms[9944:9962], - forms[9962:9989], - forms[9989:10016], - forms[10016:10020], - forms[10020:10032], - forms[10032:10050], - forms[10050:10068], - forms[10068:10080], - forms[10080:10092], - forms[10092:10110], - forms[10110:10128], - forms[10128:10140], - forms[10140:10158], - forms[10158:10185], - forms[10185:10212], - forms[10212:10230], - forms[10230:10248], - forms[10248:10275], - forms[10275:10302], - forms[10302:10320], - forms[10320:10324], - forms[10324:10351], - forms[10351:10378], - forms[10378:10408], - forms[10408:10438], - forms[10438:10447], - forms[10447:10456], - forms[10456:10483], - forms[10483:10510], - forms[10510:10516], + forms[9101:9104], + forms[9104:9107], + forms[9107:9125], + forms[9125:9152], + forms[9152:9170], + forms[9170:9188], + forms[9188:9192], + forms[9192:9196], + forms[9196:9200], + forms[9200:9245], + forms[9245:9251], + forms[9251:9296], + forms[9296:9323], + forms[9323:9350], + forms[9350:9368], + forms[9368:9404], + forms[9404:9449], + forms[9449:9494], + forms[9494:9521], + forms[9521:9548], + forms[9548:9566], + forms[9566:9602], + forms[9602:9647], + forms[9647:9653], + forms[9653:9698], + forms[9698:9725], + forms[9725:9752], + forms[9752:9770], + forms[9770:9806], + forms[9806:9824], + forms[9824:9851], + forms[9851:9878], + forms[9878:9896], + forms[9896:9914], + forms[9914:9932], + forms[9932:9950], + forms[9950:9968], + forms[9968:9995], + forms[9995:10022], + forms[10022:10026], + forms[10026:10038], + forms[10038:10056], + forms[10056:10074], + forms[10074:10086], + forms[10086:10098], + forms[10098:10116], + forms[10116:10134], + forms[10134:10146], + forms[10146:10164], + forms[10164:10191], + forms[10191:10218], + forms[10218:10236], + forms[10236:10254], + forms[10254:10281], + forms[10281:10308], + forms[10308:10326], + forms[10326:10330], + forms[10330:10357], + forms[10357:10384], + forms[10384:10414], + forms[10414:10444], + forms[10444:10453], + forms[10453:10462], + forms[10462:10489], + forms[10489:10516], forms[10516:10522], - forms[10522:10534], - forms[10534:10546], - forms[10546:10555], - forms[10555:10564], - forms[10564:10568], - forms[10568:10570], - forms[10570:10597], - forms[10597:10624], - forms[10624:10630], + forms[10522:10528], + forms[10528:10540], + forms[10540:10552], + forms[10552:10561], + forms[10561:10570], + forms[10570:10574], + forms[10574:10576], + forms[10576:10603], + forms[10603:10630], forms[10630:10636], - forms[10636:10666], - forms[10666:10696], - forms[10696:10705], - forms[10705:10714], - forms[10714:10718], - forms[10718:10722], - forms[10722:10724], - forms[10724:10726], - forms[10726:10753], - forms[10753:10780], - forms[10780:10786], + forms[10636:10642], + forms[10642:10672], + forms[10672:10702], + forms[10702:10711], + forms[10711:10720], + forms[10720:10724], + forms[10724:10728], + forms[10728:10730], + forms[10730:10732], + forms[10732:10759], + forms[10759:10786], forms[10786:10792], - forms[10792:10804], - forms[10804:10816], - forms[10816:10825], - forms[10825:10834], - forms[10834:10838], - forms[10838:10840], - forms[10840:10870], - forms[10870:10900], - forms[10900:10909], - forms[10909:10918], - forms[10918:10921], - forms[10921:10924], + forms[10792:10798], + forms[10798:10810], + forms[10810:10822], + forms[10822:10831], + forms[10831:10840], + forms[10840:10844], + forms[10844:10846], + forms[10846:10876], + forms[10876:10906], + forms[10906:10915], + forms[10915:10924], forms[10924:10927], forms[10927:10930], - forms[10930:10948], - forms[10948:10966], - forms[10966:10984], - forms[10984:11002], - forms[11002:11029], - forms[11029:11056], - forms[11056:11086], - forms[11086:11116], - forms[11116:11125], - forms[11125:11134], - forms[11134:11135], - forms[11135:11165], - forms[11165:11195], - forms[11195:11204], - forms[11204:11213], - forms[11213:11217], - forms[11217:11221], - forms[11221:11224], - forms[11224:11227], - forms[11227:11254], - forms[11254:11281], - forms[11281:11308], - forms[11308:11335], - forms[11335:11362], - forms[11362:11389], - forms[11389:11390], - forms[11390:11391], - forms[11391:11393], - forms[11393:11395], - forms[11395:11397], + forms[10930:10933], + forms[10933:10936], + forms[10936:10954], + forms[10954:10972], + forms[10972:10990], + forms[10990:11008], + forms[11008:11035], + forms[11035:11062], + forms[11062:11092], + forms[11092:11122], + forms[11122:11131], + forms[11131:11140], + forms[11140:11141], + forms[11141:11171], + forms[11171:11201], + forms[11201:11210], + forms[11210:11219], + forms[11219:11223], + forms[11223:11227], + forms[11227:11230], + forms[11230:11233], + forms[11233:11260], + forms[11260:11287], + forms[11287:11314], + forms[11314:11341], + forms[11341:11368], + forms[11368:11395], + forms[11395:11396], + forms[11396:11397], forms[11397:11399], - forms[11399:11402], - forms[11402:11407], - forms[11407:11412], - forms[11412:11417], - forms[11417:11418], - forms[11418:11419], - forms[11419:11425], - forms[11425:11433], - forms[11433:11435], - forms[11435:11437], - forms[11437:11445], - forms[11445:11453], + forms[11399:11401], + forms[11401:11403], + forms[11403:11405], + forms[11405:11408], + forms[11408:11413], + forms[11413:11418], + forms[11418:11423], + forms[11423:11424], + forms[11424:11425], + forms[11425:11431], + forms[11431:11439], + forms[11439:11441], + forms[11441:11443], + forms[11443:11451], + forms[11451:11459], } From 69eb79467b704b6959f2cf5038377e2c37626cca Mon Sep 17 00:00:00 2001 From: Michael McLoughlin Date: Sun, 27 Nov 2022 18:40:33 -0800 Subject: [PATCH 10/10] note on the expectations for extras list --- internal/opcodesextra/instructions.go | 7 +++++++ 1 file changed, 7 insertions(+) diff --git a/internal/opcodesextra/instructions.go b/internal/opcodesextra/instructions.go index b4916e80..39a42490 100644 --- a/internal/opcodesextra/instructions.go +++ b/internal/opcodesextra/instructions.go @@ -10,6 +10,13 @@ var sets = [][]*inst.Instruction{ } // Instructions returns a list of extras to add to the instructions database. +// +// Note that instructions returned are expected to be injected into the loading +// process, as if they had been read out of the Opcodes database. As such, they +// are not expected to be in the final form required for the instruction +// database. For example, AVX-512 instruction form transformations do not need +// to be applied, and operand types such as xmm{k}{z} or m256/m64bcst may be +// used for brevity. func Instructions() []*inst.Instruction { // Concatenate and clone the instruction lists. It can be convenient for // forms lists and other data structures to be shared in the curated lists,