RFA: Make classify_insn available to the generators
diff mbox

Message ID 87381w3p88.fsf@googlemail.com
State New
Headers show

Commit Message

Richard Sandiford June 13, 2015, 9:57 a.m. UTC
gen_expand and gen_split have some fairly complex tests that really just
repeat what's in classify_insn.  This patch moves classify_insn to rtl.c,
so that it's available to the generators.  It also adds a generator-specific
UNKNOWN return code for cases where we need to choose at (GCC) runtime.

This is preparing for a patch series that I'll post about soon.

Bootstrapped & regression-tested on x86_64-linux-gnu.  Also tested
with config-list.mk.  OK for the rtl bits?

The test for whether a barrier is needed seems a little weak: what
about indirect jumps, jumps with match_operand sources, or jumps in
PARALLELs?  That for another day though.  At least this patch means
we'll only have to update one place rather than two.

Thanks,
Richard


gcc/
	* rtl.h (classify_insn): Declare.
	* emit-rtl.c (classify_insn): Move to...
	* rtl.c: ...here and add generator support.
	* gensupport.h (get_emit_function, needs_barrier_p): Declare.
	* gensupport.c (get_emit_function, needs_barrier_p): New functions.
	* genemit.c (gen_emit_seq): New function.
	(gen_expand, gen_split): Use it.

Comments

Eric Botcazou June 13, 2015, 10:25 a.m. UTC | #1
> gen_expand and gen_split have some fairly complex tests that really just
> repeat what's in classify_insn.  This patch moves classify_insn to rtl.c,
> so that it's available to the generators.  It also adds a generator-specific
> UNKNOWN return code for cases where we need to choose at (GCC) runtime.
> 
> This is preparing for a patch series that I'll post about soon.
> 
> Bootstrapped & regression-tested on x86_64-linux-gnu.  Also tested
> with config-list.mk.  OK for the rtl bits?

Sure.

> The test for whether a barrier is needed seems a little weak: what
> about indirect jumps, jumps with match_operand sources, or jumps in
> PARALLELs?  That for another day though.  At least this patch means
> we'll only have to update one place rather than two.

Agreed.

Patch
diff mbox

Index: gcc/rtl.h
===================================================================
--- gcc/rtl.h	2015-06-13 10:37:47.781963830 +0100
+++ gcc/rtl.h	2015-06-13 10:38:55.640981540 +0100
@@ -2665,6 +2665,7 @@  extern rtvec rtvec_alloc (int);
 extern rtvec shallow_copy_rtvec (rtvec);
 extern bool shared_const_p (const_rtx);
 extern rtx copy_rtx (rtx);
+extern enum rtx_code classify_insn (rtx);
 extern void dump_rtx_statistics (void);
 
 /* In emit-rtl.c */
Index: gcc/emit-rtl.c
===================================================================
--- gcc/emit-rtl.c	2015-06-13 10:37:47.781963830 +0100
+++ gcc/emit-rtl.c	2015-06-13 10:38:55.638981628 +0100
@@ -5309,43 +5309,6 @@  set_dst_reg_note (rtx insn, enum reg_not
   return NULL_RTX;
 }
 
-/* Return an indication of which type of insn should have X as a body.
-   The value is CODE_LABEL, INSN, CALL_INSN or JUMP_INSN.  */
-
-static enum rtx_code
-classify_insn (rtx x)
-{
-  if (LABEL_P (x))
-    return CODE_LABEL;
-  if (GET_CODE (x) == CALL)
-    return CALL_INSN;
-  if (ANY_RETURN_P (x))
-    return JUMP_INSN;
-  if (GET_CODE (x) == SET)
-    {
-      if (SET_DEST (x) == pc_rtx)
-	return JUMP_INSN;
-      else if (GET_CODE (SET_SRC (x)) == CALL)
-	return CALL_INSN;
-      else
-	return INSN;
-    }
-  if (GET_CODE (x) == PARALLEL)
-    {
-      int j;
-      for (j = XVECLEN (x, 0) - 1; j >= 0; j--)
-	if (GET_CODE (XVECEXP (x, 0, j)) == CALL)
-	  return CALL_INSN;
-	else if (GET_CODE (XVECEXP (x, 0, j)) == SET
-		 && SET_DEST (XVECEXP (x, 0, j)) == pc_rtx)
-	  return JUMP_INSN;
-	else if (GET_CODE (XVECEXP (x, 0, j)) == SET
-		 && GET_CODE (SET_SRC (XVECEXP (x, 0, j))) == CALL)
-	  return CALL_INSN;
-    }
-  return INSN;
-}
-
 /* Emit the rtl pattern X as an appropriate kind of insn.
    If X is a label, it is simply added into the insn chain.  */
 
Index: gcc/rtl.c
===================================================================
--- gcc/rtl.c	2015-06-13 10:37:47.781963830 +0100
+++ gcc/rtl.c	2015-06-13 10:38:55.639981584 +0100
@@ -658,6 +658,54 @@  rtx_equal_p (const_rtx x, const_rtx y)
   return 1;
 }
 
+/* Return an indication of which type of insn should have X as a body.
+   In generator files, this can be UNKNOWN if the answer is only known
+   at (GCC) runtime.  Otherwise the value is CODE_LABEL, INSN, CALL_INSN
+   or JUMP_INSN.  */
+
+enum rtx_code
+classify_insn (rtx x)
+{
+  if (LABEL_P (x))
+    return CODE_LABEL;
+  if (GET_CODE (x) == CALL)
+    return CALL_INSN;
+  if (ANY_RETURN_P (x))
+    return JUMP_INSN;
+  if (GET_CODE (x) == SET)
+    {
+      if (GET_CODE (SET_DEST (x)) == PC)
+	return JUMP_INSN;
+      else if (GET_CODE (SET_SRC (x)) == CALL)
+	return CALL_INSN;
+      else
+	return INSN;
+    }
+  if (GET_CODE (x) == PARALLEL)
+    {
+      int j;
+      for (j = XVECLEN (x, 0) - 1; j >= 0; j--)
+	if (GET_CODE (XVECEXP (x, 0, j)) == CALL)
+	  return CALL_INSN;
+	else if (GET_CODE (XVECEXP (x, 0, j)) == SET
+		 && GET_CODE (SET_DEST (XVECEXP (x, 0, j))) == PC)
+	  return JUMP_INSN;
+	else if (GET_CODE (XVECEXP (x, 0, j)) == SET
+		 && GET_CODE (SET_SRC (XVECEXP (x, 0, j))) == CALL)
+	  return CALL_INSN;
+    }
+#ifdef GENERATOR_FILE
+  if (GET_CODE (x) == MATCH_OPERAND
+      || GET_CODE (x) == MATCH_OPERATOR
+      || GET_CODE (x) == MATCH_PARALLEL
+      || GET_CODE (x) == MATCH_OP_DUP
+      || GET_CODE (x) == MATCH_DUP
+      || GET_CODE (x) == PARALLEL)
+    return UNKNOWN;
+#endif
+  return INSN;
+}
+
 void
 dump_rtx_statistics (void)
 {
Index: gcc/gensupport.h
===================================================================
--- gcc/gensupport.h	2015-06-13 10:38:52.370125288 +0100
+++ gcc/gensupport.h	2015-06-13 10:38:55.639981584 +0100
@@ -111,5 +111,7 @@  struct pattern_stats
 
 extern void get_pattern_stats (struct pattern_stats *ranges, rtvec vec);
 extern void compute_test_codes (rtx, int, char *);
+extern const char *get_emit_function (rtx);
+extern bool needs_barrier_p (rtx);
 
 #endif /* GCC_GENSUPPORT_H */
Index: gcc/gensupport.c
===================================================================
--- gcc/gensupport.c	2015-06-13 10:38:52.370125288 +0100
+++ gcc/gensupport.c	2015-06-13 10:38:55.639981584 +0100
@@ -2983,3 +2983,37 @@  get_pattern_stats (struct pattern_stats
 				  MAX (stats->max_dup_opno,
 				       stats->max_scratch_opno)) + 1;
 }
+
+/* Return the emit_* function that should be used for pattern X.  */
+
+const char *
+get_emit_function (rtx x)
+{
+  switch (classify_insn (x))
+    {
+    case INSN:
+      return "emit_insn";
+
+    case CALL_INSN:
+      return "emit_call_insn";
+
+    case JUMP_INSN:
+      return "emit_jump_insn";
+
+    case UNKNOWN:
+      return "emit";
+
+    default:
+      gcc_unreachable ();
+    }
+}
+
+/* Return true if we must emit a barrier after pattern X.  */
+
+bool
+needs_barrier_p (rtx x)
+{
+  return (GET_CODE (x) == SET
+	  && GET_CODE (SET_DEST (x)) == PC
+	  && GET_CODE (SET_SRC (x)) == LABEL_REF);
+}
Index: gcc/genemit.c
===================================================================
--- gcc/genemit.c	2015-06-13 10:38:52.369125332 +0100
+++ gcc/genemit.c	2015-06-13 10:38:55.639981584 +0100
@@ -268,6 +268,23 @@  gen_exp (rtx x, enum rtx_code subroutine
     }
   printf (")");
 }
+
+/* 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)
+{
+  for (int i = 0, len = GET_NUM_ELEM (vec); i < len; ++i)
+    {
+      rtx next = RTVEC_ELT (vec, i);
+      printf ("  %s (", get_emit_function (next));
+      gen_exp (next, DEFINE_EXPAND, used);
+      printf (");\n");
+      if (needs_barrier_p (next))
+	printf ("  emit_barrier ();");
+    }
+}
 
 /* Generate the `gen_...' function for a DEFINE_INSN.  */
 
@@ -475,49 +492,8 @@  gen_expand (rtx expand)
       printf ("  }\n");
     }
 
-  /* Output code to construct the rtl for the instruction bodies.
-     Use emit_insn to add them to the sequence being accumulated.
-     But don't do this if the user's code has set `no_more' nonzero.  */
-
   used = XCNEWVEC (char, stats.num_operand_vars);
-
-  for (i = 0; i < XVECLEN (expand, 1); i++)
-    {
-      rtx next = XVECEXP (expand, 1, i);
-      if ((GET_CODE (next) == SET && GET_CODE (SET_DEST (next)) == PC)
-	  || (GET_CODE (next) == PARALLEL
-	      && ((GET_CODE (XVECEXP (next, 0, 0)) == SET
-		   && GET_CODE (SET_DEST (XVECEXP (next, 0, 0))) == PC)
-		  || ANY_RETURN_P (XVECEXP (next, 0, 0))))
-	  || ANY_RETURN_P (next))
-	printf ("  emit_jump_insn (");
-      else if ((GET_CODE (next) == SET && GET_CODE (SET_SRC (next)) == CALL)
-	       || GET_CODE (next) == CALL
-	       || (GET_CODE (next) == PARALLEL
-		   && GET_CODE (XVECEXP (next, 0, 0)) == SET
-		   && GET_CODE (SET_SRC (XVECEXP (next, 0, 0))) == CALL)
-	       || (GET_CODE (next) == PARALLEL
-		   && GET_CODE (XVECEXP (next, 0, 0)) == CALL))
-	printf ("  emit_call_insn (");
-      else if (LABEL_P (next))
-	printf ("  emit_label (");
-      else if (GET_CODE (next) == MATCH_OPERAND
-	       || GET_CODE (next) == MATCH_DUP
-	       || GET_CODE (next) == MATCH_OPERATOR
-	       || GET_CODE (next) == MATCH_OP_DUP
-	       || GET_CODE (next) == MATCH_PARALLEL
-	       || GET_CODE (next) == MATCH_PAR_DUP
-	       || GET_CODE (next) == PARALLEL)
-	printf ("  emit (");
-      else
-	printf ("  emit_insn (");
-      gen_exp (next, DEFINE_EXPAND, used);
-      printf (");\n");
-      if (GET_CODE (next) == SET && GET_CODE (SET_DEST (next)) == PC
-	  && GET_CODE (SET_SRC (next)) == LABEL_REF)
-	printf ("  emit_barrier ();");
-    }
-
+  gen_emit_seq (XVEC (expand, 1), used);
   XDELETEVEC (used);
 
   /* Call `get_insns' to extract the list of all the
@@ -601,44 +577,7 @@  gen_split (rtx split)
       printf ("  (void) operand%d;\n", i);
     }
 
-  /* Output code to construct the rtl for the instruction bodies.
-     Use emit_insn to add them to the sequence being accumulated.
-     But don't do this if the user's code has set `no_more' nonzero.  */
-
-  for (i = 0; i < XVECLEN (split, 2); i++)
-    {
-      rtx next = XVECEXP (split, 2, i);
-      if ((GET_CODE (next) == SET && GET_CODE (SET_DEST (next)) == PC)
-	  || (GET_CODE (next) == PARALLEL
-	      && GET_CODE (XVECEXP (next, 0, 0)) == SET
-	      && GET_CODE (SET_DEST (XVECEXP (next, 0, 0))) == PC)
-	  || ANY_RETURN_P (next))
-	printf ("  emit_jump_insn (");
-      else if ((GET_CODE (next) == SET && GET_CODE (SET_SRC (next)) == CALL)
-	       || GET_CODE (next) == CALL
-	       || (GET_CODE (next) == PARALLEL
-		   && GET_CODE (XVECEXP (next, 0, 0)) == SET
-		   && GET_CODE (SET_SRC (XVECEXP (next, 0, 0))) == CALL)
-	       || (GET_CODE (next) == PARALLEL
-		   && GET_CODE (XVECEXP (next, 0, 0)) == CALL))
-	printf ("  emit_call_insn (");
-      else if (LABEL_P (next))
-	printf ("  emit_label (");
-      else if (GET_CODE (next) == MATCH_OPERAND
-	       || GET_CODE (next) == MATCH_OPERATOR
-	       || GET_CODE (next) == MATCH_PARALLEL
-	       || GET_CODE (next) == MATCH_OP_DUP
-	       || GET_CODE (next) == MATCH_DUP
-	       || GET_CODE (next) == PARALLEL)
-	printf ("  emit (");
-      else
-	printf ("  emit_insn (");
-      gen_exp (next, GET_CODE (split), used);
-      printf (");\n");
-      if (GET_CODE (next) == SET && GET_CODE (SET_DEST (next)) == PC
-	  && GET_CODE (SET_SRC (next)) == LABEL_REF)
-	printf ("  emit_barrier ();");
-    }
+  gen_emit_seq (XVEC (split, 2), used);
 
   /* Call `get_insns' to make a list of all the
      insns emitted within this gen_... function.  */