From b21ce9ce3bc76be56a358bef9018f8a70f170450 Mon Sep 17 00:00:00 2001 From: Richard Biener Date: Thu, 30 Jul 2015 11:20:21 +0000 Subject: [PATCH] genmatch.c (decision_tree::gen_gimple): Merge with ... 2015-07-30 Richard Biener * genmatch.c (decision_tree::gen_gimple): Merge with ... (decision_tree::gen_generic): ... this into ... (decision_tree::gen): ... this. (main): Adjust callers. From-SVN: r226396 --- gcc/ChangeLog | 7 ++ gcc/genmatch.c | 175 ++++++++++++++++++------------------------------- 2 files changed, 70 insertions(+), 112 deletions(-) diff --git a/gcc/ChangeLog b/gcc/ChangeLog index cebfcdd53d0..dfb8ddf66ca 100644 --- a/gcc/ChangeLog +++ b/gcc/ChangeLog @@ -1,3 +1,10 @@ +2015-07-30 Richard Biener + + * genmatch.c (decision_tree::gen_gimple): Merge with ... + (decision_tree::gen_generic): ... this into ... + (decision_tree::gen): ... this. + (main): Adjust callers. + 2015-07-30 Richard Biener * genmatch.c (verbose): New global. diff --git a/gcc/genmatch.c b/gcc/genmatch.c index fc17840ea35..0579449a8ea 100644 --- a/gcc/genmatch.c +++ b/gcc/genmatch.c @@ -1310,8 +1310,7 @@ struct decision_tree dt_node *root; void insert (struct simplify *, unsigned); - void gen_gimple (FILE *f = stderr); - void gen_generic (FILE *f = stderr); + void gen (FILE *f, bool gimple); void print (FILE *f = stderr); decision_tree () { root = new dt_node (dt_node::DT_NODE); } @@ -2997,92 +2996,14 @@ dt_simplify::gen (FILE *f, int indent, bool gimple) tree. */ void -decision_tree::gen_gimple (FILE *f) +decision_tree::gen (FILE *f, bool gimple) { root->analyze (); - fprintf (stderr, "GIMPLE decision tree has %u leafs, maximum depth %u and " - "a total number of %u nodes\n", root->num_leafs, root->max_level, - root->total_size); - - 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(root->kids[i]); - expr *e = static_cast(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" - " code_helper code, tree type"); - for (unsigned i = 0; i < n; ++i) - fprintf (f, ", tree op%d", i); - fprintf (f, ")\n"); - fprintf (f, "{\n"); - - fprintf (f, " switch (code.get_rep())\n" - " {\n"); - for (unsigned i = 0; i < root->kids.length (); i++) - { - dt_operand *dop = static_cast(root->kids[i]); - expr *e = static_cast(dop->op); - if (e->ops.length () != n) - continue; - - if (*e->operation == CONVERT_EXPR - || *e->operation == NOP_EXPR) - fprintf (f, " CASE_CONVERT:\n"); - else - fprintf (f, " case %s%s:\n", - is_a (e->operation) ? "-" : "", - e->operation->id); - 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"); - - fprintf (f, " return false;\n"); - fprintf (f, "}\n"); - } -} - -/* Main entry to generate code for matching GENERIC IL off the decision - tree. */ - -void -decision_tree::gen_generic (FILE *f) -{ - root->analyze (); - - fprintf (stderr, "GENERIC decision tree has %u leafs, maximum depth %u and " - "a total number of %u nodes\n", root->num_leafs, root->max_level, - root->total_size); + fprintf (stderr, "%s decision tree has %u leafs, maximum depth %u and " + "a total number of %u nodes\n", + gimple ? "GIMPLE" : "GENERIC", + root->num_leafs, root->max_level, root->total_size); for (unsigned n = 1; n <= 3; ++n) { @@ -3093,64 +3014,97 @@ decision_tree::gen_generic (FILE *f) expr *e = static_cast(dop->op); if (e->ops.length () != n /* Builtin simplifications are somewhat premature on - GENERIC. The following drops patterns with outermost + 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) + || (!gimple + && 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); + if (gimple) + 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); + else + 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"); + dop->gen_kids (f, 2, gimple); + if (gimple) + fprintf (f, " return false;\n"); + else + 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"); + if (gimple) + fprintf (f, "\nstatic bool\n" + "gimple_simplify (code_helper *res_code, tree *res_ops,\n" + " gimple_seq *seq, tree (*valueize)(tree),\n" + " code_helper code, tree type"); + else + fprintf (f, "\ntree\n" + "generic_simplify (location_t loc, enum tree_code code, " + "tree type ATTRIBUTE_UNUSED"); for (unsigned i = 0; i < n; ++i) fprintf (f, ", tree op%d", i); fprintf (f, ")\n"); fprintf (f, "{\n"); - fprintf (f, " switch (code)\n" - " {\n"); + if (gimple) + fprintf (f, " switch (code.get_rep())\n" + " {\n"); + else + fprintf (f, " switch (code)\n" + " {\n"); for (unsigned i = 0; i < root->kids.length (); i++) { dt_operand *dop = static_cast(root->kids[i]); expr *e = static_cast(dop->op); if (e->ops.length () != n /* Builtin simplifications are somewhat premature on - GENERIC. The following drops patterns with outermost + 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) + || (!gimple + && e->operation->kind != id_base::CODE)) continue; - operator_id *op_id = static_cast (e->operation); - if (op_id->code == NOP_EXPR || op_id->code == CONVERT_EXPR) + if (*e->operation == CONVERT_EXPR + || *e->operation == NOP_EXPR) fprintf (f, " CASE_CONVERT:\n"); else - fprintf (f, " case %s:\n", e->operation->id); - fprintf (f, " return generic_simplify_%s (loc, code, type", - e->operation->id); + fprintf (f, " case %s%s:\n", + is_a (e->operation) ? "-" : "", + e->operation->id); + if (gimple) + fprintf (f, " return gimple_simplify_%s (res_code, res_ops, " + "seq, valueize, code, type", e->operation->id); + else + 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"); + fprintf (f, " default:;\n" + " }\n"); - fprintf (f, " return NULL_TREE;\n"); + if (gimple) + fprintf (f, " return false;\n"); + else + fprintf (f, " return NULL_TREE;\n"); fprintf (f, "}\n"); } } @@ -4317,10 +4271,7 @@ add_operator (VIEW_CONVERT2, "VIEW_CONVERT2", "tcc_unary", 1); if (verbose == 2) dt.print (stderr); - if (gimple) - dt.gen_gimple (stdout); - else - dt.gen_generic (stdout); + dt.gen (stdout, gimple); /* Finalize. */ cpp_finish (r, NULL); -- 2.30.2