[gcc.git] / gcc / genopinit.c

/* Generate code to initialize optabs from machine description.
   Copyright (C) 1993, 94-98, 1999 Free Software Foundation, Inc.

This file is part of GNU CC.

GNU CC is free software; you can redistribute it and/or modify
it under the terms of the GNU General Public License as published by
the Free Software Foundation; either version 2, or (at your option)
any later version.

GNU CC 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 GNU CC; see the file COPYING.  If not, write to
the Free Software Foundation, 59 Temple Place - Suite 330,
Boston, MA 02111-1307, USA.  */


#include "hconfig.h"
#include "system.h"
#include "rtl.h"
#include "obstack.h"

static struct obstack obstack;
struct obstack *rtl_obstack = &obstack;

#define obstack_chunk_alloc xmalloc
#define obstack_chunk_free free

void fatal PVPROTO ((const char *, ...))
  ATTRIBUTE_PRINTF_1 ATTRIBUTE_NORETURN;

/* Many parts of GCC use arrays that are indexed by machine mode and
   contain the insn codes for pattern in the MD file that perform a given
   operation on operands of that mode.

   These patterns are present in the MD file with names that contain
   the mode(s) used and the name of the operation.  This program
   writes a function `init_all_optabs' that initializes the optabs with
   all the insn codes of the relevant patterns present in the MD file.

   This array contains a list of optabs that need to be initialized.  Within
   each string, the name of the pattern to be matched against is delimited
   with %( and %).  In the string, %a and %b are used to match a short mode
   name (the part of the mode name not including `mode' and converted to
   lower-case).  When writing out the initializer, the entire string is
   used.  %A and %B are replaced with the full name of the mode; %a and %b
   are replaced with the short form of the name, as above.

   If %N is present in the pattern, it means the two modes must be consecutive
   widths in the same mode class (e.g, QImode and HImode).  %I means that
   only integer modes should be considered for the next mode, and %F means
   that only float modes should be considered.

   For some optabs, we store the operation by RTL codes.  These are only
   used for comparisons.  In that case, %c and %C are the lower-case and
   upper-case forms of the comparison, respectively.  */

/* The reason we use \% is to avoid sequences of the form %-capletter-%
   which SCCS treats as magic.  This gets warnings which you should ignore.  */

const char *optabs[] =
{ "extendtab[(int) %B][(int) %A][0] = CODE_FOR_%(extend%a\%b2%)",
  "extendtab[(int) %B][(int) %A][1] = CODE_FOR_%(zero_extend%a\%b2%)",
  "fixtab[(int) %A][(int) %B][0] = CODE_FOR_%(fix%F\%a%I\%b2%)",
  "fixtab[(int) %A][(int) %B][1] = CODE_FOR_%(fixuns%F\%a%b2%)",
  "fixtrunctab[(int) %A][(int) %B][0] = CODE_FOR_%(fix_trunc%F\%a%I\%b2%)",
  "fixtrunctab[(int) %A][(int) %B][1] = CODE_FOR_%(fixuns_trunc%F\%a%I\%b2%)",
  "floattab[(int) %B][(int) %A][0] = CODE_FOR_%(float%I\%a%F\%b2%)",
  "floattab[(int) %B][(int) %A][1] = CODE_FOR_%(floatuns%I\%a%F\%b2%)",
  "add_optab->handlers[(int) %A].insn_code = CODE_FOR_%(add%a3%)",
  "sub_optab->handlers[(int) %A].insn_code = CODE_FOR_%(sub%a3%)",
  "smul_optab->handlers[(int) %A].insn_code = CODE_FOR_%(mul%a3%)",
  "umul_highpart_optab->handlers[(int) %A].insn_code = CODE_FOR_%(umul%a3_highpart%)",
  "smul_highpart_optab->handlers[(int) %A].insn_code = CODE_FOR_%(smul%a3_highpart%)",
  "smul_widen_optab->handlers[(int) %B].insn_code = CODE_FOR_%(mul%a%b3%)%N",
  "umul_widen_optab->handlers[(int) %B].insn_code = CODE_FOR_%(umul%a%b3%)%N",
  "sdiv_optab->handlers[(int) %A].insn_code = CODE_FOR_%(div%I\%a3%)",
  "udiv_optab->handlers[(int) %A].insn_code = CODE_FOR_%(udiv%I\%a3%)",
  "sdivmod_optab->handlers[(int) %A].insn_code = CODE_FOR_%(divmod%a4%)",
  "udivmod_optab->handlers[(int) %A].insn_code = CODE_FOR_%(udivmod%a4%)",
  "smod_optab->handlers[(int) %A].insn_code = CODE_FOR_%(mod%a3%)",
  "umod_optab->handlers[(int) %A].insn_code = CODE_FOR_%(umod%a3%)",
  "flodiv_optab->handlers[(int) %A].insn_code = CODE_FOR_%(div%F\%a3%)",
  "ftrunc_optab->handlers[(int) %A].insn_code = CODE_FOR_%(ftrunc%F\%a2%)",
  "and_optab->handlers[(int) %A].insn_code = CODE_FOR_%(and%a3%)",
  "ior_optab->handlers[(int) %A].insn_code = CODE_FOR_%(ior%a3%)",
  "xor_optab->handlers[(int) %A].insn_code = CODE_FOR_%(xor%a3%)",
  "ashl_optab->handlers[(int) %A].insn_code = CODE_FOR_%(ashl%a3%)",
  "ashr_optab->handlers[(int) %A].insn_code = CODE_FOR_%(ashr%a3%)",
  "lshr_optab->handlers[(int) %A].insn_code = CODE_FOR_%(lshr%a3%)",
  "rotl_optab->handlers[(int) %A].insn_code = CODE_FOR_%(rotl%a3%)",
  "rotr_optab->handlers[(int) %A].insn_code = CODE_FOR_%(rotr%a3%)",
  "smin_optab->handlers[(int) %A].insn_code = CODE_FOR_%(smin%I\%a3%)",
  "smin_optab->handlers[(int) %A].insn_code = CODE_FOR_%(min%F\%a3%)",
  "smax_optab->handlers[(int) %A].insn_code = CODE_FOR_%(smax%I\%a3%)",
  "smax_optab->handlers[(int) %A].insn_code = CODE_FOR_%(max%F\%a3%)",
  "umin_optab->handlers[(int) %A].insn_code = CODE_FOR_%(umin%I\%a3%)",
  "umax_optab->handlers[(int) %A].insn_code = CODE_FOR_%(umax%I\%a3%)",
  "neg_optab->handlers[(int) %A].insn_code = CODE_FOR_%(neg%a2%)",
  "abs_optab->handlers[(int) %A].insn_code = CODE_FOR_%(abs%a2%)",
  "sqrt_optab->handlers[(int) %A].insn_code = CODE_FOR_%(sqrt%a2%)",
  "sin_optab->handlers[(int) %A].insn_code = CODE_FOR_%(sin%a2%)",
  "cos_optab->handlers[(int) %A].insn_code = CODE_FOR_%(cos%a2%)",
  "strlen_optab->handlers[(int) %A].insn_code = CODE_FOR_%(strlen%a%)",
  "one_cmpl_optab->handlers[(int) %A].insn_code = CODE_FOR_%(one_cmpl%a2%)",
  "ffs_optab->handlers[(int) %A].insn_code = CODE_FOR_%(ffs%a2%)",
  "mov_optab->handlers[(int) %A].insn_code = CODE_FOR_%(mov%a%)",
  "movstrict_optab->handlers[(int) %A].insn_code = CODE_FOR_%(movstrict%a%)",
  "cmp_optab->handlers[(int) %A].insn_code = CODE_FOR_%(cmp%a%)",
  "tst_optab->handlers[(int) %A].insn_code = CODE_FOR_%(tst%a%)",
  "bcc_gen_fctn[(int) %C] = gen_%(b%c%)",
  "setcc_gen_code[(int) %C] = CODE_FOR_%(s%c%)",
  "movcc_gen_code[(int) %A] = CODE_FOR_%(mov%acc%)",
  "reload_in_optab[(int) %A] = CODE_FOR_%(reload_in%a%)",
  "reload_out_optab[(int) %A] = CODE_FOR_%(reload_out%a%)",
  "movstr_optab[(int) %A] = CODE_FOR_%(movstr%a%)",
  "clrstr_optab[(int) %A] = CODE_FOR_%(clrstr%a%)" };

/* Allow linking with print-rtl.c.  */
char **insn_name_ptr;

static void gen_insn PROTO((rtx));

static void
gen_insn (insn)
     rtx insn;
{
  char *name = XSTR (insn, 0);
  int m1, m2, op;
  size_t pindex;
  int i;
  const char *np, *pp, *p, *q;

  /* Don't mention instructions whose names are the null string.
     They are in the machine description just to be recognized.  */
  if (*name == 0)
    return;

  /* See if NAME matches one of the patterns we have for the optabs we know
     about.  */

  for (pindex = 0; pindex < sizeof optabs / sizeof optabs[0]; pindex++)
    {
      int force_float = 0, force_int = 0;
      int force_consec = 0;
      int matches = 1;

      for (pp = optabs[pindex]; pp[0] != '%' || pp[1] != '('; pp++)
	;

      for (pp += 2, np = name; matches && ! (pp[0] == '%' && pp[1] == ')');
	   pp++)
	{
	  if (*pp != '%')
	    {
	      if (*pp != *np++)
		break;
	    }
	  else
	    switch (*++pp)
	      {
	      case 'N':
		force_consec = 1;
		break;
	      case 'I':
		force_int = 1;
		break;
	      case 'F':
		force_float = 1;
		break;
	      case 'c':
		for (op = 0; op < NUM_RTX_CODE; op++)
		  {
		    for (p = GET_RTX_NAME(op), q = np; *p; p++, q++)
		      if (*p != *q)
			break;

		    /* We have to be concerned about matching "gt" and
		       missing "gtu", e.g., so verify we have reached the
		       end of thing we are to match.  */
		    if (*p == 0 && *q == 0 && GET_RTX_CLASS(op) == '<')
		      break;
		  }

		if (op == NUM_RTX_CODE)
		  matches = 0;
		else
		  np += strlen (GET_RTX_NAME(op));
		break;
	      case 'a':
	      case 'b':
		/* This loop will stop at the first prefix match, so
                   look through the modes in reverse order, in case
                   EXTRA_CC_MODES was used and CC is a prefix of the
                   CC modes (as it should be).  */
		for (i = ((int) MAX_MACHINE_MODE) - 1; i >= 0; i--)
		  {
		    for (p = GET_MODE_NAME(i), q = np; *p; p++, q++)
		      if (tolower ((unsigned char)*p) != *q)
			break;

		    if (*p == 0
			&& (! force_int || mode_class[i] == MODE_INT)
			&& (! force_float || mode_class[i] == MODE_FLOAT))
		      break;
		  }

		if (i < 0)
		  matches = 0;
		else if (*pp == 'a')
		  m1 = i, np += strlen (GET_MODE_NAME(i));
		else
		  m2 = i, np += strlen (GET_MODE_NAME(i));

		force_int = force_float = 0;
		break;

	      default:
		abort ();
	      }
	}

      if (matches && pp[0] == '%' && pp[1] == ')'
	  && *np == 0
	  && (! force_consec || (int) GET_MODE_WIDER_MODE(m1) == m2))
	break;
    }

  if (pindex == sizeof optabs / sizeof optabs[0])
    return;

  /* We found a match.  If this pattern is only conditionally present,
     write out the "if" and two extra blanks.  */

  if (*XSTR (insn, 2) != 0)
    printf ("  if (HAVE_%s)\n  ", name);

  printf ("  ");

  /* Now write out the initialization, making all required substitutions.  */
  for (pp = optabs[pindex]; *pp; pp++)
    {
      if (*pp != '%')
	printf ("%c", *pp);
      else
	switch (*++pp)
	  {
	  case '(':  case ')':
	  case 'I':  case 'F':  case 'N':
	    break;
	  case 'a':
	    for (np = GET_MODE_NAME(m1); *np; np++)
	      printf ("%c", tolower ((unsigned char)*np));
	    break;
	  case 'b':
	    for (np = GET_MODE_NAME(m2); *np; np++)
	      printf ("%c", tolower ((unsigned char)*np));
	    break;
	  case 'A':
	    printf ("%smode", GET_MODE_NAME(m1));
	    break;
	  case 'B':
	    printf ("%smode", GET_MODE_NAME(m2));
	    break;
	  case 'c':
	    printf ("%s", GET_RTX_NAME(op));
	    break;
	  case 'C':
	    for (np = GET_RTX_NAME(op); *np; np++)
	      printf ("%c", toupper ((unsigned char)*np));
	    break;
	  }
    }

  printf (";\n");
}
\f
PTR
xmalloc (size)
  size_t size;
{
  register PTR val = (PTR) malloc (size);

  if (val == 0)
    fatal ("virtual memory exhausted");

  return val;
}

PTR
xrealloc (old, size)
  PTR old;
  size_t size;
{
  register PTR ptr;
  if (old)
    ptr = (PTR) realloc (old, size);
  else
    ptr = (PTR) malloc (size);
  if (!ptr)
    fatal ("virtual memory exhausted");
  return ptr;
}

void
fatal VPROTO ((const char *format, ...))
{
#ifndef ANSI_PROTOTYPES
  const char *format;
#endif
  va_list ap;

  VA_START (ap, format);

#ifndef ANSI_PROTOTYPES
  format = va_arg (ap, const char *);
#endif

  fprintf (stderr, "genopinit: ");
  vfprintf (stderr, format, ap);
  va_end (ap);
  fprintf (stderr, "\n");
  exit (FATAL_EXIT_CODE);
}

int
main (argc, argv)
     int argc;
     char **argv;
{
  rtx desc;
  FILE *infile;
  register int c;

  obstack_init (rtl_obstack);

  if (argc <= 1)
    fatal ("No input file name.");

  infile = fopen (argv[1], "r");
  if (infile == 0)
    {
      perror (argv[1]);
      exit (FATAL_EXIT_CODE);
    }

  init_rtl ();

  printf ("/* Generated automatically by the program `genopinit'\n\
from the machine description file `md'.  */\n\n");

  printf ("#include \"config.h\"\n");
  printf ("#include \"system.h\"\n");
  printf ("#include \"rtl.h\"\n");
  printf ("#include \"flags.h\"\n");
  printf ("#include \"insn-flags.h\"\n");
  printf ("#include \"insn-codes.h\"\n");
  printf ("#include \"insn-config.h\"\n");
  printf ("#include \"recog.h\"\n");
  printf ("#include \"expr.h\"\n");
  printf ("#include \"reload.h\"\n\n");

  printf ("void\ninit_all_optabs ()\n{\n");

  /* Read the machine description.  */

  while (1)
    {
      c = read_skip_spaces (infile);
      if (c == EOF)
	break;
      ungetc (c, infile);

      desc = read_rtx (infile);
      if (GET_CODE (desc) == DEFINE_INSN || GET_CODE (desc) == DEFINE_EXPAND)
	gen_insn (desc);
    }

  printf ("}\n");

  fflush (stdout);
  exit (ferror (stdout) != 0 ? FATAL_EXIT_CODE : SUCCESS_EXIT_CODE);
  /* NOTREACHED */
  return 0;
}
Commit	Line	Data
af9e4a0c	1	/* Generate code to initialize optabs from machine description.
34627ce6	2	Copyright (C) 1993, 94-98, 1999 Free Software Foundation, Inc.
af9e4a0c RK	3
	4	This file is part of GNU CC.
	5
	6	GNU CC is free software; you can redistribute it and/or modify
	7	it under the terms of the GNU General Public License as published by
	8	the Free Software Foundation; either version 2, or (at your option)
	9	any later version.
	10
	11	GNU CC is distributed in the hope that it will be useful,
	12	but WITHOUT ANY WARRANTY; without even the implied warranty of
	13	MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
	14	GNU General Public License for more details.
	15
	16	You should have received a copy of the GNU General Public License
	17	along with GNU CC; see the file COPYING. If not, write to
a35311b0 RK	18	the Free Software Foundation, 59 Temple Place - Suite 330,
a35311b0 RK	19	Boston, MA 02111-1307, USA. */
af9e4a0c RK	20
af9e4a0c RK	21
af9e4a0c	22	#include "hconfig.h"
0b93b64e	23	#include "system.h"
af9e4a0c RK	24	#include "rtl.h"
af9e4a0c RK	25	#include "obstack.h"
ccd043a9	26
af9e4a0c RK	27	static struct obstack obstack;
	28	struct obstack *rtl_obstack = &obstack;
	29
	30	#define obstack_chunk_alloc xmalloc
	31	#define obstack_chunk_free free
	32
2a611d21	33	void fatal PVPROTO ((const char *, ...))
bf94d1ec	34	ATTRIBUTE_PRINTF_1 ATTRIBUTE_NORETURN;
af9e4a0c RK	35
	36	/* Many parts of GCC use arrays that are indexed by machine mode and
	37	contain the insn codes for pattern in the MD file that perform a given
	38	operation on operands of that mode.
	39
	40	These patterns are present in the MD file with names that contain
	41	the mode(s) used and the name of the operation. This program
	42	writes a function `init_all_optabs' that initializes the optabs with
	43	all the insn codes of the relevant patterns present in the MD file.
	44
	45	This array contains a list of optabs that need to be initialized. Within
	46	each string, the name of the pattern to be matched against is delimited
	47	with %( and %). In the string, %a and %b are used to match a short mode
	48	name (the part of the mode name not including `mode' and converted to
	49	lower-case). When writing out the initializer, the entire string is
	50	used. %A and %B are replaced with the full name of the mode; %a and %b
	51	are replaced with the short form of the name, as above.
	52
	53	If %N is present in the pattern, it means the two modes must be consecutive
	54	widths in the same mode class (e.g, QImode and HImode). %I means that
	55	only integer modes should be considered for the next mode, and %F means
	56	that only float modes should be considered.
	57
	58	For some optabs, we store the operation by RTL codes. These are only
	59	used for comparisons. In that case, %c and %C are the lower-case and
	60	upper-case forms of the comparison, respectively. */
	61
8c9881d1 RS	62	/* The reason we use \% is to avoid sequences of the form %-capletter-%
	63	which SCCS treats as magic. This gets warnings which you should ignore. */
	64
85fda1eb	65	const char *optabs[] =
8c9881d1 RS	66	{ "extendtab[(int) %B][(int) %A][0] = CODE_FOR_%(extend%a\%b2%)",
	67	"extendtab[(int) %B][(int) %A][1] = CODE_FOR_%(zero_extend%a\%b2%)",
	68	"fixtab[(int) %A][(int) %B][0] = CODE_FOR_%(fix%F\%a%I\%b2%)",
	69	"fixtab[(int) %A][(int) %B][1] = CODE_FOR_%(fixuns%F\%a%b2%)",
	70	"fixtrunctab[(int) %A][(int) %B][0] = CODE_FOR_%(fix_trunc%F\%a%I\%b2%)",
	71	"fixtrunctab[(int) %A][(int) %B][1] = CODE_FOR_%(fixuns_trunc%F\%a%I\%b2%)",
	72	"floattab[(int) %B][(int) %A][0] = CODE_FOR_%(float%I\%a%F\%b2%)",
53f26922	73	"floattab[(int) %B][(int) %A][1] = CODE_FOR_%(floatuns%I\%a%F\%b2%)",
af9e4a0c RK	74	"add_optab->handlers[(int) %A].insn_code = CODE_FOR_%(add%a3%)",
	75	"sub_optab->handlers[(int) %A].insn_code = CODE_FOR_%(sub%a3%)",
	76	"smul_optab->handlers[(int) %A].insn_code = CODE_FOR_%(mul%a3%)",
af309004 TG	77	"umul_highpart_optab->handlers[(int) %A].insn_code = CODE_FOR_%(umul%a3_highpart%)",
af309004 TG	78	"smul_highpart_optab->handlers[(int) %A].insn_code = CODE_FOR_%(smul%a3_highpart%)",
af9e4a0c RK	79	"smul_widen_optab->handlers[(int) %B].insn_code = CODE_FOR_%(mul%a%b3%)%N",
af9e4a0c RK	80	"umul_widen_optab->handlers[(int) %B].insn_code = CODE_FOR_%(umul%a%b3%)%N",
8c9881d1 RS	81	"sdiv_optab->handlers[(int) %A].insn_code = CODE_FOR_%(div%I\%a3%)",
8c9881d1 RS	82	"udiv_optab->handlers[(int) %A].insn_code = CODE_FOR_%(udiv%I\%a3%)",
af9e4a0c RK	83	"sdivmod_optab->handlers[(int) %A].insn_code = CODE_FOR_%(divmod%a4%)",
	84	"udivmod_optab->handlers[(int) %A].insn_code = CODE_FOR_%(udivmod%a4%)",
	85	"smod_optab->handlers[(int) %A].insn_code = CODE_FOR_%(mod%a3%)",
	86	"umod_optab->handlers[(int) %A].insn_code = CODE_FOR_%(umod%a3%)",
8c9881d1 RS	87	"flodiv_optab->handlers[(int) %A].insn_code = CODE_FOR_%(div%F\%a3%)",
8c9881d1 RS	88	"ftrunc_optab->handlers[(int) %A].insn_code = CODE_FOR_%(ftrunc%F\%a2%)",
af9e4a0c RK	89	"and_optab->handlers[(int) %A].insn_code = CODE_FOR_%(and%a3%)",
	90	"ior_optab->handlers[(int) %A].insn_code = CODE_FOR_%(ior%a3%)",
	91	"xor_optab->handlers[(int) %A].insn_code = CODE_FOR_%(xor%a3%)",
	92	"ashl_optab->handlers[(int) %A].insn_code = CODE_FOR_%(ashl%a3%)",
	93	"ashr_optab->handlers[(int) %A].insn_code = CODE_FOR_%(ashr%a3%)",
af9e4a0c RK	94	"lshr_optab->handlers[(int) %A].insn_code = CODE_FOR_%(lshr%a3%)",
	95	"rotl_optab->handlers[(int) %A].insn_code = CODE_FOR_%(rotl%a3%)",
	96	"rotr_optab->handlers[(int) %A].insn_code = CODE_FOR_%(rotr%a3%)",
8c9881d1 RS	97	"smin_optab->handlers[(int) %A].insn_code = CODE_FOR_%(smin%I\%a3%)",
	98	"smin_optab->handlers[(int) %A].insn_code = CODE_FOR_%(min%F\%a3%)",
	99	"smax_optab->handlers[(int) %A].insn_code = CODE_FOR_%(smax%I\%a3%)",
	100	"smax_optab->handlers[(int) %A].insn_code = CODE_FOR_%(max%F\%a3%)",
	101	"umin_optab->handlers[(int) %A].insn_code = CODE_FOR_%(umin%I\%a3%)",
	102	"umax_optab->handlers[(int) %A].insn_code = CODE_FOR_%(umax%I\%a3%)",
af9e4a0c RK	103	"neg_optab->handlers[(int) %A].insn_code = CODE_FOR_%(neg%a2%)",
	104	"abs_optab->handlers[(int) %A].insn_code = CODE_FOR_%(abs%a2%)",
	105	"sqrt_optab->handlers[(int) %A].insn_code = CODE_FOR_%(sqrt%a2%)",
	106	"sin_optab->handlers[(int) %A].insn_code = CODE_FOR_%(sin%a2%)",
	107	"cos_optab->handlers[(int) %A].insn_code = CODE_FOR_%(cos%a2%)",
ed58a128	108	"strlen_optab->handlers[(int) %A].insn_code = CODE_FOR_%(strlen%a%)",
af9e4a0c RK	109	"one_cmpl_optab->handlers[(int) %A].insn_code = CODE_FOR_%(one_cmpl%a2%)",
	110	"ffs_optab->handlers[(int) %A].insn_code = CODE_FOR_%(ffs%a2%)",
	111	"mov_optab->handlers[(int) %A].insn_code = CODE_FOR_%(mov%a%)",
	112	"movstrict_optab->handlers[(int) %A].insn_code = CODE_FOR_%(movstrict%a%)",
	113	"cmp_optab->handlers[(int) %A].insn_code = CODE_FOR_%(cmp%a%)",
	114	"tst_optab->handlers[(int) %A].insn_code = CODE_FOR_%(tst%a%)",
	115	"bcc_gen_fctn[(int) %C] = gen_%(b%c%)",
	116	"setcc_gen_code[(int) %C] = CODE_FOR_%(s%c%)",
3c9958cd	117	"movcc_gen_code[(int) %A] = CODE_FOR_%(mov%acc%)",
af9e4a0c RK	118	"reload_in_optab[(int) %A] = CODE_FOR_%(reload_in%a%)",
af9e4a0c RK	119	"reload_out_optab[(int) %A] = CODE_FOR_%(reload_out%a%)",
fd18db65 RK	120	"movstr_optab[(int) %A] = CODE_FOR_%(movstr%a%)",
fd18db65 RK	121	"clrstr_optab[(int) %A] = CODE_FOR_%(clrstr%a%)" };
af9e4a0c	122
53f26922 RS	123	/* Allow linking with print-rtl.c. */
	124	char **insn_name_ptr;
	125
56c0e996 BS	126	static void gen_insn PROTO((rtx));
56c0e996 BS	127
af9e4a0c RK	128	static void
	129	gen_insn (insn)
	130	rtx insn;
	131	{
	132	char *name = XSTR (insn, 0);
	133	int m1, m2, op;
5ae9a7e9	134	size_t pindex;
af9e4a0c	135	int i;
85fda1eb	136	const char np, pp, p, q;
af9e4a0c RK	137
	138	/* Don't mention instructions whose names are the null string.
	139	They are in the machine description just to be recognized. */
	140	if (*name == 0)
	141	return;
	142
	143	/* See if NAME matches one of the patterns we have for the optabs we know
	144	about. */
	145
	146	for (pindex = 0; pindex < sizeof optabs / sizeof optabs[0]; pindex++)
	147	{
	148	int force_float = 0, force_int = 0;
	149	int force_consec = 0;
	150	int matches = 1;
	151
	152	for (pp = optabs[pindex]; pp[0] != '%' \|\| pp[1] != '('; pp++)
	153	;
	154
	155	for (pp += 2, np = name; matches && ! (pp[0] == '%' && pp[1] == ')');
	156	pp++)
	157	{
	158	if (*pp != '%')
	159	{
	160	if (pp != np++)
	161	break;
	162	}
	163	else
	164	switch (*++pp)
	165	{
	166	case 'N':
	167	force_consec = 1;
	168	break;
	169	case 'I':
	170	force_int = 1;
	171	break;
	172	case 'F':
	173	force_float = 1;
	174	break;
	175	case 'c':
	176	for (op = 0; op < NUM_RTX_CODE; op++)
	177	{
5f06c983	178	for (p = GET_RTX_NAME(op), q = np; *p; p++, q++)
af9e4a0c RK	179	if (p != q)
	180	break;
	181
	182	/* We have to be concerned about matching "gt" and
	183	missing "gtu", e.g., so verify we have reached the
4639555c	184	end of thing we are to match. */
1f9a015e	185	if (p == 0 && q == 0 && GET_RTX_CLASS(op) == '<')
af9e4a0c RK	186	break;
	187	}
	188
	189	if (op == NUM_RTX_CODE)
	190	matches = 0;
	191	else
5f06c983	192	np += strlen (GET_RTX_NAME(op));
af9e4a0c RK	193	break;
	194	case 'a':
	195	case 'b':
4639555c ILT	196	/* This loop will stop at the first prefix match, so
	197	look through the modes in reverse order, in case
	198	EXTRA_CC_MODES was used and CC is a prefix of the
	199	CC modes (as it should be). */
	200	for (i = ((int) MAX_MACHINE_MODE) - 1; i >= 0; i--)
af9e4a0c	201	{
a4ec8d12	202	for (p = GET_MODE_NAME(i), q = np; *p; p++, q++)
79c9824e	203	if (tolower ((unsigned char)p) != q)
af9e4a0c RK	204	break;
	205
	206	if (*p == 0
	207	&& (! force_int \|\| mode_class[i] == MODE_INT)
	208	&& (! force_float \|\| mode_class[i] == MODE_FLOAT))
	209	break;
	210	}
	211
4639555c	212	if (i < 0)
af9e4a0c RK	213	matches = 0;
af9e4a0c RK	214	else if (*pp == 'a')
a4ec8d12	215	m1 = i, np += strlen (GET_MODE_NAME(i));
af9e4a0c	216	else
a4ec8d12	217	m2 = i, np += strlen (GET_MODE_NAME(i));
af9e4a0c RK	218
	219	force_int = force_float = 0;
	220	break;
	221
	222	default:
	223	abort ();
	224	}
	225	}
	226
	227	if (matches && pp[0] == '%' && pp[1] == ')'
	228	&& *np == 0
88a5e9da	229	&& (! force_consec \|\| (int) GET_MODE_WIDER_MODE(m1) == m2))
af9e4a0c RK	230	break;
	231	}
	232
	233	if (pindex == sizeof optabs / sizeof optabs[0])
	234	return;
	235
	236	/* We found a match. If this pattern is only conditionally present,
	237	write out the "if" and two extra blanks. */
	238
	239	if (*XSTR (insn, 2) != 0)
	240	printf (" if (HAVE_%s)\n ", name);
	241
	242	printf (" ");
	243
	244	/* Now write out the initialization, making all required substitutions. */
	245	for (pp = optabs[pindex]; *pp; pp++)
	246	{
	247	if (*pp != '%')
	248	printf ("%c", *pp);
	249	else
	250	switch (*++pp)
	251	{
	252	case '(': case ')':
	253	case 'I': case 'F': case 'N':
	254	break;
	255	case 'a':
a4ec8d12	256	for (np = GET_MODE_NAME(m1); *np; np++)
79c9824e	257	printf ("%c", tolower ((unsigned char)*np));
af9e4a0c RK	258	break;
af9e4a0c RK	259	case 'b':
a4ec8d12	260	for (np = GET_MODE_NAME(m2); *np; np++)
79c9824e	261	printf ("%c", tolower ((unsigned char)*np));
af9e4a0c RK	262	break;
af9e4a0c RK	263	case 'A':
a4ec8d12	264	printf ("%smode", GET_MODE_NAME(m1));
af9e4a0c RK	265	break;
af9e4a0c RK	266	case 'B':
a4ec8d12	267	printf ("%smode", GET_MODE_NAME(m2));
af9e4a0c RK	268	break;
af9e4a0c RK	269	case 'c':
5f06c983	270	printf ("%s", GET_RTX_NAME(op));
af9e4a0c RK	271	break;
af9e4a0c RK	272	case 'C':
5f06c983	273	for (np = GET_RTX_NAME(op); *np; np++)
79c9824e	274	printf ("%c", toupper ((unsigned char)*np));
af9e4a0c RK	275	break;
	276	}
	277	}
	278
	279	printf (";\n");
	280	}
	281	\f
2778b98d	282	PTR
af9e4a0c	283	xmalloc (size)
2778b98d	284	size_t size;
af9e4a0c	285	{
2778b98d	286	register PTR val = (PTR) malloc (size);
af9e4a0c RK	287
	288	if (val == 0)
	289	fatal ("virtual memory exhausted");
	290
	291	return val;
	292	}
	293
2778b98d	294	PTR
470b68c0 RH	295	xrealloc (old, size)
470b68c0 RH	296	PTR old;
2778b98d	297	size_t size;
af9e4a0c	298	{
470b68c0	299	register PTR ptr;
09d83d25	300	if (old)
470b68c0 RH	301	ptr = (PTR) realloc (old, size);
	302	else
	303	ptr = (PTR) malloc (size);
	304	if (!ptr)
af9e4a0c	305	fatal ("virtual memory exhausted");
470b68c0	306	return ptr;
af9e4a0c RK	307	}
af9e4a0c RK	308
2a611d21	309	void
85fda1eb	310	fatal VPROTO ((const char *format, ...))
af9e4a0c	311	{
5148a72b	312	#ifndef ANSI_PROTOTYPES
85fda1eb	313	const char *format;
320e7c40 KG	314	#endif
	315	va_list ap;
	316
	317	VA_START (ap, format);
	318
5148a72b	319	#ifndef ANSI_PROTOTYPES
85fda1eb	320	format = va_arg (ap, const char *);
320e7c40 KG	321	#endif
320e7c40 KG	322
af9e4a0c	323	fprintf (stderr, "genopinit: ");
320e7c40 KG	324	vfprintf (stderr, format, ap);
320e7c40 KG	325	va_end (ap);
af9e4a0c RK	326	fprintf (stderr, "\n");
	327	exit (FATAL_EXIT_CODE);
	328	}
	329
af9e4a0c RK	330	int
	331	main (argc, argv)
	332	int argc;
	333	char **argv;
	334	{
	335	rtx desc;
af9e4a0c RK	336	FILE *infile;
	337	register int c;
	338
	339	obstack_init (rtl_obstack);
	340
	341	if (argc <= 1)
	342	fatal ("No input file name.");
	343
	344	infile = fopen (argv[1], "r");
	345	if (infile == 0)
	346	{
	347	perror (argv[1]);
	348	exit (FATAL_EXIT_CODE);
	349	}
	350
	351	init_rtl ();
	352
	353	printf ("/* Generated automatically by the program `genopinit'\n\
	354	from the machine description file `md'. */\n\n");
	355
	356	printf ("#include \"config.h\"\n");
729da3f5	357	printf ("#include \"system.h\"\n");
af9e4a0c RK	358	printf ("#include \"rtl.h\"\n");
	359	printf ("#include \"flags.h\"\n");
	360	printf ("#include \"insn-flags.h\"\n");
	361	printf ("#include \"insn-codes.h\"\n");
	362	printf ("#include \"insn-config.h\"\n");
	363	printf ("#include \"recog.h\"\n");
	364	printf ("#include \"expr.h\"\n");
	365	printf ("#include \"reload.h\"\n\n");
	366
	367	printf ("void\ninit_all_optabs ()\n{\n");
	368
	369	/* Read the machine description. */
	370
	371	while (1)
	372	{
	373	c = read_skip_spaces (infile);
	374	if (c == EOF)
	375	break;
	376	ungetc (c, infile);
	377
	378	desc = read_rtx (infile);
	379	if (GET_CODE (desc) == DEFINE_INSN \|\| GET_CODE (desc) == DEFINE_EXPAND)
	380	gen_insn (desc);
	381	}
	382
	383	printf ("}\n");
	384
	385	fflush (stdout);
	386	exit (ferror (stdout) != 0 ? FATAL_EXIT_CODE : SUCCESS_EXIT_CODE);
	387	/* NOTREACHED */
	388	return 0;
	389	}