qemu-e2k/target/hexagon/dectree.py

#!/usr/bin/env python3

##
##  Copyright(c) 2019-2023 Qualcomm Innovation Center, Inc. All Rights Reserved.
##
##  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 iset

encs = {
    tag: "".join(reversed(iset.iset[tag]["enc"].replace(" ", "")))
    for tag in iset.tags
    if iset.iset[tag]["enc"] != "MISSING ENCODING"
}

enc_classes = set([iset.iset[tag]["enc_class"] for tag in encs.keys()])
subinsn_enc_classes = set(
    [enc_class for enc_class in enc_classes if enc_class.startswith("SUBINSN_")]
)
ext_enc_classes = set(
    [
        enc_class
        for enc_class in enc_classes
        if enc_class not in ("NORMAL", "16BIT") and not enc_class.startswith("SUBINSN_")
    ]
)

try:
    subinsn_groupings = iset.subinsn_groupings
except AttributeError:
    subinsn_groupings = {}

for tag, subinsn_grouping in subinsn_groupings.items():
    encs[tag] = "".join(reversed(subinsn_grouping["enc"].replace(" ", "")))

dectree_normal = {"leaves": set()}
dectree_16bit = {"leaves": set()}
dectree_subinsn_groupings = {"leaves": set()}
dectree_subinsns = {name: {"leaves": set()} for name in subinsn_enc_classes}
dectree_extensions = {name: {"leaves": set()} for name in ext_enc_classes}

for tag in encs.keys():
    if tag in subinsn_groupings:
        dectree_subinsn_groupings["leaves"].add(tag)
        continue
    enc_class = iset.iset[tag]["enc_class"]
    if enc_class.startswith("SUBINSN_"):
        if len(encs[tag]) != 32:
            encs[tag] = encs[tag] + "0" * (32 - len(encs[tag]))
        dectree_subinsns[enc_class]["leaves"].add(tag)
    elif enc_class == "16BIT":
        if len(encs[tag]) != 16:
            raise Exception(
                'Tag "{}" has enc_class "{}" and not an encoding '
                + "width of 16 bits!".format(tag, enc_class)
            )
        dectree_16bit["leaves"].add(tag)
    else:
        if len(encs[tag]) != 32:
            raise Exception(
                'Tag "{}" has enc_class "{}" and not an encoding '
                + "width of 32 bits!".format(tag, enc_class)
            )
        if enc_class == "NORMAL":
            dectree_normal["leaves"].add(tag)
        else:
            dectree_extensions[enc_class]["leaves"].add(tag)

faketags = set()
for tag, enc in iset.enc_ext_spaces.items():
    faketags.add(tag)
    encs[tag] = "".join(reversed(enc.replace(" ", "")))
    dectree_normal["leaves"].add(tag)

faketags |= set(subinsn_groupings.keys())


def every_bit_counts(bitset):
    for i in range(1, len(next(iter(bitset)))):
        if len(set([bits[:i] + bits[i + 1 :] for bits in bitset])) == len(bitset):
            return False
    return True


def auto_separate(node):
    tags = node["leaves"]
    if len(tags) <= 1:
        return
    enc_width = len(encs[next(iter(tags))])
    opcode_bit_for_all = [
        all([encs[tag][i] in "01" for tag in tags]) for i in range(enc_width)
    ]
    opcode_bit_is_0_for_all = [
        opcode_bit_for_all[i] and all([encs[tag][i] == "0" for tag in tags])
        for i in range(enc_width)
    ]
    opcode_bit_is_1_for_all = [
        opcode_bit_for_all[i] and all([encs[tag][i] == "1" for tag in tags])
        for i in range(enc_width)
    ]
    differentiator_opcode_bit = [
        opcode_bit_for_all[i]
        and not (opcode_bit_is_0_for_all[i] or opcode_bit_is_1_for_all[i])
        for i in range(enc_width)
    ]
    best_width = 0
    for width in range(4, 0, -1):
        for lsb in range(enc_width - width, -1, -1):
            bitset = set([encs[tag][lsb : lsb + width] for tag in tags])
            if all(differentiator_opcode_bit[lsb : lsb + width]) and (
                len(bitset) == len(tags) or every_bit_counts(bitset)
            ):
                best_width = width
                best_lsb = lsb
                caught_all_tags = len(bitset) == len(tags)
                break
        if best_width != 0:
            break
    if best_width == 0:
        raise Exception(
            "Could not find a way to differentiate the encodings "
            + "of the following tags:\n{}".format("\n".join(tags))
        )
    if caught_all_tags:
        for width in range(1, best_width):
            for lsb in range(enc_width - width, -1, -1):
                bitset = set([encs[tag][lsb : lsb + width] for tag in tags])
                if all(differentiator_opcode_bit[lsb : lsb + width]) and len(
                    bitset
                ) == len(tags):
                    best_width = width
                    best_lsb = lsb
                    break
            else:
                continue
            break
    node["separator_lsb"] = best_lsb
    node["separator_width"] = best_width
    node["children"] = []
    for value in range(2**best_width):
        child = {}
        bits = "".join(reversed("{:0{}b}".format(value, best_width)))
        child["leaves"] = set(
            [tag for tag in tags if encs[tag][best_lsb : best_lsb + best_width] == bits]
        )
        node["children"].append(child)
    for child in node["children"]:
        auto_separate(child)


auto_separate(dectree_normal)
auto_separate(dectree_16bit)
if subinsn_groupings:
    auto_separate(dectree_subinsn_groupings)
for dectree_subinsn in dectree_subinsns.values():
    auto_separate(dectree_subinsn)
for dectree_ext in dectree_extensions.values():
    auto_separate(dectree_ext)

for tag in faketags:
    del encs[tag]


def table_name(parents, node):
    path = parents + [node]
    root = path[0]
    tag = next(iter(node["leaves"]))
    if tag in subinsn_groupings:
        enc_width = len(subinsn_groupings[tag]["enc"].replace(" ", ""))
    else:
        tag = next(iter(node["leaves"] - faketags))
        enc_width = len(encs[tag])
    determining_bits = ["_"] * enc_width
    for parent, child in zip(path[:-1], path[1:]):
        lsb = parent["separator_lsb"]
        width = parent["separator_width"]
        value = parent["children"].index(child)
        determining_bits[lsb : lsb + width] = list(
            reversed("{:0{}b}".format(value, width))
        )
    if tag in subinsn_groupings:
        name = "DECODE_ROOT_EE"
    else:
        enc_class = iset.iset[tag]["enc_class"]
        if enc_class in ext_enc_classes:
            name = "DECODE_EXT_{}".format(enc_class)
        elif enc_class in subinsn_enc_classes:
            name = "DECODE_SUBINSN_{}".format(enc_class)
        else:
            name = "DECODE_ROOT_{}".format(enc_width)
    if node != root:
        name += "_" + "".join(reversed(determining_bits))
    return name


def print_node(f, node, parents):
    if len(node["leaves"]) <= 1:
        return
    name = table_name(parents, node)
    lsb = node["separator_lsb"]
    width = node["separator_width"]
    print(
        "DECODE_NEW_TABLE({},{},DECODE_SEPARATOR_BITS({},{}))".format(
            name, 2**width, lsb, width
        ),
        file=f,
    )
    for child in node["children"]:
        if len(child["leaves"]) == 0:
            print("INVALID()", file=f)
        elif len(child["leaves"]) == 1:
            (tag,) = child["leaves"]
            if tag in subinsn_groupings:
                class_a = subinsn_groupings[tag]["class_a"]
                class_b = subinsn_groupings[tag]["class_b"]
                enc = subinsn_groupings[tag]["enc"].replace(" ", "")
                if "RESERVED" in tag:
                    print("INVALID()", file=f)
                else:
                    print(
                        'SUBINSNS({},{},{},"{}")'.format(tag, class_a, class_b, enc),
                        file=f,
                    )
            elif tag in iset.enc_ext_spaces:
                enc = iset.enc_ext_spaces[tag].replace(" ", "")
                print('EXTSPACE({},"{}")'.format(tag, enc), file=f)
            else:
                enc = "".join(reversed(encs[tag]))
                print('TERMINAL({},"{}")'.format(tag, enc), file=f)
        else:
            print("TABLE_LINK({})".format(table_name(parents + [node], child)), file=f)
    print(
        "DECODE_END_TABLE({},{},DECODE_SEPARATOR_BITS({},{}))".format(
            name, 2**width, lsb, width
        ),
        file=f,
    )
    print(file=f)
    parents.append(node)
    for child in node["children"]:
        print_node(f, child, parents)
    parents.pop()


def print_tree(f, tree):
    print_node(f, tree, [])


def print_match_info(f):
    for tag in sorted(encs.keys(), key=iset.tags.index):
        enc = "".join(reversed(encs[tag]))
        mask = int(re.sub(r"[^1]", r"0", enc.replace("0", "1")), 2)
        match = int(re.sub(r"[^01]", r"0", enc), 2)
        suffix = ""
        print(
            "DECODE{}_MATCH_INFO({},0x{:x}U,0x{:x}U)".format(suffix, tag, mask, match),
            file=f,
        )


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)


implicit_registers = {"SP": 29, "FP": 30, "LR": 31}

num_registers = {"R": 32, "V": 32}


def print_op_info(f):
    for tag in sorted(encs.keys(), key=iset.tags.index):
        enc = encs[tag]
        print(file=f)
        print("DECODE_OPINFO({},".format(tag), file=f)
        regs = ordered_unique(regre.findall(iset.iset[tag]["syntax"]))
        imms = ordered_unique(immre.findall(iset.iset[tag]["syntax"]))
        regno = 0
        for reg in regs:
            reg_type = reg[0]
            reg_letter = reg[1][0]
            reg_num_choices = int(reg[3].rstrip("S"))
            reg_mapping = reg[0] + "".join(["_" for letter in reg[1]]) + reg[3]
            reg_enc_fields = re.findall(reg_letter + "+", enc)
            if len(reg_enc_fields) == 0:
                raise Exception('Tag "{}" missing register field!'.format(tag))
            if len(reg_enc_fields) > 1:
                raise Exception('Tag "{}" has split register field!'.format(tag))
            reg_enc_field = reg_enc_fields[0]
            if 2 ** len(reg_enc_field) != reg_num_choices:
                raise Exception(
                    'Tag "{}" has incorrect register field width!'.format(tag)
                )
            print(
                "        DECODE_REG({},{},{})".format(
                    regno, len(reg_enc_field), enc.index(reg_enc_field)
                ),
                file=f,
            )
            if reg_type in num_registers and reg_num_choices != num_registers[reg_type]:
                print(
                    "        DECODE_MAPPED_REG({},{})".format(regno, reg_mapping),
                    file=f,
                )
            regno += 1

        def implicit_register_key(reg):
            return implicit_registers[reg]

        for reg in sorted(
            set(
                [
                    r
                    for r in (
                        iset.iset[tag]["rregs"].split(",")
                        + iset.iset[tag]["wregs"].split(",")
                    )
                    if r in implicit_registers
                ]
            ),
            key=implicit_register_key,
        ):
            print(
                "        DECODE_IMPL_REG({},{})".format(regno, implicit_registers[reg]),
                file=f,
            )
            regno += 1
        if imms and imms[0][0].isupper():
            imms = reversed(imms)
        for imm in imms:
            if imm[0].isupper():
                immno = 1
            else:
                immno = 0
            imm_type = imm[0]
            imm_width = int(imm[1])
            imm_shift = imm[2]
            if imm_shift:
                imm_shift = int(imm_shift)
            else:
                imm_shift = 0
            if imm_type.islower():
                imm_letter = "i"
            else:
                imm_letter = "I"
            remainder = imm_width
            for m in reversed(list(re.finditer(imm_letter + "+", enc))):
                remainder -= m.end() - m.start()
                print(
                    "        DECODE_IMM({},{},{},{})".format(
                        immno, m.end() - m.start(), m.start(), remainder
                    ),
                    file=f,
                )
            if remainder != 0:
                if imm[2]:
                    imm[2] = ":" + imm[2]
                raise Exception(
                    'Tag "{}" has an incorrect number of '
                    + 'encoding bits for immediate "{}"'.format(tag, "".join(imm))
                )
            if imm_type.lower() in "sr":
                print("        DECODE_IMM_SXT({},{})".format(immno, imm_width), file=f)
            if imm_type.lower() == "n":
                print("        DECODE_IMM_NEG({},{})".format(immno, imm_width), file=f)
            if imm_shift:
                print(
                    "        DECODE_IMM_SHIFT({},{})".format(immno, imm_shift), file=f
                )
        print(")", file=f)


if __name__ == "__main__":
    with open(sys.argv[1], "w") as f:
        print_tree(f, dectree_normal)
        print_tree(f, dectree_16bit)
        if subinsn_groupings:
            print_tree(f, dectree_subinsn_groupings)
        for name, dectree_subinsn in sorted(dectree_subinsns.items()):
            print_tree(f, dectree_subinsn)
        for name, dectree_ext in sorted(dectree_extensions.items()):
            print_tree(f, dectree_ext)
        print_match_info(f)
        print_op_info(f)