sim/igen/gen-icache.c - binutils-gdb - Git at Google

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

    Copyright 2002, 2007, 2008 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 3 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, see <http://www.gnu.org/licenses/>.  */


 #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");
     }
 }
	/* The IGEN simulator generator for GDB, the GNU Debugger.

	Copyright 2002, 2007, 2008 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 3 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, see <http://www.gnu.org/licenses/>. */


	#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");
	}
	}