blob: a4fcd622c541e4f2943508079d18ca4af26727aa [file] [log] [blame]
#!/usr/bin/env python3
##
## Copyright (c) 2024 Taylor Simpson <ltaylorsimpson@gmail.com>
##
## This program is free software; you can redistribute it and/or modify
## it under the terms of the GNU General Public License as published by
## the Free Software Foundation; either version 2 of the License, or
## (at your option) any later version.
##
## This program is distributed in the hope that it will be useful,
## but WITHOUT ANY WARRANTY; without even the implied warranty of
## MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
## GNU General Public License for more details.
##
## You should have received a copy of the GNU General Public License
## along with this program; if not, see <http://www.gnu.org/licenses/>.
##
import io
import re
import sys
import textwrap
import iset
import hex_common
encs = {
tag: "".join(reversed(iset.iset[tag]["enc"].replace(" ", "")))
for tag in iset.tags
if iset.iset[tag]["enc"] != "MISSING ENCODING"
}
regre = re.compile(r"((?<!DUP)[MNORCPQXSGVZA])([stuvwxyzdefg]+)([.]?[LlHh]?)(\d+S?)")
immre = re.compile(r"[#]([rRsSuUm])(\d+)(?:[:](\d+))?")
def ordered_unique(l):
return sorted(set(l), key=l.index)
num_registers = {"R": 32, "V": 32}
operand_letters = {
"P",
"i",
"I",
"r",
"s",
"t",
"u",
"v",
"w",
"x",
"y",
"z",
"d",
"e",
"f",
"g",
}
#
# These instructions have unused operand letters in their encoding
# They don't correspond to actual operands in the instruction semantics
# We will mark them as ignored in QEMU decodetree
#
tags_with_unused_d_encoding = {
"R6_release_at_vi",
"R6_release_st_vi",
"S4_stored_rl_at_vi",
"S4_stored_rl_st_vi",
"S2_storew_rl_at_vi",
"S2_stored_rl_at_vi",
"S2_storew_rl_st_vi",
}
tags_with_unused_t_encoding = {
"R6_release_at_vi",
"R6_release_st_vi",
}
def skip_tag(tag, class_to_decode):
enc_class = iset.iset[tag]["enc_class"]
return enc_class != class_to_decode
##
## Generate the QEMU decodetree file for each instruction in class_to_decode
## For A2_add: Rd32=add(Rs32,Rt32)
## We produce:
## %A2_add_Rd 0:5
## %A2_add_Rs 16:5
## %A2_add_Rt 8:5
## @A2_add 11110011000.......-.....---..... Rd=%A2_add_Rd Rs=%A2_add_Rs Rt=%A2_add_Rt %PP
## A2_add ..................-.....---..... @A2_add
##
def gen_decodetree_file(f, class_to_decode):
is_subinsn = class_to_decode.startswith("SUBINSN_")
f.write(f"## DO NOT MODIFY - This file is generated by {sys.argv[0]}\n\n")
if not is_subinsn:
f.write("%PP\t14:2\n\n")
for tag in sorted(encs.keys(), key=iset.tags.index):
if skip_tag(tag, class_to_decode):
continue
enc = encs[tag]
enc_str = "".join(reversed(encs[tag]))
f.write(("#" * 80) + "\n"
f"## {tag}:\t{enc_str}\n"
"##\n")
# The subinstructions come with a 13-bit encoding, but
# decodetree.py needs 16 bits
if is_subinsn:
enc_str = "---" + enc_str
regs = ordered_unique(regre.findall(iset.iset[tag]["syntax"]))
imms = ordered_unique(immre.findall(iset.iset[tag]["syntax"]))
# Write the field definitions for the registers
for regno, reg in enumerate(regs):
reg_type, reg_id, _, reg_enc_size = reg
reg_letter = reg_id[0]
reg_num_choices = int(reg_enc_size.rstrip("S"))
reg_mapping = reg_type + "".join("_" for letter in reg_id) + \
reg_enc_size
reg_enc_fields = re.findall(reg_letter + "+", enc)
# Check for some errors
if len(reg_enc_fields) == 0:
raise Exception(f"{tag} missing register field!")
if len(reg_enc_fields) > 1:
raise Exception(f"{tag} has split register field!")
reg_enc_field = reg_enc_fields[0]
if 2 ** len(reg_enc_field) != reg_num_choices:
raise Exception(f"{tag} has incorrect register field width!")
f.write(f"%{tag}_{reg_type}{reg_id}\t"
f"{enc.index(reg_enc_field)}:{len(reg_enc_field)}")
if (reg_type in num_registers and
reg_num_choices != num_registers[reg_type]):
f.write(f"\t!function=decode_mapped_reg_{reg_mapping}")
f.write("\n")
# Write the field definitions for the immediates
for imm in imms:
immno = 1 if imm[0].isupper() else 0
imm_type = imm[0]
imm_width = int(imm[1])
imm_letter = "i" if imm_type.islower() else "I"
fields = []
sign_mark = "s" if imm_type.lower() in "sr" else ""
for m in reversed(list(re.finditer(imm_letter + "+", enc))):
fields.append(f"{m.start()}:{sign_mark}{m.end() - m.start()}")
sign_mark = ""
field_str = " ".join(fields)
f.write(f"%{tag}_{imm_type}{imm_letter}\t{field_str}\n")
## Handle instructions with unused encoding letters
## Change the unused letters to ignored
if tag in tags_with_unused_d_encoding:
enc_str = enc_str.replace("d", "-")
if tag in tags_with_unused_t_encoding:
enc_str = enc_str.replace("t", "-")
# Replace the operand letters with .
for x in operand_letters:
enc_str = enc_str.replace(x, ".")
# Write the instruction format
f.write(f"@{tag}\t{enc_str}")
for reg in regs:
reg_type = reg[0]
reg_id = reg[1]
f.write(f" {reg_type}{reg_id}=%{tag}_{reg_type}{reg_id}")
for imm in imms:
imm_type = imm[0]
imm_letter = "i" if imm_type.islower() else "I"
f.write(f" {imm_type}{imm_letter}=%{tag}_{imm_type}{imm_letter}")
if not is_subinsn:
f.write(" %PP")
f.write("\n")
# Replace the 0s and 1s with .
enc_str = enc_str.replace("0", ".").replace("1", ".")
# Write the instruction pattern
f.write(f"{tag}\t{enc_str} @{tag}\n")
if __name__ == "__main__":
hex_common.read_semantics_file(sys.argv[1])
class_to_decode = sys.argv[2]
with open(sys.argv[3], "w") as f:
gen_decodetree_file(f, class_to_decode)