Subversion Repositories or1k

/* The IGEN simulator generator for GDB, the GNU Debugger.

   Copyright 2002 Free Software Foundation, Inc.

   Contributed by Andrew Cagney.

   This file is part of GDB.

   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., 59 Temple Place - Suite 330,

   Boston, MA 02111-1307, USA.  */

#include "misc.h"

#include "lf.h"

#include "table.h"

#include "filter.h"

#include "igen.h"

#include "ld-insn.h"

#include "ld-decode.h"

#include "gen.h"

#include "gen-semantics.h"

#include "gen-idecode.h"

#include "gen-icache.h"

static void

print_icache_function_header (lf *file,

                              const char *basename,

                              const char *format_name,

                              opcode_bits *expanded_bits,

                              int is_function_definition,

                              int nr_prefetched_words)

{

  lf_printf (file, "\n");

  lf_print__function_type_function (file, print_icache_function_type,

                                    "EXTERN_ICACHE", " ");

  print_function_name (file,

                       basename, format_name, NULL,

                       expanded_bits, function_name_prefix_icache);

  lf_printf (file, "\n(");

  print_icache_function_formal (file, nr_prefetched_words);

  lf_printf (file, ")");

  if (!is_function_definition)

    lf_printf (file, ";");

  lf_printf (file, "\n");

}

void

print_icache_declaration (lf *file,

                          insn_entry * insn,

                          opcode_bits *expanded_bits,

                          insn_opcodes *opcodes, int nr_prefetched_words)

{

  print_icache_function_header (file,

                                insn->name,

                                insn->format_name,

                                expanded_bits,

                                nr_prefetched_words);

}

static void

print_icache_extraction (lf *file,

                         const char *format_name,

                         cache_entry_type cache_type,

                         const char *entry_name,

                         const char *entry_type,

                         const char *entry_expression,

                         char *single_insn_field,

                         line_ref *line,

                         insn_field_entry *cur_field,

                         opcode_bits *expanded_bits,

                         icache_decl_type what_to_declare,

                         icache_body_type what_to_do)

{

  const char *expression;

  opcode_bits *bits;

  char *reason;

  ASSERT (format_name != NULL);

  ASSERT (entry_name != NULL);

  /* figure out exactly what should be going on here */

  switch (cache_type)

    {

    case scratch_value:

      if ((what_to_do & put_values_in_icache)

          || what_to_do == do_not_use_icache)

        {

          reason = "scratch";

          what_to_do = do_not_use_icache;

        }

      else

        return;

      break;

    case compute_value:

      if ((what_to_do & get_values_from_icache)

          || what_to_do == do_not_use_icache)

        {

          reason = "compute";

          what_to_do = do_not_use_icache;

        }

      else

        return;

      break;

    case cache_value:

      if ((what_to_declare != undef_variables)

          || !(what_to_do & put_values_in_icache))

        {

          reason = "cache";

          what_to_declare = ((what_to_do & put_values_in_icache)

                             ? declare_variables : what_to_declare);

        }

      else

        return;

      break;

    default:

      abort ();                 /* Bad switch.  */

    }

  /* For the type, default to a simple unsigned */

  if (entry_type == NULL || strlen (entry_type) == 0)

    entry_type = "unsigned";

  /* look through the set of expanded sub fields to see if this field

     has been given a constant value */

  for (bits = expanded_bits; bits != NULL; bits = bits->next)

    {

      if (bits->field == cur_field)

        break;

    }

  /* Define a storage area for the cache element */

  switch (what_to_declare)

    {

    case undef_variables:

      /* We've finished with the #define value - destory it */

      lf_indent_suppress (file);

      lf_printf (file, "#undef %s\n", entry_name);

      return;

    case define_variables:

      /* Using direct access for this entry, clear any prior

         definition, then define it */

      lf_indent_suppress (file);

      lf_printf (file, "#undef %s\n", entry_name);

      /* Don't type cast pointer types! */

      lf_indent_suppress (file);

      if (strchr (entry_type, '*') != NULL)

        lf_printf (file, "#define %s (", entry_name);

      else

        lf_printf (file, "#define %s ((%s) ", entry_name, entry_type);

      break;

    case declare_variables:

      /* using variables to define the value */

      if (line != NULL)

        lf_print__line_ref (file, line);

      lf_printf (file, "%s const %s UNUSED = ", entry_type, entry_name);

      break;

    }

  /* define a value for that storage area as determined by what is in

     the cache */

  if (bits != NULL

      && single_insn_field != NULL

      && strcmp (entry_name, single_insn_field) == 0

      && strcmp (entry_name, cur_field->val_string) == 0

      && ((bits->opcode->is_boolean && bits->value == 0)

          || (!bits->opcode->is_boolean)))

    {

      /* The cache rule is specifying what to do with a simple

         instruction field.

         Because of instruction expansion, the field is either a

         constant value or equal to the specified constant (boolean

         comparison). (The latter indicated by bits->value == 0).

         The case of a field not being equal to the specified boolean

         value is handled later. */

      expression = "constant field";

      ASSERT (bits->field == cur_field);

      if (bits->opcode->is_boolean)

        {

          ASSERT (bits->value == 0);

          lf_printf (file, "%d", bits->opcode->boolean_constant);

        }

      else if (bits->opcode->last < bits->field->last)

        {

          lf_printf (file, "%d",

                     bits->value << (bits->field->last - bits->opcode->last));

        }

      else

        {

          lf_printf (file, "%d", bits->value);

        }

    }

  else if (bits != NULL

           && single_insn_field != NULL

           && strncmp (entry_name,

                       single_insn_field,

                       strlen (single_insn_field)) == 0

           && strncmp (entry_name + strlen (single_insn_field),

                       "_is_",

                       strlen ("_is_")) == 0

           && ((bits->opcode->is_boolean

                && ((unsigned)

                    atol (entry_name + strlen (single_insn_field) +

                          strlen ("_is_")) == bits->opcode->boolean_constant))

               || (!bits->opcode->is_boolean)))

    {

      /* The cache rule defines an entry for the comparison between a

         single instruction field and a constant.  The value of the

         comparison in someway matches that of the opcode field that

         was made constant through expansion. */

      expression = "constant compare";

      if (bits->opcode->is_boolean)

        {

          lf_printf (file, "%d /* %s == %d */",

                     bits->value == 0,

                     single_insn_field, bits->opcode->boolean_constant);

        }

      else if (bits->opcode->last < bits->field->last)

        {

          lf_printf (file, "%d /* %s == %d */",

                     (atol

                      (entry_name + strlen (single_insn_field) +

                       strlen ("_is_")) ==

                      (bits->

                       value << (bits->field->last - bits->opcode->last))),

                     single_insn_field,

                     (bits->

                      value << (bits->field->last - bits->opcode->last)));

        }

      else

        {

          lf_printf (file, "%d /* %s == %d */",

                     (atol

                      (entry_name + strlen (single_insn_field) +

                       strlen ("_is_")) == bits->value), single_insn_field,

                     bits->value);

        }

    }

  else

    {

      /* put the field in the local variable, possibly also enter it

         into the cache */

      expression = "extraction";

      /* handle the cache */

      if ((what_to_do & get_values_from_icache)

          || (what_to_do & put_values_in_icache))

        {

          lf_printf (file, "cache_entry->crack.%s.%s",

                     format_name, entry_name);

          if (what_to_do & put_values_in_icache)        /* also put it in the cache? */

            {

              lf_printf (file, " = ");

            }

        }

      if ((what_to_do & put_values_in_icache)

          || what_to_do == do_not_use_icache)

        {

          if (cur_field != NULL)

            {

              if (entry_expression != NULL && strlen (entry_expression) > 0)

                error (line,

                       "Instruction field entry with nonempty expression\n");

              if (cur_field->first == 0

                  && cur_field->last == options.insn_bit_size - 1)

                lf_printf (file, "(instruction_%d)", cur_field->word_nr);

              else if (cur_field->last == options.insn_bit_size - 1)

                lf_printf (file, "MASKED%d (instruction_%d, %d, %d)",

                           options.insn_bit_size,

                           cur_field->word_nr,

                           i2target (options.hi_bit_nr, cur_field->first),

                           i2target (options.hi_bit_nr, cur_field->last));

              else

                lf_printf (file, "EXTRACTED%d (instruction_%d, %d, %d)",

                           options.insn_bit_size,

                           cur_field->word_nr,

                           i2target (options.hi_bit_nr, cur_field->first),

                           i2target (options.hi_bit_nr, cur_field->last));

            }

          else

            {

              lf_printf (file, "%s", entry_expression);

            }

        }

    }

  switch (what_to_declare)

    {

    case define_variables:

      lf_printf (file, ")");

      break;

    case undef_variables:

      break;

    case declare_variables:

      lf_printf (file, ";");

      break;

    }

  ASSERT (reason != NULL && expression != NULL);

  lf_printf (file, " /* %s - %s */\n", reason, expression);

}

void

print_icache_body (lf *file,

                   insn_entry * instruction,

                   opcode_bits *expanded_bits,

                   cache_entry *cache_rules,

                   icache_decl_type what_to_declare,

                   icache_body_type what_to_do, int nr_prefetched_words)

{

  /* extract instruction fields */

  lf_printf (file, "/* Extraction: %s\n", instruction->name);

  lf_printf (file, "     ");

  switch (what_to_declare)

    {

    case define_variables:

      lf_printf (file, "#define");

      break;

    case declare_variables:

      lf_printf (file, "declare");

      break;

    case undef_variables:

      lf_printf (file, "#undef");

      break;

    }

  lf_printf (file, " ");

  switch (what_to_do)

    {

    case get_values_from_icache:

      lf_printf (file, "get-values-from-icache");

      break;

    case put_values_in_icache:

      lf_printf (file, "put-values-in-icache");

      break;

    case both_values_and_icache:

      lf_printf (file, "get-values-from-icache|put-values-in-icache");

      break;

    case do_not_use_icache:

      lf_printf (file, "do-not-use-icache");

      break;

    }

  lf_printf (file, "\n     ");

  print_insn_words (file, instruction);

  lf_printf (file, " */\n");

  /* pass zero - fetch from memory any missing instructions.

     Some of the instructions will have already been fetched (in the

     instruction array), others will still need fetching. */

  switch (what_to_do)

    {

    case get_values_from_icache:

      break;

    case put_values_in_icache:

    case both_values_and_icache:

    case do_not_use_icache:

      {

        int word_nr;

        switch (what_to_declare)

          {

          case undef_variables:

            break;

          case define_variables:

          case declare_variables:

            for (word_nr = nr_prefetched_words;

                 word_nr < instruction->nr_words; word_nr++)

              {

                /* FIXME - should be using print_icache_extraction? */

                lf_printf (file,

                           "%sinstruction_word instruction_%d UNUSED = ",

                           options.module.global.prefix.l, word_nr);

                lf_printf (file, "IMEM%d_IMMED (cia, %d)",

                           options.insn_bit_size, word_nr);

                lf_printf (file, ";\n");

              }

          }

      }

    }

  /* if putting the instruction words in the cache, define references

     for them */

  if (options.gen.insn_in_icache)

    {

      /* FIXME: is the instruction_word type correct? */

      print_icache_extraction (file, instruction->format_name, cache_value, "insn",     /* name */

                               "instruction_word",      /* type */

                               "instruction",   /* expression */

                               NULL,    /* origin */

                               NULL,    /* line */

                               NULL, NULL, what_to_declare, what_to_do);

    }

  lf_printf (file, "\n");

  /* pass one - process instruction fields.

     If there is no cache rule, the default is to enter the field into

     the cache */

  {

    insn_word_entry *word;

    for (word = instruction->words; word != NULL; word = word->next)

      {

        insn_field_entry *cur_field;

        for (cur_field = word->first;

             cur_field->first < options.insn_bit_size;

             cur_field = cur_field->next)

          {

            if (cur_field->type == insn_field_string)

              {

                cache_entry *cache_rule;

                cache_entry_type value_type = cache_value;

                line_ref *value_line = instruction->line;

                /* check the cache table to see if it contains a rule

                   overriding the default cache action for an

                   instruction field */

                for (cache_rule = cache_rules;

                     cache_rule != NULL; cache_rule = cache_rule->next)

                  {

                    if (filter_is_subset (instruction->field_names,

                                          cache_rule->original_fields)

                        && strcmp (cache_rule->name,

                                   cur_field->val_string) == 0)

                      {

                        value_type = cache_rule->entry_type;

                        value_line = cache_rule->line;

                        if (value_type == compute_value)

                          {

                            options.warning (cache_rule->line,

                                             "instruction field of type `compute' changed to `cache'\n");

                            cache_rule->entry_type = cache_value;

                          }

                        break;

                      }

                  }

                /* Define an entry for the field within the

                   instruction */

                print_icache_extraction (file, instruction->format_name, value_type, cur_field->val_string,     /* name */

                                         NULL,  /* type */

                                         NULL,  /* expression */

                                         cur_field->val_string, /* insn field */

                                         value_line,

                                         cur_field,

                                         expanded_bits,

                                         what_to_declare, what_to_do);

              }

          }

      }

  }

  /* pass two - any cache fields not processed above */

  {

    cache_entry *cache_rule;

    for (cache_rule = cache_rules;

         cache_rule != NULL; cache_rule = cache_rule->next)

      {

        if (filter_is_subset (instruction->field_names,

                              cache_rule->original_fields)

            && !filter_is_member (instruction->field_names, cache_rule->name))

          {

            char *single_field =

              filter_next (cache_rule->original_fields, "");

            if (filter_next (cache_rule->original_fields, single_field) !=

                NULL)

              single_field = NULL;

            print_icache_extraction (file, instruction->format_name, cache_rule->entry_type, cache_rule->name, cache_rule->type, cache_rule->expression, single_field, cache_rule->line, NULL,  /* cur_field */

                                     expanded_bits,

                                     what_to_declare, what_to_do);

          }

      }

  }

  lf_print__internal_ref (file);

}

typedef struct _form_fields form_fields;

struct _form_fields

{

  char *name;

  filter *fields;

  form_fields *next;

};

static form_fields *

insn_table_cache_fields (insn_table *isa)

{

  form_fields *forms = NULL;

  insn_entry *insn;

  for (insn = isa->insns; insn != NULL; insn = insn->next)

    {

      form_fields **form = &forms;

      while (1)

        {

          if (*form == NULL)

            {

              /* new format name, add it */

              form_fields *new_form = ZALLOC (form_fields);

              new_form->name = insn->format_name;

              filter_add (&new_form->fields, insn->field_names);

              *form = new_form;

              break;

            }

          else if (strcmp ((*form)->name, insn->format_name) == 0)

            {

              /* already present, add field names to the existing list */

              filter_add (&(*form)->fields, insn->field_names);

              break;

            }

          form = &(*form)->next;

        }

    }

  return forms;

}

extern void

print_icache_struct (lf *file, insn_table *isa, cache_entry *cache_rules)

{

  /* Create a list of all the different instruction formats with their

     corresponding field names. */

  form_fields *formats = insn_table_cache_fields (isa);

  lf_printf (file, "\n");

  lf_printf (file, "#define WITH_%sIDECODE_CACHE_SIZE %d\n",

             options.module.global.prefix.u,

             (options.gen.icache ? options.gen.icache_size : 0));

  lf_printf (file, "\n");

  /* create an instruction cache if being used */

  if (options.gen.icache)

    {

      lf_printf (file, "typedef struct _%sidecode_cache {\n",

                 options.module.global.prefix.l);

      lf_indent (file, +2);

      {

        form_fields *format;

        lf_printf (file, "unsigned_word address;\n");

        lf_printf (file, "void *semantic;\n");

        lf_printf (file, "union {\n");

        lf_indent (file, +2);

        for (format = formats; format != NULL; format = format->next)

          {

            lf_printf (file, "struct {\n");

            lf_indent (file, +2);

            {

              cache_entry *cache_rule;

              char *field;

              /* space for any instruction words */

              if (options.gen.insn_in_icache)

                lf_printf (file, "instruction_word insn[%d];\n",

                           isa->max_nr_words);

              /* define an entry for any applicable cache rules */

              for (cache_rule = cache_rules;

                   cache_rule != NULL; cache_rule = cache_rule->next)

                {

                  /* nb - sort of correct - should really check against

                     individual instructions */

                  if (filter_is_subset

                      (format->fields, cache_rule->original_fields))

                    {

                      char *memb;

                      lf_printf (file, "%s %s;",

                                 (cache_rule->type == NULL

                                  ? "unsigned"

                                  : cache_rule->type), cache_rule->name);

                      lf_printf (file, " /*");

                      for (memb =

                           filter_next (cache_rule->original_fields, "");

                           memb != NULL;

                           memb =

                           filter_next (cache_rule->original_fields, memb))

                        {

                          lf_printf (file, " %s", memb);

                        }

                      lf_printf (file, " */\n");

                    }

                }

              /* define an entry for any fields not covered by a cache rule */

              for (field = filter_next (format->fields, "");

                   field != NULL; field = filter_next (format->fields, field))

                {

                  cache_entry *cache_rule;

                  int found_rule = 0;

                  for (cache_rule = cache_rules;

                       cache_rule != NULL; cache_rule = cache_rule->next)

                    {

                      if (strcmp (cache_rule->name, field) == 0)

                        {

                          found_rule = 1;

                          break;

                        }

                    }

                  if (!found_rule)

                    lf_printf (file, "unsigned %s; /* default */\n", field);

                }

            }

            lf_indent (file, -2);

            lf_printf (file, "} %s;\n", format->name);

          }

        lf_indent (file, -2);

        lf_printf (file, "} crack;\n");

      }

      lf_indent (file, -2);

      lf_printf (file, "} %sidecode_cache;\n",

                 options.module.global.prefix.l);

    }

  else

    {

      /* alernativly, since no cache, emit a dummy definition for

         idecode_cache so that code refering to the type can still compile */

      lf_printf (file, "typedef void %sidecode_cache;\n",

                 options.module.global.prefix.l);

    }

  lf_printf (file, "\n");

}

static void

print_icache_function (lf *file,

                       insn_entry * instruction,

                       opcode_bits *expanded_bits,

                       insn_opcodes *opcodes,

                       cache_entry *cache_rules, int nr_prefetched_words)

{

  int indent;

  /* generate code to enter decoded instruction into the icache */

  lf_printf (file, "\n");

  lf_print__function_type_function (file, print_icache_function_type,

                                    "EXTERN_ICACHE", "\n");

  indent = print_function_name (file,

                                instruction->name,

                                instruction->format_name,

                                NULL,

                                expanded_bits, function_name_prefix_icache);

  indent += lf_printf (file, " ");

  lf_indent (file, +indent);

  lf_printf (file, "(");

  print_icache_function_formal (file, nr_prefetched_words);

  lf_printf (file, ")\n");

  lf_indent (file, -indent);

  /* function header */

  lf_printf (file, "{\n");

  lf_indent (file, +2);

  print_my_defines (file,

                    instruction->name,

                    instruction->format_name, expanded_bits);

  print_itrace (file, instruction, 1 /*putting-value-in-cache */ );