golang.org/x/arch@v0.17.0/s390x/s390xmap/map.go

// Copyright 2024 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.

// s390xmap constructs the s390x opcode map from the instruction set CSV file.
//
// Usage:
//
//	s390map [-fmt=format] s390x.csv
//
// The known output formats are:
//
//	text (default) - print decoding tree in text form
//	decoder - print decoding tables for the s390xasm package
//	encoder - generate a self-contained file which can be used to encode
//		  go obj.Progs into machine code
//	asm - generate a GNU asm file which can be compiled by gcc containing
//	      all opcodes discovered in s390x.csv using macro friendly arguments.
package main

import (
	"bytes"
	"encoding/csv"
	"flag"
	"fmt"
	gofmt "go/format"
	"log"
	"os"
	"regexp"
	"strconv"
	"strings"

	asm "golang.org/x/arch/s390x/s390xasm"
)

var format = flag.String("fmt", "text", "output format: text, decoder, asm")
var debug = flag.Bool("debug", false, "enable debugging output")

var inputFile string

func usage() {
	fmt.Fprintf(os.Stderr, "usage: s390xmap [-fmt=format] s390x.csv\n")
	os.Exit(2)
}

func main() {
	log.SetFlags(0)
	log.SetPrefix("s390xmap: ")

	flag.Usage = usage
	flag.Parse()
	if flag.NArg() != 1 {
		usage()
	}

	inputFile = flag.Arg(0)

	var printTyp func(*Prog)
	switch *format {
	default:
		log.Fatalf("unknown output format %q", *format)
	case "text":
		printTyp = printText
	case "decoder":
		printTyp = printDecoder
	case "asm":
		printTyp = printASM
	case "encoder":
		printTyp = printEncoder
	}

	p, err := readCSV(flag.Arg(0))
	if err != nil {
		log.Fatal(err)
	}
	log.Printf("Parsed %d instruction forms.", len(p.Insts))
	printTyp(p)
}

// readCSV reads the CSV file and returns the corresponding Prog.
// It may print details about problems to standard error using the log package.
func readCSV(file string) (*Prog, error) {
	// Read input.
	// Skip leading blank and # comment lines.
	f, err := os.Open(file)
	if err != nil {
		return nil, err
	}
	csvReader := csv.NewReader(f)
	csvReader.Comment = '#'
	table, err := csvReader.ReadAll()
	if err != nil {
		return nil, fmt.Errorf("parsing %s: %v", file, err)
	}
	if len(table) == 0 {
		return nil, fmt.Errorf("empty csv input")
	}
	if len(table[0]) < 3 {
		return nil, fmt.Errorf("csv too narrow: need at least four columns")
	}

	p := &Prog{}
	for _, row := range table {
		add(p, row[0], row[1], row[2], row[3])
	}
	return p, nil
}

type Prog struct {
	Insts     []Inst
	OpRanges  map[string]string
	nextOrder int // Next position value (used for Insts[x].order)
}

type Field struct {
	Name     string
	BitField asm.BitField
	Type     asm.ArgType
	flags    uint16
}

func (f Field) String() string {
	return fmt.Sprintf("%v(%s%v)", f.Type, f.Name, f.BitField)
}

type Inst struct {
	Text     string
	Encoding string
	Op       string
	Mask     uint64
	Value    uint64
	DontCare uint64
	Len      uint16
	Fields   []Field
}

func (i Inst) String() string {
	return fmt.Sprintf("%s (%s) %08x/%08x %v (%s)", i.Op, i.Encoding, i.Value, i.Mask, i.Fields, i.Text)
}

type Arg struct {
	Name string
	Bits int8
	Offs int8
}

func (a Arg) String() string {
	return fmt.Sprintf("%s[%d:%d]", a.Name, a.Offs, a.Offs+a.Bits-1)
}

func (a Arg) Maximum() int {
	return 1<<uint8(a.Bits) - 1
}

func (a Arg) BitMask() uint64 {
	return uint64(a.Maximum()) << a.Shift()
}

func (a Arg) Shift() uint8 {
	return uint8(64 - a.Offs - a.Bits)
}

type Args []Arg

func (as Args) String() string {
	ss := make([]string, len(as))
	for i := range as {
		ss[i] = as[i].String()
	}
	return strings.Join(ss, "|")
}

func (as Args) Find(name string) int {
	for i := range as {
		if as[i].Name == name {
			return i
		}
	}
	return -1
}

func (as *Args) Append(a Arg) {
	*as = append(*as, a)
}

func (as *Args) Delete(i int) {
	*as = append((*as)[:i], (*as)[i+1:]...)
}

func (as Args) Clone() Args {
	return append(Args{}, as...)
}

func (a Arg) isDontCare() bool {
	return a.Name[0] == '/' && a.Name == strings.Repeat("/", len(a.Name))
}

// Split the string encoding into an Args. The encoding string loosely matches the regex
// (arg@bitpos|)+
func parseFields(encoding, text string) Args {
	var err error
	var args Args

	fields := strings.Split(encoding, "|")

	for i, f := range fields {
		name, off := "", -1
		if f == "" {
			off = 64
			if i == 0 || i != len(fields)-1 {
				fmt.Fprintf(os.Stderr, "%s: wrong %d-th encoding field: %q\n", text, i, f)
				panic("Invalid encoding entry.")
			}
		} else {
			j := strings.Index(f, "@")
			if j < 0 {
				fmt.Fprintf(os.Stderr, "%s: wrong %d-th encoding field: %q\n", text, i, f)
				panic("Invalid encoding entry.")
			}
			off, err = strconv.Atoi(f[j+1:])
			if err != nil {
				fmt.Fprintf(os.Stderr, "err for: %s has: %s for %s\n", f[:j], err, f[j+1:])
			}
			name = f[:j]
		}
		if len(args) > 0 {
			args[len(args)-1].Bits += int8(off)
		}
		if name != "" && name != "??" {
			arg := Arg{Name: name, Offs: int8(off), Bits: int8(-off)}
			args.Append(arg)
		}
	}
	return args
}

// Compute the Mask (usually Opcode + secondary Opcode bitfields),
// the Value (the expected value under the mask), and
// reserved bits (i.e the // fields which should be set to 0)
func computeMaskValueReserved(args Args, text string) (mask, value, reserved uint64) {
	for i := 0; i < len(args); i++ {
		arg := args[i]
		v, err := strconv.Atoi(arg.Name)
		switch {
		case err == nil && v >= 0: // is a numbered field
			if v < 0 || v > arg.Maximum() {
				fmt.Fprintf(os.Stderr, "%s: field %s value (%d) is out of range (%d-bit)\n", text, arg, v, arg.Bits)
			}
			mask |= arg.BitMask()
			value |= uint64(v) << arg.Shift()
			args.Delete(i)
			i--
		case arg.Name[0] == '/': // don't care
			if arg.Name != strings.Repeat("/", len(arg.Name)) {
				log.Fatalf("%s: arg %v named like a don't care bit, but it's not", text, arg)
			}
			reserved |= arg.BitMask()
			args.Delete(i)
			i--
		default:
			continue
		}
	}
	// sanity checks
	if mask&reserved != 0 {
		log.Fatalf("%s: mask (%08x) and don't care (%08x) collide", text, mask, reserved)
	}
	if value&^mask != 0 {
		log.Fatalf("%s: value (%08x) out of range of mask (%08x)", text, value, mask)
	}
	return
}

func Imm_signed_8bit_check(op string) bool {
	imm_8 := []string{"ASI", "AGSI", "ALSI", "ALGSI", "CIB", "CGIB", "CIJ", "CGIJ", "NI", "NIY", "OI", "OIY", "XI", "XIY"}
	var ret bool
	ret = false
	for _, str := range imm_8 {
		if strings.Compare(op, str) == 0 {
			ret = true
			break
		}
	}
	return ret
}

func Imm_signed_16bit_check(op string) bool {
	imm_16 := []string{"AHI", "AGHI", "ALHSIK", "ALGHSIK", "AHIK", "AGHIK", "LHI", "LGHI", "MVGHI", "CIT", "CGIT", "CGHI", "CGHSI", "CHHSI", "CHI", "CHSI", "CRJ", "CGRJ", "NIHH", "NILL", "NIHL", "NILH", "LLIHH", "LLILL", "LLIHL", "LLILH", "OIHH", "OILL", "OIHL", "OILH", "VLEIB", "VLEIH", "VLEIF", "VLEIG"}
	var ret bool
	ret = false
	for _, str := range imm_16 {
		if strings.Compare(op, str) == 0 {
			ret = true
			break
		}
	}
	return ret
}

func Imm_signed_32bit_check(op string) bool {
	imm_32 := []string{"AFI", "AGFI", "AIH", "CIH", "CFI", "CGFI", "CRL", "STRL", "STGRL", "LGFI", "LLIHF", "LLILF", "MSFI", "MSGFI", "MGHI", "MHI", "NIHF", "NILF", "OILF", "OIHF", "XILF", "XIHF"}
	var ret bool
	ret = false
	for _, str := range imm_32 {
		if strings.Compare(op, str) == 0 {
			ret = true
			break
		}
	}
	return ret
}

func check_flags(flags string) bool {
	if strings.Contains(flags, "Da") {
		return true
	} else if strings.Contains(flags, "Db") {
		return true
	} else if strings.Contains(flags, "Dt") {
		return true
	} else {
		return false
	}
}

// Parse a row from the CSV describing the instructions, and place the
// detected instructions into p. One entry may generate multiple intruction
// entries as each extended mnemonic listed in text is treated like a unique
// instruction.
func add(p *Prog, text, mnemonics, encoding, flags string) {
	// Parse encoding, building size and offset of each field.
	// The first field in the encoding is the smallest offset.
	// And note the MSB is bit 0, not bit 31.
	// Example: "31@0|RS@6|RA@11|///@16|26@21|Rc@31|"
	var args Args

	args = parseFields(encoding, text)
	mask, value, dontCare := computeMaskValueReserved(args, text)

	// split mnemonics into individual instructions
	inst := Inst{Text: text, Encoding: mnemonics, Value: value, Mask: mask, DontCare: dontCare}

	// order inst.Args according to mnemonics order
	for i, opr := range operandRe.FindAllString(mnemonics, -1) {
		if i == 0 { // operation
			inst.Op = opr
			continue
		}
		field := Field{Name: opr}
		typ := asm.TypeUnknown
		flag := uint16(0)
		switch opr {
		case "R1", "R2", "R3":
			s := strings.Split(mnemonics, " ")
			switch opr {
			case "R1":
				switch s[0] {
				case "CPDT", "CPXT", "CDXT", "CZXT", "CZDT":
					typ = asm.TypeFPReg
					flag = 0x2
				case "CUXTR", "EEXTR", "EEDTR", "EFPC", "ESXTR", "ESDTR", "LGDR", "SFPC", "SFASR":
					typ = asm.TypeReg
					flag = 0x1
				case "CPYA", "LAM", "LAMY", "STAM", "STAMY", "SAR", "TAR":
					typ = asm.TypeACReg
					flag = 0x3
				case "LCTL", "LCTLG", "STCTL", "STCTG":
					typ = asm.TypeCReg
					flag = 0x4
				default:
					if check_flags(flags) {
						if strings.Contains(text, "CONVERT TO") {
							typ = asm.TypeReg
							flag = 0x1
						} else {
							typ = asm.TypeFPReg
							flag = 0x2
						}
					} else {
						typ = asm.TypeReg
						flag = 0x1
					}
				}
			case "R2":
				switch s[0] {
				case "IEXTR", "IEDTR", "LDGR", "RRXTR", "RRDTR":
					typ = asm.TypeReg
					flag = 0x1
				case "CPYA", "EAR":
					typ = asm.TypeACReg
					flag = 0x3
				default:
					if check_flags(flags) {
						if strings.Contains(text, "CONVERT FROM") {
							typ = asm.TypeReg
							flag = 0x1
						} else {
							typ = asm.TypeFPReg
							flag = 0x2
						}
					} else {
						typ = asm.TypeReg
						flag = 0x1
					}
				}
			case "R3":
				switch s[0] {
				case "LAM", "LAMY", "STAM", "STAMY":
					typ = asm.TypeACReg
					flag = 0x3
				case "LCTL", "LCTLG", "STCTL", "STCTG":
					typ = asm.TypeCReg
					flag = 0x4
				default:
					if check_flags(flags) {
						typ = asm.TypeFPReg
						flag = 0x2
					} else {
						typ = asm.TypeReg
						flag = 0x1
					}
				}
			}

		case "I", "I1", "I2", "I3", "I4", "I5":
			flag = 0x0
			switch opr {
			case "I", "I1":
				typ = asm.TypeImmUnsigned

			case "I2":
				if Imm_signed_8bit_check(inst.Op) {
					typ = asm.TypeImmSigned8
					break
				} else if Imm_signed_16bit_check(inst.Op) { // "ASI", "AGSI", "ALSI", "ALGSI"
					typ = asm.TypeImmSigned16
					break
				} else if Imm_signed_32bit_check(inst.Op) { // "AHI", "AGHI", "AHIK", "AGHIK", "LHI", "LGHI"
					typ = asm.TypeImmSigned32
					break
				} else {
					typ = asm.TypeImmUnsigned
					break
				}

			case "I3", "I4", "I5":
				typ = asm.TypeImmUnsigned

			}

		case "RI2", "RI3", "RI4":
			flag = 0x80
			i := args.Find(opr)
			count := uint8(args[i].Bits)
			if count == 12 {
				typ = asm.TypeRegImSigned12
				break
			} else if count == 16 {
				typ = asm.TypeRegImSigned16
				break
			} else if count == 24 {
				typ = asm.TypeRegImSigned24
				break
			} else if count == 32 {
				typ = asm.TypeRegImSigned32
				break
			}

		case "M1", "M3", "M4", "M5", "M6":
			flag = 0x800
			typ = asm.TypeMask

		case "B1", "B2", "B3", "B4":
			typ = asm.TypeBaseReg
			flag = 0x20 | 0x01

		case "X2":
			typ = asm.TypeIndexReg
			flag = 0x40 | 0x01

		case "D1", "D2", "D3", "D4":
			flag = 0x10
			i := args.Find(opr)
			if uint8(args[i].Bits) == 20 {
				typ = asm.TypeDispSigned20
				break
			} else {
				typ = asm.TypeDispUnsigned
				break
			}

		case "L1", "L2":
			typ = asm.TypeLen
			flag = 0x10
		case "V1", "V2", "V3", "V4", "V5", "V6":
			typ = asm.TypeVecReg
			flag = 0x08
		}

		if typ == asm.TypeUnknown {
			log.Fatalf("%s %s unknown type for opr %s", text, inst, opr)
		}
		field.Type = typ
		field.flags = flag
		var f1 asm.BitField
		i := args.Find(opr)
		if i < 0 {
			log.Fatalf("%s: couldn't find %s in %s", text, opr, args)
		}
		f1.Offs, f1.Bits = uint8(args[i].Offs), uint8(args[i].Bits)
		field.BitField = f1
		inst.Fields = append(inst.Fields, field)
	}
	if strings.HasPrefix(inst.Op, "V") || strings.Contains(inst.Op, "WFC") || strings.Contains(inst.Op, "WFK") { //Check Vector Instructions
		Bits := asm.BitField{Offs: 36, Bits: 4}
		field := Field{Name: "RXB", BitField: Bits, Type: asm.TypeImmUnsigned, flags: 0xC00}
		inst.Fields = append(inst.Fields, field)
	}
	if *debug {
		fmt.Printf("%v\n", inst)
	}
	p.Insts = append(p.Insts, inst)
}

// operandRe matches each operand (including opcode) in instruction mnemonics
var operandRe = regexp.MustCompile(`([[:alpha:]][[:alnum:]_]*\.?)`)

// printText implements the -fmt=text mode, which is not implemented (yet?).
func printText(p *Prog) {
	log.Fatal("-fmt=text not implemented")
}

// printEncoder implements the -fmt=encoder mode. which is not implemented (yet?).
func printEncoder(p *Prog) {
	log.Fatal("-fmt=encoder not implemented")
}

func printASM(p *Prog) {
	fmt.Printf("#include \"hack.h\"\n")
	fmt.Printf(".text\n")
	for _, inst := range p.Insts {
		fmt.Printf("\t%s\n", inst.Encoding)
	}
}

// argFieldName constructs a name for the argField
func argFieldName(f Field) string {
	ns := []string{"ap", f.Type.String()}
	b := f.BitField
	ns = append(ns, fmt.Sprintf("%d_%d", b.Offs, b.Offs+b.Bits-1))
	return strings.Join(ns, "_")
}

// printDecoder implements the -fmt=decoder mode.
// It emits the tables.go for package armasm's decoder.
func printDecoder(p *Prog) {
	var buf bytes.Buffer

	fmt.Fprintf(&buf, "// Code generated by s390xmap -fmt=decoder %s DO NOT EDIT.\n", inputFile)
	fmt.Fprintf(&buf, "\n")

	fmt.Fprintf(&buf, "package s390xasm\n\n")

	// Build list of opcodes, using the csv order (which corresponds to ISA docs order)
	m := map[string]bool{}
	fmt.Fprintf(&buf, "const (\n\t_ Op = iota\n")
	for i := 0; i < len(p.Insts); i++ {
		name := p.Insts[i].Op
		switch name {
		case "CUUTF", "CUTFU", "PPNO":
			m[name] = false
			p.Insts = append(p.Insts[:i], p.Insts[i+1:]...)
			i--
		default:
			m[name] = true
		}
		if ok := m[name]; !ok {
			continue
		}
		fmt.Fprintf(&buf, "\t%s\n", name)
	}
	fmt.Fprint(&buf, ")\n\n\n")

	// Emit slice mapping opcode number to name string.
	m = map[string]bool{}
	fmt.Fprintf(&buf, "var opstr = [...]string{\n")
	for _, inst := range p.Insts {
		name := inst.Op
		if ok := m[name]; ok {
			continue
		}
		m[name] = true
		fmt.Fprintf(&buf, "\t%s: %q,\n", inst.Op, strings.ToLower(inst.Op))
	}
	fmt.Fprint(&buf, "}\n\n\n")

	// print out argFields
	fmt.Fprintf(&buf, "var (\n")
	m = map[string]bool{}
	for _, inst := range p.Insts {
		for _, f := range inst.Fields {
			name := argFieldName(f)
			if ok := m[name]; ok {
				continue
			}
			m[name] = true
			fmt.Fprintf(&buf, "\t%s = &argField{Type: %#v, flags: %#x, BitField: BitField", name, f.Type, f.flags)
			b := f.BitField
			fmt.Fprintf(&buf, "{%d, %d }", b.Offs, b.Bits)
			fmt.Fprintf(&buf, "}\n")
		}
	}
	fmt.Fprint(&buf, ")\n\n\n")

	// Emit decoding table.
	fmt.Fprintf(&buf, "var instFormats = [...]instFormat{\n")
	for _, inst := range p.Insts {
		m, v, dc := inst.Mask, inst.Value, inst.DontCare
		fmt.Fprintf(&buf, "\t{ %s, %#x, %#x, %#x,", inst.Op, m, v, dc)
		fmt.Fprintf(&buf, " // %s (%s)\n\t\t[8]*argField{", inst.Text, inst.Encoding)
		for _, f := range inst.Fields {
			fmt.Fprintf(&buf, "%s, ", argFieldName(f))
		}
		fmt.Fprintf(&buf, "}},\n")
	}
	fmt.Fprint(&buf, "}\n\n")

	out, err := gofmt.Source(buf.Bytes())
	if err != nil {
		log.Fatalf("gofmt error: %v", err)
		fmt.Printf("%s", buf.Bytes())
	} else {
		fmt.Printf("%s", out)
	}
}