Subversion Repositories or1k

/* generate.c -- generates file execgen.c from instruction set

   Copyright (C) 1999 Damjan Lampret, lampret@opencores.org

This file is part of OpenRISC 1000 Architectural Simulator.

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, write to the Free Software

Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA. */

#include <stdlib.h>

#include <stdio.h>

#include <string.h>

#include <stdarg.h>

#include <ctype.h>

#include "config.h"

#include "opcode/or32.h"

#include "abstract.h"

#include "labels.h"

#include "parse.h"

#include "execute.h"

#define LEAF_FLAG         (0x80000000)

#define SHIFT {int i; for (i = 0; i < level; i++) fprintf (fo, "  ");}

extern unsigned long *automata;

extern struct temp_insn_struct {

  unsigned long insn;

  unsigned long insn_mask;

  int in_pass;

} *ti;

static char *in_file;

unsigned long op[MAX_OPERANDS];

int num_op;

inline void debug(int level, const char *format, ...)

{

  char *p;

  va_list ap;

#if DEBUG

  if ((p = malloc(1000)) == NULL)

    return;

  va_start(ap, format);

  (void) vsnprintf(p, 1000, format, ap);

  va_end(ap);

  printf("%s\n", p);

  fflush(stdout);

  free(p);

#endif

}

/* Whether this instruction stores something in register */

static int write_to_reg = 0;

static int olevel;

/* Following functions recursivelly searches for substrings eval_operand and

   set_operand (see functions with the same name in execute.c) and replaces

   them with optimized code. */

char *replace_operands (FILE *fo, char *str) {

  int replace = 0;

  if (*str == '}') {olevel--;}

  else if (*str == '{') {olevel++;}

  else if (strncmp ("eval_operand", str, 12) == 0) {

    replace = 1; str += 12;

  } else if (strncmp ("set_operand", str, 11) == 0) {

    replace = 2; str += 11;

  }

  if (replace) {

    int width, oper;

    sscanf (str, "%i(%i", &width, &oper);

    while (*str && *str != '(') str++;

    while (*str && *str != ',') str++;

    str++;

    if (replace == 1) {

      if (op[oper] & OPTYPE_DIS) {

        fprintf (fo, "eval_mem%i (%c", width, 'a' + oper);

      } else {

        if (op[oper] & OPTYPE_REG) {

          fprintf (fo, "(reg[%c]", 'a' + oper);

        } else {

          fprintf (fo, "(%c", 'a' + oper);

        }

      }

    } else {

      op[oper] |= OPTYPE_DST;

      if (op[oper] & OPTYPE_DIS) {

        fprintf (fo, "set_mem%i(%c,", width, 'a' + oper);

      } else if (op[oper] & OPTYPE_REG) {

        fprintf (fo, "reg[%c] = (", 'a' + oper);

        write_to_reg = 1;

      } else {

        fprintf (stderr, "Invalid operand type.\n");

        exit (1);

      }

      while (*str != ',') str = replace_operands (fo, str) + 1;

    }

    while (*str && *str != ')') str++;

    if (op[oper] & OPTYPE_DIS) fprintf (fo, ", &breakpoint)");

    else fprintf (fo, ")");

  } else {

    fputc (*str, fo);

  }

  return str;

}

/* Generates a execute sequence for one instruction */

int output_function (FILE *fo, const char *func_name, int level)

{

  FILE *fi;

  if ((fi = fopen (in_file, "rt")) == NULL) return 1;

  while (!feof (fi)) {

    char line[10000], *str = line;

    fgets (str, sizeof (line), fi);

    line[sizeof(line) - 1] = 0;

    if (strncmp (str, "INSTRUCTION (", 13) == 0) {

      char *s;

      str += 13;

      while (isspace (*str)) str++;

      s = str;

      while (*s && *s != ')') s++;

      *s = 0;

      while (isspace(*(s - 1))) s--;

      *s = 0;

      if (strcmp (str, func_name) == 0) {

        olevel = 1;

        str += strlen (str) + 1;

        while (isspace (*str)) str++;

        s = str;

        while (*s && *s != '\n' && *s != '\r') s++;

        *s = 0;

        while (isspace(*(s - 1))) s--;

        *s = 0;

        fprintf (fo, "%s", str);

        fprintf (fo, "   /* \"%s\" */\n", func_name);

        SHIFT;

        do {

          fgets (line, sizeof (line), fi);

          line[sizeof(line) - 1] = 0;

          for (str = line; *str; str++) {

            str = replace_operands (fo, str);

          }

          SHIFT;

        } while (olevel);

        return 0;

      }

    }

  }

  fprintf (fo, "{\n");

  level++;

  SHIFT; fprintf (fo, "%s ();\n", func_name);

  level--;

  SHIFT; fprintf (fo, "}");

  return 0;

}

/* Parses and puts operands into op[] structure.

   Replacement for eval_operands routine. */

static void

gen_eval_operands (FILE *fo, int insn_index, int level)

{

  struct insn_op_struct *opd = op_start[insn_index];

  int dis = 0;

  int no = 0, num_op;

  int firstd = 1;

  while (1)

    {

      int nbits = 0, first = 1;

      while (1)

        {

          SHIFT; fprintf (fo, "tmp %s= ((insn  >> %i) & 0x%08x) << %i;\n", first ? "" : "|", opd->type & OPTYPE_SHR, (1 << opd->data) - 1, nbits);

          nbits += opd->data;

          if (opd->type & OPTYPE_OP)

            break;

          opd++;

          first = 0;

        }

      /* Do we have to sign extend? */

      if (opd->type & OPTYPE_SIG)

        {

          int sbit = (opd->type & OPTYPE_SBIT) >> OPTYPE_SBIT_SHR;

          SHIFT; fprintf (fo, "if (tmp & (1 << %i)) tmp |= 0xFFFFFFFF << %i; /* Sign extend */\n", sbit, sbit);

        }

      if (opd->type & OPTYPE_DIS) {

        /* We have to read register later.  */

        SHIFT; fprintf (fo, "data %s= tmp;\n", firstd ? "" : "+");

        firstd = 0;

        dis = 1;

      } else

        {

          if (dis && (opd->type & OPTYPE_REG)) {

            if (MAX_GPRS == (1 << nbits)) {

              SHIFT; fprintf (fo, "%c = data + reg [tmp];\n", 'a' + no);

            } else {

              SHIFT; fprintf (fo, "%c = data + eval_reg32 (tmp);\n", 'a' + no);

            }

          } else {

            SHIFT; fprintf (fo, "%c = tmp;\n", 'a' + no);

          }

          op[no] = opd->type | (dis ? OPTYPE_DIS : 0);

          no++;

          firstd = 1;

          dis = 0;

        }

      if(opd->type & OPTYPE_LAST) goto last;

      opd++;

    }

last:

  num_op = no;

  SHIFT; fprintf (fo, "if (do_stats) {\n");

  level++;

  SHIFT; fprintf (fo, "num_op = %i;\n", no);

  SHIFT; fprintf (fo, "insn_index = %i;   /* \"%s\" */\n", insn_index, insn_name (insn_index));

  for (no = 0; no < num_op; no++) {

    SHIFT; fprintf (fo, "op[%i] = %c;\n", no, 'a' + no);

    SHIFT; fprintf (fo, "op[%i + MAX_OPERANDS] = 0x%08x;\n", no, op[no]);

  }

  level--;

  SHIFT; fprintf (fo, "}\n");

}

/* Generates decode and execute for one instruction instance */

int output_call (FILE *fo, int index, int level)

{

  int i;

  printf ("%i:%s\n", index, insn_name (index));

  fprintf (fo, "{\n");

  level++;

  if (index >= 0) {

    SHIFT; fprintf (fo, "unsigned long data, tmp;\n");

    SHIFT; fprintf (fo, "unsigned long a, b, c; /* operands */\n");

  }

  write_to_reg = 0;

  if (index >= 0) {

    gen_eval_operands (fo, index, level);

  } else {

    SHIFT; fprintf (fo, "if (do_stats) {\n");

    level++;

    SHIFT; fprintf (fo, "num_op = 0;\n");

    SHIFT; fprintf (fo, "insn_index = -1;\n");

    level--;

    SHIFT; fprintf (fo, "}\n");

  }

  SHIFT;

  if (index < 0) output_function (fo, "l_invalid", level);

  else output_function (fo, or32_opcodes[index].function_name, level);

  fprintf (fo, "\n");

  for (i = 0; i < num_op; i++)

    if (op[i] & OPTYPE_DST) {

      SHIFT; fprintf (fo, "IFF (config.cpu.dependstats) op[%i + MAX_OPERANDS] |= OPTYPE_DST;\n", i);

    }

  if (write_to_reg) {

    SHIFT; fprintf (fo, "reg[0] = 0; /* Repair in case we changed it */\n", i);

  }

  level--;

  SHIFT; fprintf (fo, "}");

  return 0;

}

/* Generates .c file header */

static int generate_header (FILE *fo)

{

  fprintf (fo, "/* This file was automatically generated by generate (see cpu/or32/generate.c) */\n\n");

  fprintf (fo, "static inline void decode_execute (struct iqueue_entry *current)\n{\n");

  fprintf (fo, "  unsigned long insn = current->insn;\n");

  fprintf (fo, "  int insn_index;\n");

  fprintf (fo, "  op = &current->op[0];\n");

  return 0;

}

/* Generates .c file footer */

int generate_footer (FILE *fo)

{

  fprintf (fo, "  current->insn_index = insn_index;\n");

  fprintf (fo, "}\n");

  return 0;

}

/* Decodes all instructions and generates code for that.  This function

   is similar to insn_decode, except it decodes all instructions. */

static int generate_body (FILE *fo, unsigned long *a, unsigned long cur_mask, int level)

{

  int i;

  if (!(*a & LEAF_FLAG)) {

    unsigned int shift = *a++;

    unsigned int mask  = *a++;

    int prev_invalid = 0;

    fprintf (fo, "\n");

    SHIFT; fprintf (fo, "/* (insn >> %i) & 0x%x */\n", shift, mask);

    SHIFT; fprintf (fo, "switch ((insn >> %i) & 0x%x) {\n", shift, mask);

    level++;

    /* Print each case recursively */

    for (i = 0; i <= mask; i++, a++) {

      /* Group invalid instruction decodes together */

      if (!*a) {

        if (prev_invalid) fprintf (fo, "\n");

        prev_invalid = 1;

        SHIFT; fprintf (fo, "case 0x%02x: ", i);

      } else {

        if (prev_invalid) {

          if (output_call (fo, -1, level)) return 1;

          fprintf (fo, "  break;\n");

        }

        SHIFT; fprintf (fo, "case 0x%02x: ", i);

        if (generate_body (fo, automata + *a, cur_mask | (mask << shift), level + 1)) return 1;

        prev_invalid = 0;

      }

    }

    if (prev_invalid) {

      if (output_call (fo, -1, level)) return 1;

      fprintf (fo, "  break;\n");

    }

    level--;

    if (level > 1)

      fprintf (fo, "}  break;\n");

    else

      fprintf (fo, "}\n");

  } else {

    i = *a & ~LEAF_FLAG;

    /* Final check - do we have direct match?

       (based on or32_opcodes this should be the only possibility,

       but in case of invalid/missing instruction we must perform a check)  */

    if (ti[i].insn_mask != cur_mask) {

      fprintf (fo, "\n");

      SHIFT; fprintf (fo, "/* Not unique: real mask %08x and current mask %08x differ - do final check */\n", ti[i].insn_mask, cur_mask);

      SHIFT; fprintf (fo, "if ((insn & 0x%08x) == 0x%08x) ", ti[i].insn_mask, ti[i].insn);

      output_call (fo, i, level);

      fprintf (fo, " else ");

      if (output_call (fo, -1, level)) return 1;

    } else {

      output_call (fo, i, level - 1);

    }

    fprintf (fo, "  break;\n");

  }

  return 0;

}

/* Main function; it takes two parameters:

   input_file(possibly insnset.c) output_file(possibly execgen.c)*/

int main (int argc, char *argv[])

{

  FILE *fo;

  if (argc != 3) {

    fprintf (stderr, "USAGE: generate input_file(possibly insnset.c) output_file(possibly execgen.c)\n");

    exit (-1);

  }

  in_file = argv[1];

  if (!(fo = fopen (argv[2], "wt+"))) {

    fprintf (stderr, "Cannot create '%s'.\n", argv[2]);

    exit (1);

  }

  build_automata ();

  if (generate_header (fo)) {fprintf (stderr, "generate_header\n"); return 1;}

  if (generate_body (fo, automata, 0, 1)) {fprintf (stderr, "generate_body\n"); return 1;}

  if (generate_footer (fo)) {fprintf (stderr, "generate_footer\n"); return 1;}

  fclose (fo);

  destruct_automata ();

  return 0;

}