all: VAES instructions (#358)

Adds "Vector Advanced Encryption Standard" instruction set.

These are added via the `opcodesextra` mechanism #345, since they're missing
from the opcodes database.

Contributed by @vsivsi. Extracted from #349 with minor tweaks.

Co-authored-by: Vaughn Iverson <vsivsi@yahoo.com>

build/zinstructions.go

@@ -16894,10 +16894,14 @@ func VADDSUBPS(mxy, xy, xy1 operand.Op) { ctx.VADDSUBPS(mxy, xy, xy1) }
 //
 //	VAESDEC m128 xmm xmm
 //	VAESDEC xmm  xmm xmm
+//	VAESDEC m256 ymm ymm
+//	VAESDEC ymm  ymm ymm
+//	VAESDEC m512 zmm zmm
+//	VAESDEC zmm  zmm zmm
 //
 // Construct and append a VAESDEC instruction to the active function.
-func (c *Context) VAESDEC(mx, x, x1 operand.Op) {
+func (c *Context) VAESDEC(mxyz, xyz, xyz1 operand.Op) {
-	c.addinstruction(x86.VAESDEC(mx, x, x1))
+	c.addinstruction(x86.VAESDEC(mxyz, xyz, xyz1))
 }
 
 // VAESDEC: Perform One Round of an AES Decryption Flow.
@@ -16906,10 +16910,14 @@ func (c *Context) VAESDEC(mx, x, x1 operand.Op) {
 //
 //	VAESDEC m128 xmm xmm
 //	VAESDEC xmm  xmm xmm
+//	VAESDEC m256 ymm ymm
+//	VAESDEC ymm  ymm ymm
+//	VAESDEC m512 zmm zmm
+//	VAESDEC zmm  zmm zmm
 //
 // Construct and append a VAESDEC instruction to the active function.
 // Operates on the global context.
-func VAESDEC(mx, x, x1 operand.Op) { ctx.VAESDEC(mx, x, x1) }
+func VAESDEC(mxyz, xyz, xyz1 operand.Op) { ctx.VAESDEC(mxyz, xyz, xyz1) }
 
 // VAESDECLAST: Perform Last Round of an AES Decryption Flow.
 //
@@ -16917,10 +16925,14 @@ func VAESDEC(mx, x, x1 operand.Op) { ctx.VAESDEC(mx, x, x1) }
 //
 //	VAESDECLAST m128 xmm xmm
 //	VAESDECLAST xmm  xmm xmm
+//	VAESDECLAST m256 ymm ymm
+//	VAESDECLAST ymm  ymm ymm
+//	VAESDECLAST m512 zmm zmm
+//	VAESDECLAST zmm  zmm zmm
 //
 // Construct and append a VAESDECLAST instruction to the active function.
-func (c *Context) VAESDECLAST(mx, x, x1 operand.Op) {
+func (c *Context) VAESDECLAST(mxyz, xyz, xyz1 operand.Op) {
-	c.addinstruction(x86.VAESDECLAST(mx, x, x1))
+	c.addinstruction(x86.VAESDECLAST(mxyz, xyz, xyz1))
 }
 
 // VAESDECLAST: Perform Last Round of an AES Decryption Flow.
@@ -16929,10 +16941,14 @@ func (c *Context) VAESDECLAST(mx, x, x1 operand.Op) {
 //
 //	VAESDECLAST m128 xmm xmm
 //	VAESDECLAST xmm  xmm xmm
+//	VAESDECLAST m256 ymm ymm
+//	VAESDECLAST ymm  ymm ymm
+//	VAESDECLAST m512 zmm zmm
+//	VAESDECLAST zmm  zmm zmm
 //
 // Construct and append a VAESDECLAST instruction to the active function.
 // Operates on the global context.
-func VAESDECLAST(mx, x, x1 operand.Op) { ctx.VAESDECLAST(mx, x, x1) }
+func VAESDECLAST(mxyz, xyz, xyz1 operand.Op) { ctx.VAESDECLAST(mxyz, xyz, xyz1) }
 
 // VAESENC: Perform One Round of an AES Encryption Flow.
 //
@@ -16940,10 +16956,14 @@ func VAESDECLAST(mx, x, x1 operand.Op) { ctx.VAESDECLAST(mx, x, x1) }
 //
 //	VAESENC m128 xmm xmm
 //	VAESENC xmm  xmm xmm
+//	VAESENC m256 ymm ymm
+//	VAESENC ymm  ymm ymm
+//	VAESENC m512 zmm zmm
+//	VAESENC zmm  zmm zmm
 //
 // Construct and append a VAESENC instruction to the active function.
-func (c *Context) VAESENC(mx, x, x1 operand.Op) {
+func (c *Context) VAESENC(mxyz, xyz, xyz1 operand.Op) {
-	c.addinstruction(x86.VAESENC(mx, x, x1))
+	c.addinstruction(x86.VAESENC(mxyz, xyz, xyz1))
 }
 
 // VAESENC: Perform One Round of an AES Encryption Flow.
@@ -16952,10 +16972,14 @@ func (c *Context) VAESENC(mx, x, x1 operand.Op) {
 //
 //	VAESENC m128 xmm xmm
 //	VAESENC xmm  xmm xmm
+//	VAESENC m256 ymm ymm
+//	VAESENC ymm  ymm ymm
+//	VAESENC m512 zmm zmm
+//	VAESENC zmm  zmm zmm
 //
 // Construct and append a VAESENC instruction to the active function.
 // Operates on the global context.
-func VAESENC(mx, x, x1 operand.Op) { ctx.VAESENC(mx, x, x1) }
+func VAESENC(mxyz, xyz, xyz1 operand.Op) { ctx.VAESENC(mxyz, xyz, xyz1) }
 
 // VAESENCLAST: Perform Last Round of an AES Encryption Flow.
 //
@@ -16963,10 +16987,14 @@ func VAESENC(mx, x, x1 operand.Op) { ctx.VAESENC(mx, x, x1) }
 //
 //	VAESENCLAST m128 xmm xmm
 //	VAESENCLAST xmm  xmm xmm
+//	VAESENCLAST m256 ymm ymm
+//	VAESENCLAST ymm  ymm ymm
+//	VAESENCLAST m512 zmm zmm
+//	VAESENCLAST zmm  zmm zmm
 //
 // Construct and append a VAESENCLAST instruction to the active function.
-func (c *Context) VAESENCLAST(mx, x, x1 operand.Op) {
+func (c *Context) VAESENCLAST(mxyz, xyz, xyz1 operand.Op) {
-	c.addinstruction(x86.VAESENCLAST(mx, x, x1))
+	c.addinstruction(x86.VAESENCLAST(mxyz, xyz, xyz1))
 }
 
 // VAESENCLAST: Perform Last Round of an AES Encryption Flow.
@@ -16975,10 +17003,14 @@ func (c *Context) VAESENCLAST(mx, x, x1 operand.Op) {
 //
 //	VAESENCLAST m128 xmm xmm
 //	VAESENCLAST xmm  xmm xmm
+//	VAESENCLAST m256 ymm ymm
+//	VAESENCLAST ymm  ymm ymm
+//	VAESENCLAST m512 zmm zmm
+//	VAESENCLAST zmm  zmm zmm
 //
 // Construct and append a VAESENCLAST instruction to the active function.
 // Operates on the global context.
-func VAESENCLAST(mx, x, x1 operand.Op) { ctx.VAESENCLAST(mx, x, x1) }
+func VAESENCLAST(mxyz, xyz, xyz1 operand.Op) { ctx.VAESENCLAST(mxyz, xyz, xyz1) }
 
 // VAESIMC: Perform the AES InvMixColumn Transformation.
 //

internal/inst/ztable.go

@@ -17437,6 +17437,42 @@ var Instructions = []Instruction{
 				},
 				EncodingType: 0x3,
 			},
+			{
+				ISA: []string{"VAES"},
+				Operands: []Operand{
+					{Type: "m256", Action: 0x1},
+					{Type: "ymm", Action: 0x1},
+					{Type: "ymm", Action: 0x2},
+				},
+				EncodingType: 0x3,
+			},
+			{
+				ISA: []string{"VAES"},
+				Operands: []Operand{
+					{Type: "ymm", Action: 0x1},
+					{Type: "ymm", Action: 0x1},
+					{Type: "ymm", Action: 0x2},
+				},
+				EncodingType: 0x3,
+			},
+			{
+				ISA: []string{"AVX512F", "VAES"},
+				Operands: []Operand{
+					{Type: "m512", Action: 0x1},
+					{Type: "zmm", Action: 0x1},
+					{Type: "zmm", Action: 0x2},
+				},
+				EncodingType: 0x4,
+			},
+			{
+				ISA: []string{"AVX512F", "VAES"},
+				Operands: []Operand{
+					{Type: "zmm", Action: 0x1},
+					{Type: "zmm", Action: 0x1},
+					{Type: "zmm", Action: 0x2},
+				},
+				EncodingType: 0x4,
+			},
 		},
 	},
 	{
@@ -17461,6 +17497,42 @@ var Instructions = []Instruction{
 				},
 				EncodingType: 0x3,
 			},
+			{
+				ISA: []string{"VAES"},
+				Operands: []Operand{
+					{Type: "m256", Action: 0x1},
+					{Type: "ymm", Action: 0x1},
+					{Type: "ymm", Action: 0x2},
+				},
+				EncodingType: 0x3,
+			},
+			{
+				ISA: []string{"VAES"},
+				Operands: []Operand{
+					{Type: "ymm", Action: 0x1},
+					{Type: "ymm", Action: 0x1},
+					{Type: "ymm", Action: 0x2},
+				},
+				EncodingType: 0x3,
+			},
+			{
+				ISA: []string{"AVX512F", "VAES"},
+				Operands: []Operand{
+					{Type: "m512", Action: 0x1},
+					{Type: "zmm", Action: 0x1},
+					{Type: "zmm", Action: 0x2},
+				},
+				EncodingType: 0x4,
+			},
+			{
+				ISA: []string{"AVX512F", "VAES"},
+				Operands: []Operand{
+					{Type: "zmm", Action: 0x1},
+					{Type: "zmm", Action: 0x1},
+					{Type: "zmm", Action: 0x2},
+				},
+				EncodingType: 0x4,
+			},
 		},
 	},
 	{
@@ -17485,6 +17557,42 @@ var Instructions = []Instruction{
 				},
 				EncodingType: 0x3,
 			},
+			{
+				ISA: []string{"VAES"},
+				Operands: []Operand{
+					{Type: "m256", Action: 0x1},
+					{Type: "ymm", Action: 0x1},
+					{Type: "ymm", Action: 0x2},
+				},
+				EncodingType: 0x3,
+			},
+			{
+				ISA: []string{"VAES"},
+				Operands: []Operand{
+					{Type: "ymm", Action: 0x1},
+					{Type: "ymm", Action: 0x1},
+					{Type: "ymm", Action: 0x2},
+				},
+				EncodingType: 0x3,
+			},
+			{
+				ISA: []string{"AVX512F", "VAES"},
+				Operands: []Operand{
+					{Type: "m512", Action: 0x1},
+					{Type: "zmm", Action: 0x1},
+					{Type: "zmm", Action: 0x2},
+				},
+				EncodingType: 0x4,
+			},
+			{
+				ISA: []string{"AVX512F", "VAES"},
+				Operands: []Operand{
+					{Type: "zmm", Action: 0x1},
+					{Type: "zmm", Action: 0x1},
+					{Type: "zmm", Action: 0x2},
+				},
+				EncodingType: 0x4,
+			},
 		},
 	},
 	{
@@ -17509,6 +17617,42 @@ var Instructions = []Instruction{
 				},
 				EncodingType: 0x3,
 			},
+			{
+				ISA: []string{"VAES"},
+				Operands: []Operand{
+					{Type: "m256", Action: 0x1},
+					{Type: "ymm", Action: 0x1},
+					{Type: "ymm", Action: 0x2},
+				},
+				EncodingType: 0x3,
+			},
+			{
+				ISA: []string{"VAES"},
+				Operands: []Operand{
+					{Type: "ymm", Action: 0x1},
+					{Type: "ymm", Action: 0x1},
+					{Type: "ymm", Action: 0x2},
+				},
+				EncodingType: 0x3,
+			},
+			{
+				ISA: []string{"AVX512F", "VAES"},
+				Operands: []Operand{
+					{Type: "m512", Action: 0x1},
+					{Type: "zmm", Action: 0x1},
+					{Type: "zmm", Action: 0x2},
+				},
+				EncodingType: 0x4,
+			},
+			{
+				ISA: []string{"AVX512F", "VAES"},
+				Operands: []Operand{
+					{Type: "zmm", Action: 0x1},
+					{Type: "zmm", Action: 0x1},
+					{Type: "zmm", Action: 0x2},
+				},
+				EncodingType: 0x4,
+			},
 		},
 	},
 	{

internal/opcodesextra/instructions.go

@@ -7,6 +7,7 @@ import "github.com/mmcloughlin/avo/internal/inst"
 var sets = [][]*inst.Instruction{
 	movlqzx,
 	gfni,
+	vaes,
 }
 
 // Instructions returns a list of extras to add to the instructions database.

internal/opcodesextra/vaes.go

@@ -0,0 +1,184 @@
+package opcodesextra
+
+import "github.com/mmcloughlin/avo/internal/inst"
+
+// vaes is the "Vector Advanced Encryption Standard" instruction set.
+var vaes = []*inst.Instruction{
+	// Reference: https://github.com/golang/go/blob/go1.19.3/src/cmd/internal/obj/x86/avx_optabs.go#L1217-L1244
+	//
+	//		{as: AVAESDEC, ytab: _yvaesdec, prefix: Pavx, op: opBytes{
+	//			avxEscape | vex128 | vex66 | vex0F38 | vexW0, 0xDE,
+	//			avxEscape | vex256 | vex66 | vex0F38 | vexW0, 0xDE,
+	//			avxEscape | evex128 | evex66 | evex0F38 | evexW0, evexN16, 0xDE,
+	//			avxEscape | evex256 | evex66 | evex0F38 | evexW0, evexN32, 0xDE,
+	//			avxEscape | evex512 | evex66 | evex0F38 | evexW0, evexN64, 0xDE,
+	//		}},
+	//		{as: AVAESDECLAST, ytab: _yvaesdec, prefix: Pavx, op: opBytes{
+	//			avxEscape | vex128 | vex66 | vex0F38 | vexW0, 0xDF,
+	//			avxEscape | vex256 | vex66 | vex0F38 | vexW0, 0xDF,
+	//			avxEscape | evex128 | evex66 | evex0F38 | evexW0, evexN16, 0xDF,
+	//			avxEscape | evex256 | evex66 | evex0F38 | evexW0, evexN32, 0xDF,
+	//			avxEscape | evex512 | evex66 | evex0F38 | evexW0, evexN64, 0xDF,
+	//		}},
+	//		{as: AVAESENC, ytab: _yvaesdec, prefix: Pavx, op: opBytes{
+	//			avxEscape | vex128 | vex66 | vex0F38 | vexW0, 0xDC,
+	//			avxEscape | vex256 | vex66 | vex0F38 | vexW0, 0xDC,
+	//			avxEscape | evex128 | evex66 | evex0F38 | evexW0, evexN16, 0xDC,
+	//			avxEscape | evex256 | evex66 | evex0F38 | evexW0, evexN32, 0xDC,
+	//			avxEscape | evex512 | evex66 | evex0F38 | evexW0, evexN64, 0xDC,
+	//		}},
+	//		{as: AVAESENCLAST, ytab: _yvaesdec, prefix: Pavx, op: opBytes{
+	//			avxEscape | vex128 | vex66 | vex0F38 | vexW0, 0xDD,
+	//			avxEscape | vex256 | vex66 | vex0F38 | vexW0, 0xDD,
+	//			avxEscape | evex128 | evex66 | evex0F38 | evexW0, evexN16, 0xDD,
+	//			avxEscape | evex256 | evex66 | evex0F38 | evexW0, evexN32, 0xDD,
+	//			avxEscape | evex512 | evex66 | evex0F38 | evexW0, evexN64, 0xDD,
+	//		}},
+	//
+	{
+		Opcode:  "VAESDEC",
+		Summary: "Perform One Round of an AES Decryption Flow",
+		Forms:   vaesforms,
+	},
+	{
+		Opcode:  "VAESDECLAST",
+		Summary: "Perform Last Round of an AES Decryption Flow",
+		Forms:   vaesforms,
+	},
+	{
+		Opcode:  "VAESENC",
+		Summary: "Perform One Round of an AES Encryption Flow",
+		Forms:   vaesforms,
+	},
+	{
+		Opcode:  "VAESENCLAST",
+		Summary: "Perform Last Round of an AES Encryption Flow",
+		Forms:   vaesforms,
+	},
+}
+
+// VAESDEC, VAESDECLAST, VAESENC and VAESENCLAST forms.
+//
+// See: https://software.intel.com/en-us/download/intel-64-and-ia-32-architectures-sdm-combined-volumes-1-2a-2b-2c-2d-3a-3b-3c-3d-and-4
+//
+// Reference: https://github.com/golang/go/blob/go1.19.3/src/cmd/internal/obj/x86/avx_optabs.go#L111-L117
+//
+//	var _yvaesdec = []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: 3, args: argList{YxmEvex, YxrEvex, YxrEvex}},
+//		{zcase: Zevex_rm_v_r, zoffset: 3, args: argList{YymEvex, YyrEvex, YyrEvex}},
+//		{zcase: Zevex_rm_v_r, zoffset: 3, args: argList{Yzm, Yzr, Yzr}},
+//	}
+var vaesforms = inst.Forms{
+	// VEX.128.66.0F38.WIG DE /r VAESDEC xmm1, xmm2, xmm3/m128  AVX + AES
+	// VEX.128.66.0F38.WIG DF /r VAESDECLAST xmm1, xmm2, xmm3/m128  AVX + AES
+	// VEX.128.66.0F38.WIG DC /r VAESENC xmm1, xmm2, xmm3/m128  AVX + AES
+	// VEX.128.66.0F38.WIG DD /r VAESENCLAST xmm1, xmm2, xmm3/m128  AVX + AES
+	{
+		ISA: []string{"AES", "AVX"},
+		Operands: []inst.Operand{
+			{Type: "m128", Action: inst.R},
+			{Type: "xmm", Action: inst.R},
+			{Type: "xmm", Action: inst.W},
+		},
+		EncodingType: inst.EncodingTypeVEX,
+	},
+	{
+		ISA: []string{"AES", "AVX"},
+		Operands: []inst.Operand{
+			{Type: "xmm", Action: inst.R},
+			{Type: "xmm", Action: inst.R},
+			{Type: "xmm", Action: inst.W},
+		},
+		EncodingType: inst.EncodingTypeVEX,
+	},
+	// VEX.256.66.0F38.WIG DE /r VAESDEC ymm1, ymm2, ymm3/m256  VAES
+	// VEX.256.66.0F38.WIG DF /r VAESDECLAST ymm1, ymm2, ymm3/m256  VAES
+	// VEX.256.66.0F38.WIG DC /r VAESENC ymm1, ymm2, ymm3/m256  VAES
+	// VEX.256.66.0F38.WIG DD /r VAESENCLAST ymm1, ymm2, ymm3/m256  VAES
+	{
+		ISA: []string{"VAES"},
+		Operands: []inst.Operand{
+			{Type: "m256", Action: inst.R},
+			{Type: "ymm", Action: inst.R},
+			{Type: "ymm", Action: inst.W},
+		},
+		EncodingType: inst.EncodingTypeVEX,
+	},
+	{
+		ISA: []string{"VAES"},
+		Operands: []inst.Operand{
+			{Type: "ymm", Action: inst.R},
+			{Type: "ymm", Action: inst.R},
+			{Type: "ymm", Action: inst.W},
+		},
+		EncodingType: inst.EncodingTypeVEX,
+	},
+	// EVEX.128.66.0F38.WIG DE /r VAESDEC xmm1, xmm2, xmm3/m128  AVX512VL + VAES
+	// EVEX.128.66.0F38.WIG DF /r VAESDECLAST xmm1, xmm2, xmm3/m128  AVX512VL + VAES
+	// EVEX.128.66.0F38.WIG DC /r VAESENC xmm1, xmm2, xmm3/m128  AVX512VL + VAES
+	// EVEX.128.66.0F38.WIG DD /r VAESENCLAST xmm1, xmm2, xmm3/m128  AVX512VL + VAES
+	{
+		ISA: []string{"AVX512VL", "VAES"},
+		Operands: []inst.Operand{
+			{Type: "m128", Action: inst.R},
+			{Type: "xmm", Action: inst.R},
+			{Type: "xmm", Action: inst.W},
+		},
+		EncodingType: inst.EncodingTypeEVEX,
+	},
+	{
+		ISA: []string{"AVX512VL", "VAES"},
+		Operands: []inst.Operand{
+			{Type: "xmm", Action: inst.R},
+			{Type: "xmm", Action: inst.R},
+			{Type: "xmm", Action: inst.W},
+		},
+		EncodingType: inst.EncodingTypeEVEX,
+	},
+	// EVEX.256.66.0F38.WIG DE /r VAESDEC ymm1, ymm2, ymm3/m256  AVX512VL + VAES
+	// EVEX.256.66.0F38.WIG DF /r VAESDECLAST ymm1, ymm2, ymm3/m256  AVX512VL + VAES
+	// EVEX.256.66.0F38.WIG DC /r VAESENC ymm1, ymm2, ymm3/m256  AVX512VL + VAES
+	// EVEX.256.66.0F38.WIG DD /r VAESENCLAST ymm1, ymm2, ymm3/m256  AVX512VL + VAES
+	{
+		ISA: []string{"AVX512VL", "VAES"},
+		Operands: []inst.Operand{
+			{Type: "m256", Action: inst.R},
+			{Type: "ymm", Action: inst.R},
+			{Type: "ymm", Action: inst.W},
+		},
+		EncodingType: inst.EncodingTypeEVEX,
+	},
+	{
+		ISA: []string{"AVX512VL", "VAES"},
+		Operands: []inst.Operand{
+			{Type: "ymm", Action: inst.R},
+			{Type: "ymm", Action: inst.R},
+			{Type: "ymm", Action: inst.W},
+		},
+		EncodingType: inst.EncodingTypeEVEX,
+	},
+	// EVEX.512.66.0F38.WIG DE /r VAESDEC zmm1, zmm2, zmm3/m512  AVX512F + VAES
+	// EVEX.512.66.0F38.WIG DF /r VAESDECLAST zmm1, zmm2, zmm3/m512  AVX512F + VAES
+	// EVEX.512.66.0F38.WIG DC /r VAESENC zmm1, zmm2, zmm3/m512  AVX512F + VAES
+	// EVEX.512.66.0F38.WIG DD /r VAESENCLAST zmm1, zmm2, zmm3/m512  AVX512F + VAES
+	{
+		ISA: []string{"AVX512F", "VAES"},
+		Operands: []inst.Operand{
+			{Type: "m512", Action: inst.R},
+			{Type: "zmm", Action: inst.R},
+			{Type: "zmm", Action: inst.W},
+		},
+		EncodingType: inst.EncodingTypeEVEX,
+	},
+	{
+		ISA: []string{"AVX512F", "VAES"},
+		Operands: []inst.Operand{
+			{Type: "zmm", Action: inst.R},
+			{Type: "zmm", Action: inst.R},
+			{Type: "zmm", Action: inst.W},
+		},
+		EncodingType: inst.EncodingTypeEVEX,
+	},
+}

x86/zctors.go

@@ -7396,8 +7396,12 @@ func VADDSUBPS(mxy, xy, xy1 operand.Op) (*intrep.Instruction, error) {
 //
 //	VAESDEC m128 xmm xmm
 //	VAESDEC xmm  xmm xmm
-func VAESDEC(mx, x, x1 operand.Op) (*intrep.Instruction, error) {
+//	VAESDEC m256 ymm ymm
-	return build(opcVAESDEC.Forms(), sffxs{}, []operand.Op{mx, x, x1})
+//	VAESDEC ymm  ymm ymm
+//	VAESDEC m512 zmm zmm
+//	VAESDEC zmm  zmm zmm
+func VAESDEC(mxyz, xyz, xyz1 operand.Op) (*intrep.Instruction, error) {
+	return build(opcVAESDEC.Forms(), sffxs{}, []operand.Op{mxyz, xyz, xyz1})
 }
 
 // VAESDECLAST: Perform Last Round of an AES Decryption Flow.
@@ -7406,8 +7410,12 @@ func VAESDEC(mx, x, x1 operand.Op) (*intrep.Instruction, error) {
 //
 //	VAESDECLAST m128 xmm xmm
 //	VAESDECLAST xmm  xmm xmm
-func VAESDECLAST(mx, x, x1 operand.Op) (*intrep.Instruction, error) {
+//	VAESDECLAST m256 ymm ymm
-	return build(opcVAESDECLAST.Forms(), sffxs{}, []operand.Op{mx, x, x1})
+//	VAESDECLAST ymm  ymm ymm
+//	VAESDECLAST m512 zmm zmm
+//	VAESDECLAST zmm  zmm zmm
+func VAESDECLAST(mxyz, xyz, xyz1 operand.Op) (*intrep.Instruction, error) {
+	return build(opcVAESDECLAST.Forms(), sffxs{}, []operand.Op{mxyz, xyz, xyz1})
 }
 
 // VAESENC: Perform One Round of an AES Encryption Flow.
@@ -7416,8 +7424,12 @@ func VAESDECLAST(mx, x, x1 operand.Op) (*intrep.Instruction, error) {
 //
 //	VAESENC m128 xmm xmm
 //	VAESENC xmm  xmm xmm
-func VAESENC(mx, x, x1 operand.Op) (*intrep.Instruction, error) {
+//	VAESENC m256 ymm ymm
-	return build(opcVAESENC.Forms(), sffxs{}, []operand.Op{mx, x, x1})
+//	VAESENC ymm  ymm ymm
+//	VAESENC m512 zmm zmm
+//	VAESENC zmm  zmm zmm
+func VAESENC(mxyz, xyz, xyz1 operand.Op) (*intrep.Instruction, error) {
+	return build(opcVAESENC.Forms(), sffxs{}, []operand.Op{mxyz, xyz, xyz1})
 }
 
 // VAESENCLAST: Perform Last Round of an AES Encryption Flow.
@@ -7426,8 +7438,12 @@ func VAESENC(mx, x, x1 operand.Op) (*intrep.Instruction, error) {
 //
 //	VAESENCLAST m128 xmm xmm
 //	VAESENCLAST xmm  xmm xmm
-func VAESENCLAST(mx, x, x1 operand.Op) (*intrep.Instruction, error) {
+//	VAESENCLAST m256 ymm ymm
-	return build(opcVAESENCLAST.Forms(), sffxs{}, []operand.Op{mx, x, x1})
+//	VAESENCLAST ymm  ymm ymm
+//	VAESENCLAST m512 zmm zmm
+//	VAESENCLAST zmm  zmm zmm
+func VAESENCLAST(mxyz, xyz, xyz1 operand.Op) (*intrep.Instruction, error) {
+	return build(opcVAESENCLAST.Forms(), sffxs{}, []operand.Op{mxyz, xyz, xyz1})
 }
 
 // VAESIMC: Perform the AES InvMixColumn Transformation.

x86/zctors_test.go

@@ -7467,6 +7467,18 @@ func TestVAESDECValidFormsNoError(t *testing.T) {
 	if _, err := VAESDEC(opxmm, opxmm, opxmm); err != nil {
 		t.Fatal(err)
 	}
+	if _, err := VAESDEC(opm256, opymm, opymm); err != nil {
+		t.Fatal(err)
+	}
+	if _, err := VAESDEC(opymm, opymm, opymm); err != nil {
+		t.Fatal(err)
+	}
+	if _, err := VAESDEC(opm512, opzmm, opzmm); err != nil {
+		t.Fatal(err)
+	}
+	if _, err := VAESDEC(opzmm, opzmm, opzmm); err != nil {
+		t.Fatal(err)
+	}
 }
 
 func TestVAESDECLASTValidFormsNoError(t *testing.T) {
@@ -7476,6 +7488,18 @@ func TestVAESDECLASTValidFormsNoError(t *testing.T) {
 	if _, err := VAESDECLAST(opxmm, opxmm, opxmm); err != nil {
 		t.Fatal(err)
 	}
+	if _, err := VAESDECLAST(opm256, opymm, opymm); err != nil {
+		t.Fatal(err)
+	}
+	if _, err := VAESDECLAST(opymm, opymm, opymm); err != nil {
+		t.Fatal(err)
+	}
+	if _, err := VAESDECLAST(opm512, opzmm, opzmm); err != nil {
+		t.Fatal(err)
+	}
+	if _, err := VAESDECLAST(opzmm, opzmm, opzmm); err != nil {
+		t.Fatal(err)
+	}
 }
 
 func TestVAESENCValidFormsNoError(t *testing.T) {
@@ -7485,6 +7509,18 @@ func TestVAESENCValidFormsNoError(t *testing.T) {
 	if _, err := VAESENC(opxmm, opxmm, opxmm); err != nil {
 		t.Fatal(err)
 	}
+	if _, err := VAESENC(opm256, opymm, opymm); err != nil {
+		t.Fatal(err)
+	}
+	if _, err := VAESENC(opymm, opymm, opymm); err != nil {
+		t.Fatal(err)
+	}
+	if _, err := VAESENC(opm512, opzmm, opzmm); err != nil {
+		t.Fatal(err)
+	}
+	if _, err := VAESENC(opzmm, opzmm, opzmm); err != nil {
+		t.Fatal(err)
+	}
 }
 
 func TestVAESENCLASTValidFormsNoError(t *testing.T) {
@@ -7494,6 +7530,18 @@ func TestVAESENCLASTValidFormsNoError(t *testing.T) {
 	if _, err := VAESENCLAST(opxmm, opxmm, opxmm); err != nil {
 		t.Fatal(err)
 	}
+	if _, err := VAESENCLAST(opm256, opymm, opymm); err != nil {
+		t.Fatal(err)
+	}
+	if _, err := VAESENCLAST(opymm, opymm, opymm); err != nil {
+		t.Fatal(err)
+	}
+	if _, err := VAESENCLAST(opm512, opzmm, opzmm); err != nil {
+		t.Fatal(err)
+	}
+	if _, err := VAESENCLAST(opzmm, opzmm, opzmm); err != nil {
+		t.Fatal(err)
+	}
 }
 
 func TestVAESIMCValidFormsNoError(t *testing.T) {