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

/* Generate code from machine description to perform peephole optimizations.
   Copyright (C) 1987, 89, 92, 97, 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

/* Define this so we can link with print-rtl.o to get debug_rtx function.  */
char **insn_name_ptr = 0;

/* While tree-walking an instruction pattern, we keep a chain
   of these `struct link's to record how to get down to the
   current position.  In each one, POS is the operand number,
   and if the operand is a vector VEC is the element number.
   VEC is -1 if the operand is not a vector.  */

struct link
{
  struct link *next;
  int pos;
  int vecelt;
};

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

static int max_opno;

/* Number of operands used in current peephole definition.  */

static int n_operands;

/* Peephole optimizations get insn codes just like insn patterns.
   Count them so we know the code of the define_peephole we are handling.  */

static int insn_code_number = 0;

static void gen_peephole PROTO((rtx));
static void match_rtx PROTO((rtx, struct link *, int));
static void print_path PROTO((struct link *));
static void print_code PROTO((RTX_CODE));
\f
static void
gen_peephole (peep)
     rtx peep;
{
  int ninsns = XVECLEN (peep, 0);
  int i;

  n_operands = 0;

  printf ("  insn = ins1;\n");
#if 0
  printf ("  want_jump = 0;\n");
#endif

  for (i = 0; i < ninsns; i++)
    {
      if (i > 0)
	{
	  printf ("  do { insn = NEXT_INSN (insn);\n");
	  printf ("       if (insn == 0) goto L%d; }\n",
		  insn_code_number);
	  printf ("  while (GET_CODE (insn) == NOTE\n");
	  printf ("\t || (GET_CODE (insn) == INSN\n");
	  printf ("\t     && (GET_CODE (PATTERN (insn)) == USE\n");
	  printf ("\t\t || GET_CODE (PATTERN (insn)) == CLOBBER)));\n");

	  printf ("  if (GET_CODE (insn) == CODE_LABEL\n\
      || GET_CODE (insn) == BARRIER)\n    goto L%d;\n",
  		  insn_code_number);
	}

#if 0
      printf ("  if (GET_CODE (insn) == JUMP_INSN)\n");
      printf ("    want_jump = JUMP_LABEL (insn);\n");
#endif

      printf ("  pat = PATTERN (insn);\n");

      /* Walk the insn's pattern, remembering at all times the path
	 down to the walking point.  */

      match_rtx (XVECEXP (peep, 0, i), NULL_PTR, insn_code_number);
    }

  /* We get this far if the pattern matches.
     Now test the extra condition.  */

  if (XSTR (peep, 1) && XSTR (peep, 1)[0])
    printf ("  if (! (%s)) goto L%d;\n",
	    XSTR (peep, 1), insn_code_number);

  /* If that matches, construct new pattern and put it in the first insn.
     This new pattern will never be matched.
     It exists only so that insn-extract can get the operands back.
     So use a simple regular form: a PARALLEL containing a vector
     of all the operands.  */

  printf ("  PATTERN (ins1) = gen_rtx_PARALLEL (VOIDmode, gen_rtvec_v (%d, operands));\n", n_operands);

#if 0
  printf ("  if (want_jump && GET_CODE (ins1) != JUMP_INSN)\n");
  printf ("    {\n");
  printf ("      rtx insn2 = emit_jump_insn_before (PATTERN (ins1), ins1);\n");
  printf ("      delete_insn (ins1);\n");
  printf ("      ins1 = ins2;\n");
  printf ("    }\n");
#endif

  /* Record this define_peephole's insn code in the insn,
     as if it had been recognized to match this.  */
  printf ("  INSN_CODE (ins1) = %d;\n",
	  insn_code_number);

  /* Delete the remaining insns.  */
  if (ninsns > 1)
    printf ("  delete_for_peephole (NEXT_INSN (ins1), insn);\n");

  /* See reload1.c for insertion of NOTE which guarantees that this
     cannot be zero.  */
  printf ("  return NEXT_INSN (insn);\n");

  printf (" L%d:\n\n", insn_code_number);
}
\f
static void
match_rtx (x, path, fail_label)
     rtx x;
     struct link *path;
     int fail_label;
{
  register RTX_CODE code;
  register int i;
  register int len;
  register const char *fmt;
  struct link link;

  if (x == 0)
    return;


  code = GET_CODE (x);

  switch (code)
    {
    case MATCH_OPERAND:
      if (XINT (x, 0) > max_opno)
	max_opno = XINT (x, 0);
      if (XINT (x, 0) >= n_operands)
	n_operands = 1 + XINT (x, 0);

      printf ("  x = ");
      print_path (path);
      printf (";\n");

      printf ("  operands[%d] = x;\n", XINT (x, 0));
      if (XSTR (x, 1) && XSTR (x, 1)[0])
	printf ("  if (! %s (x, %smode)) goto L%d;\n",
		XSTR (x, 1), GET_MODE_NAME (GET_MODE (x)), fail_label);
      return;

    case MATCH_DUP:
    case MATCH_PAR_DUP:
      printf ("  x = ");
      print_path (path);
      printf (";\n");

      printf ("  if (!rtx_equal_p (operands[%d], x)) goto L%d;\n",
	      XINT (x, 0), fail_label);
      return;

    case MATCH_OP_DUP:
      printf ("  x = ");
      print_path (path);
      printf (";\n");

      printf ("  if (GET_CODE (operands[%d]) != GET_CODE (x)\n", XINT (x, 0));
      printf ("      || GET_MODE (operands[%d]) != GET_MODE (x)) goto L%d;\n",
	      XINT (x, 0), fail_label);
      printf ("  operands[%d] = x;\n", XINT (x, 0));
      link.next = path;
      link.vecelt = -1;
      for (i = 0; i < XVECLEN (x, 1); i++)
	{
	  link.pos = i;
	  match_rtx (XVECEXP (x, 1, i), &link, fail_label);
	}
      return;

    case MATCH_OPERATOR:
      if (XINT (x, 0) > max_opno)
	max_opno = XINT (x, 0);
      if (XINT (x, 0) >= n_operands)
	n_operands = 1 + XINT (x, 0);

      printf ("  x = ");
      print_path (path);
      printf (";\n");

      printf ("  operands[%d] = x;\n", XINT (x, 0));
      if (XSTR (x, 1) && XSTR (x, 1)[0])
	printf ("  if (! %s (x, %smode)) goto L%d;\n",
		XSTR (x, 1), GET_MODE_NAME (GET_MODE (x)), fail_label);
      link.next = path;
      link.vecelt = -1;
      for (i = 0; i < XVECLEN (x, 2); i++)
	{
	  link.pos = i;
	  match_rtx (XVECEXP (x, 2, i), &link, fail_label);
	}
      return;

    case MATCH_PARALLEL:
      if (XINT (x, 0) > max_opno)
	max_opno = XINT (x, 0);
      if (XINT (x, 0) >= n_operands)
	n_operands = 1 + XINT (x, 0);

      printf ("  x = ");
      print_path (path);
      printf (";\n");

      printf ("  if (GET_CODE (x) != PARALLEL) goto L%d;\n", fail_label);
      printf ("  operands[%d] = x;\n", XINT (x, 0));
      if (XSTR (x, 1) && XSTR (x, 1)[0])
	printf ("  if (! %s (x, %smode)) goto L%d;\n",
		XSTR (x, 1), GET_MODE_NAME (GET_MODE (x)), fail_label);
      link.next = path;
      link.pos = 0;
      for (i = 0; i < XVECLEN (x, 2); i++)
	{
	  link.vecelt = i;
	  match_rtx (XVECEXP (x, 2, i), &link, fail_label);
	}
      return;

    case ADDRESS:
      match_rtx (XEXP (x, 0), path, fail_label);
      return;
      
    default:
      break;
    }

  printf ("  x = ");
  print_path (path);
  printf (";\n");

  printf ("  if (GET_CODE (x) != ");
  print_code (code);
  printf (") goto L%d;\n", fail_label);

  if (GET_MODE (x) != VOIDmode)
    {
      printf ("  if (GET_MODE (x) != %smode) goto L%d;\n",
	      GET_MODE_NAME (GET_MODE (x)), fail_label);
    }

  link.next = path;
  link.vecelt = -1;
  fmt = GET_RTX_FORMAT (code);
  len = GET_RTX_LENGTH (code);
  for (i = 0; i < len; i++)
    {
      link.pos = i;
      if (fmt[i] == 'e' || fmt[i] == 'u')
	match_rtx (XEXP (x, i), &link, fail_label);
      else if (fmt[i] == 'E')
	{
	  int j;
	  printf ("  if (XVECLEN (x, %d) != %d) goto L%d;\n",
		  i, XVECLEN (x, i), fail_label);
	  for (j = 0; j < XVECLEN (x, i); j++)
	    {
	      link.vecelt = j;
	      match_rtx (XVECEXP (x, i, j), &link, fail_label);
	    }
	}
      else if (fmt[i] == 'i')
	{
	  /* Make sure that at run time `x' is the RTX we want to test.  */
	  if (i != 0)
	    {
	      printf ("  x = ");
	      print_path (path);
	      printf (";\n");
	    }

	  printf ("  if (XINT (x, %d) != %d) goto L%d;\n",
		  i, XINT (x, i), fail_label);
	}
      else if (fmt[i] == 'w')
	{
	  /* Make sure that at run time `x' is the RTX we want to test.  */
	  if (i != 0)
	    {
	      printf ("  x = ");
	      print_path (path);
	      printf (";\n");
	    }

	  printf ("  if (XWINT (x, %d) != ", i);
	  printf (HOST_WIDE_INT_PRINT_DEC, XWINT (x, i));
	  printf (") goto L%d;\n", fail_label);
	}
      else if (fmt[i] == 's')
	{
	  /* Make sure that at run time `x' is the RTX we want to test.  */
	  if (i != 0)
	    {
	      printf ("  x = ");
	      print_path (path);
	      printf (";\n");
	    }

	  printf ("  if (strcmp (XSTR (x, %d), \"%s\")) goto L%d;\n",
		  i, XSTR (x, i), fail_label);
	}
    }
}

/* Given a PATH, representing a path down the instruction's
   pattern from the root to a certain point, output code to
   evaluate to the rtx at that point.  */

static void
print_path (path)
     struct link *path;
{
  if (path == 0)
    printf ("pat");
  else if (path->vecelt >= 0)
    {
      printf ("XVECEXP (");
      print_path (path->next);
      printf (", %d, %d)", path->pos, path->vecelt);
    }
  else
    {
      printf ("XEXP (");
      print_path (path->next);
      printf (", %d)", path->pos);
    }
}
\f
static void
print_code (code)
     RTX_CODE code;
{
  register const char *p1;
  for (p1 = GET_RTX_NAME (code); *p1; p1++)
    {
      if (*p1 >= 'a' && *p1 <= 'z')
	putchar (*p1 + 'A' - 'a');
      else
	putchar (*p1);
    }
}
\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, "genpeep: ");
  vfprintf (stderr, format, ap);
  va_end (ap);
  fprintf (stderr, "\n");
  exit (FATAL_EXIT_CODE);
}

/* More 'friendly' abort that prints the line and file.
   config.h can #define abort fancy_abort if you like that sort of thing.  */

void
fancy_abort ()
{
  fatal ("Internal gcc abort.");
}
\f
int
main (argc, argv)
     int argc;
     char **argv;
{
  rtx desc;
  FILE *infile;
  register int c;

  max_opno = -1;

  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 `genpeep'\n\
from the machine description file `md'.  */\n\n");

  printf ("#include \"config.h\"\n");
  printf ("#include \"system.h\"\n");
  printf ("#include \"insn-config.h\"\n");
  printf ("#include \"rtl.h\"\n");
  printf ("#include \"regs.h\"\n");
  printf ("#include \"output.h\"\n");
  printf ("#include \"real.h\"\n");
  printf ("#include \"recog.h\"\n");
  printf ("#include \"except.h\"\n\n");
  printf ("#include \"function.h\"\n\n");

  printf ("extern rtx peep_operand[];\n\n");
  printf ("#define operands peep_operand\n\n");

  printf ("rtx\npeephole (ins1)\n     rtx ins1;\n{\n");
  printf ("  rtx insn ATTRIBUTE_UNUSED, x ATTRIBUTE_UNUSED, pat ATTRIBUTE_UNUSED;\n\n");

  /* Early out: no peepholes for insns followed by barriers.  */
  printf ("  if (NEXT_INSN (ins1)\n");
  printf ("      && GET_CODE (NEXT_INSN (ins1)) == BARRIER)\n");
  printf ("    return 0;\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_PEEPHOLE)
	{
	  gen_peephole (desc);
	  insn_code_number++;
	}
      if (GET_CODE (desc) == DEFINE_INSN
	  || GET_CODE (desc) == DEFINE_EXPAND
	  || GET_CODE (desc) == DEFINE_SPLIT)
	{
	  insn_code_number++;
	}
    }

  printf ("  return 0;\n}\n\n");

  if (max_opno == -1)
    max_opno = 1;

  printf ("rtx peep_operand[%d];\n", max_opno + 1);

  fflush (stdout);
  exit (ferror (stdout) != 0 ? FATAL_EXIT_CODE : SUCCESS_EXIT_CODE);
  /* NOTREACHED */
  return 0;
}
Commit	Line	Data
32f30c53	1	/* Generate code from machine description to perform peephole optimizations.
34627ce6	2	Copyright (C) 1987, 89, 92, 97, 98, 1999 Free Software Foundation, Inc.
32f30c53 TW	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. */
32f30c53 TW	20
32f30c53 TW	21
20f92396	22	#include "hconfig.h"
0b93b64e	23	#include "system.h"
32f30c53 TW	24	#include "rtl.h"
	25	#include "obstack.h"
	26
	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
4db83042 MM	33	/* Define this so we can link with print-rtl.o to get debug_rtx function. */
	34	char **insn_name_ptr = 0;
	35
32f30c53 TW	36	/* While tree-walking an instruction pattern, we keep a chain
	37	of these `struct link's to record how to get down to the
	38	current position. In each one, POS is the operand number,
	39	and if the operand is a vector VEC is the element number.
	40	VEC is -1 if the operand is not a vector. */
	41
	42	struct link
	43	{
	44	struct link *next;
	45	int pos;
	46	int vecelt;
	47	};
	48
2a611d21	49	void fatal PVPROTO ((const char *, ...))
bf94d1ec KG	50	ATTRIBUTE_PRINTF_1 ATTRIBUTE_NORETURN;
bf94d1ec KG	51	void fancy_abort PROTO((void)) ATTRIBUTE_NORETURN;
32f30c53 TW	52
	53	static int max_opno;
	54
	55	/* Number of operands used in current peephole definition. */
	56
	57	static int n_operands;
	58
	59	/* Peephole optimizations get insn codes just like insn patterns.
	60	Count them so we know the code of the define_peephole we are handling. */
	61
	62	static int insn_code_number = 0;
	63
56c0e996 BS	64	static void gen_peephole PROTO((rtx));
56c0e996 BS	65	static void match_rtx PROTO((rtx, struct link *, int));
0b93b64e KG	66	static void print_path PROTO((struct link *));
0b93b64e KG	67	static void print_code PROTO((RTX_CODE));
32f30c53 TW	68	\f
	69	static void
	70	gen_peephole (peep)
	71	rtx peep;
	72	{
	73	int ninsns = XVECLEN (peep, 0);
	74	int i;
	75
	76	n_operands = 0;
	77
	78	printf (" insn = ins1;\n");
	79	#if 0
	80	printf (" want_jump = 0;\n");
	81	#endif
	82
	83	for (i = 0; i < ninsns; i++)
	84	{
	85	if (i > 0)
	86	{
	87	printf (" do { insn = NEXT_INSN (insn);\n");
	88	printf (" if (insn == 0) goto L%d; }\n",
	89	insn_code_number);
	90	printf (" while (GET_CODE (insn) == NOTE\n");
	91	printf ("\t \|\| (GET_CODE (insn) == INSN\n");
	92	printf ("\t && (GET_CODE (PATTERN (insn)) == USE\n");
	93	printf ("\t\t \|\| GET_CODE (PATTERN (insn)) == CLOBBER)));\n");
	94
	95	printf (" if (GET_CODE (insn) == CODE_LABEL\n\
	96	\|\| GET_CODE (insn) == BARRIER)\n goto L%d;\n",
	97	insn_code_number);
	98	}
	99
	100	#if 0
	101	printf (" if (GET_CODE (insn) == JUMP_INSN)\n");
	102	printf (" want_jump = JUMP_LABEL (insn);\n");
	103	#endif
	104
	105	printf (" pat = PATTERN (insn);\n");
	106
	107	/* Walk the insn's pattern, remembering at all times the path
	108	down to the walking point. */
	109
5f4f0e22	110	match_rtx (XVECEXP (peep, 0, i), NULL_PTR, insn_code_number);
32f30c53 TW	111	}
	112
	113	/* We get this far if the pattern matches.
	114	Now test the extra condition. */
	115
	116	if (XSTR (peep, 1) && XSTR (peep, 1)[0])
	117	printf (" if (! (%s)) goto L%d;\n",
	118	XSTR (peep, 1), insn_code_number);
	119
	120	/* If that matches, construct new pattern and put it in the first insn.
	121	This new pattern will never be matched.
	122	It exists only so that insn-extract can get the operands back.
	123	So use a simple regular form: a PARALLEL containing a vector
	124	of all the operands. */
	125
38a448ca	126	printf (" PATTERN (ins1) = gen_rtx_PARALLEL (VOIDmode, gen_rtvec_v (%d, operands));\n", n_operands);
32f30c53 TW	127
	128	#if 0
	129	printf (" if (want_jump && GET_CODE (ins1) != JUMP_INSN)\n");
	130	printf (" {\n");
	131	printf (" rtx insn2 = emit_jump_insn_before (PATTERN (ins1), ins1);\n");
	132	printf (" delete_insn (ins1);\n");
	133	printf (" ins1 = ins2;\n");
	134	printf (" }\n");
	135	#endif
	136
	137	/* Record this define_peephole's insn code in the insn,
	138	as if it had been recognized to match this. */
	139	printf (" INSN_CODE (ins1) = %d;\n",
	140	insn_code_number);
	141
	142	/* Delete the remaining insns. */
	143	if (ninsns > 1)
	144	printf (" delete_for_peephole (NEXT_INSN (ins1), insn);\n");
	145
	146	/* See reload1.c for insertion of NOTE which guarantees that this
	147	cannot be zero. */
	148	printf (" return NEXT_INSN (insn);\n");
	149
	150	printf (" L%d:\n\n", insn_code_number);
	151	}
	152	\f
	153	static void
	154	match_rtx (x, path, fail_label)
	155	rtx x;
	156	struct link *path;
	157	int fail_label;
	158	{
	159	register RTX_CODE code;
	160	register int i;
	161	register int len;
6f7d635c	162	register const char *fmt;
32f30c53 TW	163	struct link link;
	164
	165	if (x == 0)
	166	return;
	167
	168
	169	code = GET_CODE (x);
	170
	171	switch (code)
	172	{
	173	case MATCH_OPERAND:
	174	if (XINT (x, 0) > max_opno)
	175	max_opno = XINT (x, 0);
	176	if (XINT (x, 0) >= n_operands)
	177	n_operands = 1 + XINT (x, 0);
	178
	179	printf (" x = ");
	180	print_path (path);
	181	printf (";\n");
	182
	183	printf (" operands[%d] = x;\n", XINT (x, 0));
	184	if (XSTR (x, 1) && XSTR (x, 1)[0])
	185	printf (" if (! %s (x, %smode)) goto L%d;\n",
	186	XSTR (x, 1), GET_MODE_NAME (GET_MODE (x)), fail_label);
	187	return;
	188
	189	case MATCH_DUP:
693fb02f	190	case MATCH_PAR_DUP:
32f30c53 TW	191	printf (" x = ");
	192	print_path (path);
	193	printf (";\n");
	194
	195	printf (" if (!rtx_equal_p (operands[%d], x)) goto L%d;\n",
	196	XINT (x, 0), fail_label);
	197	return;
	198
	199	case MATCH_OP_DUP:
	200	printf (" x = ");
	201	print_path (path);
	202	printf (";\n");
	203
	204	printf (" if (GET_CODE (operands[%d]) != GET_CODE (x)\n", XINT (x, 0));
	205	printf (" \|\| GET_MODE (operands[%d]) != GET_MODE (x)) goto L%d;\n",
	206	XINT (x, 0), fail_label);
	207	printf (" operands[%d] = x;\n", XINT (x, 0));
	208	link.next = path;
	209	link.vecelt = -1;
	210	for (i = 0; i < XVECLEN (x, 1); i++)
	211	{
	212	link.pos = i;
	213	match_rtx (XVECEXP (x, 1, i), &link, fail_label);
	214	}
	215	return;
	216
	217	case MATCH_OPERATOR:
	218	if (XINT (x, 0) > max_opno)
	219	max_opno = XINT (x, 0);
	220	if (XINT (x, 0) >= n_operands)
	221	n_operands = 1 + XINT (x, 0);
	222
	223	printf (" x = ");
	224	print_path (path);
	225	printf (";\n");
	226
	227	printf (" operands[%d] = x;\n", XINT (x, 0));
	228	if (XSTR (x, 1) && XSTR (x, 1)[0])
	229	printf (" if (! %s (x, %smode)) goto L%d;\n",
	230	XSTR (x, 1), GET_MODE_NAME (GET_MODE (x)), fail_label);
	231	link.next = path;
	232	link.vecelt = -1;
	233	for (i = 0; i < XVECLEN (x, 2); i++)
	234	{
	235	link.pos = i;
	236	match_rtx (XVECEXP (x, 2, i), &link, fail_label);
	237	}
	238	return;
	239
	240	case MATCH_PARALLEL:
	241	if (XINT (x, 0) > max_opno)
	242	max_opno = XINT (x, 0);
	243	if (XINT (x, 0) >= n_operands)
	244	n_operands = 1 + XINT (x, 0);
	245
	246	printf (" x = ");
	247	print_path (path);
	248	printf (";\n");
	249
	250	printf (" if (GET_CODE (x) != PARALLEL) goto L%d;\n", fail_label);
	251	printf (" operands[%d] = x;\n", XINT (x, 0));
	252	if (XSTR (x, 1) && XSTR (x, 1)[0])
	253	printf (" if (! %s (x, %smode)) goto L%d;\n",
	254	XSTR (x, 1), GET_MODE_NAME (GET_MODE (x)), fail_label);
255	link.next = path;
256	link.pos = 0;
257	for (i = 0; i < XVECLEN (x, 2); i++)
258	{
259	link.vecelt = i;
260	match_rtx (XVECEXP (x, 2, i), &link, fail_label);
261	}
262	return;
263
264	case ADDRESS:
265	match_rtx (XEXP (x, 0), path, fail_label);
266	return;
38a448ca RH	267
	268	default:
	269	break;
32f30c53 TW	270	}
	271
	272	printf (" x = ");
	273	print_path (path);
	274	printf (";\n");
	275
	276	printf (" if (GET_CODE (x) != ");
	277	print_code (code);
	278	printf (") goto L%d;\n", fail_label);
	279
	280	if (GET_MODE (x) != VOIDmode)
	281	{
	282	printf (" if (GET_MODE (x) != %smode) goto L%d;\n",
	283	GET_MODE_NAME (GET_MODE (x)), fail_label);
	284	}
	285
	286	link.next = path;
	287	link.vecelt = -1;
	288	fmt = GET_RTX_FORMAT (code);
	289	len = GET_RTX_LENGTH (code);
	290	for (i = 0; i < len; i++)
	291	{
	292	link.pos = i;
	293	if (fmt[i] == 'e' \|\| fmt[i] == 'u')
	294	match_rtx (XEXP (x, i), &link, fail_label);
	295	else if (fmt[i] == 'E')
	296	{
	297	int j;
	298	printf (" if (XVECLEN (x, %d) != %d) goto L%d;\n",
	299	i, XVECLEN (x, i), fail_label);
4231508a	300	for (j = 0; j < XVECLEN (x, i); j++)
32f30c53 TW	301	{
	302	link.vecelt = j;
	303	match_rtx (XVECEXP (x, i, j), &link, fail_label);
	304	}
	305	}
	306	else if (fmt[i] == 'i')
	307	{
	308	/* Make sure that at run time `x' is the RTX we want to test. */
	309	if (i != 0)
	310	{
	311	printf (" x = ");
	312	print_path (path);
	313	printf (";\n");
	314	}
	315
	316	printf (" if (XINT (x, %d) != %d) goto L%d;\n",
	317	i, XINT (x, i), fail_label);
	318	}
52a5538b RS	319	else if (fmt[i] == 'w')
	320	{
	321	/* Make sure that at run time `x' is the RTX we want to test. */
	322	if (i != 0)
	323	{
	324	printf (" x = ");
	325	print_path (path);
	326	printf (";\n");
	327	}
	328
76d31c63 JL	329	printf (" if (XWINT (x, %d) != ", i);
	330	printf (HOST_WIDE_INT_PRINT_DEC, XWINT (x, i));
	331	printf (") goto L%d;\n", fail_label);
52a5538b	332	}
32f30c53 TW	333	else if (fmt[i] == 's')
	334	{
	335	/* Make sure that at run time `x' is the RTX we want to test. */
	336	if (i != 0)
	337	{
	338	printf (" x = ");
	339	print_path (path);
	340	printf (";\n");
	341	}
	342
	343	printf (" if (strcmp (XSTR (x, %d), \"%s\")) goto L%d;\n",
	344	i, XSTR (x, i), fail_label);
	345	}
	346	}
	347	}
	348
	349	/* Given a PATH, representing a path down the instruction's
	350	pattern from the root to a certain point, output code to
	351	evaluate to the rtx at that point. */
	352
	353	static void
	354	print_path (path)
	355	struct link *path;
	356	{
	357	if (path == 0)
	358	printf ("pat");
	359	else if (path->vecelt >= 0)
	360	{
	361	printf ("XVECEXP (");
	362	print_path (path->next);
	363	printf (", %d, %d)", path->pos, path->vecelt);
	364	}
	365	else
	366	{
	367	printf ("XEXP (");
	368	print_path (path->next);
	369	printf (", %d)", path->pos);
	370	}
	371	}
	372	\f
	373	static void
	374	print_code (code)
	375	RTX_CODE code;
	376	{
5f06c983	377	register const char *p1;
32f30c53 TW	378	for (p1 = GET_RTX_NAME (code); *p1; p1++)
	379	{
	380	if (p1 >= 'a' && p1 <= 'z')
	381	putchar (*p1 + 'A' - 'a');
	382	else
	383	putchar (*p1);
	384	}
	385	}
	386	\f
2778b98d	387	PTR
32f30c53	388	xmalloc (size)
2778b98d	389	size_t size;
32f30c53	390	{
2778b98d	391	register PTR val = (PTR) malloc (size);
32f30c53 TW	392
	393	if (val == 0)
	394	fatal ("virtual memory exhausted");
	395	return val;
	396	}
	397
2778b98d	398	PTR
470b68c0 RH	399	xrealloc (old, size)
470b68c0 RH	400	PTR old;
2778b98d	401	size_t size;
32f30c53	402	{
470b68c0	403	register PTR ptr;
09d83d25	404	if (old)
470b68c0 RH	405	ptr = (PTR) realloc (old, size);
	406	else
	407	ptr = (PTR) malloc (size);
	408	if (!ptr)
32f30c53	409	fatal ("virtual memory exhausted");
470b68c0	410	return ptr;
32f30c53 TW	411	}
32f30c53 TW	412
2a611d21	413	void
85fda1eb	414	fatal VPROTO ((const char *format, ...))
32f30c53	415	{
5148a72b	416	#ifndef ANSI_PROTOTYPES
85fda1eb	417	const char *format;
320e7c40 KG	418	#endif
	419	va_list ap;
	420
	421	VA_START (ap, format);
	422
5148a72b	423	#ifndef ANSI_PROTOTYPES
85fda1eb	424	format = va_arg (ap, const char *);
320e7c40 KG	425	#endif
320e7c40 KG	426
32f30c53	427	fprintf (stderr, "genpeep: ");
320e7c40 KG	428	vfprintf (stderr, format, ap);
320e7c40 KG	429	va_end (ap);
32f30c53 TW	430	fprintf (stderr, "\n");
	431	exit (FATAL_EXIT_CODE);
	432	}
	433
	434	/* More 'friendly' abort that prints the line and file.
	435	config.h can #define abort fancy_abort if you like that sort of thing. */
	436
	437	void
	438	fancy_abort ()
	439	{
	440	fatal ("Internal gcc abort.");
	441	}
	442	\f
	443	int
	444	main (argc, argv)
	445	int argc;
	446	char **argv;
	447	{
	448	rtx desc;
	449	FILE *infile;
32f30c53 TW	450	register int c;
	451
	452	max_opno = -1;
	453
	454	obstack_init (rtl_obstack);
	455
	456	if (argc <= 1)
	457	fatal ("No input file name.");
	458
	459	infile = fopen (argv[1], "r");
	460	if (infile == 0)
	461	{
	462	perror (argv[1]);
	463	exit (FATAL_EXIT_CODE);
	464	}
	465
	466	init_rtl ();
	467
	468	printf ("/* Generated automatically by the program `genpeep'\n\
	469	from the machine description file `md'. */\n\n");
	470
	471	printf ("#include \"config.h\"\n");
729da3f5	472	printf ("#include \"system.h\"\n");
7f7f8214	473	printf ("#include \"insn-config.h\"\n");
32f30c53 TW	474	printf ("#include \"rtl.h\"\n");
	475	printf ("#include \"regs.h\"\n");
	476	printf ("#include \"output.h\"\n");
41fe085f	477	printf ("#include \"real.h\"\n");
7f7f8214	478	printf ("#include \"recog.h\"\n");
41fe085f	479	printf ("#include \"except.h\"\n\n");
ad171e80	480	printf ("#include \"function.h\"\n\n");
32f30c53 TW	481
	482	printf ("extern rtx peep_operand[];\n\n");
	483	printf ("#define operands peep_operand\n\n");
	484
	485	printf ("rtx\npeephole (ins1)\n rtx ins1;\n{\n");
296433e1	486	printf (" rtx insn ATTRIBUTE_UNUSED, x ATTRIBUTE_UNUSED, pat ATTRIBUTE_UNUSED;\n\n");
32f30c53 TW	487
	488	/* Early out: no peepholes for insns followed by barriers. */
	489	printf (" if (NEXT_INSN (ins1)\n");
	490	printf (" && GET_CODE (NEXT_INSN (ins1)) == BARRIER)\n");
	491	printf (" return 0;\n\n");
	492
	493	/* Read the machine description. */
	494
	495	while (1)
	496	{
	497	c = read_skip_spaces (infile);
	498	if (c == EOF)
	499	break;
	500	ungetc (c, infile);
	501
	502	desc = read_rtx (infile);
	503	if (GET_CODE (desc) == DEFINE_PEEPHOLE)
	504	{
	505	gen_peephole (desc);
	506	insn_code_number++;
	507	}
	508	if (GET_CODE (desc) == DEFINE_INSN
	509	\|\| GET_CODE (desc) == DEFINE_EXPAND
	510	\|\| GET_CODE (desc) == DEFINE_SPLIT)
	511	{
	512	insn_code_number++;
	513	}
	514	}
	515
	516	printf (" return 0;\n}\n\n");
	517
	518	if (max_opno == -1)
	519	max_opno = 1;
	520
	521	printf ("rtx peep_operand[%d];\n", max_opno + 1);
	522
	523	fflush (stdout);
	524	exit (ferror (stdout) != 0 ? FATAL_EXIT_CODE : SUCCESS_EXIT_CODE);
	525	/* NOTREACHED */
	526	return 0;
	527	}