[binutils.git] / sim / igen / gen-itable.c

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

   Copyright 2002-2013 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-itable.h"

#ifndef NULL
#define NULL 0
#endif


typedef struct _itable_info
{
  int sizeof_form;
  int sizeof_name;
  int sizeof_file;
}
itable_info;


static void
itable_h_insn (lf *file,
	       insn_table *entry, insn_entry * instruction, void *data)
{
  int len;
  itable_info *info = data;
  lf_print__line_ref (file, instruction->line);
  lf_printf (file, "  ");
  print_function_name (file,
		       instruction->name,
		       instruction->format_name,
		       NULL, NULL, function_name_prefix_itable);
  lf_printf (file, ",\n");
  /* update summary info */
  len = strlen (instruction->format_name);
  if (info->sizeof_form <= len)
    info->sizeof_form = len + 1;
  len = strlen (instruction->name);
  if (info->sizeof_name <= len)
    info->sizeof_name = len + 1;
  len = strlen (filter_filename (instruction->line->file_name));
  if (info->sizeof_file <= len)
    info->sizeof_file = len + 1;
}


/* print the list of all the different options */

static void
itable_print_enum (lf *file, filter *set, char *name)
{
  char *elem;
  lf_printf (file, "typedef enum {\n");
  lf_indent (file, +2);
  for (elem = filter_next (set, "");
       elem != NULL; elem = filter_next (set, elem))
    {
      lf_printf (file, "%sitable_%s_%s,\n",
		 options.module.itable.prefix.l, name, elem);
      if (strlen (options.module.itable.prefix.l) > 0)
	{
	  lf_indent_suppress (file);
	  lf_printf (file, "#define itable_%s_%s %sitable_%s_%s\n",
		     name, elem, options.module.itable.prefix.l, name, elem);
	}
    }
  lf_printf (file, "nr_%sitable_%ss,\n", options.module.itable.prefix.l,
	     name);

  lf_indent (file, -2);
  lf_printf (file, "} %sitable_%ss;\n", options.module.itable.prefix.l, name);
  if (strlen (options.module.itable.prefix.l) > 0)
    {
      lf_indent_suppress (file);
      lf_printf (file, "#define itable_%ss %sitable_%ss\n",
		 name, options.module.itable.prefix.l, name);
      lf_indent_suppress (file);
      lf_printf (file, "#define nr_itable_%ss nr_%sitable_%ss\n",
		 name, options.module.itable.prefix.l, name);
    }
}

/* print an array of the option names as strings */

static void
itable_print_names (lf *file, filter *set, char *name)
{
  char *elem;
  lf_printf (file, "const char *%sitable_%s_names[nr_%sitable_%ss + 1] = {\n",
	     options.module.itable.prefix.l, name,
	     options.module.itable.prefix.l, name);
  lf_indent (file, +2);
  for (elem = filter_next (set, "");
       elem != NULL; elem = filter_next (set, elem))
    {
      lf_printf (file, "\"%s\",\n", elem);
    }
  lf_printf (file, "0,\n");
  lf_indent (file, -2);
  lf_printf (file, "};\n");
}

extern void
gen_itable_h (lf *file, insn_table *isa)
{
  itable_info *info = ZALLOC (itable_info);

  /* output an enumerated type for each instruction */
  lf_printf (file, "typedef enum {\n");
  insn_table_traverse_insn (file, isa, itable_h_insn, info);
  lf_printf (file, "  nr_%sitable_entries,\n",
	     options.module.itable.prefix.l);
  lf_printf (file, "} %sitable_index;\n", options.module.itable.prefix.l);
  lf_printf (file, "\n");

  /* output an enumeration type for each flag */
  itable_print_enum (file, isa->flags, "flag");
  lf_printf (file, "extern const char *%sitable_flag_names[];\n",
	     options.module.itable.prefix.l);
  lf_printf (file, "\n");

  /* output an enumeration of all the possible options */
  itable_print_enum (file, isa->options, "option");
  lf_printf (file, "extern const char *%sitable_option_names[];\n",
	     options.module.itable.prefix.l);
  lf_printf (file, "\n");

  /* output an enumeration of all the processor models */
  itable_print_enum (file, isa->model->processors, "processor");
  lf_printf (file, "extern const char *%sitable_processor_names[];\n",
	     options.module.itable.prefix.l);
  lf_printf (file, "\n");

  /* output the table that contains the actual instruction info */
  lf_printf (file, "typedef struct _%sitable_instruction_info {\n",
	     options.module.itable.prefix.l);
  lf_printf (file, "  %sitable_index nr;\n", options.module.itable.prefix.l);
  lf_printf (file, "  char *format;\n");
  lf_printf (file, "  char *form;\n");
  lf_printf (file, "  char *flags;\n");

  /* nr_itable_* may be zero, so we add 1 to avoid an
     illegal zero-sized array. */
  lf_printf (file, "  char flag[nr_%sitable_flags + 1];\n",
	     options.module.itable.prefix.l);
  lf_printf (file, "  char *options;\n");
  lf_printf (file, "  char option[nr_%sitable_options + 1];\n",
	     options.module.itable.prefix.l);
  lf_printf (file, "  char *processors;\n");
  lf_printf (file, "  char processor[nr_%sitable_processors + 1];\n",
	     options.module.itable.prefix.l);
  lf_printf (file, "  char *name;\n");
  lf_printf (file, "  char *file;\n");
  lf_printf (file, "  int line_nr;\n");
  lf_printf (file, "} %sitable_info;\n", options.module.itable.prefix.l);
  lf_printf (file, "\n");
  lf_printf (file, "extern %sitable_info %sitable[nr_%sitable_entries];\n",
	     options.module.itable.prefix.l, options.module.itable.prefix.l,
	     options.module.itable.prefix.l);
  if (strlen (options.module.itable.prefix.l) > 0)
    {
      lf_indent_suppress (file);
      lf_printf (file, "#define itable %sitable\n",
		 options.module.itable.prefix.l);
    }
  lf_printf (file, "\n");

  /* output an enum defining the max size of various itable members */
  lf_printf (file, "enum {\n");
  lf_printf (file, "  sizeof_%sitable_form = %d,\n",
	     options.module.itable.prefix.l, info->sizeof_form);
  lf_printf (file, "  sizeof_%sitable_name = %d,\n",
	     options.module.itable.prefix.l, info->sizeof_name);
  lf_printf (file, "  sizeof_%sitable_file = %d,\n",
	     options.module.itable.prefix.l, info->sizeof_file);
  lf_printf (file, "};\n");
}


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

static void
itable_print_set (lf *file, filter *set, filter *members)
{
  char *elem;
  lf_printf (file, "\"");
  elem = filter_next (members, "");
  if (elem != NULL)
    {
      while (1)
	{
	  lf_printf (file, "%s", elem);
	  elem = filter_next (members, elem);
	  if (elem == NULL)
	    break;
	  lf_printf (file, ",");
	}
    }
  lf_printf (file, "\",\n");

  lf_printf (file, "{");
  for (elem = filter_next (set, "");
       elem != NULL; elem = filter_next (set, elem))
    {
      if (filter_is_member (members, elem))
	{
	  lf_printf (file, " 1,");
	}
      else
	{
	  lf_printf (file, " 0,");
	}

    }
  /* always print a dummy element, to avoid empty initializers. */
  lf_printf (file, " 99 },\n");
}


static void
itable_c_insn (lf *file,
	       insn_table *isa, insn_entry * instruction, void *data)
{
  lf_printf (file, "{ ");
  lf_indent (file, +2);
  print_function_name (file,
		       instruction->name,
		       instruction->format_name,
		       NULL, NULL, function_name_prefix_itable);
  lf_printf (file, ",\n");
  lf_printf (file, "\"");
  print_insn_words (file, instruction);
  lf_printf (file, "\",\n");
  lf_printf (file, "\"%s\",\n", instruction->format_name);

  itable_print_set (file, isa->flags, instruction->flags);
  itable_print_set (file, isa->options, instruction->options);
  itable_print_set (file, isa->model->processors, instruction->processors);

  lf_printf (file, "\"%s\",\n", instruction->name);
  lf_printf (file, "\"%s\",\n",
	     filter_filename (instruction->line->file_name));
  lf_printf (file, "%d,\n", instruction->line->line_nr);
  lf_printf (file, "},\n");
  lf_indent (file, -2);
}


extern void
gen_itable_c (lf *file, insn_table *isa)
{
  /* leader */
  lf_printf (file, "#include \"%sitable.h\"\n",
	     options.module.itable.prefix.l);
  lf_printf (file, "\n");

  /* FIXME - output model data??? */
  /* FIXME - output assembler data??? */

  /* output the flag, option and processor name tables */
  itable_print_names (file, isa->flags, "flag");
  itable_print_names (file, isa->options, "option");
  itable_print_names (file, isa->model->processors, "processor");

  /* output the table that contains the actual instruction info */
  lf_printf (file, "%sitable_info %sitable[nr_%sitable_entries] = {\n",
	     options.module.itable.prefix.l,
	     options.module.itable.prefix.l, options.module.itable.prefix.l);
  insn_table_traverse_insn (file, isa, itable_c_insn, NULL);

  lf_printf (file, "};\n");
}
Commit	Line	Data
feaee4bd AC	1	/* The IGEN simulator generator for GDB, the GNU Debugger.
feaee4bd AC	2
8acc9f48	3	Copyright 2002-2013 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
	24	#include "misc.h"
	25	#include "lf.h"
	26	#include "table.h"
	27	#include "filter.h"
	28	#include "igen.h"
	29
	30	#include "ld-insn.h"
	31	#include "ld-decode.h"
	32
	33	#include "gen.h"
	34
	35	#include "gen-itable.h"
	36
	37	#ifndef NULL
	38	#define NULL 0
	39	#endif
	40
	41
	42
4e0bf4c4 AC	43	typedef struct _itable_info
4e0bf4c4 AC	44	{
c906108c SS	45	int sizeof_form;
	46	int sizeof_name;
	47	int sizeof_file;
4e0bf4c4 AC	48	}
4e0bf4c4 AC	49	itable_info;
c906108c SS	50
	51
	52	static void
	53	itable_h_insn (lf *file,
4e0bf4c4	54	insn_table entry, insn_entry instruction, void *data)
c906108c SS	55	{
	56	int len;
	57	itable_info *info = data;
	58	lf_print__line_ref (file, instruction->line);
	59	lf_printf (file, " ");
	60	print_function_name (file,
	61	instruction->name,
	62	instruction->format_name,
4e0bf4c4	63	NULL, NULL, function_name_prefix_itable);
c906108c SS	64	lf_printf (file, ",\n");
	65	/* update summary info */
	66	len = strlen (instruction->format_name);
	67	if (info->sizeof_form <= len)
	68	info->sizeof_form = len + 1;
	69	len = strlen (instruction->name);
	70	if (info->sizeof_name <= len)
	71	info->sizeof_name = len + 1;
	72	len = strlen (filter_filename (instruction->line->file_name));
	73	if (info->sizeof_file <= len)
	74	info->sizeof_file = len + 1;
	75	}
	76
	77
	78	/* print the list of all the different options */
	79
	80	static void
4e0bf4c4	81	itable_print_enum (lf file, filter set, char *name)
c906108c SS	82	{
	83	char *elem;
	84	lf_printf (file, "typedef enum {\n");
	85	lf_indent (file, +2);
	86	for (elem = filter_next (set, "");
4e0bf4c4	87	elem != NULL; elem = filter_next (set, elem))
c906108c SS	88	{
	89	lf_printf (file, "%sitable_%s_%s,\n",
	90	options.module.itable.prefix.l, name, elem);
	91	if (strlen (options.module.itable.prefix.l) > 0)
	92	{
	93	lf_indent_suppress (file);
	94	lf_printf (file, "#define itable_%s_%s %sitable_%s_%s\n",
	95	name, elem, options.module.itable.prefix.l, name, elem);
	96	}
	97	}
4e0bf4c4 AC	98	lf_printf (file, "nr_%sitable_%ss,\n", options.module.itable.prefix.l,
	99	name);
	100
c906108c SS	101	lf_indent (file, -2);
	102	lf_printf (file, "} %sitable_%ss;\n", options.module.itable.prefix.l, name);
	103	if (strlen (options.module.itable.prefix.l) > 0)
	104	{
	105	lf_indent_suppress (file);
	106	lf_printf (file, "#define itable_%ss %sitable_%ss\n",
	107	name, options.module.itable.prefix.l, name);
	108	lf_indent_suppress (file);
	109	lf_printf (file, "#define nr_itable_%ss nr_%sitable_%ss\n",
	110	name, options.module.itable.prefix.l, name);
	111	}
	112	}
	113
	114	/* print an array of the option names as strings */
	115
	116	static void
4e0bf4c4	117	itable_print_names (lf file, filter set, char *name)
c906108c SS	118	{
	119	char *elem;
	120	lf_printf (file, "const char *%sitable_%s_names[nr_%sitable_%ss + 1] = {\n",
	121	options.module.itable.prefix.l, name,
	122	options.module.itable.prefix.l, name);
	123	lf_indent (file, +2);
	124	for (elem = filter_next (set, "");
4e0bf4c4	125	elem != NULL; elem = filter_next (set, elem))
c906108c SS	126	{
	127	lf_printf (file, "\"%s\",\n", elem);
	128	}
	129	lf_printf (file, "0,\n");
	130	lf_indent (file, -2);
	131	lf_printf (file, "};\n");
	132	}
	133
4e0bf4c4 AC	134	extern void
4e0bf4c4 AC	135	gen_itable_h (lf file, insn_table isa)
c906108c SS	136	{
	137	itable_info *info = ZALLOC (itable_info);
	138
	139	/* output an enumerated type for each instruction */
	140	lf_printf (file, "typedef enum {\n");
	141	insn_table_traverse_insn (file, isa, itable_h_insn, info);
4e0bf4c4 AC	142	lf_printf (file, " nr_%sitable_entries,\n",
4e0bf4c4 AC	143	options.module.itable.prefix.l);
c906108c SS	144	lf_printf (file, "} %sitable_index;\n", options.module.itable.prefix.l);
	145	lf_printf (file, "\n");
	146
	147	/* output an enumeration type for each flag */
	148	itable_print_enum (file, isa->flags, "flag");
	149	lf_printf (file, "extern const char *%sitable_flag_names[];\n",
	150	options.module.itable.prefix.l);
	151	lf_printf (file, "\n");
4e0bf4c4	152
c906108c SS	153	/* output an enumeration of all the possible options */
	154	itable_print_enum (file, isa->options, "option");
	155	lf_printf (file, "extern const char *%sitable_option_names[];\n",
	156	options.module.itable.prefix.l);
	157	lf_printf (file, "\n");
	158
	159	/* output an enumeration of all the processor models */
	160	itable_print_enum (file, isa->model->processors, "processor");
	161	lf_printf (file, "extern const char *%sitable_processor_names[];\n",
	162	options.module.itable.prefix.l);
	163	lf_printf (file, "\n");
	164
	165	/* output the table that contains the actual instruction info */
	166	lf_printf (file, "typedef struct _%sitable_instruction_info {\n",
	167	options.module.itable.prefix.l);
	168	lf_printf (file, " %sitable_index nr;\n", options.module.itable.prefix.l);
	169	lf_printf (file, " char *format;\n");
	170	lf_printf (file, " char *form;\n");
	171	lf_printf (file, " char *flags;\n");
	172
	173	/* nr_itable_* may be zero, so we add 1 to avoid an
	174	illegal zero-sized array. */
	175	lf_printf (file, " char flag[nr_%sitable_flags + 1];\n",
	176	options.module.itable.prefix.l);
	177	lf_printf (file, " char *options;\n");
	178	lf_printf (file, " char option[nr_%sitable_options + 1];\n",
	179	options.module.itable.prefix.l);
	180	lf_printf (file, " char *processors;\n");
	181	lf_printf (file, " char processor[nr_%sitable_processors + 1];\n",
	182	options.module.itable.prefix.l);
	183	lf_printf (file, " char *name;\n");
	184	lf_printf (file, " char *file;\n");
	185	lf_printf (file, " int line_nr;\n");
	186	lf_printf (file, "} %sitable_info;\n", options.module.itable.prefix.l);
	187	lf_printf (file, "\n");
	188	lf_printf (file, "extern %sitable_info %sitable[nr_%sitable_entries];\n",
	189	options.module.itable.prefix.l, options.module.itable.prefix.l,
	190	options.module.itable.prefix.l);
	191	if (strlen (options.module.itable.prefix.l) > 0)
	192	{
	193	lf_indent_suppress (file);
	194	lf_printf (file, "#define itable %sitable\n",
	195	options.module.itable.prefix.l);
	196	}
	197	lf_printf (file, "\n");
	198
	199	/* output an enum defining the max size of various itable members */
	200	lf_printf (file, "enum {\n");
	201	lf_printf (file, " sizeof_%sitable_form = %d,\n",
	202	options.module.itable.prefix.l, info->sizeof_form);
	203	lf_printf (file, " sizeof_%sitable_name = %d,\n",
	204	options.module.itable.prefix.l, info->sizeof_name);
	205	lf_printf (file, " sizeof_%sitable_file = %d,\n",
	206	options.module.itable.prefix.l, info->sizeof_file);
	207	lf_printf (file, "};\n");
	208	}
	209
	210
	211	/****************************************************************/
	212
	213	static void
4e0bf4c4	214	itable_print_set (lf file, filter set, filter *members)
c906108c SS	215	{
	216	char *elem;
	217	lf_printf (file, "\"");
	218	elem = filter_next (members, "");
	219	if (elem != NULL)
	220	{
	221	while (1)
	222	{
	223	lf_printf (file, "%s", elem);
	224	elem = filter_next (members, elem);
	225	if (elem == NULL)
	226	break;
	227	lf_printf (file, ",");
	228	}
	229	}
	230	lf_printf (file, "\",\n");
	231
4e0bf4c4	232	lf_printf (file, "{");
c906108c	233	for (elem = filter_next (set, "");
4e0bf4c4	234	elem != NULL; elem = filter_next (set, elem))
c906108c SS	235	{
	236	if (filter_is_member (members, elem))
	237	{
	238	lf_printf (file, " 1,");
	239	}
	240	else
	241	{
	242	lf_printf (file, " 0,");
	243	}
4e0bf4c4	244
c906108c SS	245	}
c906108c SS	246	/* always print a dummy element, to avoid empty initializers. */
4e0bf4c4	247	lf_printf (file, " 99 },\n");
c906108c SS	248	}
	249
	250
	251	static void
	252	itable_c_insn (lf *file,
4e0bf4c4	253	insn_table isa, insn_entry instruction, void *data)
c906108c SS	254	{
	255	lf_printf (file, "{ ");
	256	lf_indent (file, +2);
	257	print_function_name (file,
	258	instruction->name,
	259	instruction->format_name,
4e0bf4c4	260	NULL, NULL, function_name_prefix_itable);
c906108c SS	261	lf_printf (file, ",\n");
	262	lf_printf (file, "\"");
	263	print_insn_words (file, instruction);
	264	lf_printf (file, "\",\n");
	265	lf_printf (file, "\"%s\",\n", instruction->format_name);
	266
	267	itable_print_set (file, isa->flags, instruction->flags);
	268	itable_print_set (file, isa->options, instruction->options);
	269	itable_print_set (file, isa->model->processors, instruction->processors);
	270
4e0bf4c4 AC	271	lf_printf (file, "\"%s\",\n", instruction->name);
	272	lf_printf (file, "\"%s\",\n",
	273	filter_filename (instruction->line->file_name));
	274	lf_printf (file, "%d,\n", instruction->line->line_nr);
	275	lf_printf (file, "},\n");
c906108c SS	276	lf_indent (file, -2);
	277	}
	278
	279
4e0bf4c4 AC	280	extern void
4e0bf4c4 AC	281	gen_itable_c (lf file, insn_table isa)
c906108c SS	282	{
c906108c SS	283	/* leader */
4e0bf4c4 AC	284	lf_printf (file, "#include \"%sitable.h\"\n",
	285	options.module.itable.prefix.l);
	286	lf_printf (file, "\n");
c906108c SS	287
	288	/* FIXME - output model data??? */
	289	/* FIXME - output assembler data??? */
	290
	291	/* output the flag, option and processor name tables */
	292	itable_print_names (file, isa->flags, "flag");
	293	itable_print_names (file, isa->options, "option");
	294	itable_print_names (file, isa->model->processors, "processor");
	295
	296	/* output the table that contains the actual instruction info */
	297	lf_printf (file, "%sitable_info %sitable[nr_%sitable_entries] = {\n",
	298	options.module.itable.prefix.l,
4e0bf4c4	299	options.module.itable.prefix.l, options.module.itable.prefix.l);
c906108c SS	300	insn_table_traverse_insn (file, isa, itable_c_insn, NULL);
c906108c SS	301
4e0bf4c4	302	lf_printf (file, "};\n");
c906108c	303	}