genmatch.c (decision_tree::gen_gimple): Split out large subtrees into separate functions.

2015-07-27  Richard Biener  <rguenther@suse.de>

	* genmatch.c (decision_tree::gen_gimple): Split out large
	subtrees into separate functions.
	(decision_tree::gen_generic): Likewise.

From-SVN: r226241

diff --git a/gcc/ChangeLog b/gcc/ChangeLog
index 10df3252b31c2bd866166d3c95f38864f3756a19..e0eb3a2ee6a65e523db7ed64edffede4badd892e 100644 (file)
--- a/gcc/ChangeLog
+++ b/gcc/ChangeLog
@@ -1,3 +1,9 @@
+2015-07-27  Richard Biener  <rguenther@suse.de>
+
+       * genmatch.c (decision_tree::gen_gimple): Split out large
+       subtrees into separate functions.
+       (decision_tree::gen_generic): Likewise.
+
 2015-07-26  Uros Bizjak  <ubizjak@gmail.com>
 
        * config/alpha/alpha.c: Use SUBREG_P predicate.

diff --git a/gcc/genmatch.c b/gcc/genmatch.c
index ce90a74a195e50e779fc26e98bed76b40c091d25..7ad00f26b213a80f2cdef80f622d66cbfc0e3b43 100644 (file)
--- a/gcc/genmatch.c
+++ b/gcc/genmatch.c
@@ -2951,6 +2951,32 @@ decision_tree::gen_gimple (FILE *f)
 
   for (unsigned n = 1; n <= 3; ++n)
     {
+      /* First generate split-out functions.  */
+      for (unsigned i = 0; i < root->kids.length (); i++)
+       {
+         dt_operand *dop = static_cast<dt_operand *>(root->kids[i]);
+         expr *e = static_cast<expr *>(dop->op);
+         if (e->ops.length () != n)
+           continue;
+
+         fprintf (f, "\nstatic bool\n"
+                  "gimple_simplify_%s (code_helper *res_code, tree *res_ops,\n"
+                  "                 gimple_seq *seq, tree (*valueize)(tree) "
+                  "ATTRIBUTE_UNUSED,\n"
+                  "                 code_helper ARG_UNUSED (code), tree "
+                  "ARG_UNUSED (type)\n",
+                  e->operation->id);
+         for (unsigned i = 0; i < n; ++i)
+           fprintf (f, ", tree op%d", i);
+         fprintf (f, ")\n");
+         fprintf (f, "{\n");
+         dop->gen_kids (f, 2, true);
+         fprintf (f, "  return false;\n");
+         fprintf (f, "}\n");
+       }
+
+      /* Then generate the main entry with the outermost switch and
+         tail-calls to the split-out functions.  */
       fprintf (f, "\nstatic bool\n"
               "gimple_simplify (code_helper *res_code, tree *res_ops,\n"
               "                 gimple_seq *seq, tree (*valueize)(tree),\n"
@@ -2976,10 +3002,11 @@ decision_tree::gen_gimple (FILE *f)
            fprintf (f, "    case %s%s:\n",
                     is_a <fn_id *> (e->operation) ? "-" : "",
                     e->operation->id);
-         fprintf (f,   "      {\n");
-         dop->gen_kids (f, 8, true);
-         fprintf (f,   "        break;\n");
-         fprintf (f,   "      }\n");
+         fprintf (f, "      return gimple_simplify_%s (res_code, res_ops, "
+                  "seq, valueize, code, type", e->operation->id);
+         for (unsigned i = 0; i < n; ++i)
+           fprintf (f, ", op%d", i);
+         fprintf (f, ");\n");
        }
       fprintf (f,       "    default:;\n"
                        "    }\n");
@@ -3003,6 +3030,34 @@ decision_tree::gen_generic (FILE *f)
 
   for (unsigned n = 1; n <= 3; ++n)
     {
+      /* First generate split-out functions.  */
+      for (unsigned i = 0; i < root->kids.length (); i++)
+       {
+         dt_operand *dop = static_cast<dt_operand *>(root->kids[i]);
+         expr *e = static_cast<expr *>(dop->op);
+         if (e->ops.length () != n
+             /* Builtin simplifications are somewhat premature on
+                GENERIC.  The following drops patterns with outermost
+                calls.  It's easy to emit overloads for function code
+                though if necessary.  */
+             || e->operation->kind != id_base::CODE)
+           continue;
+
+         fprintf (f, "\nstatic tree\n"
+                  "generic_simplify_%s (location_t ARG_UNUSED (loc), enum "
+                  "tree_code ARG_UNUSED (code), tree ARG_UNUSED (type)",
+                  e->operation->id);
+         for (unsigned i = 0; i < n; ++i)
+           fprintf (f, ", tree op%d", i);
+         fprintf (f, ")\n");
+         fprintf (f, "{\n");
+         dop->gen_kids (f, 2, false);
+         fprintf (f, "  return NULL_TREE;\n");
+         fprintf (f, "}\n");
+       }
+
+      /* Then generate the main entry with the outermost switch and
+         tail-calls to the split-out functions.  */
       fprintf (f, "\ntree\n"
               "generic_simplify (location_t loc, enum tree_code code, "
               "tree type ATTRIBUTE_UNUSED");
@@ -3030,10 +3085,11 @@ decision_tree::gen_generic (FILE *f)
            fprintf (f, "    CASE_CONVERT:\n");
          else
            fprintf (f, "    case %s:\n", e->operation->id);
-         fprintf (f,   "      {\n");
-         dop->gen_kids (f, 8, false);
-         fprintf (f,   "        break;\n"
-                       "      }\n");
+         fprintf (f, "      return generic_simplify_%s (loc, code, type",
+                  e->operation->id);
+         for (unsigned i = 0; i < n; ++i)
+           fprintf (f, ", op%d", i);
+         fprintf (f, ");\n");
        }
       fprintf (f, "    default:;\n"
                  "    }\n");