CbC/CbC_gcc: gcc/genemit.c comparison

comparison gcc/genemit.c @ 131:84e7813d76e9

gcc-8.2

author	mir3636
date	Thu, 25 Oct 2018 07:37:49 +0900
parents	04ced10e8804
children	1830386684a0

comparison

equal deleted inserted replaced

-:04ced10e8804
+:84e7813d76e9
 /* Generate code from machine description to emit insns as rtl.
-Copyright (C) 1987-2017 Free Software Foundation, Inc.
+Copyright (C) 1987-2018 Free Software Foundation, Inc.
 This file is part of GCC.
 GCC 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
 /* Print a C expression to construct an RTX just like X,
 substituting any operand references appearing within.  */
 static void
-gen_exp (rtx x, enum rtx_code subroutine_type, char *used)
+gen_exp (rtx x, enum rtx_code subroutine_type, char *used, md_rtx_info *info)
 {
 RTX_CODE code;
 int i;
 int len;
 const char *fmt;
 else
 	printf ("%smode", GET_MODE_NAME (GET_MODE (x)));
 for (i = 0; i < XVECLEN (x, 1); i++)
 	{
 	  printf (",\n\t\t");
-	  gen_exp (XVECEXP (x, 1, i), subroutine_type, used);
+	  gen_exp (XVECEXP (x, 1, i), subroutine_type, used, info);
 	}
 printf (")");
 return;
 case MATCH_OPERATOR:
 printf (" (GET_CODE (operand%d)", XINT (x, 0));
 printf (", %smode", GET_MODE_NAME (GET_MODE (x)));
 for (i = 0; i < XVECLEN (x, 2); i++)
 	{
 	  printf (",\n\t\t");
-	  gen_exp (XVECEXP (x, 2, i), subroutine_type, used);
+	  gen_exp (XVECEXP (x, 2, i), subroutine_type, used, info);
 	}
 printf (")");
 return;
 case MATCH_PARALLEL:
 printf ("simple_return_rtx");
 return;
 case CLOBBER:
 if (REG_P (XEXP (x, 0)))
 	{
-	  printf ("gen_hard_reg_clobber (%smode, %i)", GET_MODE_NAME (GET_MODE (XEXP (x, 0))),
+	  printf ("gen_hard_reg_clobber (%smode, %i)",
-			  			     REGNO (XEXP (x, 0)));
+		  GET_MODE_NAME (GET_MODE (XEXP (x, 0))),
+		  REGNO (XEXP (x, 0)));
 	  return;
 	}
 break;
+case CLOBBER_HIGH:
+if (!REG_P (XEXP (x, 0)))
+	error ("CLOBBER_HIGH argument is not a register expr, at %s:%d",
+	       info->loc.filename, info->loc.lineno);
+printf ("gen_hard_reg_clobber_high (%smode, %i)",
+	      GET_MODE_NAME (GET_MODE (XEXP (x, 0))),
+	      REGNO (XEXP (x, 0)));
+return;
+break;
 case CC0:
 printf ("cc0_rtx");
 return;
 case CONST_INT:
 	break;
 fputs (sep, stdout);
 switch (fmt[i])
 	{
 	case 'e': case 'u':
-	  gen_exp (XEXP (x, i), subroutine_type, used);
+	  gen_exp (XEXP (x, i), subroutine_type, used, info);
 	  break;
 	case 'i':
 	  printf ("%u", XINT (x, i));
 	  break;
 	case 'r':
 	  printf ("%u", REGNO (x));
+	  break;
+	case 'p':
+	  /* We don't have a way of parsing polynomial offsets yet,
+	     and hopefully never will.  */
+	  printf ("%d", SUBREG_BYTE (x).to_constant ());
 	  break;
 	case 's':
 	  printf ("\"%s\"", XSTR (x, i));
 	  break;
 	    int j;
 	    printf ("gen_rtvec (%d", XVECLEN (x, i));
 	    for (j = 0; j < XVECLEN (x, i); j++)
 	      {
 		printf (",\n\t\t");
-		gen_exp (XVECEXP (x, i, j), subroutine_type, used);
+		gen_exp (XVECEXP (x, i, j), subroutine_type, used, info);
 	      }
 	    printf (")");
 	    break;
 	  }
 /* Output code to emit the instruction patterns in VEC, with each element
 becoming a separate instruction.  USED is as for gen_exp.  */
 static void
-gen_emit_seq (rtvec vec, char *used)
+gen_emit_seq (rtvec vec, char *used, md_rtx_info *info)
 {
 for (int i = 0, len = GET_NUM_ELEM (vec); i < len; ++i)
 {
 bool last_p = (i == len - 1);
 rtx next = RTVEC_ELT (vec, i);
 if (const char *name = get_emit_function (next))
 	{
 	  printf ("  %s (", name);
-	  gen_exp (next, DEFINE_EXPAND, used);
+	  gen_exp (next, DEFINE_EXPAND, used, info);
 	  printf (");\n");
 	  if (!last_p && needs_barrier_p (next))
 	    printf ("  emit_barrier ();");
 	}
 else
 	{
 	  printf ("  emit (");
-	  gen_exp (next, DEFINE_EXPAND, used);
+	  gen_exp (next, DEFINE_EXPAND, used, info);
 	  printf (", %s);\n", last_p ? "false" : "true");
 	}
 }
 }
 {
 int has_hard_reg = 0;
 for (i = XVECLEN (insn, 1) - 1; i > 0; i--)
 	{
-	  if (GET_CODE (XVECEXP (insn, 1, i)) != CLOBBER)
+	  if (GET_CODE (XVECEXP (insn, 1, i)) != CLOBBER
+	      && GET_CODE (XVECEXP (insn, 1, i)) != CLOBBER_HIGH)
 	    break;
 	  if (REG_P (XEXP (XVECEXP (insn, 1, i), 0)))
 	    has_hard_reg = 1;
 	  else if (GET_CODE (XEXP (XVECEXP (insn, 1, i), 0)) != MATCH_SCRATCH)
 		  rtx new_rtx = XEXP (XVECEXP (insn, 1, j), 0);
 		  /* OLD and NEW_INSN are the same if both are to be a SCRATCH
 		     of the same mode,
 		     or if both are registers of the same mode and number.  */
-		  if (! (GET_MODE (old_rtx) == GET_MODE (new_rtx)
+		  if (! (GET_CODE (old_rtx) == GET_CODE (new_rtx)
+			 && GET_MODE (old_rtx) == GET_MODE (new_rtx)
 			 && ((GET_CODE (old_rtx) == MATCH_SCRATCH
 			      && GET_CODE (new_rtx) == MATCH_SCRATCH)
 			     || (REG_P (old_rtx) && REG_P (new_rtx)
 				 && REGNO (old_rtx) == REGNO (new_rtx)))))
 		    break;
 /* ??? This is the traditional behavior, but seems suspect.  */
 char *used = (XVECLEN (insn, 1) == 1
 		? NULL
 		: XCNEWVEC (char, stats.num_generator_args));
 printf ("  return ");
-gen_exp (pattern, DEFINE_INSN, used);
+gen_exp (pattern, DEFINE_INSN, used, info);
 printf (";\n}\n\n");
 XDELETEVEC (used);
 }
 /* Generate the `gen_...' function for a DEFINE_EXPAND.  */
 if ((XSTR (expand, 3) == 0 || *XSTR (expand, 3) == '\0')
 && stats.max_opno >= stats.max_dup_opno
 && XVECLEN (expand, 1) == 1)
 {
 printf ("  return ");
-gen_exp (XVECEXP (expand, 1, 0), DEFINE_EXPAND, NULL);
+gen_exp (XVECEXP (expand, 1, 0), DEFINE_EXPAND, NULL, info);
 printf (";\n}\n\n");
 return;
 }
 /* For each operand referred to only with MATCH_DUPs,
 	}
 printf ("  }\n");
 }
 used = XCNEWVEC (char, stats.num_operand_vars);
-gen_emit_seq (XVEC (expand, 1), used);
+gen_emit_seq (XVEC (expand, 1), used, info);
 XDELETEVEC (used);
 /* Call `get_insns' to extract the list of all the
 insns emitted within this gen_... function.  */
 {
 printf ("  operand%d = operands[%d];\n", i, i);
 printf ("  (void) operand%d;\n", i);
 }
-gen_emit_seq (XVEC (split, 2), used);
+gen_emit_seq (XVEC (split, 2), used, info);
 /* Call `get_insns' to make a list of all the
 insns emitted within this gen_... function.  */
 printf ("  _val = get_insns ();\n");
 /* Write a function, `add_clobbers', that is given a PARALLEL of sufficient
 size for the insn and an INSN_CODE, and inserts the required CLOBBERs at
 the end of the vector.  */
 static void
-output_add_clobbers (void)
+output_add_clobbers (md_rtx_info *info)
 {
 struct clobber_pat *clobber;
 struct clobber_ent *ent;
 int i;
 for (i = clobber->first_clobber; i < XVECLEN (clobber->pattern, 1); i++)
 	{
 	  printf ("      XVECEXP (pattern, 0, %d) = ", i);
 	  gen_exp (XVECEXP (clobber->pattern, 1, i),
-		   GET_CODE (clobber->pattern), NULL);
+		   GET_CODE (clobber->pattern), NULL, info);
 	  printf (";\n");
 	}
 printf ("      break;\n\n");
 }
 else if (GET_CODE (elt) != MATCH_DUP)
 	insn_nr++;
 }
 }
+/* Print "arg<N>" parameter declarations for each argument N of ONAME.  */
+static void
+print_overload_arguments (overloaded_name *oname)
+{
+for (unsigned int i = 0; i < oname->arg_types.length (); ++i)
+printf ("%s%s arg%d", i == 0 ? "" : ", ", oname->arg_types[i], i);
+}
+/* Print code to test whether INSTANCE should be chosen, given that
+argument N of the overload is available as "arg<N>".  */
+static void
+print_overload_test (overloaded_instance *instance)
+{
+for (unsigned int i = 0; i < instance->arg_values.length (); ++i)
+printf ("%sarg%d == %s", i == 0 ? "  if (" : "\n      && ",
+	    i, instance->arg_values[i]);
+printf (")\n");
+}
+/* Emit a maybe_code_for_* function for ONAME.  */
+static void
+handle_overloaded_code_for (overloaded_name *oname)
+{
+/* Print the function prototype.  */
+printf ("\ninsn_code\nmaybe_code_for_%s (", oname->name);
+print_overload_arguments (oname);
+printf (")\n{\n");
+/* Use a sequence of "if" statements for each instance.  */
+for (overloaded_instance *instance = oname->first_instance;
+instance; instance = instance->next)
+{
+print_overload_test (instance);
+printf ("    return CODE_FOR_%s;\n", instance->name);
+}
+/* Return null if no match was found.  */
+printf ("  return CODE_FOR_nothing;\n}\n");
+}
+/* Emit a maybe_gen_* function for ONAME.  */
+static void
+handle_overloaded_gen (overloaded_name *oname)
+{
+/* All patterns must have the same number of operands.  */
+pattern_stats stats;
+get_pattern_stats (&stats, XVEC (oname->first_instance->insn, 1));
+for (overloaded_instance *instance = oname->first_instance->next;
+instance; instance = instance->next)
+{
+pattern_stats stats2;
+get_pattern_stats (&stats2, XVEC (instance->insn, 1));
+if (stats.num_generator_args != stats2.num_generator_args)
+	fatal_at (get_file_location (instance->insn),
+		  "inconsistent number of operands for '%s'; "
+		  "this instance has %d, but previous instances had %d",
+		  oname->name, stats2.num_generator_args,
+		  stats.num_generator_args);
+}
+/* Print the function prototype.  */
+printf ("\nrtx\nmaybe_gen_%s (", oname->name);
+print_overload_arguments (oname);
+for (int i = 0; i < stats.num_generator_args; ++i)
+printf (", rtx x%d", i);
+printf (")\n{\n");
+/* Use maybe_code_for_*, instead of duplicating the selection logic here.  */
+printf ("  insn_code code = maybe_code_for_%s (", oname->name);
+for (unsigned int i = 0; i < oname->arg_types.length (); ++i)
+printf ("%sarg%d", i == 0 ? "" : ", ", i);
+printf (");\n"
+	  "  if (code != CODE_FOR_nothing)\n"
+	  "    return GEN_FCN (code) (");
+for (int i = 0; i < stats.num_generator_args; ++i)
+printf ("%sx%d", i == 0 ? "" : ", ", i);
+printf (");\n"
+	  "  else\n"
+	  "    return NULL_RTX;\n"
+	  "}\n");
+}
 int
 main (int argc, const char **argv)
 {
 progname = "genemit";
 in parallel with the tables in insn-output.c.  */
 printf ("/* Generated automatically by the program `genemit'\n\
 from the machine description file `md'.  */\n\n");
+printf ("#define IN_TARGET_CODE 1\n");
 printf ("#include \"config.h\"\n");
 printf ("#include \"system.h\"\n");
 printf ("#include \"coretypes.h\"\n");
 printf ("#include \"backend.h\"\n");
 printf ("#include \"predict.h\"\n");
 	break;
 }
 /* Write out the routines to add CLOBBERs to a pattern and say whether they
 clobber a hard reg.  */
-output_add_clobbers ();
+output_add_clobbers (&info);
 output_added_clobbers_hard_reg_p ();
+for (overloaded_name *oname = rtx_reader_ptr->get_overloads ();
+oname; oname = oname->next)
+{
+handle_overloaded_code_for (oname);
+handle_overloaded_gen (oname);
+}
 fflush (stdout);
 return (ferror (stdout) != 0 ? FATAL_EXIT_CODE : SUCCESS_EXIT_CODE);
 }

Mercurial > hg > CbC > CbC_gcc

comparison gcc/genemit.c @ 131:84e7813d76e9