x86/x86avxgen/decode.go - arch - Git at Google

 // Copyright 2018 The Go Authors. All rights reserved.
 // Use of this source code is governed by a BSD-style
 // license that can be found in the LICENSE file.

 package main

 import (
 	"fmt"
 	"log"
 	"regexp"
 	"strings"

 	"golang.org/x/arch/x86/xeddata"
 )

 // encoding is decoded XED instruction pattern.
 type encoding struct {
 	// opbyte is opcode byte (one that follows [E]VEX prefix).
 	// It's called "opcode" in Intel manual, but we use that for
 	// instruction name (iclass in XED terms).
 	opbyte string

 	// opdigit is ModRM.Reg field used to encode opcode extension.
 	// In Intel manual, "/digit" notation is used.
 	opdigit string

 	// vex represents [E]VEX fields that are used in a first [E]VEX
 	// opBytes element (see prefixExpr function).
 	vex struct {
 		P string // 66/F2/F3
 		L string // 128/256/512
 		M string // 0F/0F38/0F3A
 		W string // W0/W1
 	}

 	// evexScale is a scaling factor used to calculate compact disp-8.
 	evexScale string

 	// evexBcstScale is like evexScale, but used during broadcasting.
 	// Empty for optab entries that do not have broadcasting support.
 	evexBcstScale string

 	// evex describes which features of EVEX can be used by optab entry.
 	// All flags are "false" for VEX-encoded insts.
 	evex struct {
 		// There is no "broadcast" flag because it's inferred
 		// from non-empty evexBcstScale.

 		SAE      bool // EVEX.b controls SAE for reg-reg insts
 		Rounding bool // EVEX.b + EVEX.RC (VL) control rounding for FP insts
 		Zeroing  bool // Instruction can use zeroing.
 	}
 }

 type decoder struct {
 	ctx   *context
 	insts []*instruction
 }

 // decodeGroups fills ctx.groups with decoded instruction groups.
 //
 // Reads XED objects from ctx.xedPath.
 func decodeGroups(ctx *context) {
 	d := decoder{ctx: ctx}
 	groups := make(map[string][]*instruction)
 	for _, inst := range d.DecodeAll() {
 		groups[inst.opcode] = append(groups[inst.opcode], inst)
 	}
 	for op, insts := range groups {
 		ctx.groups = append(ctx.groups, &instGroup{
 			opcode: op,
 			list:   insts,
 		})
 	}
 }

 // DecodeAll decodes every XED instruction.
 func (d *decoder) DecodeAll() []*instruction {
 	err := xeddata.WalkInsts(d.ctx.xedPath, func(inst *xeddata.Inst) {
 		inst.Pattern = xeddata.ExpandStates(d.ctx.db, inst.Pattern)
 		pset := xeddata.NewPatternSet(inst.Pattern)

 		opcode := inst.Iclass

 		switch {
 		case inst.HasAttribute("AMDONLY") || inst.Extension == "XOP":
 			return // Only VEX and EVEX are supported
 		case !pset.Is("VEX") && !pset.Is("EVEX"):
 			return // Skip non-AVX instructions
 		case inst.RealOpcode == "N":
 			return // Skip unstable instructions
 		}

 		// Expand some patterns to simplify decodePattern.
 		pset.Replace("FIX_ROUND_LEN128()", "VL=0")
 		pset.Replace("FIX_ROUND_LEN512()", "VL=2")

 		mask, args := d.decodeArgs(pset, inst)
 		d.insts = append(d.insts, &instruction{
 			pset:   pset,
 			opcode: opcode,
 			mask:   mask,
 			args:   args,
 			enc:    d.decodePattern(pset, inst),
 		})
 	})
 	if err != nil {
 		log.Fatalf("walk insts: %v", err)
 	}
 	return d.insts
 }

 // registerArgs maps XED argument name RHS to its decoded version.
 var registerArgs = map[string]argument{
 	"GPR32_R()":  {"Yrl", "reg"},
 	"GPR64_R()":  {"Yrl", "reg"},
 	"VGPR32_R()": {"Yrl", "reg"},
 	"VGPR64_R()": {"Yrl", "reg"},
 	"VGPR32_N()": {"Yrl", "regV"},
 	"VGPR64_N()": {"Yrl", "regV"},
 	"GPR32_B()":  {"Yrl", "reg/mem"},
 	"GPR64_B()":  {"Yrl", "reg/mem"},
 	"VGPR32_B()": {"Yrl", "reg/mem"},
 	"VGPR64_B()": {"Yrl", "reg/mem"},

 	"XMM_R()":  {"Yxr", "reg"},
 	"XMM_R3()": {"YxrEvex", "reg"},
 	"XMM_N()":  {"Yxr", "regV"},
 	"XMM_N3()": {"YxrEvex", "regV"},
 	"XMM_B()":  {"Yxr", "reg/mem"},
 	"XMM_B3()": {"YxrEvex", "reg/mem"},
 	"XMM_SE()": {"Yxr", "regIH"},

 	"YMM_R()":  {"Yyr", "reg"},
 	"YMM_R3()": {"YyrEvex", "reg"},
 	"YMM_N()":  {"Yyr", "regV"},
 	"YMM_N3()": {"YyrEvex", "regV"},
 	"YMM_B()":  {"Yyr", "reg/mem"},
 	"YMM_B3()": {"YyrEvex", "reg/mem"},
 	"YMM_SE()": {"Yyr", "regIH"},

 	"ZMM_R3()": {"Yzr", "reg"},
 	"ZMM_N3()": {"Yzr", "regV"},
 	"ZMM_B3()": {"Yzr", "reg/mem"},

 	"MASK_R()": {"Yk", "reg"},
 	"MASK_N()": {"Yk", "regV"},
 	"MASK_B()": {"Yk", "reg/mem"},

 	"MASKNOT0()": {"Yknot0", "kmask"},

 	// Handled specifically in "generate".
 	"MASK1()": {"MASK1()", "MASK1()"},
 }

 func (d *decoder) decodeArgs(pset xeddata.PatternSet, inst *xeddata.Inst) (mask *argument, args []*argument) {
 	for i, f := range strings.Fields(inst.Operands) {
 		xarg, err := xeddata.NewOperand(d.ctx.db, f)
 		if err != nil {
 			log.Fatalf("%s: args[%d]: %v", inst, i, err)
 		}

 		switch {
 		case xarg.Action == "":
 			continue // Skip meta args like EMX_BROADCAST_1TO32_8
 		case !xarg.IsVisible():
 			continue
 		}

 		arg := &argument{}
 		args = append(args, arg)

 		switch xarg.NameLHS() {
 		case "IMM0":
 			if xarg.Width != "b" {
 				log.Fatalf("%s: args[%d]: expected width=b, found %s", inst, i, xarg.Width)
 			}
 			if pset["IMM0SIGNED=1"] {
 				arg.ytype = "Yi8"
 			} else {
 				arg.ytype = "Yu8"
 			}
 			arg.zkind = "imm8"

 		case "REG0", "REG1", "REG2", "REG3":
 			rhs := xarg.NameRHS()
 			if rhs == "MASK1()" {
 				mask = arg
 			}
 			*arg = registerArgs[rhs]
 			if arg.ytype == "" {
 				log.Fatalf("%s: args[%d]: unexpected %s reg", inst, i, rhs)
 			}
 			if xarg.Attributes["MULTISOURCE4"] {
 				arg.ytype += "Multi4"
 			}

 		case "MEM0":
 			arg.ytype = pset.MatchOrDefault("Ym",
 				"VMODRM_XMM()", "Yxvm",
 				"VMODRM_YMM()", "Yyvm",
 				"UISA_VMODRM_XMM()", "YxvmEvex",
 				"UISA_VMODRM_YMM()", "YyvmEvex",
 				"UISA_VMODRM_ZMM()", "Yzvm",
 			)
 			arg.zkind = "reg/mem"

 		default:
 			log.Fatalf("%s: args[%d]: unexpected %s", inst, i, xarg.NameRHS())
 		}
 	}

 	// Reverse args.
 	for i := len(args)/2 - 1; i >= 0; i-- {
 		j := len(args) - 1 - i
 		args[i], args[j] = args[j], args[i]
 	}

 	return mask, args
 }

 func (d *decoder) decodePattern(pset xeddata.PatternSet, inst *xeddata.Inst) *encoding {
 	var enc encoding

 	enc.opdigit = d.findOpdigit(pset)
 	enc.opbyte = d.findOpbyte(pset, inst)

 	if strings.Contains(inst.Attributes, "DISP8_") {
 		enc.evexScale = d.findEVEXScale(pset)
 		enc.evexBcstScale = d.findEVEXBcstScale(pset, inst)
 	}

 	enc.vex.P = pset.Match(
 		"VEX_PREFIX=1", "66",
 		"VEX_PREFIX=2", "F2",
 		"VEX_PREFIX=3", "F3")
 	enc.vex.M = pset.Match(
 		"MAP=1", "0F",
 		"MAP=2", "0F38",
 		"MAP=3", "0F3A")
 	enc.vex.L = pset.MatchOrDefault("128",
 		"VL=0", "128",
 		"VL=1", "256",
 		"VL=2", "512")
 	enc.vex.W = pset.MatchOrDefault("W0",
 		"REXW=0", "W0",
 		"REXW=1", "W1")

 	if pset.Is("EVEX") {
 		enc.evex.SAE = strings.Contains(inst.Operands, "TXT=SAESTR")
 		enc.evex.Rounding = strings.Contains(inst.Operands, "TXT=ROUNDC")
 		enc.evex.Zeroing = strings.Contains(inst.Operands, "TXT=ZEROSTR")
 	}

 	// Prefix each non-empty part with vex or evex.
 	parts := [...]*string{
 		&enc.evexScale, &enc.evexBcstScale,
 		&enc.vex.P, &enc.vex.M, &enc.vex.L, &enc.vex.W,
 	}
 	for _, p := range parts {
 		if *p == "" {
 			continue
 		}
 		if pset.Is("EVEX") {
 			*p = "evex" + *p
 		} else {
 			*p = "vex" + *p
 		}
 	}

 	return &enc
 }

 func (d *decoder) findOpdigit(pset xeddata.PatternSet) string {
 	reg := pset.Index(
 		"REG[0b000]",
 		"REG[0b001]",
 		"REG[0b010]",
 		"REG[0b011]",
 		"REG[0b100]",
 		"REG[0b101]",
 		"REG[0b110]",
 		"REG[0b111]",
 	)
 	// Fixed ModRM.Reg field means that it is used for opcode extension.
 	if reg != -1 {
 		return fmt.Sprintf("0%d", reg)
 	}
 	return ""
 }

 // opbyteRE matches uint8 hex literal.
 var opbyteRE = regexp.MustCompile(`0x[0-9A-F]{2}`)

 func (d *decoder) findOpbyte(pset xeddata.PatternSet, inst *xeddata.Inst) string {
 	opbyte := ""
 	for k := range pset {
 		if opbyteRE.MatchString(k) {
 			if opbyte == "" {
 				opbyte = k
 			} else {
 				log.Fatalf("%s: multiple opbytes", inst)
 			}
 		}
 	}
 	return opbyte
 }

 func (d *decoder) findEVEXScale(pset xeddata.PatternSet) string {
 	switch {
 	case pset["NELEM_FULL()"], pset["NELEM_FULLMEM()"]:
 		return pset.Match(
 			"VL=0", "N16",
 			"VL=1", "N32",
 			"VL=2", "N64")
 	case pset["NELEM_MOVDDUP()"]:
 		return pset.Match(
 			"VL=0", "N8",
 			"VL=1", "N32",
 			"VL=2", "N64")
 	case pset["NELEM_HALF()"], pset["NELEM_HALFMEM()"]:
 		return pset.Match(
 			"VL=0", "N8",
 			"VL=1", "N16",
 			"VL=2", "N32")
 	case pset["NELEM_QUARTERMEM()"]:
 		return pset.Match(
 			"VL=0", "N4",
 			"VL=1", "N8",
 			"VL=2", "N16")
 	case pset["NELEM_EIGHTHMEM()"]:
 		return pset.Match(
 			"VL=0", "N2",
 			"VL=1", "N4",
 			"VL=2", "N8")
 	case pset["NELEM_TUPLE2()"]:
 		return pset.Match(
 			"ESIZE_32_BITS()", "N8",
 			"ESIZE_64_BITS()", "N16")
 	case pset["NELEM_TUPLE4()"]:
 		return pset.Match(
 			"ESIZE_32_BITS()", "N16",
 			"ESIZE_64_BITS()", "N32")
 	case pset["NELEM_TUPLE8()"]:
 		return "N32"
 	case pset["NELEM_MEM128()"], pset["NELEM_TUPLE1_4X()"]:
 		return "N16"
 	}

 	// Explicit list is required to make it possible to
 	// detect unhandled nonterminals for the caller.
 	scalars := [...]string{
 		"NELEM_SCALAR()",
 		"NELEM_GSCAT()",
 		"NELEM_GPR_READER()",
 		"NELEM_GPR_READER_BYTE()",
 		"NELEM_GPR_READER_WORD()",
 		"NELEM_GPR_WRITER_STORE()",
 		"NELEM_GPR_WRITER_STORE_BYTE()",
 		"NELEM_GPR_WRITER_STORE_WORD()",
 		"NELEM_GPR_WRITER_LDOP_D()",
 		"NELEM_GPR_WRITER_LDOP_Q()",
 		"NELEM_TUPLE1()",
 		"NELEM_TUPLE1_BYTE()",
 		"NELEM_TUPLE1_WORD()",
 	}
 	for _, scalar := range scalars {
 		if pset[scalar] {
 			return pset.Match(
 				"ESIZE_8_BITS()", "N1",
 				"ESIZE_16_BITS()", "N2",
 				"ESIZE_32_BITS()", "N4",
 				"ESIZE_64_BITS()", "N8")
 		}
 	}

 	return ""
 }

 func (d *decoder) findEVEXBcstScale(pset xeddata.PatternSet, inst *xeddata.Inst) string {
 	// Only FULL and HALF tuples are affected by the broadcasting.
 	switch {
 	case pset["NELEM_FULL()"]:
 		return pset.Match(
 			"ESIZE_32_BITS()", "BcstN4",
 			"ESIZE_64_BITS()", "BcstN8")
 	case pset["NELEM_HALF()"]:
 		return "BcstN4"
 	default:
 		if inst.HasAttribute("BROADCAST_ENABLED") {
 			log.Fatalf("%s: unexpected tuple for bcst", inst)
 		}
 		return ""
 	}
 }
	// Copyright 2018 The Go Authors. All rights reserved.
	// Use of this source code is governed by a BSD-style
	// license that can be found in the LICENSE file.

	package main

	import (
	"fmt"
	"log"
	"regexp"
	"strings"

	"golang.org/x/arch/x86/xeddata"
	)

	// encoding is decoded XED instruction pattern.
	type encoding struct {
	// opbyte is opcode byte (one that follows [E]VEX prefix).
	// It's called "opcode" in Intel manual, but we use that for
	// instruction name (iclass in XED terms).
	opbyte string

	// opdigit is ModRM.Reg field used to encode opcode extension.
	// In Intel manual, "/digit" notation is used.
	opdigit string

	// vex represents [E]VEX fields that are used in a first [E]VEX
	// opBytes element (see prefixExpr function).
	vex struct {
	P string // 66/F2/F3
	L string // 128/256/512
	M string // 0F/0F38/0F3A
	W string // W0/W1
	}

	// evexScale is a scaling factor used to calculate compact disp-8.
	evexScale string

	// evexBcstScale is like evexScale, but used during broadcasting.
	// Empty for optab entries that do not have broadcasting support.
	evexBcstScale string

	// evex describes which features of EVEX can be used by optab entry.
	// All flags are "false" for VEX-encoded insts.
	evex struct {
	// There is no "broadcast" flag because it's inferred
	// from non-empty evexBcstScale.

	SAE bool // EVEX.b controls SAE for reg-reg insts
	Rounding bool // EVEX.b + EVEX.RC (VL) control rounding for FP insts
	Zeroing bool // Instruction can use zeroing.
	}
	}

	type decoder struct {
	ctx *context
	insts []*instruction
	}

	// decodeGroups fills ctx.groups with decoded instruction groups.
	//
	// Reads XED objects from ctx.xedPath.
	func decodeGroups(ctx *context) {
	d := decoder{ctx: ctx}
	groups := make(map[string][]*instruction)
	for _, inst := range d.DecodeAll() {
	groups[inst.opcode] = append(groups[inst.opcode], inst)
	}
	for op, insts := range groups {
	ctx.groups = append(ctx.groups, &instGroup{
	opcode: op,
	list: insts,
	})
	}
	}

	// DecodeAll decodes every XED instruction.
	func (d decoder) DecodeAll() []instruction {
	err := xeddata.WalkInsts(d.ctx.xedPath, func(inst *xeddata.Inst) {
	inst.Pattern = xeddata.ExpandStates(d.ctx.db, inst.Pattern)
	pset := xeddata.NewPatternSet(inst.Pattern)

	opcode := inst.Iclass

	switch {
	case inst.HasAttribute("AMDONLY") \|\| inst.Extension == "XOP":
	return // Only VEX and EVEX are supported
	case !pset.Is("VEX") && !pset.Is("EVEX"):
	return // Skip non-AVX instructions
	case inst.RealOpcode == "N":
	return // Skip unstable instructions
	}

	// Expand some patterns to simplify decodePattern.
	pset.Replace("FIX_ROUND_LEN128()", "VL=0")
	pset.Replace("FIX_ROUND_LEN512()", "VL=2")

	mask, args := d.decodeArgs(pset, inst)
	d.insts = append(d.insts, &instruction{
	pset: pset,
	opcode: opcode,
	mask: mask,
	args: args,
	enc: d.decodePattern(pset, inst),
	})
	})
	if err != nil {
	log.Fatalf("walk insts: %v", err)
	}
	return d.insts
	}

	// registerArgs maps XED argument name RHS to its decoded version.
	var registerArgs = map[string]argument{
	"GPR32_R()": {"Yrl", "reg"},
	"GPR64_R()": {"Yrl", "reg"},
	"VGPR32_R()": {"Yrl", "reg"},
	"VGPR64_R()": {"Yrl", "reg"},
	"VGPR32_N()": {"Yrl", "regV"},
	"VGPR64_N()": {"Yrl", "regV"},
	"GPR32_B()": {"Yrl", "reg/mem"},
	"GPR64_B()": {"Yrl", "reg/mem"},
	"VGPR32_B()": {"Yrl", "reg/mem"},
	"VGPR64_B()": {"Yrl", "reg/mem"},

	"XMM_R()": {"Yxr", "reg"},
	"XMM_R3()": {"YxrEvex", "reg"},
	"XMM_N()": {"Yxr", "regV"},
	"XMM_N3()": {"YxrEvex", "regV"},
	"XMM_B()": {"Yxr", "reg/mem"},
	"XMM_B3()": {"YxrEvex", "reg/mem"},
	"XMM_SE()": {"Yxr", "regIH"},

	"YMM_R()": {"Yyr", "reg"},
	"YMM_R3()": {"YyrEvex", "reg"},
	"YMM_N()": {"Yyr", "regV"},
	"YMM_N3()": {"YyrEvex", "regV"},
	"YMM_B()": {"Yyr", "reg/mem"},
	"YMM_B3()": {"YyrEvex", "reg/mem"},
	"YMM_SE()": {"Yyr", "regIH"},

	"ZMM_R3()": {"Yzr", "reg"},
	"ZMM_N3()": {"Yzr", "regV"},
	"ZMM_B3()": {"Yzr", "reg/mem"},

	"MASK_R()": {"Yk", "reg"},
	"MASK_N()": {"Yk", "regV"},
	"MASK_B()": {"Yk", "reg/mem"},

	"MASKNOT0()": {"Yknot0", "kmask"},

	// Handled specifically in "generate".
	"MASK1()": {"MASK1()", "MASK1()"},
	}

	func (d decoder) decodeArgs(pset xeddata.PatternSet, inst xeddata.Inst) (mask argument, args []argument) {
	for i, f := range strings.Fields(inst.Operands) {
	xarg, err := xeddata.NewOperand(d.ctx.db, f)
	if err != nil {
	log.Fatalf("%s: args[%d]: %v", inst, i, err)
	}

	switch {
	case xarg.Action == "":
	continue // Skip meta args like EMX_BROADCAST_1TO32_8
	case !xarg.IsVisible():
	continue
	}

	arg := &argument{}
	args = append(args, arg)

	switch xarg.NameLHS() {
	case "IMM0":
	if xarg.Width != "b" {
	log.Fatalf("%s: args[%d]: expected width=b, found %s", inst, i, xarg.Width)
	}
	if pset["IMM0SIGNED=1"] {
	arg.ytype = "Yi8"
	} else {
	arg.ytype = "Yu8"
	}
	arg.zkind = "imm8"

	case "REG0", "REG1", "REG2", "REG3":
	rhs := xarg.NameRHS()
	if rhs == "MASK1()" {
	mask = arg
	}
	*arg = registerArgs[rhs]
	if arg.ytype == "" {
	log.Fatalf("%s: args[%d]: unexpected %s reg", inst, i, rhs)
	}
	if xarg.Attributes["MULTISOURCE4"] {
	arg.ytype += "Multi4"
	}

	case "MEM0":
	arg.ytype = pset.MatchOrDefault("Ym",
	"VMODRM_XMM()", "Yxvm",
	"VMODRM_YMM()", "Yyvm",
	"UISA_VMODRM_XMM()", "YxvmEvex",
	"UISA_VMODRM_YMM()", "YyvmEvex",
	"UISA_VMODRM_ZMM()", "Yzvm",
	)
	arg.zkind = "reg/mem"

	default:
	log.Fatalf("%s: args[%d]: unexpected %s", inst, i, xarg.NameRHS())
	}
	}

	// Reverse args.
	for i := len(args)/2 - 1; i >= 0; i-- {
	j := len(args) - 1 - i
	args[i], args[j] = args[j], args[i]
	}

	return mask, args
	}

	func (d decoder) decodePattern(pset xeddata.PatternSet, inst xeddata.Inst) *encoding {
	var enc encoding

	enc.opdigit = d.findOpdigit(pset)
	enc.opbyte = d.findOpbyte(pset, inst)

	if strings.Contains(inst.Attributes, "DISP8_") {
	enc.evexScale = d.findEVEXScale(pset)
	enc.evexBcstScale = d.findEVEXBcstScale(pset, inst)
	}

	enc.vex.P = pset.Match(
	"VEX_PREFIX=1", "66",
	"VEX_PREFIX=2", "F2",
	"VEX_PREFIX=3", "F3")
	enc.vex.M = pset.Match(
	"MAP=1", "0F",
	"MAP=2", "0F38",
	"MAP=3", "0F3A")
	enc.vex.L = pset.MatchOrDefault("128",
	"VL=0", "128",
	"VL=1", "256",
	"VL=2", "512")
	enc.vex.W = pset.MatchOrDefault("W0",
	"REXW=0", "W0",
	"REXW=1", "W1")

	if pset.Is("EVEX") {
	enc.evex.SAE = strings.Contains(inst.Operands, "TXT=SAESTR")
	enc.evex.Rounding = strings.Contains(inst.Operands, "TXT=ROUNDC")
	enc.evex.Zeroing = strings.Contains(inst.Operands, "TXT=ZEROSTR")
	}

	// Prefix each non-empty part with vex or evex.
	parts := [...]*string{
	&enc.evexScale, &enc.evexBcstScale,
	&enc.vex.P, &enc.vex.M, &enc.vex.L, &enc.vex.W,
	}
	for _, p := range parts {
	if *p == "" {
	continue
	}
	if pset.Is("EVEX") {
	p = "evex" + p
	} else {
	p = "vex" + p
	}
	}

	return &enc
	}

	func (d *decoder) findOpdigit(pset xeddata.PatternSet) string {
	reg := pset.Index(
	"REG[0b000]",
	"REG[0b001]",
	"REG[0b010]",
	"REG[0b011]",
	"REG[0b100]",
	"REG[0b101]",
	"REG[0b110]",
	"REG[0b111]",
	)
	// Fixed ModRM.Reg field means that it is used for opcode extension.
	if reg != -1 {
	return fmt.Sprintf("0%d", reg)
	}
	return ""
	}

	// opbyteRE matches uint8 hex literal.
	var opbyteRE = regexp.MustCompile(`0x[0-9A-F]{2}`)

	func (d decoder) findOpbyte(pset xeddata.PatternSet, inst xeddata.Inst) string {
	opbyte := ""
	for k := range pset {
	if opbyteRE.MatchString(k) {
	if opbyte == "" {
	opbyte = k
	} else {
	log.Fatalf("%s: multiple opbytes", inst)
	}
	}
	}
	return opbyte
	}

	func (d *decoder) findEVEXScale(pset xeddata.PatternSet) string {
	switch {
	case pset["NELEM_FULL()"], pset["NELEM_FULLMEM()"]:
	return pset.Match(
	"VL=0", "N16",
	"VL=1", "N32",
	"VL=2", "N64")
	case pset["NELEM_MOVDDUP()"]:
	return pset.Match(
	"VL=0", "N8",
	"VL=1", "N32",
	"VL=2", "N64")
	case pset["NELEM_HALF()"], pset["NELEM_HALFMEM()"]:
	return pset.Match(
	"VL=0", "N8",
	"VL=1", "N16",
	"VL=2", "N32")
	case pset["NELEM_QUARTERMEM()"]:
	return pset.Match(
	"VL=0", "N4",
	"VL=1", "N8",
	"VL=2", "N16")
	case pset["NELEM_EIGHTHMEM()"]:
	return pset.Match(
	"VL=0", "N2",
	"VL=1", "N4",
	"VL=2", "N8")
	case pset["NELEM_TUPLE2()"]:
	return pset.Match(
	"ESIZE_32_BITS()", "N8",
	"ESIZE_64_BITS()", "N16")
	case pset["NELEM_TUPLE4()"]:
	return pset.Match(
	"ESIZE_32_BITS()", "N16",
	"ESIZE_64_BITS()", "N32")
	case pset["NELEM_TUPLE8()"]:
	return "N32"
	case pset["NELEM_MEM128()"], pset["NELEM_TUPLE1_4X()"]:
	return "N16"
	}

	// Explicit list is required to make it possible to
	// detect unhandled nonterminals for the caller.
	scalars := [...]string{
	"NELEM_SCALAR()",
	"NELEM_GSCAT()",
	"NELEM_GPR_READER()",
	"NELEM_GPR_READER_BYTE()",
	"NELEM_GPR_READER_WORD()",
	"NELEM_GPR_WRITER_STORE()",
	"NELEM_GPR_WRITER_STORE_BYTE()",
	"NELEM_GPR_WRITER_STORE_WORD()",
	"NELEM_GPR_WRITER_LDOP_D()",
	"NELEM_GPR_WRITER_LDOP_Q()",
	"NELEM_TUPLE1()",
	"NELEM_TUPLE1_BYTE()",
	"NELEM_TUPLE1_WORD()",
	}
	for _, scalar := range scalars {
	if pset[scalar] {
	return pset.Match(
	"ESIZE_8_BITS()", "N1",
	"ESIZE_16_BITS()", "N2",
	"ESIZE_32_BITS()", "N4",
	"ESIZE_64_BITS()", "N8")
	}
	}

	return ""
	}

	func (d decoder) findEVEXBcstScale(pset xeddata.PatternSet, inst xeddata.Inst) string {
	// Only FULL and HALF tuples are affected by the broadcasting.
	switch {
	case pset["NELEM_FULL()"]:
	return pset.Match(
	"ESIZE_32_BITS()", "BcstN4",
	"ESIZE_64_BITS()", "BcstN8")
	case pset["NELEM_HALF()"]:
	return "BcstN4"
	default:
	if inst.HasAttribute("BROADCAST_ENABLED") {
	log.Fatalf("%s: unexpected tuple for bcst", inst)
	}
	return ""
	}
	}