[deliverable/binutils-gdb.git] / sim / igen / gen-icache.c

/* 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,
				0/* is not function definition */,
				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*/);
  
  print_idecode_validate (file, instruction, opcodes);
  
  lf_printf (file, "\n");
  lf_printf (file, "{\n");
  lf_indent (file, +2);
  if (options.gen.semantic_icache)
    lf_printf (file, "unsigned_word nia;\n");
  print_icache_body (file,
		     instruction,
		     expanded_bits,
		     cache_rules,
		     (options.gen.direct_access
		      ? define_variables
		      : declare_variables),
		     (options.gen.semantic_icache
		      ? both_values_and_icache
		      : put_values_in_icache),
		     nr_prefetched_words);
  
  lf_printf (file, "\n");
  lf_printf (file, "cache_entry->address = cia;\n");
  lf_printf (file, "cache_entry->semantic = ");
  print_function_name (file,
		       instruction->name,
		       instruction->format_name,
		       NULL,
		       expanded_bits,
		       function_name_prefix_semantics);
  lf_printf (file, ";\n");
  lf_printf (file, "\n");

  if (options.gen.semantic_icache) {
    lf_printf (file, "/* semantic routine */\n");
    print_semantic_body (file,
			 instruction,
			 expanded_bits,
			 opcodes);
    lf_printf (file, "return nia;\n");
  }
  
  if (!options.gen.semantic_icache)
    {
      lf_printf (file, "/* return the function proper */\n");
      lf_printf (file, "return ");
      print_function_name (file,
			   instruction->name,
			   instruction->format_name,
			   NULL,
			   expanded_bits,
			   function_name_prefix_semantics);
      lf_printf (file, ";\n");
    }
  
  if (options.gen.direct_access)
    {
      print_icache_body (file,
			 instruction,
			 expanded_bits,
			 cache_rules,
			 undef_variables,
			 (options.gen.semantic_icache
			  ? both_values_and_icache
			  : put_values_in_icache),
			 nr_prefetched_words);
    }
  
  lf_indent (file, -2);
  lf_printf (file, "}\n");
  lf_indent (file, -2);
  lf_printf (file, "}\n");
}


void
print_icache_definition (lf *file,
			 insn_entry *insn,
			 opcode_bits *expanded_bits,
			 insn_opcodes *opcodes,
			 cache_entry *cache_rules,
			 int nr_prefetched_words)
{
  print_icache_function (file,
			 insn,
			 expanded_bits,
			 opcodes,
			 cache_rules,
			 nr_prefetched_words);
}


void
print_icache_internal_function_declaration (lf *file,
					    function_entry *function,
					    void *data)
{
  ASSERT (options.gen.icache);
  if (function->is_internal)
    {
      lf_printf (file, "\n");
      lf_print__function_type_function (file, print_icache_function_type,
					"INLINE_ICACHE", "\n");
      print_function_name (file,
			   function->name,
			   NULL,
			   NULL,
			   NULL,
			   function_name_prefix_icache);
      lf_printf (file, "\n(");
      print_icache_function_formal (file, 0);
      lf_printf (file, ");\n");
    }
}


void
print_icache_internal_function_definition (lf *file,
					   function_entry *function,
					   void *data)
{
  ASSERT (options.gen.icache);
  if (function->is_internal)
    {
      lf_printf (file, "\n");
      lf_print__function_type_function (file, print_icache_function_type,
					"INLINE_ICACHE", "\n");
      print_function_name (file,
			   function->name,
			   NULL,
			   NULL,
			   NULL,
			   function_name_prefix_icache);
      lf_printf (file, "\n(");
      print_icache_function_formal (file, 0);
      lf_printf (file, ")\n");
      lf_printf (file, "{\n");
      lf_indent (file, +2);
      lf_printf (file, "/* semantic routine */\n");
      if (options.gen.semantic_icache)
	{
	  lf_print__line_ref (file, function->code->line);
	  table_print_code (file, function->code);
	  lf_printf (file, "error (\"Internal function must longjump\\n\");\n");
	  lf_printf (file, "return 0;\n");
	}
      else
	{
	  lf_printf (file, "return ");
	  print_function_name (file,
			       function->name,
			       NULL,
			       NULL,
			       NULL,
			       function_name_prefix_semantics);
	  lf_printf (file, ";\n");
	}
      
      lf_print__internal_ref (file);
      lf_indent (file, -2);
      lf_printf (file, "}\n");
    }
}