[thirdparty/binutils-gdb.git] / sim / igen / gen-model.c

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

   Copyright 2002, 2007, 2008, 2009 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 "ld-decode.h"
#include "ld-insn.h"

#include "gen-model.h"

#ifndef NULL
#define NULL 0
#endif


#if 0
static void
model_c_or_h_data (insn_table *table, lf *file, table_entry *data)
{
  if (data->annex)
    {
      table_entry_print_cpp_line_nr (file, data->annex_line);
      lf_print__c_code (file, data->annex);
      lf_print__internal_reference (file);
      lf_printf (file, "\n");
    }
}

static void
model_c_or_h_function (insn_table *entry,
		       lf *file, table_entry *function, char *prefix)
{
  if (function->fields[function_type] == NULL
      || function->fields[function_type][0] == '\0')
    {
      error ("Model function type not specified for %s",
	     function->fields[function_name]);
    }
  lf_printf (file, "\n");
  lf_print_function_type (file, function->fields[function_type], prefix, " ");
  lf_printf (file, "%s\n(%s);\n",
	     function->fields[function_name],
	     function->fields[function_param]);
  lf_printf (file, "\n");
}

void
gen_model_h (insn_table *table, lf *file)
{
  insn *insn_ptr;
  model *model_ptr;
  insn *macro;
  char *name;
  int model_create_p = 0;
  int model_init_p = 0;
  int model_halt_p = 0;
  int model_mon_info_p = 0;
  int model_mon_info_free_p = 0;

  for (macro = model_macros; macro; macro = macro->next)
    {
      model_c_or_h_data (table, file, macro->file_entry);
    }

  lf_printf (file, "typedef enum _model_enum {\n");
  lf_printf (file, "  MODEL_NONE,\n");
  for (model_ptr = models; model_ptr; model_ptr = model_ptr->next)
    {
      lf_printf (file, "  MODEL_%s,\n", model_ptr->name);
    }
  lf_printf (file, "  nr_models\n");
  lf_printf (file, "} model_enum;\n");
  lf_printf (file, "\n");

  lf_printf (file, "#define DEFAULT_MODEL MODEL_%s\n",
	     (models) ? models->name : "NONE");
  lf_printf (file, "\n");

  lf_printf (file, "typedef struct _model_data model_data;\n");
  lf_printf (file, "typedef struct _model_time model_time;\n");
  lf_printf (file, "\n");

  lf_printf (file, "extern model_enum current_model;\n");
  lf_printf (file, "extern const char *model_name[ (int)nr_models ];\n");
  lf_printf (file,
	     "extern const char *const *const model_func_unit_name[ (int)nr_models ];\n");
  lf_printf (file,
	     "extern const model_time *const model_time_mapping[ (int)nr_models ];\n");
  lf_printf (file, "\n");

  for (insn_ptr = model_functions; insn_ptr; insn_ptr = insn_ptr->next)
    {
      model_c_or_h_function (table, file, insn_ptr->file_entry,
			     "INLINE_MODEL");
      name = insn_ptr->file_entry->fields[function_name];
      if (strcmp (name, "model_create") == 0)
	model_create_p = 1;
      else if (strcmp (name, "model_init") == 0)
	model_init_p = 1;
      else if (strcmp (name, "model_halt") == 0)
	model_halt_p = 1;
      else if (strcmp (name, "model_mon_info") == 0)
	model_mon_info_p = 1;
      else if (strcmp (name, "model_mon_info_free") == 0)
	model_mon_info_free_p = 1;
    }

  if (!model_create_p)
    {
      lf_print_function_type (file, "model_data *", "INLINE_MODEL", " ");
      lf_printf (file, "model_create\n");
      lf_printf (file, "(sim_cpu *cpu);\n");
      lf_printf (file, "\n");
    }

  if (!model_init_p)
    {
      lf_print_function_type (file, "void", "INLINE_MODEL", " ");
      lf_printf (file, "model_init\n");
      lf_printf (file, "(model_data *model_ptr);\n");
      lf_printf (file, "\n");
    }

  if (!model_halt_p)
    {
      lf_print_function_type (file, "void", "INLINE_MODEL", " ");
      lf_printf (file, "model_halt\n");
      lf_printf (file, "(model_data *model_ptr);\n");
      lf_printf (file, "\n");
    }

  if (!model_mon_info_p)
    {
      lf_print_function_type (file, "model_print *", "INLINE_MODEL", " ");
      lf_printf (file, "model_mon_info\n");
      lf_printf (file, "(model_data *model_ptr);\n");
      lf_printf (file, "\n");
    }

  if (!model_mon_info_free_p)
    {
      lf_print_function_type (file, "void", "INLINE_MODEL", " ");
      lf_printf (file, "model_mon_info_free\n");
      lf_printf (file, "(model_data *model_ptr,\n");
      lf_printf (file, " model_print *info_ptr);\n");
      lf_printf (file, "\n");
    }

  lf_print_function_type (file, "void", "INLINE_MODEL", " ");
  lf_printf (file, "model_set\n");
  lf_printf (file, "(const char *name);\n");
}

/****************************************************************/

typedef struct _model_c_passed_data model_c_passed_data;
struct _model_c_passed_data
{
  lf *file;
  model *model_ptr;
};

static void
model_c_insn (insn_table *entry,
	      lf *phony_file, void *data, insn * instruction, int depth)
{
  model_c_passed_data *data_ptr = (model_c_passed_data *) data;
  lf *file = data_ptr->file;
  char *current_name = data_ptr->model_ptr->printable_name;
  table_model_entry *model_ptr = instruction->file_entry->model_first;

  while (model_ptr)
    {
      if (model_ptr->fields[insn_model_name] == current_name)
	{
	  lf_printf (file, "  { %-*s },  /* %s */\n",
		     max_model_fields_len,
		     model_ptr->fields[insn_model_fields],
		     instruction->file_entry->fields[insn_name]);
	  return;
	}

      model_ptr = model_ptr->next;
    }

  lf_printf (file, "  { %-*s },  /* %s */\n",
	     max_model_fields_len,
	     data_ptr->model_ptr->insn_default,
	     instruction->file_entry->fields[insn_name]);
}

static void
model_c_function (insn_table *table,
		  lf *file, table_entry *function, const char *prefix)
{
  if (function->fields[function_type] == NULL
      || function->fields[function_type][0] == '\0')
    {
      error ("Model function return type not specified for %s",
	     function->fields[function_name]);
    }
  else
    {
      lf_printf (file, "\n");
      lf_print_function_type (file, function->fields[function_type], prefix,
			      "\n");
      lf_printf (file, "%s(%s)\n", function->fields[function_name],
		 function->fields[function_param]);
    }
  lf_printf (file, "{\n");
  if (function->annex)
    {
      lf_indent (file, +2);
      table_entry_print_cpp_line_nr (file, function->annex_line);
      lf_print__c_code (file, function->annex);
      lf_indent (file, -2);
    }
  lf_printf (file, "}\n");
  lf_print__internal_reference (file);
  lf_printf (file, "\n");
}

void
gen_model_c (insn_table *table, lf *file)
{
  insn *insn_ptr;
  model *model_ptr;
  char *name;
  int model_create_p = 0;
  int model_init_p = 0;
  int model_halt_p = 0;
  int model_mon_info_p = 0;
  int model_mon_info_free_p = 0;

  lf_printf (file, "\n");
  lf_printf (file, "#include \"cpu.h\"\n");
  lf_printf (file, "#include \"mon.h\"\n");
  lf_printf (file, "\n");
  lf_printf (file, "#ifdef HAVE_STDLIB_H\n");
  lf_printf (file, "#include <stdlib.h>\n");
  lf_printf (file, "#endif\n");
  lf_printf (file, "\n");

  for (insn_ptr = model_data; insn_ptr; insn_ptr = insn_ptr->next)
    {
      model_c_or_h_data (table, file, insn_ptr->file_entry);
    }

  for (insn_ptr = model_static; insn_ptr; insn_ptr = insn_ptr->next)
    {
      model_c_or_h_function (table, file, insn_ptr->file_entry,
			     "/*h*/STATIC");
    }

  for (insn_ptr = model_internal; insn_ptr; insn_ptr = insn_ptr->next)
    {
      model_c_or_h_function (table, file, insn_ptr->file_entry,
			     "STATIC_INLINE_MODEL");
    }

  for (insn_ptr = model_static; insn_ptr; insn_ptr = insn_ptr->next)
    {
      model_c_function (table, file, insn_ptr->file_entry, "/*c*/STATIC");
    }

  for (insn_ptr = model_internal; insn_ptr; insn_ptr = insn_ptr->next)
    {
      model_c_function (table, file, insn_ptr->file_entry,
			"STATIC_INLINE_MODEL");
    }

  for (insn_ptr = model_functions; insn_ptr; insn_ptr = insn_ptr->next)
    {
      model_c_function (table, file, insn_ptr->file_entry, "INLINE_MODEL");
      name = insn_ptr->file_entry->fields[function_name];
      if (strcmp (name, "model_create") == 0)
	model_create_p = 1;
      else if (strcmp (name, "model_init") == 0)
	model_init_p = 1;
      else if (strcmp (name, "model_halt") == 0)
	model_halt_p = 1;
      else if (strcmp (name, "model_mon_info") == 0)
	model_mon_info_p = 1;
      else if (strcmp (name, "model_mon_info_free") == 0)
	model_mon_info_free_p = 1;
    }

  if (!model_create_p)
    {
      lf_print_function_type (file, "model_data *", "INLINE_MODEL", "\n");
      lf_printf (file, "model_create(sim_cpu *cpu)\n");
      lf_printf (file, "{\n");
      lf_printf (file, "  return (model_data *)0;\n");
      lf_printf (file, "}\n");
      lf_printf (file, "\n");
    }

  if (!model_init_p)
    {
      lf_print_function_type (file, "void", "INLINE_MODEL", "\n");
      lf_printf (file, "model_init(model_data *model_ptr)\n");
      lf_printf (file, "{\n");
      lf_printf (file, "}\n");
      lf_printf (file, "\n");
    }

  if (!model_halt_p)
    {
      lf_print_function_type (file, "void", "INLINE_MODEL", "\n");
      lf_printf (file, "model_halt(model_data *model_ptr)\n");
      lf_printf (file, "{\n");
      lf_printf (file, "}\n");
      lf_printf (file, "\n");
    }

  if (!model_mon_info_p)
    {
      lf_print_function_type (file, "model_print *", "INLINE_MODEL", "\n");
      lf_printf (file, "model_mon_info(model_data *model_ptr)\n");
      lf_printf (file, "{\n");
      lf_printf (file, "  return (model_print *)0;\n");
      lf_printf (file, "}\n");
      lf_printf (file, "\n");
    }

  if (!model_mon_info_free_p)
    {
      lf_print_function_type (file, "void", "INLINE_MODEL", "\n");
      lf_printf (file, "model_mon_info_free(model_data *model_ptr,\n");
      lf_printf (file, "                    model_print *info_ptr)\n");
      lf_printf (file, "{\n");
      lf_printf (file, "}\n");
      lf_printf (file, "\n");
    }

  lf_printf (file, "/* Insn functional unit info */\n");
  for (model_ptr = models; model_ptr; model_ptr = model_ptr->next)
    {
      model_c_passed_data data;

      lf_printf (file, "static const model_time model_time_%s[] = {\n",
		 model_ptr->name);
      data.file = file;
      data.model_ptr = model_ptr;
      insn_table_traverse_insn (table, NULL, (void *) &data, model_c_insn);

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

  lf_printf (file, "#ifndef _INLINE_C_\n");
  lf_printf (file,
	     "const model_time *const model_time_mapping[ (int)nr_models ] = {\n");
  lf_printf (file, "  (const model_time *const)0,\n");
  for (model_ptr = models; model_ptr; model_ptr = model_ptr->next)
    {
      lf_printf (file, "  model_time_%s,\n", model_ptr->name);
    }
  lf_printf (file, "};\n");
  lf_printf (file, "#endif\n");
  lf_printf (file, "\n");

  lf_printf (file, "\f\n");
  lf_printf (file, "/* map model enumeration into printable string */\n");
  lf_printf (file, "#ifndef _INLINE_C_\n");
  lf_printf (file, "const char *model_name[ (int)nr_models ] = {\n");
  lf_printf (file, "  \"NONE\",\n");
  for (model_ptr = models; model_ptr; model_ptr = model_ptr->next)
    {
      lf_printf (file, "  \"%s\",\n", model_ptr->printable_name);
    }
  lf_printf (file, "};\n");
  lf_printf (file, "#endif\n");
  lf_printf (file, "\n");

  lf_print_function_type (file, "void", "INLINE_MODEL", "\n");
  lf_printf (file, "model_set(const char *name)\n");
  lf_printf (file, "{\n");
  if (models)
    {
      lf_printf (file, "  model_enum model;\n");
      lf_printf (file,
		 "  for(model = MODEL_%s; model < nr_models; model++) {\n",
		 models->name);
      lf_printf (file, "    if(strcmp(name, model_name[model]) == 0) {\n");
      lf_printf (file, "      current_model = model;\n");
      lf_printf (file, "      return;\n");
      lf_printf (file, "    }\n");
      lf_printf (file, "  }\n");
      lf_printf (file, "\n");
      lf_printf (file,
		 "  error(\"Unknown model '%%s', Models which are known are:%%s\n\",\n");
      lf_printf (file, "        name,\n");
      lf_printf (file, "        \"");
      for (model_ptr = models; model_ptr; model_ptr = model_ptr->next)
	{
	  lf_printf (file, "\\n\\t%s", model_ptr->printable_name);
	}
      lf_printf (file, "\");\n");
    }
  else
    {
      lf_printf (file, "  error(\"No models are currently known about\");\n");
    }

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

#endif


void
gen_model_h (lf *file, insn_table *table)
{
  lf_print__this_file_is_empty (file, "suffering bit rot");
}


void
gen_model_c (lf *file, insn_table *table)
{
  lf_print__this_file_is_empty (file, "suffering bit rot");
}
Commit	Line	Data
feaee4bd AC	1	/* The IGEN simulator generator for GDB, the GNU Debugger.
feaee4bd AC	2
e4d013fc	3	Copyright 2002, 2007, 2008, 2009 Free Software Foundation, Inc.
feaee4bd AC	4
	5	Contributed by Andrew Cagney.
	6
	7	This file is part of GDB.
	8
	9	This program is free software; you can redistribute it and/or modify
	10	it under the terms of the GNU General Public License as published by
4744ac1b	11	the Free Software Foundation; either version 3 of the License, or
feaee4bd AC	12	(at your option) any later version.
	13
	14	This program is distributed in the hope that it will be useful,
	15	but WITHOUT ANY WARRANTY; without even the implied warranty of
	16	MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
	17	GNU General Public License for more details.
	18
	19	You should have received a copy of the GNU General Public License
4744ac1b	20	along with this program. If not, see <http://www.gnu.org/licenses/>. */
c906108c SS	21
	22
	23	#include "misc.h"
	24	#include "lf.h"
	25	#include "table.h"
	26
	27	#include "filter.h"
	28
	29	#include "ld-decode.h"
	30	#include "ld-insn.h"
	31
	32	#include "gen-model.h"
	33
	34	#ifndef NULL
	35	#define NULL 0
	36	#endif
	37
	38
	39	#if 0
	40	static void
4e0bf4c4	41	model_c_or_h_data (insn_table table, lf file, table_entry *data)
c906108c	42	{
4e0bf4c4 AC	43	if (data->annex)
	44	{
	45	table_entry_print_cpp_line_nr (file, data->annex_line);
	46	lf_print__c_code (file, data->annex);
	47	lf_print__internal_reference (file);
	48	lf_printf (file, "\n");
	49	}
c906108c SS	50	}
	51
	52	static void
4e0bf4c4 AC	53	model_c_or_h_function (insn_table *entry,
4e0bf4c4 AC	54	lf file, table_entry function, char *prefix)
c906108c SS	55	{
c906108c SS	56	if (function->fields[function_type] == NULL
4e0bf4c4 AC	57	\|\| function->fields[function_type][0] == '\0')
	58	{
	59	error ("Model function type not specified for %s",
	60	function->fields[function_name]);
	61	}
	62	lf_printf (file, "\n");
	63	lf_print_function_type (file, function->fields[function_type], prefix, " ");
	64	lf_printf (file, "%s\n(%s);\n",
	65	function->fields[function_name],
	66	function->fields[function_param]);
	67	lf_printf (file, "\n");
c906108c SS	68	}
c906108c SS	69
4e0bf4c4 AC	70	void
4e0bf4c4 AC	71	gen_model_h (insn_table table, lf file)
c906108c SS	72	{
	73	insn *insn_ptr;
	74	model *model_ptr;
	75	insn *macro;
	76	char *name;
	77	int model_create_p = 0;
	78	int model_init_p = 0;
	79	int model_halt_p = 0;
	80	int model_mon_info_p = 0;
	81	int model_mon_info_free_p = 0;
	82
4e0bf4c4 AC	83	for (macro = model_macros; macro; macro = macro->next)
	84	{
	85	model_c_or_h_data (table, file, macro->file_entry);
	86	}
	87
	88	lf_printf (file, "typedef enum _model_enum {\n");
	89	lf_printf (file, " MODEL_NONE,\n");
	90	for (model_ptr = models; model_ptr; model_ptr = model_ptr->next)
	91	{
	92	lf_printf (file, " MODEL_%s,\n", model_ptr->name);
	93	}
	94	lf_printf (file, " nr_models\n");
	95	lf_printf (file, "} model_enum;\n");
	96	lf_printf (file, "\n");
	97
	98	lf_printf (file, "#define DEFAULT_MODEL MODEL_%s\n",
	99	(models) ? models->name : "NONE");
	100	lf_printf (file, "\n");
	101
	102	lf_printf (file, "typedef struct _model_data model_data;\n");
	103	lf_printf (file, "typedef struct _model_time model_time;\n");
	104	lf_printf (file, "\n");
	105
	106	lf_printf (file, "extern model_enum current_model;\n");
	107	lf_printf (file, "extern const char *model_name[ (int)nr_models ];\n");
	108	lf_printf (file,
	109	"extern const char const const model_func_unit_name[ (int)nr_models ];\n");
	110	lf_printf (file,
	111	"extern const model_time *const model_time_mapping[ (int)nr_models ];\n");
	112	lf_printf (file, "\n");
	113
	114	for (insn_ptr = model_functions; insn_ptr; insn_ptr = insn_ptr->next)
	115	{
	116	model_c_or_h_function (table, file, insn_ptr->file_entry,
	117	"INLINE_MODEL");
	118	name = insn_ptr->file_entry->fields[function_name];
	119	if (strcmp (name, "model_create") == 0)
	120	model_create_p = 1;
	121	else if (strcmp (name, "model_init") == 0)
	122	model_init_p = 1;
	123	else if (strcmp (name, "model_halt") == 0)
	124	model_halt_p = 1;
	125	else if (strcmp (name, "model_mon_info") == 0)
	126	model_mon_info_p = 1;
	127	else if (strcmp (name, "model_mon_info_free") == 0)
	128	model_mon_info_free_p = 1;
	129	}
	130
	131	if (!model_create_p)
	132	{
	133	lf_print_function_type (file, "model_data *", "INLINE_MODEL", " ");
	134	lf_printf (file, "model_create\n");
	135	lf_printf (file, "(sim_cpu *cpu);\n");
	136	lf_printf (file, "\n");
	137	}
	138
	139	if (!model_init_p)
	140	{
	141	lf_print_function_type (file, "void", "INLINE_MODEL", " ");
	142	lf_printf (file, "model_init\n");
	143	lf_printf (file, "(model_data *model_ptr);\n");
	144	lf_printf (file, "\n");
	145	}
	146
147	if (!model_halt_p)
148	{
149	lf_print_function_type (file, "void", "INLINE_MODEL", " ");
150	lf_printf (file, "model_halt\n");
151	lf_printf (file, "(model_data *model_ptr);\n");
152	lf_printf (file, "\n");
153	}
154
155	if (!model_mon_info_p)
156	{
157	lf_print_function_type (file, "model_print *", "INLINE_MODEL", " ");
158	lf_printf (file, "model_mon_info\n");
159	lf_printf (file, "(model_data *model_ptr);\n");
160	lf_printf (file, "\n");
161	}
162
163	if (!model_mon_info_free_p)
164	{
165	lf_print_function_type (file, "void", "INLINE_MODEL", " ");
166	lf_printf (file, "model_mon_info_free\n");
167	lf_printf (file, "(model_data *model_ptr,\n");
168	lf_printf (file, " model_print *info_ptr);\n");
169	lf_printf (file, "\n");
170	}
171
172	lf_print_function_type (file, "void", "INLINE_MODEL", " ");
173	lf_printf (file, "model_set\n");
174	lf_printf (file, "(const char *name);\n");
c906108c SS	175	}
	176
	177	/****************************************************************/
	178
	179	typedef struct _model_c_passed_data model_c_passed_data;
4e0bf4c4 AC	180	struct _model_c_passed_data
4e0bf4c4 AC	181	{
c906108c SS	182	lf *file;
	183	model *model_ptr;
	184	};
	185
	186	static void
4e0bf4c4 AC	187	model_c_insn (insn_table *entry,
4e0bf4c4 AC	188	lf phony_file, void data, insn * instruction, int depth)
c906108c	189	{
4e0bf4c4	190	model_c_passed_data data_ptr = (model_c_passed_data ) data;
c906108c SS	191	lf *file = data_ptr->file;
	192	char *current_name = data_ptr->model_ptr->printable_name;
	193	table_model_entry *model_ptr = instruction->file_entry->model_first;
	194
4e0bf4c4 AC	195	while (model_ptr)
	196	{
	197	if (model_ptr->fields[insn_model_name] == current_name)
	198	{
	199	lf_printf (file, " { %-s }, / %s */\n",
	200	max_model_fields_len,
	201	model_ptr->fields[insn_model_fields],
	202	instruction->file_entry->fields[insn_name]);
	203	return;
	204	}
	205
	206	model_ptr = model_ptr->next;
c906108c SS	207	}
c906108c SS	208
4e0bf4c4 AC	209	lf_printf (file, " { %-s }, / %s */\n",
	210	max_model_fields_len,
	211	data_ptr->model_ptr->insn_default,
	212	instruction->file_entry->fields[insn_name]);
c906108c SS	213	}
	214
	215	static void
4e0bf4c4 AC	216	model_c_function (insn_table *table,
4e0bf4c4 AC	217	lf file, table_entry function, const char *prefix)
c906108c SS	218	{
	219	if (function->fields[function_type] == NULL
	220	\|\| function->fields[function_type][0] == '\0')
	221	{
4e0bf4c4 AC	222	error ("Model function return type not specified for %s",
4e0bf4c4 AC	223	function->fields[function_name]);
c906108c SS	224	}
	225	else
	226	{
4e0bf4c4 AC	227	lf_printf (file, "\n");
	228	lf_print_function_type (file, function->fields[function_type], prefix,
	229	"\n");
	230	lf_printf (file, "%s(%s)\n", function->fields[function_name],
	231	function->fields[function_param]);
c906108c	232	}
4e0bf4c4	233	lf_printf (file, "{\n");
c906108c SS	234	if (function->annex)
c906108c SS	235	{
4e0bf4c4 AC	236	lf_indent (file, +2);
	237	table_entry_print_cpp_line_nr (file, function->annex_line);
	238	lf_print__c_code (file, function->annex);
	239	lf_indent (file, -2);
c906108c	240	}
4e0bf4c4 AC	241	lf_printf (file, "}\n");
	242	lf_print__internal_reference (file);
	243	lf_printf (file, "\n");
c906108c SS	244	}
c906108c SS	245
4e0bf4c4 AC	246	void
4e0bf4c4 AC	247	gen_model_c (insn_table table, lf file)
c906108c SS	248	{
	249	insn *insn_ptr;
	250	model *model_ptr;
	251	char *name;
	252	int model_create_p = 0;
	253	int model_init_p = 0;
	254	int model_halt_p = 0;
	255	int model_mon_info_p = 0;
	256	int model_mon_info_free_p = 0;
	257
4e0bf4c4 AC	258	lf_printf (file, "\n");
	259	lf_printf (file, "#include \"cpu.h\"\n");
	260	lf_printf (file, "#include \"mon.h\"\n");
	261	lf_printf (file, "\n");
	262	lf_printf (file, "#ifdef HAVE_STDLIB_H\n");
	263	lf_printf (file, "#include <stdlib.h>\n");
	264	lf_printf (file, "#endif\n");
	265	lf_printf (file, "\n");
	266
	267	for (insn_ptr = model_data; insn_ptr; insn_ptr = insn_ptr->next)
	268	{
	269	model_c_or_h_data (table, file, insn_ptr->file_entry);
	270	}
	271
	272	for (insn_ptr = model_static; insn_ptr; insn_ptr = insn_ptr->next)
	273	{
	274	model_c_or_h_function (table, file, insn_ptr->file_entry,
	275	"/h/STATIC");
	276	}
	277
	278	for (insn_ptr = model_internal; insn_ptr; insn_ptr = insn_ptr->next)
	279	{
	280	model_c_or_h_function (table, file, insn_ptr->file_entry,
	281	"STATIC_INLINE_MODEL");
	282	}
	283
	284	for (insn_ptr = model_static; insn_ptr; insn_ptr = insn_ptr->next)
	285	{
	286	model_c_function (table, file, insn_ptr->file_entry, "/c/STATIC");
	287	}
	288
	289	for (insn_ptr = model_internal; insn_ptr; insn_ptr = insn_ptr->next)
	290	{
	291	model_c_function (table, file, insn_ptr->file_entry,
	292	"STATIC_INLINE_MODEL");
	293	}
	294
	295	for (insn_ptr = model_functions; insn_ptr; insn_ptr = insn_ptr->next)
	296	{
	297	model_c_function (table, file, insn_ptr->file_entry, "INLINE_MODEL");
	298	name = insn_ptr->file_entry->fields[function_name];
	299	if (strcmp (name, "model_create") == 0)
	300	model_create_p = 1;
	301	else if (strcmp (name, "model_init") == 0)
	302	model_init_p = 1;
	303	else if (strcmp (name, "model_halt") == 0)
	304	model_halt_p = 1;
	305	else if (strcmp (name, "model_mon_info") == 0)
	306	model_mon_info_p = 1;
	307	else if (strcmp (name, "model_mon_info_free") == 0)
	308	model_mon_info_free_p = 1;
	309	}
	310
	311	if (!model_create_p)
	312	{
	313	lf_print_function_type (file, "model_data *", "INLINE_MODEL", "\n");
	314	lf_printf (file, "model_create(sim_cpu *cpu)\n");
	315	lf_printf (file, "{\n");
	316	lf_printf (file, " return (model_data *)0;\n");
	317	lf_printf (file, "}\n");
	318	lf_printf (file, "\n");
	319	}
	320
	321	if (!model_init_p)
322	{
323	lf_print_function_type (file, "void", "INLINE_MODEL", "\n");
324	lf_printf (file, "model_init(model_data *model_ptr)\n");
325	lf_printf (file, "{\n");
326	lf_printf (file, "}\n");
327	lf_printf (file, "\n");
328	}
329
330	if (!model_halt_p)
331	{
332	lf_print_function_type (file, "void", "INLINE_MODEL", "\n");
333	lf_printf (file, "model_halt(model_data *model_ptr)\n");
334	lf_printf (file, "{\n");
335	lf_printf (file, "}\n");
336	lf_printf (file, "\n");
337	}
338
339	if (!model_mon_info_p)
340	{
341	lf_print_function_type (file, "model_print *", "INLINE_MODEL", "\n");
342	lf_printf (file, "model_mon_info(model_data *model_ptr)\n");
343	lf_printf (file, "{\n");
344	lf_printf (file, " return (model_print *)0;\n");
345	lf_printf (file, "}\n");
346	lf_printf (file, "\n");
347	}
348
349	if (!model_mon_info_free_p)
350	{
351	lf_print_function_type (file, "void", "INLINE_MODEL", "\n");
352	lf_printf (file, "model_mon_info_free(model_data *model_ptr,\n");
353	lf_printf (file, " model_print *info_ptr)\n");
354	lf_printf (file, "{\n");
355	lf_printf (file, "}\n");
356	lf_printf (file, "\n");
357	}
358
359	lf_printf (file, "/* Insn functional unit info */\n");
360	for (model_ptr = models; model_ptr; model_ptr = model_ptr->next)
361	{
362	model_c_passed_data data;
363
364	lf_printf (file, "static const model_time model_time_%s[] = {\n",
365	model_ptr->name);
366	data.file = file;
367	data.model_ptr = model_ptr;
368	insn_table_traverse_insn (table, NULL, (void *) &data, model_c_insn);
369
370	lf_printf (file, "};\n");
371	lf_printf (file, "\n");
372	lf_printf (file, "\f\n");
373	}
374
375	lf_printf (file, "#ifndef _INLINE_C_\n");
376	lf_printf (file,
377	"const model_time *const model_time_mapping[ (int)nr_models ] = {\n");
378	lf_printf (file, " (const model_time *const)0,\n");
379	for (model_ptr = models; model_ptr; model_ptr = model_ptr->next)
380	{
381	lf_printf (file, " model_time_%s,\n", model_ptr->name);
382	}
383	lf_printf (file, "};\n");
384	lf_printf (file, "#endif\n");
385	lf_printf (file, "\n");
386
387	lf_printf (file, "\f\n");
388	lf_printf (file, "/* map model enumeration into printable string */\n");
389	lf_printf (file, "#ifndef _INLINE_C_\n");
390	lf_printf (file, "const char *model_name[ (int)nr_models ] = {\n");
391	lf_printf (file, " \"NONE\",\n");
392	for (model_ptr = models; model_ptr; model_ptr = model_ptr->next)
393	{
394	lf_printf (file, " \"%s\",\n", model_ptr->printable_name);
395	}
396	lf_printf (file, "};\n");
397	lf_printf (file, "#endif\n");
398	lf_printf (file, "\n");
399
400	lf_print_function_type (file, "void", "INLINE_MODEL", "\n");
401	lf_printf (file, "model_set(const char *name)\n");
402	lf_printf (file, "{\n");
403	if (models)
404	{
405	lf_printf (file, " model_enum model;\n");
406	lf_printf (file,
407	" for(model = MODEL_%s; model < nr_models; model++) {\n",
408	models->name);
409	lf_printf (file, " if(strcmp(name, model_name[model]) == 0) {\n");
410	lf_printf (file, " current_model = model;\n");
411	lf_printf (file, " return;\n");
412	lf_printf (file, " }\n");
413	lf_printf (file, " }\n");
414	lf_printf (file, "\n");
415	lf_printf (file,
416	" error(\"Unknown model '%%s', Models which are known are:%%s\n\",\n");
417	lf_printf (file, " name,\n");
418	lf_printf (file, " \"");
419	for (model_ptr = models; model_ptr; model_ptr = model_ptr->next)
420	{
421	lf_printf (file, "\\n\\t%s", model_ptr->printable_name);
422	}
423	lf_printf (file, "\");\n");
424	}
425	else
426	{
427	lf_printf (file, " error(\"No models are currently known about\");\n");
c906108c	428	}
c906108c	429
4e0bf4c4	430	lf_printf (file, "}\n");
c906108c SS	431	}
	432
	433	#endif
	434
	435
	436
	437	void
4e0bf4c4	438	gen_model_h (lf file, insn_table table)
c906108c SS	439	{
	440	lf_print__this_file_is_empty (file, "suffering bit rot");
	441	}
	442
	443
	444	void
4e0bf4c4	445	gen_model_c (lf file, insn_table table)
c906108c SS	446	{
	447	lf_print__this_file_is_empty (file, "suffering bit rot");
	448	}