/* SPDX-License-Identifier: GPL-2.0 */
/*
 * Generate opcode table initializers for the in-kernel disassembler.
 *
 *    Copyright IBM Corp. 2017
 *
 */

#include <stdlib.h>
#include <string.h>
#include <ctype.h>
#include <stdio.h>

#define STRING_SIZE_MAX 20

struct insn_type {
        unsigned char byte;
        unsigned char mask;
        char **format;
};

struct insn {
        struct insn_type *type;
        char opcode[STRING_SIZE_MAX];
        char name[STRING_SIZE_MAX];
        char upper[STRING_SIZE_MAX];
        char format[STRING_SIZE_MAX];
        unsigned int name_len;
};

struct insn_group {
        struct insn_type *type;
        int offset;
        int count;
        char opcode[2];
};

struct insn_format {
        char *format;
        int type;
};

struct gen_opcode {
        struct insn *insn;
        int nr;
        struct insn_group *group;
        int nr_groups;
};

/*
 * Table of instruction format types. Each opcode is defined with at
 * least one byte (two nibbles), three nibbles, or two bytes (four
 * nibbles).
 * The byte member of each instruction format type entry defines
 * within which byte of an instruction the third (and fourth) nibble
 * of an opcode can be found. The mask member is the and-mask that
 * needs to be applied on this byte in order to get the third (and
 * fourth) nibble of the opcode.
 * The format array defines all instruction formats (as defined in the
 * Principles of Operation) which have the same position of the opcode
 * nibbles.
 * A special case are instruction formats with 1-byte opcodes. In this
 * case the byte member always is zero, so that the mask is applied on
 * the (only) byte that contains the opcode.
 */
static struct insn_type insn_type_table[] = {
        {
                .byte = 0,
                .mask = 0xff,
                .format = (char *[]) {
                        "MII",
                        "RR",
                        "RS",
                        "RSI",
                        "RX",
                        "SI",
                        "SMI",
                        "SS",
                        NULL,
                },
        },
        {
                .byte = 1,
                .mask = 0x0f,
                .format = (char *[]) {
                        "RI",
                        "RIL",
                        "SSF",
                        NULL,
                },
        },
        {
                .byte = 1,
                .mask = 0xff,
                .format = (char *[]) {
                        "E",
                        "IE",
                        "RRE",
                        "RRF",
                        "RRR",
                        "S",
                        "SIL",
                        "SSE",
                        NULL,
                },
        },
        {
                .byte = 5,
                .mask = 0xff,
                .format = (char *[]) {
                        "RIE",
                        "RIS",
                        "RRS",
                        "RSE",
                        "RSL",
                        "RSY",
                        "RXE",
                        "RXF",
                        "RXY",
                        "SIY",
                        "VRI",
                        "VRR",
                        "VRS",
                        "VRV",
                        "VRX",
                        "VSI",
                        NULL,
                },
        },
};

static struct insn_type *insn_format_to_type(char *format)
{
        char tmp[STRING_SIZE_MAX];
        char *base_format, **ptr;
        int i;

        strcpy(tmp, format);
        base_format = tmp;
        base_format = strsep(&base_format, "_");
        for (i = 0; i < sizeof(insn_type_table) / sizeof(insn_type_table[0]); i++) {
                ptr = insn_type_table[i].format;
                while (*ptr) {
                        if (!strcmp(base_format, *ptr))
                                return &insn_type_table[i];
                        ptr++;
                }
        }
        exit(EXIT_FAILURE);
}

static void read_instructions(struct gen_opcode *desc)
{
        struct insn insn;
        int rc, i;

        while (1) {
                rc = scanf("%s %s %s", insn.opcode, insn.name, insn.format);
                if (rc == EOF)
                        break;
                if (rc != 3)
                        exit(EXIT_FAILURE);
                insn.type = insn_format_to_type(insn.format);
                insn.name_len = strlen(insn.name);
                for (i = 0; i <= insn.name_len; i++)
                        insn.upper[i] = toupper((unsigned char)insn.name[i]);
                desc->nr++;
                desc->insn = realloc(desc->insn, desc->nr * sizeof(*desc->insn));
                if (!desc->insn)
                        exit(EXIT_FAILURE);
                desc->insn[desc->nr - 1] = insn;
        }
}

static int cmpformat(const void *a, const void *b)
{
        return strcmp(((struct insn *)a)->format, ((struct insn *)b)->format);
}

static void print_formats(struct gen_opcode *desc)
{
        char *format;
        int i, count;

        qsort(desc->insn, desc->nr, sizeof(*desc->insn), cmpformat);
        format = "";
        count = 0;
        printf("enum {\n");
        for (i = 0; i < desc->nr; i++) {
                if (!strcmp(format, desc->insn[i].format))
                        continue;
                count++;
                format = desc->insn[i].format;
                printf("\tINSTR_%s,\n", format);
        }
        printf("}; /* %d */\n\n", count);
}

static int cmp_long_insn(const void *a, const void *b)
{
        return strcmp(((struct insn *)a)->name, ((struct insn *)b)->name);
}

static void print_insn_name(const char *name)
{
        size_t i, len;

        len = strlen(name);
        printf("{");
        for (i = 0; i < len; i++)
                printf(" \'%c\',", name[i]);
        printf(" }");
}

static void print_long_insn(struct gen_opcode *desc)
{
        struct insn *insn;
        int i, count;

        qsort(desc->insn, desc->nr, sizeof(*desc->insn), cmp_long_insn);
        count = 0;
        printf("enum {\n");
        for (i = 0; i < desc->nr; i++) {
                insn = &desc->insn[i];
                if (insn->name_len < 6)
                        continue;
                printf("\tLONG_INSN_%s,\n", insn->upper);
                count++;
        }
        printf("}; /* %d */\n\n", count);

        printf("#define LONG_INSN_INITIALIZER { \\\n");
        for (i = 0; i < desc->nr; i++) {
                insn = &desc->insn[i];
                if (insn->name_len < 6)
                        continue;
                printf("\t[LONG_INSN_%s] = ", insn->upper);
                print_insn_name(insn->name);
                printf(", \\\n");
        }
        printf("}\n\n");
}

static void print_opcode(struct insn *insn, int nr)
{
        char *opcode;

        opcode = insn->opcode;
        if (insn->type->byte != 0)
                opcode += 2;
        printf("\t[%4d] = { .opfrag = 0x%s, .format = INSTR_%s, ", nr, opcode, insn->format);
        if (insn->name_len < 6) {
                printf(".name =  ");
                print_insn_name(insn->name);
        } else {
                printf(".offset = LONG_INSN_%s", insn->upper);
        }
        printf(" }, \\\n");
}

static void add_to_group(struct gen_opcode *desc, struct insn *insn, int offset)
{
        struct insn_group *group;

        group = desc->group ? &desc->group[desc->nr_groups - 1] : NULL;
        if (group && (!strncmp(group->opcode, insn->opcode, 2) || group->type->byte == 0)) {
                group->count++;
                return;
        }
        desc->nr_groups++;
        desc->group = realloc(desc->group, desc->nr_groups * sizeof(*desc->group));
        if (!desc->group)
                exit(EXIT_FAILURE);
        group = &desc->group[desc->nr_groups - 1];
        memcpy(group->opcode, insn->opcode, 2);
        group->type = insn->type;
        group->offset = offset;
        group->count = 1;
}

static int cmpopcode(const void *a, const void *b)
{
        return strcmp(((struct insn *)a)->opcode, ((struct insn *)b)->opcode);
}

static void print_opcode_table(struct gen_opcode *desc)
{
        char opcode[2] = "";
        struct insn *insn;
        int i, offset;

        qsort(desc->insn, desc->nr, sizeof(*desc->insn), cmpopcode);
        printf("#define OPCODE_TABLE_INITIALIZER { \\\n");
        offset = 0;
        for (i = 0; i < desc->nr; i++) {
                insn = &desc->insn[i];
                if (insn->type->byte == 0)
                        continue;
                add_to_group(desc, insn, offset);
                if (strncmp(opcode, insn->opcode, 2)) {
                        memcpy(opcode, insn->opcode, 2);
                        printf("\t/* %.2s */ \\\n", opcode);
                }
                print_opcode(insn, offset);
                offset++;
        }
        printf("\t/* 1-byte opcode instructions */ \\\n");
        for (i = 0; i < desc->nr; i++) {
                insn = &desc->insn[i];
                if (insn->type->byte != 0)
                        continue;
                add_to_group(desc, insn, offset);
                print_opcode(insn, offset);
                offset++;
        }
        printf("}\n\n");
}

static void print_opcode_table_offsets(struct gen_opcode *desc)
{
        struct insn_group *group;
        int i;

        printf("#define OPCODE_OFFSET_INITIALIZER { \\\n");
        for (i = 0; i < desc->nr_groups; i++) {
                group = &desc->group[i];
                printf("\t{ .opcode = 0x%.2s, .mask = 0x%02x, .byte = %d, .offset = %d, .count = %d }, \\\n",
                       group->opcode, group->type->mask, group->type->byte, group->offset, group->count);
        }
        printf("}\n\n");
}

int main(int argc, char **argv)
{
        struct gen_opcode _desc = { 0 };
        struct gen_opcode *desc = &_desc;

        read_instructions(desc);
        printf("#ifndef __S390_GENERATED_DIS_DEFS_H__\n");
        printf("#define __S390_GENERATED_DIS_DEFS_H__\n");
        printf("/*\n");
        printf(" * DO NOT MODIFY.\n");
        printf(" *\n");
        printf(" * This file was generated by %s\n", __FILE__);
        printf(" */\n\n");
        print_formats(desc);
        print_long_insn(desc);
        print_opcode_table(desc);
        print_opcode_table_offsets(desc);
        printf("#endif\n");
        exit(EXIT_SUCCESS);
}