URL https://opencores.org/ocsvn/ag_6502/ag_6502/trunk
Subversion Repositories ag_6502

[/] [ag_6502/] [trunk/] [genstates/] [genstates.c] - Blame information for rev 3

Go to most recent revision | Details | Compare with Previous | View Log

#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <assert.h>
#include <ctype.h>
 
 
#define ACTION_INVALID  0
#define ACTION_ASSIGN   1
#define ACTION_EXEC     2
 
 
int opt_level = 1; // 0 to allow verilog optimizer to produce better design, 
                   // (-1) to do not even find common bits
 
struct STATE_ACTION
{
        int     atype;
        const char*astr;
        const char*astr_parsed; // w/o spaces, used to compare
};
 
#define TIME_ANY        (-1)
#define TIME_INC        (-2)
#define PHASE_ANY       (-1)
 
#define NO_CODE (-1)
#define NO_MACROS (-1)
 
#define MIN_TIME 0
#define MAX_TIME 7
#define MIN_PHASE 1
#define MAX_PHASE 2
 
#define TIME_COUNT (MAX_TIME - MIN_TIME + 1)
 
struct STATE_ENTRY
{
        int     time, phase;
        int     action_id;
};
 
#define MAX_MACROS_SIZE 256
 
struct STATE_MACROS
{
        const char*name;
        int     n_entries;
        int     entries[MAX_MACROS_SIZE];
};
 
#define MAX_CODE_SIZE 64
struct STATE_CODE
{
        const char*comment;
        int     n_entries;
        int     entries[MAX_CODE_SIZE];
};
 
 
#define MAX_ACTIONS     8192
#define MAX_ENTRIES     8192
#define MAX_MACROSES    8192
#define MAX_CODES       512
 
#define MAX_STRING      1024
 
struct STATE_DATA
{
        int n_actions, n_entries, n_macroses;
        struct STATE_ACTION actions[MAX_ACTIONS];
        struct STATE_ENTRY entries[MAX_ENTRIES];
        struct STATE_MACROS macroses[MAX_MACROSES];
        struct STATE_CODE codes[MAX_CODES];
 
        int cur_time, cur_phase, cur_code, cur_macros;
};
 
static const char SPACES[] = " \t";
 
int get_action_code(const char*str)
{
        return strstr(str, "<=")?ACTION_EXEC: ACTION_ASSIGN;
}
 
void clean_action(const char*str, char*buf)
{
        for (; *str; ++str) if (!strchr(SPACES, *str)) *buf++ = *str;
        *buf = 0;
}
 
void action_to_name(const char*str, char*buf)
{
        for (; *str; ++str, ++buf) {
                if (!isalnum(*str)) *buf = '_';
                else *buf = *str;
        }
        *buf = 0;
}
 
int find_action(struct STATE_DATA*sd, const char*buf)
{
        int i;
        for (i = 0; i < sd->n_actions; ++i) {
                if (!strcmp(sd->actions[i].astr_parsed, buf)) return i;
        }
        return -1;
}
 
int append_action(struct STATE_DATA*sd, const char*str)
{
        char buf[MAX_STRING];
        struct STATE_ACTION*a = sd->actions + sd->n_actions;
        int r;
        assert(sd->n_actions < MAX_ACTIONS);
        clean_action(str, buf);
//      puts(buf);
        r = find_action(sd, buf);
        if (r >= 0) return r;
        a->atype = get_action_code(buf);
        if (a->atype == ACTION_INVALID) {
                fprintf(stderr, "invalid action: %s\n", str);
                abort();
        }
        a->astr = _strdup(str);
        a->astr_parsed = _strdup(buf);
        return sd->n_actions++;
}
 
int find_entry(struct STATE_DATA*sd, int time, int phase, int action_id)
{
        int i;
        struct STATE_ENTRY*e = sd->entries;
        for (i = 0; i < sd->n_entries; ++i, ++e) {
                if (e->time == time && e->phase == phase && e->action_id == action_id) return i;
        }
        return -1;
}
 
int append_entry_copy(struct STATE_DATA*sd, int time, int phase, int action_id)
{
        struct STATE_ENTRY*e = sd->entries + sd->n_entries;
        int r;
        r = find_entry(sd, time, phase, action_id);
        if (r >= 0) return r;
        assert(sd->n_entries < MAX_ENTRIES);
        e->time = time;
        e->phase = phase;
        e->action_id = action_id;
        return sd->n_entries++;
}
 
 
int append_entry(struct STATE_DATA*sd, int time, int phase, const char*str)
{
        return append_entry_copy(sd, time, phase, append_action(sd, str));
}
 
int find_macros(struct STATE_DATA*sd, const char*name)
{
        int i;
        for (i = 0; i < sd->n_macroses; ++i) {
                if (!strcmp(sd->macroses[i].name, name)) return i;
        }
        return -1;
}
 
int append_macros(struct STATE_DATA*sd, const char*name)
{
        struct STATE_MACROS*m = sd->macroses + sd->n_macroses;
        int r;
        assert(sd->n_macroses < MAX_MACROSES);
        r = find_macros(sd, name);
        if (r >= 0) return r;
        m->name = _strdup(name);
        m->n_entries = 0;
        return sd->n_macroses++;
}
 
int find_macros_entry(struct STATE_DATA*sd, int macro_id, int entry_id)
{
        struct STATE_MACROS*m = sd->macroses + macro_id;
        int i;
        assert(macro_id >= 0 && macro_id < sd->n_macroses);
        for (i = 0; i < m->n_entries; ++i) {
                if (m->entries[i] == entry_id) return i;
        }
        return -1;
}
 
int append_macros_entry(struct STATE_DATA*sd, int macro_id, int entry_id)
{
        struct STATE_MACROS*m = sd->macroses + macro_id;
        int r;
//      r = find_macros_entry(sd, macro_id, entry_id);
//      if (r >= 0) return r;
        assert(macro_id >= 0 && macro_id < sd->n_macroses);
        assert(m->n_entries < MAX_MACROS_SIZE);
        m->entries[m->n_entries++] = entry_id;
        return m->n_entries - 1;
}
 
 
int append_code(struct STATE_DATA*sd, int value, const char*comment)
{
        struct STATE_CODE*c = sd->codes + value;
        assert(value >= 0 && value < MAX_CODES);
        if (!c->comment) c->comment = comment?_strdup(comment):NULL;
        else return -5;
        return value;
}
 
 
int find_code_entry(struct STATE_DATA*sd, int code_id, int entry_id)
{
        struct STATE_CODE*c = sd->codes + code_id;
        int i;
        assert(code_id >= 0 && code_id < MAX_CODES);
        for (i = 0; i < c->n_entries; ++i) {
                if (c->entries[i] == entry_id) return i;
        }
        return -1;
}
 
int append_code_entry(struct STATE_DATA*sd, int code_id, int entry_id)
{
        struct STATE_CODE*c = sd->codes + code_id;
        int r;
        r = find_code_entry(sd, code_id, entry_id);
        if (r >= 0) return r;
        assert(code_id >= 0 && code_id < MAX_CODES);
        assert(c->n_entries < MAX_CODE_SIZE);
        c->entries[c->n_entries++] = entry_id;
        return c->n_entries - 1;
}
 
int clear_data(struct STATE_DATA*sd)
{
        memset(sd, 0, sizeof(*sd));
        sd->cur_time = TIME_ANY;
        sd->cur_phase = PHASE_ANY;
        sd->cur_code = NO_CODE;
        sd->cur_macros = NO_MACROS;
        return 0;
}
 
int append_code_macros(struct STATE_DATA*sd, int code_id, int m_id)
{
        struct STATE_MACROS*s = sd->macroses + m_id;
        int i, r;
//      printf("append_code_macros (%02X, %i): n_entries = %i\n", code_id, m_id, s->n_entries);
        for (i = 0; i < s->n_entries; ++i) {
                int e = s->entries[i];
                int t = sd->entries[e].time;
                int ph = sd->entries[e].phase;
                if (t == TIME_INC) {
                        if (sd->cur_time == TIME_ANY) {
                                return -4;
                        }
                        t = sd->cur_time + 1;
                }
                if (t == TIME_ANY) t = sd->cur_time;
                if (ph == PHASE_ANY) ph = sd->cur_phase;
                if (t == TIME_ANY) return -1;
                if (ph == PHASE_ANY) return -2;
                sd->cur_time = t;
                sd->cur_phase = ph;
                r = append_code_entry(sd, code_id, append_entry_copy(sd, t, ph, sd->entries[e].action_id));
//              printf("append_code_entry: %i: action_id = %i\n", r, sd->entries[e].action_id);
                if (r < 0) return -3;
        }
        return 0;
}
 
int append_macros_macros(struct STATE_DATA*sd, int macro_id, int m_id)
{
        struct STATE_MACROS*s = sd->macroses + m_id;
        int i, r;
        for (i = 0; i < s->n_entries; ++i) {
                int e = s->entries[i];
                int t = sd->entries[e].time;
                int ph = sd->entries[e].phase;
                if (t == TIME_ANY) t = sd->cur_time;
                if (ph == PHASE_ANY) ph = sd->cur_phase;
                sd->cur_time = t;
                sd->cur_phase = ph;
                r = append_macros_entry(sd, macro_id, append_entry_copy(sd, t, ph, sd->entries[e].action_id));
                if (r < 0) return -3;
        }
        return 0;
}
 
 
int insert_macros(struct STATE_DATA*sd, const char*str)
{
        int m_id, r;
        m_id = find_macros(sd, str);
//      printf("insert_macros: %s (%i)\n", str, m_id);
        if (m_id < 0) {
                fprintf(stderr, "error: unable to find macros: %s\n", str);
                return 50;
        }
        if (sd->cur_code != NO_CODE) {
                r = append_code_macros(sd, sd->cur_code, m_id);
        } else {
                r = append_macros_macros(sd, sd->cur_macros, m_id);
        }
        if (r < 0) {
                fprintf(stderr, "error: unable to insert macros: %s: %i\n", str, r);
                return 51;
        }
        return 0;
}
 
int parse_action(struct STATE_DATA*sd, char*str)
{
        int e, r;
        char*p;
        p = strchr(str, '%');
        if (p) *p = 0; // remove comment
//      printf("action: %s\n", str);
        if (sd->cur_code == NO_CODE && sd->cur_macros == NO_MACROS) {
                fprintf(stderr, "error: no current macros or code in action: %s\n", str);
                return 41;
        }
        if (str[0] == '@') return insert_macros(sd, str + 1);
        if (sd->cur_code != NO_CODE && (sd->cur_time == TIME_ANY || sd->cur_phase == PHASE_ANY)) {
                fprintf(stderr, "error: no current phase or time in action: %s\n", str);
                return 42;
        }
        e = append_entry(sd, sd->cur_time, sd->cur_phase, str);
        if (sd->cur_code != NO_CODE) {
                r = append_code_entry(sd, sd->cur_code, e);
        } else {
                r = append_macros_entry(sd, sd->cur_macros, e);
        }
        if (r < 0) {
                fprintf(stderr, "error: unable to append action: %s\n", str);
                return 43;
        }
        return 0;
}
 
int parse_code(struct STATE_DATA*sd, char*str)
{
        char*p, *c = NULL;
        int v;
        v = strtoul(str, &p, 16);
        if (p[0] != ':') {
                fprintf(stderr, "error: invalid code format: %s\n", str);
                return 20;
        }
        ++ p; p += strspn(p, SPACES);
        if (p[0]) {
                if (p[0] == '%') {
                        c = p + 1;
                } else {
                        fprintf(stderr, "error: invalid code comment %s: %i\n", str, sd->cur_code);
                        return 22;
                }
        }
        sd->cur_code = append_code(sd, v, c);
        if (sd->cur_code < 0) {
                fprintf(stderr, "error: unable to append code %s: %i\n", str, sd->cur_code);
                return 21;
        }
        sd->cur_macros = NO_MACROS;
        sd->cur_time = TIME_ANY;
        sd->cur_phase = PHASE_ANY;
        return 0;
}
 
int parse_macros(struct STATE_DATA*sd, char*str)
{
        char*p = strchr(str, ':');
        if (!p || p[1]) {
                fprintf(stderr, "error: invalid macros format: %s\n", str);
                return 30;
        }
        *p = 0;
        sd->cur_macros = append_macros(sd, str);
        if (sd->cur_macros < 0) {
                fprintf(stderr, "error: unable to append macros %s: %i\n", str, sd->cur_macros);
                return 31;
        }
        sd->cur_code = NO_CODE;
        sd->cur_time = TIME_ANY;
        sd->cur_phase = PHASE_ANY;
        return 0;
}
 
int parse_place(struct STATE_DATA*sd, char*str)
{
        int t, ph;
        char*p, *s0 = str;
        if (str[0] == '+' && str[1] == ':') {
                if (sd->cur_time == TIME_ANY) {
                        if (sd->cur_code != NO_CODE) {
                                fprintf(stderr, "error: no current time for increment: %s\n", str);
                                return 14;
                        } else {
                                sd->cur_time = TIME_INC;
                        }
                } else ++sd->cur_time;
                ++str;
        }
        if (str[0] != ':') {
                t = strtoul(str, &p, 10);
                if (*p != ':') {
                        fprintf(stderr, "error: invalid place format: %s\n", str);
                        return 10;
                }
                if (t < MIN_TIME || t > MAX_TIME) {
                        fprintf(stderr, "error: invalid time value: %i\n", t);
                        return 11;
                }
                sd->cur_time = t;
                str = p;
        }
        ++str;
        if (!strchr(SPACES, str[0])) {
                ph = strtoul(str, &p, 10);
                if (!strchr(SPACES, *p)) {
                        fprintf(stderr, "error: invalid place format: %s\n", str);
                        return 12;
                }
                if (ph < MIN_PHASE || ph > MAX_PHASE) {
                        fprintf(stderr, "error: invalid phase value: %i\n", ph);
                        return 13;
                }
                sd->cur_phase = ph;
                str = p;
        }
        ++str;
        return str - s0 + strspn(str, SPACES) + 1;
}
 
int parse_line(struct STATE_DATA*sd, char*str)
{
        int n = strspn(str, SPACES), r;
        if (!str[n]) return 0;
        switch (str[0]) {
        case '#':
                return parse_code(sd, str + 1);
        case '@':
                return parse_macros(sd, str + 1);
        case '(':
                n = parse_place(sd, str + 1);
                if (n < 0) return n;
        case ' ': case '\t':
                r = parse_action(sd, str + n);
                if (sd->cur_time == TIME_INC) sd->cur_time = TIME_ANY;
                return r;
        case '%':
                return 0; // comment
        }
        fprintf(stderr, "error: invalid string format: %s\n", str);
        return 9;
}
 
int load_data(struct STATE_DATA*sd, const char*fname)
{
        FILE*in;
        int lno = 0;
        int r = 0;
        char buf[MAX_STRING];
 
        in = fopen(fname, "rt");
        if (!in) {
                perror(fname);
                return -1;
        }
 
        while (fgets(buf, sizeof(buf), in)) {
                int l;
                ++ lno;
                l = strlen(buf);
                if (l && buf[l - 1] == '\n') buf[--l] = 0;
                r = parse_line(sd, buf);
                if (r) {
                        fprintf(stderr, "%s: error parsing line %i: %i\n", fname, lno, r);
                        break;
                }
        }
        fclose(in);
        return r;
}
 
int write_data(struct STATE_DATA*sd, const char*fname)
{
        FILE*out;
        int i, j, k, l, ct, cp;
        out = fopen(fname, "wt");
        if (!out) {
                perror(fname);
                return -1;
        }
 
        for (i = 0; i < MAX_CODES; ++i) {
                struct STATE_CODE*c = sd->codes + i;
                if (!c->n_entries) continue;
                ct = TIME_ANY;
                cp = PHASE_ANY;
                if (c->comment) fprintf(out, "#%02X: %%%s\n", i, c->comment);
                else fprintf(out, "#%02X:\n", i);
                for (j = MIN_TIME; j <= MAX_TIME; ++j) {
                        for (k = MIN_PHASE; k <= MAX_PHASE; ++k) {
                                for (l = 0; l < c->n_entries; ++l) {
                                        struct STATE_ENTRY*e = sd->entries + c->entries[l];
                                        if (e->time != j || e->phase != k) continue;
                                        if (ct != j || cp != k) {
                                                fprintf(out, "(%i:%i", j, k);
                                                ct = j;
                                                cp = k;
                                        }
                                        fprintf(out, "\t%s\n", sd->actions[e->action_id].astr);
                                }
                        }
                }
                fprintf(out, "\n");
        }
 
        fclose(out);
        return 0;
}
 
int validate_data(struct STATE_DATA*sd)
{
        int i, j;
 
        for (i = 0; i < MAX_CODES; ++i) {
                struct STATE_CODE*c = sd->codes + i;
                if (!c->n_entries) continue;
                for (j = 0; j < c->n_entries; ++j) {
                        struct STATE_ENTRY*e = sd->entries + c->entries[j];
                        struct STATE_ACTION*a = sd->actions + e->action_id;
                        if (e->phase == 2 && a->atype == ACTION_ASSIGN) {
                                fprintf(stderr, "error: no assignments are valid in phase 2 for code %02X: %s\n",
                                                i, a->astr);
                                return -10;
                        }
                }
        }
        return 0;
}
 
 
int code_has_action(struct STATE_DATA*sd, int code_id, int time, int action_id)
{
        struct STATE_CODE*c = sd->codes + code_id;
        int i;
 
        for (i = 0; i < c->n_entries; ++i) {
                if (sd->entries[c->entries[i]].time == time && sd->entries[c->entries[i]].action_id == action_id) return 1;
        }
        return 0;
}
 
 
#define CODE_NONE       0
#define CODE_ACTION     1
 
#define BIT_COMMON      0
#define BIT_OTHER       1
 
#define N_BITS          (8+3)
 
#define VBIT_0          0
#define VBIT_1          1
#define VBIT_UNKNOWN    2
#define VBIT_VAR        3
 
unsigned prepare_selector(int code, int time)
{
        return code | (time << 8);
}
 
void print_selector(FILE*out, unsigned sel)
{
        int k;
        for (k = N_BITS - 1; k >= 0; --k, sel <<= 1) {
                int c;
                fputc((sel & (1<<(N_BITS - 1)))?'1': '0', out);
                if (!(k & 7)) fputc(' ', out);
        }
}
 
#define DEBUG 1
 
 
 
unsigned expand_common_bits(FILE*out, unsigned other_mask,
        const unsigned other_codes[], int n_other,
        int common_bit, int bit_val,
        unsigned *mask, unsigned*val,
        unsigned sel_mask, unsigned sel_val)
{
        int i, j, c;
        unsigned m, mc, vc, r;
        char out_bits[N_BITS];
        mc = 1 << common_bit;
        vc = bit_val ? mc: 0;
        other_mask &= ~mc;
        memset(out_bits, VBIT_UNKNOWN, sizeof(out_bits));
        for (j = 0; j < n_other; ++j) {
                if ((other_codes[j] & sel_mask) != sel_val) continue;
                if ((other_codes[j] & mc) != vc) continue;
                for (i = 0, m = 1; i < N_BITS; ++i, m <<= 1) {
                        if (!(other_mask & m)) continue;
                        if (out_bits[i] == VBIT_VAR) continue;
//                      fprintf(out, "bits[%03X:%i] = %i (%i)\n", other_codes[j], i, out_bits[i], (other_codes[j] & m)?1:0);
                        if (other_codes[j] & m) {
                                if (out_bits[i] == VBIT_UNKNOWN)
                                        out_bits[i] = VBIT_1;
                                else if (out_bits[i] != VBIT_1)
                                        out_bits[i] = VBIT_VAR;
                        } else {
                                if (out_bits[i] == VBIT_UNKNOWN)
                                        out_bits[i] = VBIT_0;
                                else if (out_bits[i] != VBIT_0)
                                        out_bits[i] = VBIT_VAR;
                        }
                }
        }
        *val = 0;
        for (i = 0, r = 0, m = 1, c = 0; i < N_BITS; ++i, m <<= 1) {
                if ((out_bits[i] == VBIT_1) || (out_bits[i] == VBIT_0)) {
                        r |= m;
                        if (out_bits[i] == VBIT_1) *val |= m;
                        ++ c;
                }
        }
        *mask = r;
        return c;
}
 
int check_full_bits(FILE*out, unsigned other_mask,
                const unsigned other_codes[], int n_other,
                unsigned sel_mask, unsigned sel_val)
{
        int i, j;
        unsigned m;
        int nv;
        unsigned test_codes[MAX_CODES * TIME_COUNT];
        int n_codes, f_codes;
 
 
/*      fprintf(out, "****check_full_bits: other_mask = ");
        print_selector(out, other_mask);
        fprintf(out, ", sel_mask = ");
        print_selector(out, sel_mask);
        fprintf(out, ", sel_val = ");
        print_selector(out, sel_val);
        fprintf(out, "\n");*/
 
        if (!other_mask) return 1;
 
 
        for (i = 0, nv = 0, m = 1; i < N_BITS; ++i, m <<= 1) {
                if (other_mask & m) ++ nv;
        }
        assert(nv);
        f_codes = 1 << nv;
 
        for (j = 0, n_codes = 0; j < n_other; ++j) {
                int f = 0;
                unsigned oc;
                if ((other_codes[j] & sel_mask) != sel_val) continue;
                oc = other_codes[j] & other_mask;
                for (i = 0; i < n_codes; ++i) {
                        if (test_codes[i] == oc) {
                                f = 1;
                                break;
                        }
                }
                if (f) continue;
        /*      fprintf(out,"uniq code: ");
                print_selector(out, oc);
                fprintf(out, "\n");        */
                test_codes[n_codes++] = oc;
                if (n_codes == f_codes) return 1;
        }
        return 0;
}
 
 
 
int find_common_bit(FILE*out, unsigned other_mask,
                const unsigned other_codes[], int n_other,
                unsigned sel_mask, unsigned sel_val,
                int nn[2], unsigned mm[2], unsigned vv[2])
{
        int counts[N_BITS][2];
        unsigned masks[N_BITS][2];
        unsigned vals[N_BITS][2];
//      int fulls[N_BITS][2];
        unsigned m, mv;
        int i, j;
        int max_count = -1;
        int max_bit = -1;
 
        memset(counts, 0, sizeof(counts));
 
        // print available codes
/*
        for (j = 0; j < n_other; ++j) {
                if ((other_codes[j] & sel_mask) != sel_val) continue;
                fprintf(out, "***code[%i]: ", j);
                print_selector(out, other_codes[j]);
                fprintf(out, "\n");
        }
*/
        // compute counts
/*      for (i = 0, m = 1; i < N_BITS; ++i, m <<= 1) {
                if (!(other_mask & m)) continue;
                for (j = 0; j < n_other; ++j) {
                        if ((other_codes[j] & sel_mask) != sel_val) continue;
                        ++ counts[i][(other_codes[j] & m)?1:0];
                }
        }
*/
 
        for (i = 0, m = 1; i < N_BITS; ++i, m <<= 1) {
                if (!(other_mask & m)) continue;
                counts[i][0] = expand_common_bits(out, other_mask,
                                other_codes, n_other, i, 0,
                                masks[i] + 0, vals[i] + 0,
                                sel_mask, sel_val);
                counts[i][1] = expand_common_bits(out, other_mask,
                                other_codes, n_other, i, 1,
                                masks[i] + 1, vals[i] + 1,
                                sel_mask, sel_val);
/*              fulls[i][0] = check_full_bits(out,
                                        other_mask & ~(masks[i][0] | m),
                                        other_codes, n_other,
                                        sel_mask | (masks[i][0] | m),
                                        sel_val | (vals[i][0]));
                fulls[i][1] = check_full_bits(out,
                                        other_mask & ~(masks[i][1] | m),
                                        other_codes, n_other,
                                        sel_mask | (masks[i][1] | m),
                                        sel_val | (vals[i][1] | m));*/
//              fprintf(out, "counts[%i] = %i, %i (%i,%i)\n", i, 
//                              counts[i][0], counts[i][1],
//                              fulls[i][0], fulls[i][1]);
        }
 
        for (i = 0, m = 1; i < N_BITS; ++i, m <<= 1) {
                if (!(other_mask & m)) continue;
                if (max_count < counts[i][0]) {
                        max_count = counts[i][0];
                        max_bit = i;
                } else if (max_count < counts[i][1]) {
                        max_count = counts[i][1];
                        max_bit = i;
                }
        }
        if (max_bit == -1) return -1;
 
        // compute result counts
        nn[0] = nn[1] = 0;
        mv = 1 << max_bit;
        for (j = 0; j < n_other; ++j) {
                if ((other_codes[j] & sel_mask) != sel_val) continue;
                if (other_codes[j] & mv) ++nn[1]; else ++nn[0];
        }
 
//      nn[0] = counts[max_bit][0];
//      nn[1] = counts[max_bit][1];
 
        mm[0] = masks[max_bit][0];
        mm[1] = masks[max_bit][1];
 
        vv[0] = vals[max_bit][0];
        vv[1] = vals[max_bit][1];
 
 
 
 
        // print counts
/*      fprintf(out, "****Counts for mask (max_bit = %i): ", max_bit);
        print_selector(out, other_mask);
        fprintf(out, "\n");
        for (i = 0, m = 1; i < N_BITS; ++i, m <<= 1) {
                if (!(other_mask & m)) continue;
                fprintf(out, "//\t\tbit %i: (%i, %i)\n", i, counts[i][0], counts[i][1]);
        }*/
 
        return max_bit;
}
 
 
int print_sel_bits(FILE*out, unsigned mask, unsigned val)
{
        int nv, rv;
        int i, iv, vv;
        unsigned m;
        for (i = 0, nv = 0, m = 1; i < N_BITS; ++i, m <<= 1) {
                if (mask & m) {
                        ++ nv;
                        iv = i;
                        vv = (val & m)?1:0;
                }
        }
        if (nv == 1) {
                fprintf(out, "%sL[%i]", vv?"":"!", iv);
                return 1;
        }
        fprintf(out, "({");
        for (i = 0, rv = 0, m = 1; i < N_BITS; ++i, m <<= 1) {
                if (mask & m) {
                        if (rv) fprintf(out, ",");
                        fprintf(out, "L[%i]", i);
                        ++ rv;
                }
        }
        fprintf(out, "} == %i'b", nv);
        for (i = 0, m = 1; i < N_BITS; ++i, m <<= 1) {
                if (mask & m) {
                        fprintf(out, "%c", (val & m)?'1':'0');
                }
        }
        fprintf(out, ")");
        return nv;
 
}
 
void print_other(FILE*out, unsigned other_mask, const unsigned other_codes[], int n_other, unsigned sel_mask, unsigned sel_val)
{
        int j, nn = 0;
        for (j = 0; j < n_other; ++j) {
                if ((other_codes[j] & sel_mask) != sel_val) continue;
//              if (!nn) fprintf(out, "(");
                if (nn) fprintf(out, " || ");
                print_sel_bits(out, other_mask, other_codes[j]);
                ++nn;
        }
//      if (nn) fprintf(out, ")");
}
 
 
void recurse_other(FILE*out, unsigned other_mask, const unsigned other_codes[], int n_other, unsigned sel_mask, unsigned sel_val, int level)
{
        int nn[2];
        unsigned mm[2], vv[2];
        unsigned cbm;
        int cb;
        unsigned sm0, sm1, sv0, sv1;
        int cf0, cf1;
 
/*      fprintf(out, "\n**recurse_other[%i]: n_other = %i, other_mask = ", level, n_other);
        print_selector(out, other_mask);
        fprintf(out, ", sel_mask = ");
        print_selector(out, sel_mask);
        fprintf(out, ", sel_val = ");
        print_selector(out, sel_val);
        fprintf(out, "\n");
*/
        if (opt_level != -1 && level >= opt_level) {
                print_other(out, other_mask, other_codes, n_other, sel_mask, sel_val);
                return;
        }
 
        if (!other_mask) return;
 
 
        cb = find_common_bit(out, other_mask, other_codes, n_other,
                        sel_mask, sel_val, nn, mm, vv);
        if (cb == -1) exit(100);
        cbm = 1<<cb;
//      expand_common_bits(out, other_mask, other_codes, n_other, cb, 0, &m0, &v0, sel_mask, sel_val);
//      expand_common_bits(out, other_mask, other_codes, n_other, cb, 1, &m1, &v1, sel_mask, sel_val);
/*      fprintf(out, "** find_common_bit: %i: ", cb);
        print_selector(out, mm[0]);
        fprintf(out, ", ");
        print_selector(out, mm[1]);
        fprintf(out, "\n");
*/
        if (cbm == other_mask && !mm[0] && !mm[1]) {
                fprintf(out, "1'b1");
                return;
        }
 
        mm[0] |= cbm;
        mm[1] |= cbm;
        vv[1] |= cbm;
 
        sm0 = sel_mask | mm[0];
        sm1 = sel_mask | mm[1];
 
        sv0 = sel_val | vv[0];
        sv1 = sel_val | vv[1];
 
        cf0 = check_full_bits(out, other_mask & ~mm[0], other_codes, n_other, sm0, sv0);
        cf1 = check_full_bits(out, other_mask & ~mm[1], other_codes, n_other, sm1, sv1);
 
//      fprintf(out, "\nnn[0] = %i, nn[1] = %i, cf0 = %i, cf1 = %i\n", nn[0], nn[1], cf0, cf1);
 
        if (nn[0]) {
                if (!cf0 && nn[1]) {
                        fprintf(out, "(");
                }
                print_sel_bits(out, mm[0], vv[0]);
                if (!cf0) {
                        fprintf(out, " && (");
                        recurse_other(out, other_mask & ~mm[0], other_codes, n_other, sm0, sv0, level + 1);
                        fprintf(out, ")");
                        if (nn[1]) fprintf(out, ")");
                }
                if (nn[1]) fprintf(out, " || ");
        }
        if (nn[1]) {
                if (!cf1 && nn[0]) {
                        fprintf(out, "(");
                }
                print_sel_bits(out, mm[1], vv[1]);
                if (!cf1) {
                        fprintf(out, " && (");
                        recurse_other(out, other_mask & ~mm[1], other_codes, n_other,  sm1, sv1, level + 1);
                        fprintf(out, ")");
                        if (nn[0]) fprintf(out, ")");
                }
        }
}
 
int print_verilog_line(FILE*out, const char bits[N_BITS], const char vbits[N_BITS], const int codes[MAX_CODES][MAX_TIME-MIN_TIME + 1])
{
        int i;
        int n_bits[4] = {0, 0, 0, 0};
        int common_vals[N_BITS], common_inds[N_BITS];
        int other_inds[N_BITS];
        unsigned other_mask = 0, m;
        unsigned other_codes[MAX_CODES * TIME_COUNT];
        int n_other;
        for (i = 0, m = 1; i < N_BITS; ++i, m <<= 1) {
                int n = n_bits[bits[i]] ++;
                switch (bits[i]) {
                case BIT_COMMON:
                        common_vals[n] = (vbits[i] == VBIT_0)?0:1;
                        common_inds[n] = i;
                        break;
                case BIT_OTHER:
                        other_inds[n] = i;
                        other_mask |= m;
                        break;
                }
        }
 
        // check for full other list
        if (n_bits[BIT_OTHER]) {
                int j, t;
                n_other = 0;
                for (j = 0; j < MAX_CODES; ++j) {
                        for (t = MIN_TIME; t <= MAX_TIME; ++t) {
                                unsigned int val = prepare_selector(j, t) & other_mask;
                                int r = -1;
                                if (codes[j][t] != CODE_ACTION) continue;
                                for (i = 0; i < n_other; ++i) {
                                        if (other_codes[i] == val) { r = i; break; }
                                }
                                if (r == -1) other_codes[n_other++] = val;
                        }
                }
//              fprintf(out, "//\tn_other = %i (%i)\n", n_other, 1 << n_bits[BIT_OTHER]);
                if (n_other == (1 << n_bits[BIT_OTHER])) n_bits[BIT_OTHER] = 0;
        }
 
        if (!n_bits[BIT_COMMON] && !n_bits[BIT_OTHER]) {
                fprintf(out, "1'b1");
                return 0;
        }
        if (n_bits[BIT_COMMON]) {
                fprintf(out, "({");
                for (i = 0; i < n_bits[BIT_COMMON]; ++i) {
                        fprintf(out, "L[%i]", common_inds[i]);
                        if (i < n_bits[BIT_COMMON] - 1) fprintf(out, ",");
                }
                fprintf(out, "} == %i'b", n_bits[BIT_COMMON]);
                for (i = 0; i < n_bits[BIT_COMMON]; ++i) {
                        fprintf(out, "%i", common_vals[i]);
                }
                fprintf(out, ")");
                if (n_bits[BIT_OTHER]) fprintf(out, " && (");
        }
        if (n_bits[BIT_OTHER]) {
//              fprintf(out, "(");
                recurse_other(out, other_mask, other_codes, n_other, 0, 0, 1);
//              fprintf(out, ")");
        }
        if (n_bits[BIT_COMMON]) {
                if (n_bits[BIT_OTHER]) fprintf(out, ")");
        }
/*      if (n_bits[BIT_OTHER]) {
                int j, t;
                fprintf(out, "(");
                n_other = 0;
                for (j = 0; j < MAX_CODES; ++j) {
                        for (t = MIN_TIME; t <= MAX_TIME; ++t) {
                                unsigned int val = prepare_selector(j, t) & other_mask;
                                int r = -1;
 
                                if (codes[j][t] != CODE_ACTION) continue;
 
                                for (i = 0; i < n_other; ++i) {
                                        if (other_codes[i] == val) { r = i; break; }
                                }
                                if (r != -1) continue;
 
                                if (n_other) fprintf(out, " || ");
                                fprintf(out, "({");
                                for (i = 0; i < n_bits[BIT_OTHER]; ++i) {
                                        fprintf(out, "L[%i]", other_inds[i]);
                                        if (i < n_bits[BIT_OTHER] - 1) fprintf(out, ",");
                                }
                                fprintf(out, "} == %i'b", n_bits[BIT_OTHER]);
                                for (i = 0, m = 1; i < N_BITS; ++i, m <<= 1) {
                                        if (other_mask & m) {
                                                fprintf(out, "%i", (val&m)?1:0);
                                        }
                                }
                                fprintf(out, ")");
                                other_codes[n_other++] = val;
                        }
                }
                fprintf(out, ")");
        }*/
        return 0;
}
 
 
int process_data(struct STATE_DATA*sd, const char*fname)
{
        int i, j, k, l, t;
        int r;
        unsigned m;
        FILE*out;
        int codes[MAX_CODES][TIME_COUNT];
        char bits[N_BITS];
        char vbits[N_BITS];
        out = fopen(fname, "wt");
        if (!out) {
                perror(fname);
                return -1;
        }
        fprintf(out, "// This file has been generated automatically\n"
                        "//\tby the GenStates tool\n"
                        "// Copyright (c) Oleg Odintsov\n"
                        "// This tool is a part of Agat hardware project\n\n");
 
        if (opt_level == -1) {
                fprintf(out, "//\tLevel of optimization: infinite\n");
        } else {
                fprintf(out, "//\tLevel of optimization: %i\n", opt_level);
        }
 
        fprintf(out, "//\tTotal number of actions: %i\n", sd->n_actions);
        for (i = 0; i < sd->n_actions; ++i) {
                char name[MAX_STRING];
                action_to_name(sd->actions[i].astr_parsed, name);
                fprintf(out, "\twire %s%s;\n", (sd->actions[i].atype == ACTION_EXEC)?"E_": "A_", name);
        }
        fprintf(out, "\n//\tActions assignments\n");
        // for all actions
        for (i = 0; i < sd->n_actions; ++i) {
                const char*p;
                int n;
                char name[MAX_STRING];
                int n_active = 0;
#if DEBUG
                fprintf(out, "\n//\taction: %s:\n", sd->actions[i].astr);
#endif
                memset(codes, CODE_NONE, sizeof(codes));
                // find codes with this action
                for (j = 0; j < MAX_CODES; ++j) {
                        for (t = MIN_TIME; t <= MAX_TIME; ++t)
                                if (code_has_action(sd, j, t, i)) {
                                        codes[j][t] = CODE_ACTION;
                                        ++ n_active;
/*#if DEBUG
                                        fprintf(out, "//\t\t(%i, %02X: ", t, j);
                                        print_selector(out, prepare_selector(j, t));
                                        fprintf(out, ")\n");
#endif*/
                                }
                }
                if (!n_active) {
                        action_to_name(sd->actions[i].astr_parsed, name);
                        fprintf(out, "\tassign %s%s = 1'b0;\n", (sd->actions[i].atype == ACTION_EXEC)?"E_": "A_", name);
                        continue;
                }
 
 
                // Selecting common bits@action (BIT_COMMON)
                if (opt_level == 1) {
                        memset(bits, BIT_COMMON, sizeof(bits));
                        memset(vbits, VBIT_UNKNOWN, sizeof(vbits));
                for (j = 0; j < MAX_CODES; ++j) {
                        for (t = MIN_TIME; t <= MAX_TIME; ++t) {
                                unsigned int val = prepare_selector(j, t);
                                if (codes[j][t] != CODE_ACTION) continue;
                                for (k = 0, m = 1; k < N_BITS; ++k, m<<=1) {
                                        if (bits[k] != BIT_COMMON) continue;
                                        if (val & m) {
                                                if (vbits[k] == VBIT_UNKNOWN)
                                                        vbits[k] = VBIT_1;
                                                else if (vbits[k] != VBIT_1)
                                                        bits[k] = BIT_OTHER;
                                        } else {
                                                if (vbits[k] == VBIT_UNKNOWN)
                                                        vbits[k] = VBIT_0;
                                                else if (vbits[k] != VBIT_0)
                                                        bits[k] = BIT_OTHER;
                                        }
                                }
                        }
                }
                } else {
                        memset(bits, BIT_OTHER, sizeof(bits));
                        memset(vbits, VBIT_UNKNOWN, sizeof(vbits));
                }
                // debug print
/*
#if DEBUG
                fprintf(out, "//        %14s: ", sd->actions[i].astr);
                for (k = N_BITS - 1; k >= 0; --k) {
                        int c;
                        if (bits[k] == BIT_COMMON) c = (vbits[k] == VBIT_0)?'0':(vbits[k] == VBIT_1)?'1':'2';
                        else c = '?';
                        fprintf(out, "%c", c);
                        if (!(k & 7)) fprintf(out, " ");
                }
                fprintf(out, "\n");
#endif
*/
                // verilog output
                action_to_name(sd->actions[i].astr_parsed, name);
                fprintf(out, "\tassign %s%s = ", (sd->actions[i].atype == ACTION_EXEC)?"E_": "A_", name);
                print_verilog_line(out, bits, vbits, codes);
                fprintf(out, ";\n");
        }
        fclose(out);
        return 0;
}
 
 
void print_help(const char*cmd)
{
        printf("Use %s [-Olevel | -h] [states.txt] [states_out.txt] [states.v]\n"
                "\t-h\tPrint this help;\n"
                "\t-Olevel\tSpecify level of optimization (default is 1):\n"
                "\t\t0 - no optimization\n"
                "\t\t1 - just group common bits (default, best for hardware)\n"
                "\t\t>1 - higher levels\n"
                "\t\t-1 - infinite optimization (best for simulation).\n\n"
                "Copyright (c) Odintsov Oleg, nnop@newmail.ru\n"
                "This tool is a part of Agat hardware project.\n", cmd);
        exit(100);
}
 
struct STATE_DATA sd;
 
int main(int argc, const char*argv[])
{
        int r;
        int s = 0;
        if (argc > 1 && argv[1][0] == '-') {
                switch (argv[1][1]) {
                case '?': case 'h': case 'H': print_help(argv[0]);
                case 'O':
                        opt_level = atoi(argv[1] + 2);
                        if (opt_level == -1) {
                                printf("level of optimization: infinite\n");
                        } else {
                                printf("level of optimization: %i\n", opt_level);
                        }
                }
                s = 1;
        }
        clear_data(&sd);
        r = load_data(&sd, (argc > (s + 1))? argv[s + 1]: "states.txt");
        if (r) return r;
        r = validate_data(&sd);
        if (r) return r;
        r = write_data(&sd, (argc > (s + 2))? argv[s + 2]: "states_out.txt");
        if (r) return r;
        r = process_data(&sd, (argc > (s + 3))? argv[s + 3]: "states.v");
        if (r) return r;
        return 0;
}
Browse

Tools

Subversion Repositories ag_6502

[/] [ag_6502/] [trunk/] [genstates/] [genstates.c] - Blame information for rev 3

Line No.	Rev	Author	Line
1	2	olegodints	`#include <stdio.h>`
2			`#include <stdlib.h>`
3			`#include <string.h>`
4			`#include <assert.h>`
5			`#include <ctype.h>`
6
7
8			`#define ACTION_INVALID 0`
9			`#define ACTION_ASSIGN 1`
10			`#define ACTION_EXEC 2`
11
12
13			`int opt_level = 1; // 0 to allow verilog optimizer to produce better design,`
14			`// (-1) to do not even find common bits`
15
16			`struct STATE_ACTION`
17			`{`
18			`int atype;`
19			`const char*astr;`
20			`const char*astr_parsed; // w/o spaces, used to compare`
21			`};`
22
23			`#define TIME_ANY (-1)`
24			`#define TIME_INC (-2)`
25			`#define PHASE_ANY (-1)`
26
27			`#define NO_CODE (-1)`
28			`#define NO_MACROS (-1)`
29
30			`#define MIN_TIME 0`
31			`#define MAX_TIME 7`
32			`#define MIN_PHASE 1`
33			`#define MAX_PHASE 2`
34
35			`#define TIME_COUNT (MAX_TIME - MIN_TIME + 1)`
36
37			`struct STATE_ENTRY`
38			`{`
39			`int time, phase;`
40			`int action_id;`