[thirdparty/gcc.git] / gcc / genopinit.c

/* Generate code to initialize optabs from machine description.
   Copyright (C) 1993, 1994, 1995, 1996, 1997, 1998,
   1999, 2000 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 "errors.h"
#include "gensupport.h"


/* 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 full integer modes should be considered for the next mode, and $F
   means that only float modes should be considered.
   $P means that both full and partial integer modes should be considered.

   $V means to emit 'v' if the first mode is a MODE_FLOAT mode.

   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.  */

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

static void gen_insn PARAMS ((rtx));

static void
gen_insn (insn)
     rtx insn;
{
  const char *name = XSTR (insn, 0);
  int m1 = 0, m2 = 0, op = 0;
  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 < ARRAY_SIZE (optabs); pindex++)
    {
      int force_float = 0, force_int = 0, force_partial_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 'P':
                force_partial_int = 1;
                break;
	      case 'F':
		force_float = 1;
		break;
	      case 'V':
                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 (*p) != *q)
			break;

		    if (*p == 0
			&& (! force_int || mode_class[i] == MODE_INT)
		        && (! force_partial_int
                            || mode_class[i] == MODE_INT
                            || mode_class[i] == MODE_PARTIAL_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_partial_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 == ARRAY_SIZE (optabs))
    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 != '$')
	putchar (*pp);
      else
	switch (*++pp)
	  {
	  case '(':  case ')':
	  case 'I':  case 'F':  case 'N':
	    break;
	  case 'V':
            if (GET_MODE_CLASS (m1) == MODE_FLOAT)
              printf ("v");
            break;
	  case 'a':
	    for (np = GET_MODE_NAME(m1); *np; np++)
	      putchar (TOLOWER (*np));
	    break;
	  case 'b':
	    for (np = GET_MODE_NAME(m2); *np; np++)
	      putchar (TOLOWER (*np));
	    break;
	  case 'A':
	    printf ("(int) %smode", GET_MODE_NAME(m1));
	    break;
	  case 'B':
	    printf ("(int) %smode", GET_MODE_NAME(m2));
	    break;
	  case 'c':
	    printf ("%s", GET_RTX_NAME(op));
	    break;
	  case 'C':
	    printf ("(int) ");
	    for (np = GET_RTX_NAME(op); *np; np++)
	      putchar (TOUPPER (*np));
	    break;
	  }
    }

  printf (";\n");
}

extern int main PARAMS ((int, char **));

int
main (argc, argv)
     int argc;
     char **argv;
{
  rtx desc;

  progname = "genopinit";

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

  if (init_md_reader (argv[1]) != SUCCESS_EXIT_CODE)
    return (FATAL_EXIT_CODE);

  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-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)
    {
      int line_no, insn_code_number = 0;

      desc = read_md_rtx (&line_no, &insn_code_number);
      if (desc == NULL)
	break;

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

  printf ("}\n");

  fflush (stdout);
  return (ferror (stdout) != 0 ? FATAL_EXIT_CODE : SUCCESS_EXIT_CODE);
}

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