// 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 (
	"bytes"
	"log"
	"strings"
)

// ytab is ytabList element.
type ytab struct {
	Zcase   string
	Zoffset int
	ArgList string // Ytypes that are matched by this ytab.
}

// ytabList is a named set of ytab objects.
// In asm6.go represented as []ytab.
type ytabList struct {
	Name  string
	Ytabs []ytab
}

// optab describes instruction encodings for specific opcode.
type optab struct {
	Opcode   string
	YtabList *ytabList
	OpLines  []string
}

type generator struct {
	ctx       *context
	ytabLists map[string]*ytabList
}

// generateOptabs fills ctx.optabs and ctx.ytabLists with objects created
// from decoded instructions.
func generateOptabs(ctx *context) {
	gen := generator{ctx: ctx, ytabLists: make(map[string]*ytabList)}
	optabs := make(map[string]*optab)
	for _, g := range ctx.groups {
		optabs[g.opcode] = gen.GenerateGroup(g)
	}
	ctx.optabs = optabs
	ctx.ytabLists = gen.ytabLists
}

// GenerateGroup converts g into optab.
// Populates internal ytab list map.
func (gen *generator) GenerateGroup(g *instGroup) *optab {
	var opLines []string
	for _, inst := range g.list {
		opLines = append(opLines, gen.generateOpLine(inst))
	}
	return &optab{
		Opcode:   "A" + g.opcode,
		OpLines:  opLines,
		YtabList: gen.internYtabList(g),
	}
}

// generateOpLine returns string that describes opBytes for single instruction form.
func (gen *generator) generateOpLine(inst *instruction) string {
	parts := []string{gen.prefixExpr(inst)}
	if inst.pset.Is("EVEX") {
		parts = append(parts, gen.evexPrefixExpr(inst))
	}
	parts = append(parts, inst.enc.opbyte)
	if inst.enc.opdigit != "" {
		parts = append(parts, inst.enc.opdigit)
	}
	return strings.Join(parts, ", ")
}

func (gen *generator) prefixExpr(inst *instruction) string {
	enc := inst.enc
	return gen.joinPrefixParts([]string{
		// Special constant that makes AVX byte different from 0x0F,
		// making it unnecessary to check for both VEX+EVEX when
		// assigning dealing with legacy instructions that skip it
		// without advancing "z" counter.
		"avxEscape",
		enc.vex.L,
		enc.vex.P,
		enc.vex.M,
		enc.vex.W,
	})
}

func (gen *generator) evexPrefixExpr(inst *instruction) string {
	enc := inst.enc
	parts := []string{
		enc.evexScale,
		enc.evexBcstScale,
	}
	if enc.evex.SAE {
		parts = append(parts, "evexSaeEnabled")
	}
	if enc.evex.Rounding {
		parts = append(parts, "evexRoundingEnabled")
	}
	if enc.evex.Zeroing {
		parts = append(parts, "evexZeroingEnabled")
	}
	return gen.joinPrefixParts(parts)
}

// joinPrefixParts returns the Go OR-expression for every non-empty name.
// If every name is empty, returns "0".
func (gen *generator) joinPrefixParts(names []string) string {
	filterEmptyStrings := func(xs []string) []string {
		ys := xs[:0]
		for _, x := range xs {
			if x != "" {
				ys = append(ys, x)
			}
		}
		return ys
	}

	names = filterEmptyStrings(names)
	if len(names) == 0 {
		return "0"
	}
	return strings.Join(names, "|")
}

// internYtabList returns ytabList for given group.
//
// Returned ytab lists are interned.
// Same ytab list can be returned for different groups.
func (gen *generator) internYtabList(g *instGroup) *ytabList {
	var key string
	{
		var buf bytes.Buffer
		for _, inst := range g.list {
			buf.WriteString(inst.zform)
			buf.WriteByte('=')
			buf.WriteString(inst.YtypeListString())
			buf.WriteByte(';')
		}
		key = buf.String()
	}
	if ylist := gen.ytabLists[key]; ylist != nil {
		return ylist
	}

	var ytabs []ytab
	for _, inst := range g.list {
		zoffset := 2
		if inst.pset.Is("EVEX") {
			zoffset++ // Always at least 3 bytes
		}
		if inst.enc.opdigit != "" {
			zoffset++
		}

		if inst.mask != nil {
			ytabs = append(ytabs, gen.makeMaskYtabs(zoffset, inst)...)
		} else {
			ytabs = append(ytabs, gen.makeYtab(zoffset, inst.zform, inst.args))
		}
	}
	ylist := &ytabList{
		Name:  "_y" + strings.ToLower(g.opcode),
		Ytabs: ytabs,
	}
	gen.ytabLists[key] = ylist
	return ylist
}

var zcaseByZform = map[string]string{
	"evex imm8 reg kmask reg/mem":          "Zevex_i_r_k_rm",
	"evex imm8 reg reg/mem":                "Zevex_i_r_rm",
	"evex imm8 reg/mem kmask reg":          "Zevex_i_rm_k_r",
	"evex imm8 reg/mem kmask regV opdigit": "Zevex_i_rm_k_vo",
	"evex imm8 reg/mem reg":                "Zevex_i_rm_r",
	"evex imm8 reg/mem regV opdigit":       "Zevex_i_rm_vo",
	"evex imm8 reg/mem regV kmask reg":     "Zevex_i_rm_v_k_r",
	"evex imm8 reg/mem regV reg":           "Zevex_i_rm_v_r",
	"evex kmask reg/mem opdigit":           "Zevex_k_rmo",
	"evex reg kmask reg/mem":               "Zevex_r_k_rm",
	"evex reg reg/mem":                     "Zevex_r_v_rm",
	"evex reg regV kmask reg/mem":          "Zevex_r_v_k_rm",
	"evex reg regV reg/mem":                "Zevex_r_v_rm",
	"evex reg/mem kmask reg":               "Zevex_rm_k_r",
	"evex reg/mem reg":                     "Zevex_rm_v_r",
	"evex reg/mem regV kmask reg":          "Zevex_rm_v_k_r",
	"evex reg/mem regV reg":                "Zevex_rm_v_r",

	"":                          "Zvex",
	"imm8 reg reg/mem":          "Zvex_i_r_rm",
	"imm8 reg/mem reg":          "Zvex_i_rm_r",
	"imm8 reg/mem regV opdigit": "Zvex_i_rm_vo",
	"imm8 reg/mem regV reg":     "Zvex_i_rm_v_r",
	"reg reg/mem":               "Zvex_r_v_rm",
	"reg regV reg/mem":          "Zvex_r_v_rm",
	"reg/mem opdigit":           "Zvex_rm_v_ro",
	"reg/mem reg":               "Zvex_rm_v_r",
	"reg/mem regV opdigit":      "Zvex_rm_r_vo",
	"reg/mem regV reg":          "Zvex_rm_v_r",
	"reg/mem":                   "Zvex_rm_v_r",
	"regIH reg/mem regV reg":    "Zvex_hr_rm_v_r",
	"regV reg/mem reg":          "Zvex_v_rm_r",
}

func (gen *generator) makeYtab(zoffset int, zform string, args []*argument) ytab {
	var ytypes []string
	for _, arg := range args {
		if arg.ytype != "Ynone" {
			ytypes = append(ytypes, arg.ytype)
		}
	}
	argList := strings.Join(ytypes, ", ")
	zcase := zcaseByZform[zform]
	if zcase == "" {
		log.Fatalf("no zcase for %q", zform)
	}
	return ytab{
		Zcase:   zcase,
		Zoffset: zoffset,
		ArgList: argList,
	}
}

// makeMaskYtabs returns 2 ytabs created from instruction with MASK1() argument.
//
// This is required due to how masking is implemented in asm6.
// Single MASK1() instruction produces 2 ytabs, for example:
//  1. OP xmm, mem     | Yxr, Yxm         | Does not permit K arguments (K0 implied)
//  2. OP xmm, K2, mem | Yxr, Yknot0, Yxm | Does not permit K0 argument
//
// This function also exploits that both ytab entries have same opbytes,
// hence it is efficient to emit only one opbytes line and 0 Z-offset
// for first ytab object.
func (gen *generator) makeMaskYtabs(zoffset int, inst *instruction) []ytab {
	var k0 ytab
	{
		zform := strings.Replace(inst.zform, "MASK1() ", "", 1)
		inst.mask.ytype = "Ynone"
		k0 = gen.makeYtab(0, zform, inst.args)
	}
	var knot0 ytab
	{
		zform := strings.Replace(inst.zform, "MASK1() ", "kmask ", 1)
		inst.mask.ytype = "Yknot0"
		knot0 = gen.makeYtab(zoffset, zform, inst.args)
	}

	inst.mask.ytype = "MASK1()" // Restore Y-type
	return []ytab{k0, knot0}
}