On 09/03/2018 02:54 PM, Martin Liška wrote:
> On 09/03/2018 02:41 PM, Richard Biener wrote:
>> On Mon, 3 Sep 2018, Martin Liška wrote:
>>
>>> On 04/25/2018 01:42 PM, Richard Biener wrote:
>>>>
>>>> The following patch^Whack splits $subject files into three, one
>>>> for the predicates (due to an implementation detail) and two for
>>>> the rest - for now into similar LOC size files.
>>>>
>>>> I'd like to get help on the makefile changes to make them less
>>>> verbose, somehow globbing the -[12p] parts.
>>>>
>>>> Also you can see the split point is manually chosen which means
>>>> it will bitrot. Timings for the stage2 compiles on a x86_64
>>>> box are
>>>>
>>>> gimple-match-p.c 5s
>>>> generic-match-p.c 3s
>>>> gimple-match-1.c 85s
>>>> generic-match-1.c 56s
>>>> gimple-match-2.c 82s
>>>> generic-match-2.c 31s
>>>>
>>>> the required header files are quite big (and of course everything
>>>> needs to be exported without the analysis work becoming too cumbersome),
>>>> it's 3342 LOC for gimple-match-head.h and 1556 LOC for
>>>> generic-match-head.h
>>>>
>>>> The machine I tested is quite fast so the 80ish second timings are still
>>>> too slow I guess and thus splitting up into four files for gimple and
>>>> three files for generic looks better.
>>>>
>>>> Note we lose some inlining/cloning capability in the splitting process
>>>> (I see quite a bit of constprop/isra work being done on the generated
>>>> files). I didn't try to measure the runtime impact though.
>>>>
>>>> The patch still needs quite some TLC, it really is a bit hacky but I'd
>>>> like to get feedback on the approach and I didn't want to spend time
>>>> on programatically finding optimal split points (so everything is output
>>>> in the same semi-random order as before).
>>>>
>>>> Richard.
>>>>
>>>> <insert ChangeLog here>
>>>>
>>>> Index: gcc/genmatch.c
>>>> ===================================================================
>>>> --- gcc/genmatch.c (revision 259638)
>>>> +++ gcc/genmatch.c (working copy)
>>>> @@ -1641,7 +1641,7 @@ struct decision_tree
>>>> dt_node *root;
>>>>
>>>> void insert (struct simplify *, unsigned);
>>>> - void gen (FILE *f, bool gimple);
>>>> + void gen (const char *, FILE *, vec<unsigned long> &, bool gimple);
>>>> void print (FILE *f = stderr);
>>>>
>>>> decision_tree () { root = new dt_node (dt_node::DT_NODE, NULL); }
>>>> @@ -3608,12 +3608,25 @@ sinfo_hashmap_traits::equal_keys (const
>>>> return compare_op (v->s->result, v->s, candidate->s->result,
>>>> candidate->s);
>>>> }
>>>>
>>>> +/* Write the common header for the GIMPLE/GENERIC IL matching routines.
>>>> */
>>>> +
>>>> +static void
>>>> +write_header (FILE *f, bool gimple)
>>>> +{
>>>> + fprintf (f, "/* Generated automatically by the program `genmatch'
>>>> from\n");
>>>> + fprintf (f, " a IL pattern matching and simplification description.
>>>> */\n");
>>>> +
>>>> + /* Include the header instead of writing it awkwardly quoted here. */
>>>> + fprintf (f, "\n#include \"%s-match-head.c\"\n",
>>>> + gimple ? "gimple" : "generic");
>>>> +}
>>>>
>>>> /* Main entry to generate code for matching GIMPLE IL off the decision
>>>> tree. */
>>>>
>>>> void
>>>> -decision_tree::gen (FILE *f, bool gimple)
>>>> +decision_tree::gen (const char *output, FILE *headerf,
>>>> + vec<unsigned long> &pieces, bool gimple)
>>>> {
>>>> sinfo_map_t si;
>>>>
>>>> @@ -3624,6 +3637,34 @@ decision_tree::gen (FILE *f, bool gimple
>>>> gimple ? "GIMPLE" : "GENERIC",
>>>> root->num_leafs, root->max_level, root->total_size);
>>>>
>>>> + FILE *f;
>>>> + char *outputtem = NULL;
>>>> + if (output)
>>>> + outputtem = XNEWVEC (char, strlen (output) + strlen ("-1.c") + 1);
>>>> +
>>>> + unsigned do_header = headerf ? 2 : 1;
>>>> + unsigned n_per_part = -1U;
>>>> + unsigned file_n = output ? 1 : 2;
>>>> + do
>>>> + {
>>>> + unsigned n_fn = 0;
>>>> + do_header--;
>>>> +
>>>> + if (do_header)
>>>> + f = headerf;
>>>> + else if (!output)
>>>> + f = stdout;
>>>> + else
>>>> + {
>>>> + sprintf (outputtem, "%s-%d.c", output, file_n++);
>>>> + f = fopen (outputtem, "w");
>>>> + if (!f)
>>>> + {
>>>> + perror ("failed to open output file");
>>>> + exit(1);
>>>> + }
>>>> + write_header (f, gimple);
>>>> + }
>>>> /* First split out the transform part of equal leafs. */
>>>> unsigned rcnt = 0;
>>>> unsigned fcnt = 1;
>>>> @@ -3643,21 +3684,22 @@ decision_tree::gen (FILE *f, bool gimple
>>>> }
>>>>
>>>> /* Generate a split out function with the leaf transform code. */
>>>> + if (do_header || !output)
>>>> s->fname = xasprintf ("%s_simplify_%u", gimple ? "gimple" :
>>>> "generic",
>>>> fcnt++);
>>>> if (gimple)
>>>> - fprintf (f, "\nstatic bool\n"
>>>> + fprintf (f, "\n%sbool\n"
>>>> "%s (code_helper *res_code, tree *res_ops,\n"
>>>> " gimple_seq *seq, tree (*valueize)(tree) "
>>>> "ATTRIBUTE_UNUSED,\n"
>>>> " const tree ARG_UNUSED (type), tree
>>>> *ARG_UNUSED "
>>>> "(captures)\n",
>>>> - s->fname);
>>>> + headerf ? "" : "static ", s->fname);
>>>> else
>>>> {
>>>> - fprintf (f, "\nstatic tree\n"
>>>> + fprintf (f, "\n%stree\n"
>>>> "%s (location_t ARG_UNUSED (loc), const tree ARG_UNUSED
>>>> (type),\n",
>>>> - (*iter).second->fname);
>>>> + headerf ? "" : "static ", (*iter).second->fname);
>>>> for (unsigned i = 0;
>>>> i < as_a <expr *>(s->s->s->match)->ops.length (); ++i)
>>>> fprintf (f, " tree ARG_UNUSED (op%d),", i);
>>>> @@ -3674,7 +3716,12 @@ decision_tree::gen (FILE *f, bool gimple
>>>> fprintf (f, ", const combined_fn ARG_UNUSED (%s)",
>>>> s->s->s->for_subst_vec[i].first->id);
>>>> }
>>>> -
>>>> + n_fn++;
>>>> + if (do_header)
>>>> + {
>>>> + fprintf (f, ");\n");
>>>> + continue;
>>>> + }
>>>> fprintf (f, ")\n{\n");
>>>> s->s->gen_1 (f, 2, gimple, s->s->s->result);
>>>> if (gimple)
>>>> @@ -3682,7 +3729,22 @@ decision_tree::gen (FILE *f, bool gimple
>>>> else
>>>> fprintf (f, " return NULL_TREE;\n");
>>>> fprintf (f, "}\n");
>>>> +
>>>> + if (n_fn == pieces[file_n - 2])
>>>> + {
>>>> + fclose (f);
>>>> + sprintf (outputtem, "%s-%d.c", output, file_n++);
>>>> + f = fopen (outputtem, "w");
>>>> + if (!f)
>>>> + {
>>>> + perror ("failed to open output file");
>>>> + exit(1);
>>>> + }
>>>> + write_header (f, gimple);
>>>> + n_fn = 0;
>>>> + }
>>>> }
>>>> + if (!do_header)
>>>> fprintf (stderr, "removed %u duplicate tails\n", rcnt);
>>>>
>>>> for (unsigned n = 1; n <= 3; ++n)
>>>> @@ -3702,20 +3764,26 @@ decision_tree::gen (FILE *f, bool gimple
>>>> continue;
>>>>
>>>> if (gimple)
>>>> - fprintf (f, "\nstatic bool\n"
>>>> + fprintf (f, "\n%sbool\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);
>>>> + headerf ? "" : "static ", e->operation->id);
>>>> else
>>>> - fprintf (f, "\nstatic tree\n"
>>>> + fprintf (f, "\n%stree\n"
>>>> "generic_simplify_%s (location_t ARG_UNUSED (loc), enum "
>>>> "tree_code ARG_UNUSED (code), const tree ARG_UNUSED
>>>> (type)",
>>>> - e->operation->id);
>>>> + headerf ? "" : "static ", e->operation->id);
>>>> for (unsigned i = 0; i < n; ++i)
>>>> fprintf (f, ", tree op%d", i);
>>>> + n_fn++;
>>>> + if (do_header)
>>>> + {
>>>> + fprintf (f, ");\n");
>>>> + continue;
>>>> + }
>>>> fprintf (f, ")\n");
>>>> fprintf (f, "{\n");
>>>> dop->gen_kids (f, 2, gimple);
>>>> @@ -3724,21 +3792,43 @@ decision_tree::gen (FILE *f, bool gimple
>>>> else
>>>> fprintf (f, " return NULL_TREE;\n");
>>>> fprintf (f, "}\n");
>>>> +
>>>> + if (n_fn == pieces[file_n - 2])
>>>> + {
>>>> + fclose (f);
>>>> + sprintf (outputtem, "%s-%d.c", output, file_n++);
>>>> + f = fopen (outputtem, "w");
>>>> + if (!f)
>>>> + {
>>>> + perror ("failed to open output file");
>>>> + exit(1);
>>>> + }
>>>> + write_header (f, gimple);
>>>> + n_fn = 0;
>>>> + }
>>>> +
>>>> }
>>>>
>>>> /* Then generate the main entry with the outermost switch and
>>>> tail-calls to the split-out functions. */
>>>> if (gimple)
>>>> - fprintf (f, "\nstatic bool\n"
>>>> + fprintf (f, "\n%sbool\n"
>>>> "gimple_simplify (code_helper *res_code, tree *res_ops,\n"
>>>> " gimple_seq *seq, tree (*valueize)(tree),\n"
>>>> - " code_helper code, const tree type");
>>>> + " code_helper code, const tree type",
>>>> + headerf ? "" : "static ");
>>>> else
>>>> fprintf (f, "\ntree\n"
>>>> "generic_simplify (location_t loc, enum tree_code code, "
>>>> "const tree type ATTRIBUTE_UNUSED");
>>>> for (unsigned i = 0; i < n; ++i)
>>>> fprintf (f, ", tree op%d", i);
>>>> + n_fn++;
>>>> + if (do_header)
>>>> + {
>>>> + fprintf (f, ");\n");
>>>> + continue;
>>>> + }
>>>> fprintf (f, ")\n");
>>>> fprintf (f, "{\n");
>>>>
>>>> @@ -3786,19 +3876,46 @@ decision_tree::gen (FILE *f, bool gimple
>>>> else
>>>> fprintf (f, " return NULL_TREE;\n");
>>>> fprintf (f, "}\n");
>>>> + if (n_fn == pieces[file_n - 2])
>>>> + {
>>>> + fclose (f);
>>>> + sprintf (outputtem, "%s-%d.c", output, file_n++);
>>>> + f = fopen (outputtem, "w");
>>>> + if (!f)
>>>> + {
>>>> + perror ("failed to open output file");
>>>> + exit(1);
>>>> + }
>>>> + write_header (f, gimple);
>>>> + n_fn = 0;
>>>> + }
>>>> + }
>>>> +
>>>> + n_per_part = n_fn / 4 + 1;
>>>> }
>>>> + while (do_header);
>>>> + if (output)
>>>> + fclose (f);
>>>> }
>>>>
>>>> /* Output code to implement the predicate P from the decision tree DT. */
>>>>
>>>> void
>>>> -write_predicate (FILE *f, predicate_id *p, decision_tree &dt, bool gimple)
>>>> +write_predicate (FILE *f, predicate_id *p, decision_tree &dt, bool gimple,
>>>> + bool for_header)
>>>> {
>>>> fprintf (f, "\nbool\n"
>>>> - "%s%s (tree t%s%s)\n"
>>>> - "{\n", gimple ? "gimple_" : "tree_", p->id,
>>>> + "%s%s (tree t%s%s)",
>>>> + gimple ? "gimple_" : "tree_", p->id,
>>>> p->nargs > 0 ? ", tree *res_ops" : "",
>>>> gimple ? ", tree (*valueize)(tree) ATTRIBUTE_UNUSED" : "");
>>>> + if (for_header)
>>>> + {
>>>> + fprintf (f, ";\n");
>>>> + return;
>>>> + }
>>>> +
>>>> + fprintf (f, "\n{\n");
>>>> /* Conveniently make 'type' available. */
>>>> fprintf_indent (f, 2, "const tree type = TREE_TYPE (t);\n");
>>>>
>>>> @@ -3810,18 +3927,6 @@ write_predicate (FILE *f, predicate_id *
>>>> "}\n");
>>>> }
>>>>
>>>> -/* Write the common header for the GIMPLE/GENERIC IL matching routines.
>>>> */
>>>> -
>>>> -static void
>>>> -write_header (FILE *f, const char *head)
>>>> -{
>>>> - fprintf (f, "/* Generated automatically by the program `genmatch'
>>>> from\n");
>>>> - fprintf (f, " a IL pattern matching and simplification description.
>>>> */\n");
>>>> -
>>>> - /* Include the header instead of writing it awkwardly quoted here. */
>>>> - fprintf (f, "\n#include \"%s\"\n", head);
>>>> -}
>>>> -
>>>>
>>>>
>>>> /* AST parsing. */
>>>> @@ -4969,6 +5074,9 @@ main (int argc, char **argv)
>>>>
>>>> bool gimple = true;
>>>> char *input = argv[argc-1];
>>>> + char *output = NULL;
>>>> + char *header = NULL;
>>>> + auto_vec<unsigned long> pieces;
>>>> for (int i = 1; i < argc - 1; ++i)
>>>> {
>>>> if (strcmp (argv[i], "--gimple") == 0)
>>>> @@ -4979,13 +5087,25 @@ main (int argc, char **argv)
>>>> verbose = 1;
>>>> else if (strcmp (argv[i], "-vv") == 0)
>>>> verbose = 2;
>>>> + else if (strcmp (argv[i], "-c") == 0)
>>>> + {
>>>> + char *endp;
>>>> + output = argv[++i];
>>>> + while (i + 1 < argc - 1
>>>> + && ISDIGIT (argv[i + 1][0]))
>>>> + pieces.safe_push (strtoul (argv[++i], &endp, 10));
>>>> + }
>>>> + else if (strcmp (argv[i], "-h") == 0)
>>>> + header = argv[++i];
>>>> else
>>>> {
>>>> fprintf (stderr, "Usage: genmatch "
>>>> - "[--gimple] [--generic] [-v[v]] input\n");
>>>> + "[--gimple] [--generic] [-v[v]] "
>>>> + "[-c output num...] [-h header] input\n");
>>>> return 1;
>>>> }
>>>> }
>>>> + pieces.safe_push (-1UL);
>>>>
>>>> line_table = XCNEW (struct line_maps);
>>>> linemap_init (line_table, 0);
>>>> @@ -5039,10 +5159,32 @@ add_operator (VIEW_CONVERT2, "view_conve
>>>> /* Parse ahead! */
>>>> parser p (r);
>>>>
>>>> - if (gimple)
>>>> - write_header (stdout, "gimple-match-head.c");
>>>> + FILE *f, *headerf = NULL;
>>>> + if (!output)
>>>> + f = stdout;
>>>> else
>>>> - write_header (stdout, "generic-match-head.c");
>>>> + {
>>>> + char *outputtem = XNEWVEC (char, strlen (output) + strlen ("-1.c")
>>>> + 1);
>>>> + sprintf (outputtem, "%s-p.c", output);
>>>> + f = fopen (outputtem, "w");
>>>> + if (!f)
>>>> + {
>>>> + perror ("failed to open output file");
>>>> + exit(1);
>>>> + }
>>>> + }
>>>> + if (header)
>>>> + {
>>>> + headerf = fopen (header, "w");
>>>> + if (!headerf)
>>>> + {
>>>> + perror ("failed to open output file");
>>>> + exit(1);
>>>> + }
>>>> + }
>>>> +
>>>> + fprintf (f, "#define GENFOO_MAIN_FILE 1\n");
>>>> + write_header (f, gimple);
>>>>
>>>> /* Go over all predicates defined with patterns and perform
>>>> lowering and code generation. */
>>>> @@ -5062,8 +5204,12 @@ add_operator (VIEW_CONVERT2, "view_conve
>>>> if (verbose == 2)
>>>> dt.print (stderr);
>>>>
>>>> - write_predicate (stdout, pred, dt, gimple);
>>>> + if (header)
>>>> + write_predicate (headerf, pred, dt, gimple, true);
>>>> + write_predicate (f, pred, dt, gimple, false);
>>>> }
>>>> + if (output)
>>>> + fclose (f);
>>>>
>>>> /* Lower the main simplifiers and generate code for them. */
>>>> lower (p.simplifiers, gimple);
>>>> @@ -5079,7 +5225,10 @@ add_operator (VIEW_CONVERT2, "view_conve
>>>> if (verbose == 2)
>>>> dt.print (stderr);
>>>>
>>>> - dt.gen (stdout, gimple);
>>>> + dt.gen (output, headerf, pieces, gimple);
>>>> +
>>>> + if (header)
>>>> + fclose (headerf);
>>>>
>>>> /* Finalize. */
>>>> cpp_finish (r, NULL);
>>>> Index: gcc/gimple-match-head.c
>>>> ===================================================================
>>>> --- gcc/gimple-match-head.c (revision 259638)
>>>> +++ gcc/gimple-match-head.c (working copy)
>>>> @@ -40,21 +40,10 @@ along with GCC; see the file COPYING3.
>>>> #include "case-cfn-macros.h"
>>>> #include "gimplify.h"
>>>> #include "optabs-tree.h"
>>>> +#include "gimple-match-head.h"
>>>>
>>>>
>>>> -/* Forward declarations of the private auto-generated matchers.
>>>> - They expect valueized operands in canonical order and do not
>>>> - perform simplification of all-constant operands. */
>>>> -static bool gimple_simplify (code_helper *, tree *,
>>>> - gimple_seq *, tree (*)(tree),
>>>> - code_helper, tree, tree);
>>>> -static bool gimple_simplify (code_helper *, tree *,
>>>> - gimple_seq *, tree (*)(tree),
>>>> - code_helper, tree, tree, tree);
>>>> -static bool gimple_simplify (code_helper *, tree *,
>>>> - gimple_seq *, tree (*)(tree),
>>>> - code_helper, tree, tree, tree, tree);
>>>> -
>>>> +#if GENFOO_MAIN_FILE
>>>>
>>>> /* Return whether T is a constant that we'll dispatch to fold to
>>>> evaluate fully constant expressions. */
>>>> @@ -772,6 +761,8 @@ gimple_simplify (gimple *stmt,
>>>> return false;
>>>> }
>>>>
>>>> +#endif
>>>> +
>>>>
>>>> /* Helper for the autogenerated code, valueize OP. */
>>>>
>>>> Index: gcc/generic-match-head.c
>>>> ===================================================================
>>>> --- gcc/generic-match-head.c (revision 259638)
>>>> +++ gcc/generic-match-head.c (working copy)
>>>> @@ -34,6 +34,7 @@ along with GCC; see the file COPYING3.
>>>> #include "case-cfn-macros.h"
>>>> #include "gimplify.h"
>>>> #include "optabs-tree.h"
>>>> +#include "generic-match-head.h"
>>>>
>>>>
>>>> /* Routine to determine if the types T1 and T2 are effectively
>>>> Index: gcc/Makefile.in
>>>> ===================================================================
>>>> --- gcc/Makefile.in (revision 259638)
>>>> +++ gcc/Makefile.in (working copy)
>>>> @@ -216,8 +216,12 @@ gengtype-lex.o-warn = -Wno-error
>>>> libgcov-util.o-warn = -Wno-error
>>>> libgcov-driver-tool.o-warn = -Wno-error
>>>> libgcov-merge-tool.o-warn = -Wno-error
>>>> -gimple-match.o-warn = -Wno-unused
>>>> -generic-match.o-warn = -Wno-unused
>>>> +gimple-match-p.o-warn = -Wno-unused
>>>> +gimple-match-1.o-warn = -Wno-unused
>>>> +gimple-match-2.o-warn = -Wno-unused
>>>> +generic-match-p.o-warn = -Wno-unused
>>>> +generic-match-1.o-warn = -Wno-unused
>>>> +generic-match-2.o-warn = -Wno-unused
>>>> dfp.o-warn = -Wno-strict-aliasing
>>>>
>>>> # All warnings have to be shut off in stage1 if the compiler used then
>>>> @@ -771,7 +775,7 @@ COMPILERS = @all_compilers@
>>>>
>>>> # List of things which should already be built whenever we try to use xgcc
>>>> # to compile anything (without linking).
>>>> -GCC_PASSES=xgcc$(exeext) specs
>>>> +GCC_PASSES=xgcc$(exeext)
>>>>
>>>> # Directory to link to, when using the target `maketest'.
>>>> DIR = ../gcc
>>>> @@ -1207,8 +1211,12 @@ C_COMMON_OBJS = c-family/c-common.o c-fa
>>>> # will build them sooner, because they are large and otherwise tend to be
>>>> # the last objects to finish building.
>>>> OBJS = \
>>>> - gimple-match.o \
>>>> - generic-match.o \
>>>> + gimple-match-p.o \
>>>> + generic-match-p.o \
>>>> + gimple-match-1.o \
>>>> + generic-match-1.o \
>>>> + gimple-match-2.o \
>>>> + generic-match-2.o \
>>>> insn-attrtab.o \
>>>> insn-automata.o \
>>>> insn-dfatab.o \
>>>> @@ -1654,7 +1662,9 @@ MOSTLYCLEANFILES = insn-flags.h insn-con
>>>> insn-output.c insn-recog.c insn-emit.c insn-extract.c insn-peep.c \
>>>> insn-attr.h insn-attr-common.h insn-attrtab.c insn-dfatab.c \
>>>> insn-latencytab.c insn-opinit.c insn-opinit.h insn-preds.c
>>>> insn-constants.h \
>>>> - tm-preds.h tm-constrs.h checksum-options gimple-match.c generic-match.c \
>>>> + tm-preds.h tm-constrs.h checksum-options gimple-match-head.h
>>>> gimple-match-1.c \
>>>> + gimple-match-2.c gimple-match-p.c generic-match-head.h generic-match-1.c
>>>> \
>>>> + generic-match-p.c generic-match-2.c \
>>>> tree-check.h min-insn-modes.c insn-modes.c insn-modes.h
>>>> insn-modes-inline.h \
>>>> genrtl.h gt-*.h gtype-*.h gtype-desc.c gtyp-input.list \
>>>> case-cfn-macros.h cfn-operators.pd \
>>>> @@ -1899,7 +1909,7 @@ all.internal: start.encap rest.encap doc
>>>> all.cross: native gcc-cross$(exeext) cpp$(exeext) specs \
>>>> libgcc-support lang.all.cross doc selftest @GENINSRC@ srcextra
>>>> # This is what must be made before installing GCC and converting
>>>> libraries.
>>>> -start.encap: native xgcc$(exeext) cpp$(exeext) specs \
>>>> +start.encap: native xgcc$(exeext) cpp$(exeext) \
>>>> libgcc-support lang.start.encap @GENINSRC@ srcextra
>>>> # These can't be made until after GCC can run.
>>>> rest.encap: lang.rest.encap
>>>> @@ -2054,7 +2064,7 @@ checksum-options:
>>>> libgcc-support: libgcc.mvars stmp-int-hdrs $(TCONFIG_H) \
>>>> $(MACHMODE_H) gcov-iov.h
>>>>
>>>> -libgcc.mvars: config.status Makefile specs xgcc$(exeext)
>>>> +libgcc.mvars: config.status Makefile xgcc$(exeext)
>>>> : > tmp-libgcc.mvars
>>>> echo GCC_CFLAGS = '$(GCC_CFLAGS)' >> tmp-libgcc.mvars
>>>> echo INHIBIT_LIBC_CFLAGS = '$(INHIBIT_LIBC_CFLAGS)' >> tmp-libgcc.mvars
>>>> @@ -2271,8 +2281,9 @@ $(common_out_object_file): $(common_out_
>>>> .PRECIOUS: insn-config.h insn-flags.h insn-codes.h insn-constants.h \
>>>> insn-emit.c insn-recog.c insn-extract.c insn-output.c insn-peep.c \
>>>> insn-attr.h insn-attr-common.h insn-attrtab.c insn-dfatab.c \
>>>> - insn-latencytab.c insn-preds.c gimple-match.c generic-match.c \
>>>> - insn-target-def.h
>>>> + insn-latencytab.c insn-preds.c gimple-match-head.h gimple-match-1.c \
>>>> + gimple-match-2.c generic-match-head.h generic-match-1.c
>>>> generic-match-2.c \
>>>> + gimple-match-p.c generic-match-p.c insn-target-def.h
>>>>
>>>> # Dependencies for the md file. The first time through, we just assume
>>>> # the md file itself and the generated dependency file (in order to get
>>>> @@ -2504,18 +2515,36 @@ s-tm-texi: build/genhooks$(build_exeext)
>>>> false; \
>>>> fi
>>>>
>>>> -gimple-match.c: s-match gimple-match-head.c ; @true
>>>> -generic-match.c: s-match generic-match-head.c ; @true
>>>> +gimple-match-p.c: s-match gimple-match-head.c ; @true
>>>> +gimple-match-1.c: s-match gimple-match-head.c ; @true
>>>> +gimple-match-2.c: s-match gimple-match-head.c ; @true
>>>> +generic-match-p.c: s-match generic-match-head.c ; @true
>>>> +generic-match-1.c: s-match generic-match-head.c ; @true
>>>> +generic-match-2.c: s-match generic-match-head.c ; @true
>>>>
>>>> s-match: build/genmatch$(build_exeext) $(srcdir)/match.pd cfn-operators.pd
>>>> - $(RUN_GEN) build/genmatch$(build_exeext) --gimple $(srcdir)/match.pd \
>>>> - > tmp-gimple-match.c
>>>> - $(RUN_GEN) build/genmatch$(build_exeext) --generic $(srcdir)/match.pd \
>>>> - > tmp-generic-match.c
>>>> - $(SHELL) $(srcdir)/../move-if-change tmp-gimple-match.c \
>>>> - gimple-match.c
>>>> - $(SHELL) $(srcdir)/../move-if-change tmp-generic-match.c \
>>>> - generic-match.c
>>>> + $(RUN_GEN) build/genmatch$(build_exeext) --gimple \
>>>> + -h tmp-gimple-match-head.h -c tmp-gimple-match 460 \
>>>> + $(srcdir)/match.pd
>>>> + $(RUN_GEN) build/genmatch$(build_exeext) --generic \
>>>> + -h tmp-generic-match-head.h -c tmp-generic-match 290 \
>>>> + $(srcdir)/match.pd
>>>> + $(SHELL) $(srcdir)/../move-if-change tmp-gimple-match-head.h \
>>>> + gimple-match-head.h
>>>> + $(SHELL) $(srcdir)/../move-if-change tmp-gimple-match-1.c \
>>>> + gimple-match-1.c
>>>> + $(SHELL) $(srcdir)/../move-if-change tmp-gimple-match-2.c \
>>>> + gimple-match-2.c
>>>> + $(SHELL) $(srcdir)/../move-if-change tmp-gimple-match-p.c \
>>>> + gimple-match-p.c
>>>> + $(SHELL) $(srcdir)/../move-if-change tmp-generic-match-head.h \
>>>> + generic-match-head.h
>>>> + $(SHELL) $(srcdir)/../move-if-change tmp-generic-match-1.c \
>>>> + generic-match-1.c
>>>> + $(SHELL) $(srcdir)/../move-if-change tmp-generic-match-2.c \
>>>> + generic-match-2.c
>>>> + $(SHELL) $(srcdir)/../move-if-change tmp-generic-match-p.c \
>>>> + generic-match-p.c
>>>> $(STAMP) s-match
>>>>
>>>> GTFILES = $(CPP_ID_DATA_H) $(srcdir)/input.h $(srcdir)/coretypes.h \
>>>>
>>>
>>> Hi.
>>>
>>> I took a look at gimple-match.c and what about doing a split in following
>>> way:
>>> - all gimple_simplify_$number going into a separate header file (~12000 LOC)
>>> - all the function can be marked as static inline
>>> - all other gimple_simplify_$code can be split into arbitrary number of
>>> parts
>>> - we have 287 such functions where each function only calls
>>> gimple_simplify_$number and
>>> on average there 10 of such calls
>>> - that would allow to remove most of gimple_simplify_$number functions from
>>> the header file
>>>
>>> Richi do you think it will be viable?
>>
>> That relies on the cgraph code DCEing all unused gimple_simplify_$number
>> functions from the header fast as they are now effectively duplicated
>> into all parts, correct? Also I'm not sure if we actually want to inline
>> them... they are split out to get both code size and compile-time
>> under control. Unfortunately we have still high max-inline-insns-single
>> which is used for inline marked functions.
>>
>> Eventually doing a "proper" partitioning algorithm is viable, that is,
>> partition based on gimple_simplify_$code and put gimple_simplify_$number
>> where they are used. If they are used across different codes then
>> merge those partitions. I guess you'll see that that'll merge the
>> biggest _$code parititions :/ (MINUS_EXPR, PLUS_EXPR).
>
> Yes, that should be much better. I'm attaching a 'callgraph' that was done by
> grepping.
> Function starting at the beginning of a line is function definition, with an
> indentation
> one can see calls.
>
> Yes, PLUS and MINUS call ~20 gimple_simplify_$number calls.
>
> Well, generating some simple call graph format for the source file and a
> source file
> annotation of nodes can be input for a partitioning tool that can do the
> split.
>
> Issue with the generated files is that one needs to fix the most offenders
> (*-match.c, insn-recog.c, insn-emit.c, ..)
> in order to see some improvement.
>
> Looking at insn-recog.c, maybe similar callgraph-based split can be done for
> recog_$number functions?
>
> Martin
>
>>
>> Richard.
>>
>
I'm sending SCC components for gimple-match.c. So there are 3 quite big one and
rest is small. It's questionable
whether partitioning based on that will provide desired speed up?
Martin
total functions: 590
['gimple_simplify_ABS_EXPR']
['gimple_simplify_CFN_BUILT_IN_COSF']
['gimple_simplify_CFN_BUILT_IN_COS']
['gimple_simplify_CFN_BUILT_IN_COSL']
['gimple_simplify_CFN_COS']
['gimple_simplify_CFN_BUILT_IN_COSHF']
['gimple_simplify_CFN_BUILT_IN_COSH']
['gimple_simplify_CFN_BUILT_IN_COSHL']
['gimple_simplify_CFN_BUILT_IN_CCOSF']
['gimple_simplify_CFN_BUILT_IN_CCOS']
['gimple_simplify_CFN_BUILT_IN_CCOSL']
['gimple_simplify_CFN_BUILT_IN_CCOSHF']
['gimple_simplify_CFN_BUILT_IN_CCOSH']
['gimple_simplify_CFN_BUILT_IN_CCOSHL']
['gimple_simplify_CFN_BUILT_IN_CABSF']
['gimple_simplify_CFN_BUILT_IN_CABS']
['gimple_simplify_CFN_BUILT_IN_CABSL']
['gimple_simplify_VIEW_CONVERT_EXPR']
['gimple_simplify_FLOAT_EXPR']
['gimple_simplify_FIX_TRUNC_EXPR']
['gimple_simplify_PAREN_EXPR']
['gimple_simplify_REALPART_EXPR']
['gimple_simplify_IMAGPART_EXPR']
['gimple_simplify_CFN_BUILT_IN_EXPF']
['gimple_simplify_CFN_BUILT_IN_EXP']
['gimple_simplify_CFN_BUILT_IN_EXPL']
['gimple_simplify_CFN_EXP']
['gimple_simplify_CFN_BUILT_IN_EXP2F']
['gimple_simplify_CFN_BUILT_IN_EXP2']
['gimple_simplify_CFN_BUILT_IN_EXP2L']
['gimple_simplify_CFN_EXP2']
['gimple_simplify_CFN_BUILT_IN_EXP10F']
['gimple_simplify_CFN_BUILT_IN_EXP10']
['gimple_simplify_CFN_BUILT_IN_EXP10L']
['gimple_simplify_CFN_EXP10']
['gimple_simplify_CFN_BUILT_IN_POW10F']
['gimple_simplify_CFN_BUILT_IN_POW10']
['gimple_simplify_CFN_BUILT_IN_POW10L']
['gimple_simplify_CFN_BUILT_IN_SQRTF']
['gimple_simplify_CFN_BUILT_IN_SQRT']
['gimple_simplify_CFN_BUILT_IN_SQRTL']
['gimple_simplify_CFN_SQRT']
['gimple_simplify_CFN_BUILT_IN_CBRTF']
['gimple_simplify_CFN_BUILT_IN_CBRT']
['gimple_simplify_CFN_BUILT_IN_CBRTL']
['gimple_simplify_CFN_BUILT_IN_CEXPF']
['gimple_simplify_CFN_BUILT_IN_CEXP']
['gimple_simplify_CFN_BUILT_IN_CEXPL']
['gimple_simplify_CFN_BUILT_IN_IFLOORF']
['gimple_simplify_CFN_BUILT_IN_LFLOORF']
['gimple_simplify_CFN_BUILT_IN_LLFLOORF']
['gimple_simplify_CFN_BUILT_IN_ICEILF']
['gimple_simplify_CFN_BUILT_IN_LCEILF']
['gimple_simplify_CFN_BUILT_IN_LLCEILF']
['gimple_simplify_CFN_BUILT_IN_IROUNDF']
['gimple_simplify_CFN_BUILT_IN_LROUNDF']
['gimple_simplify_CFN_BUILT_IN_LLROUNDF']
['gimple_simplify_CFN_BUILT_IN_IRINTF']
['gimple_simplify_CFN_BUILT_IN_LRINTF']
['gimple_simplify_CFN_BUILT_IN_LLRINTF']
['gimple_simplify_CFN_BUILT_IN_CPROJF']
['gimple_simplify_CFN_BUILT_IN_CPROJ']
['gimple_simplify_CFN_BUILT_IN_CPROJL']
['gimple_simplify_CFN_BUILT_IN_SIGNBITF']
['gimple_simplify_CFN_BUILT_IN_SIGNBIT']
['gimple_simplify_CFN_BUILT_IN_SIGNBITL']
['gimple_simplify_POINTER_PLUS_EXPR']
['gimple_simplify_POINTER_DIFF_EXPR']
['gimple_simplify_CFN_BUILT_IN_HYPOTF']
['gimple_simplify_CFN_BUILT_IN_HYPOT']
['gimple_simplify_CFN_BUILT_IN_HYPOTL']
['gimple_simplify_COMPLEX_EXPR']
['gimple_simplify_TRUTH_ORIF_EXPR']
['gimple_simplify_TRUTH_OR_EXPR']
['gimple_simplify_BIT_FIELD_REF']
['gimple_simplify_CONJ_EXPR', 'gimple_simplify_286']
['gimple_simplify_NEGATE_EXPR', 'gimple_simplify_56', 'gimple_simplify_202']
['gimple_simplify_CFN_FMS', 'gimple_simplify_239', 'gimple_simplify_234']
['gimple_simplify_CFN_FNMA', 'gimple_simplify_268', 'gimple_simplify_259']
['gimple_simplify_CFN_FNMS', 'gimple_simplify_274', 'gimple_simplify_272']
['gimple_simplify_CONVERT_EXPR', 'gimple_simplify_58', 'gimple_simplify_29',
'gimple_simplify_236']
['gimple_simplify_CFN_BUILT_IN_POWIL', 'gimple_simplify_CFN_BUILT_IN_POWIF',
'gimple_simplify_CFN_BUILT_IN_POWI', 'gimple_simplify_108']
['gimple_simplify_CFN_TAN', 'gimple_simplify_CFN_BUILT_IN_TANL',
'gimple_simplify_CFN_BUILT_IN_TANF', 'gimple_simplify_CFN_BUILT_IN_TAN',
'gimple_simplify_77']
['gimple_simplify_CFN_BUILT_IN_POPCOUNTLL',
'gimple_simplify_CFN_BUILT_IN_POPCOUNTL',
'gimple_simplify_CFN_BUILT_IN_POPCOUNTIMAX',
'gimple_simplify_CFN_BUILT_IN_POPCOUNT', 'gimple_simplify_214']
['gimple_simplify_COND_EXPR', 'gimple_simplify_71', 'gimple_simplify_275',
'gimple_simplify_261', 'gimple_simplify_13']
['gimple_simplify_CFN_BUILT_IN_BSWAP64',
'gimple_simplify_CFN_BUILT_IN_BSWAP32', 'gimple_simplify_CFN_BUILT_IN_BSWAP16',
'gimple_simplify_195', 'gimple_simplify_174', 'gimple_simplify_171']
['gimple_simplify_CFN_POW', 'gimple_simplify_CFN_BUILT_IN_POWL',
'gimple_simplify_CFN_BUILT_IN_POWF', 'gimple_simplify_CFN_BUILT_IN_POW',
'gimple_simplify_70', 'gimple_simplify_45', 'gimple_simplify_40']
['gimple_simplify_CFN_FMA', 'gimple_simplify_CFN_BUILT_IN_FMAL',
'gimple_simplify_CFN_BUILT_IN_FMAF', 'gimple_simplify_CFN_BUILT_IN_FMA',
'gimple_simplify_231', 'gimple_simplify_229', 'gimple_simplify_224']
['gimple_simplify_RDIV_EXPR', 'gimple_simplify_4', 'gimple_simplify_287',
'gimple_simplify_285', 'gimple_simplify_255', 'gimple_simplify_219',
'gimple_simplify_212', 'gimple_simplify_21', 'gimple_simplify_164']
['gimple_simplify_VEC_COND_EXPR', 'gimple_simplify_74', 'gimple_simplify_269',
'gimple_simplify_266', 'gimple_simplify_209', 'gimple_simplify_165',
'gimple_simplify_161', 'gimple_simplify_122', 'gimple_simplify_106']
['gimple_simplify_CFN_LDEXP', 'gimple_simplify_CFN_BUILT_IN_SCALBNL',
'gimple_simplify_CFN_BUILT_IN_SCALBNF', 'gimple_simplify_CFN_BUILT_IN_SCALBN',
'gimple_simplify_CFN_BUILT_IN_SCALBLNL',
'gimple_simplify_CFN_BUILT_IN_SCALBLNF',
'gimple_simplify_CFN_BUILT_IN_SCALBLN', 'gimple_simplify_CFN_BUILT_IN_LDEXPL',
'gimple_simplify_CFN_BUILT_IN_LDEXPF', 'gimple_simplify_CFN_BUILT_IN_LDEXP',
'gimple_simplify_46', 'gimple_simplify_119']
['gimple_simplify_BIT_NOT_EXPR', 'gimple_simplify_75', 'gimple_simplify_61',
'gimple_simplify_302', 'gimple_simplify_282', 'gimple_simplify_247',
'gimple_simplify_24', 'gimple_simplify_207', 'gimple_simplify_167',
'gimple_simplify_144', 'gimple_simplify_143', 'gimple_simplify_126',
'gimple_simplify_123']
['gimple_simplify_CFN_LOG2', 'gimple_simplify_CFN_LOG10',
'gimple_simplify_CFN_LOG', 'gimple_simplify_CFN_BUILT_IN_LOGL',
'gimple_simplify_CFN_BUILT_IN_LOGF', 'gimple_simplify_CFN_BUILT_IN_LOG2L',
'gimple_simplify_CFN_BUILT_IN_LOG2F', 'gimple_simplify_CFN_BUILT_IN_LOG2',
'gimple_simplify_CFN_BUILT_IN_LOG10L', 'gimple_simplify_CFN_BUILT_IN_LOG10F',
'gimple_simplify_CFN_BUILT_IN_LOG10', 'gimple_simplify_CFN_BUILT_IN_LOG',
'gimple_simplify_93']
['gimple_simplify_TRUNC_MOD_EXPR', 'gimple_simplify_ROUND_MOD_EXPR',
'gimple_simplify_FLOOR_MOD_EXPR', 'gimple_simplify_CEIL_MOD_EXPR',
'gimple_simplify_91', 'gimple_simplify_9', 'gimple_simplify_84',
'gimple_simplify_76', 'gimple_simplify_57', 'gimple_simplify_290',
'gimple_simplify_213', 'gimple_simplify_194', 'gimple_simplify_131']
['gimple_simplify_RSHIFT_EXPR', 'gimple_simplify_RROTATE_EXPR',
'gimple_simplify_LSHIFT_EXPR', 'gimple_simplify_LROTATE_EXPR',
'gimple_simplify_73', 'gimple_simplify_59', 'gimple_simplify_22',
'gimple_simplify_190', 'gimple_simplify_179', 'gimple_simplify_170',
'gimple_simplify_115', 'gimple_simplify_107', 'gimple_simplify_101']
['gimple_simplify_CFN_COPYSIGN', 'gimple_simplify_CFN_BUILT_IN_COPYSIGNL',
'gimple_simplify_CFN_BUILT_IN_COPYSIGNF64X',
'gimple_simplify_CFN_BUILT_IN_COPYSIGNF64',
'gimple_simplify_CFN_BUILT_IN_COPYSIGNF32X',
'gimple_simplify_CFN_BUILT_IN_COPYSIGNF32',
'gimple_simplify_CFN_BUILT_IN_COPYSIGNF16',
'gimple_simplify_CFN_BUILT_IN_COPYSIGNF128X',
'gimple_simplify_CFN_BUILT_IN_COPYSIGNF128',
'gimple_simplify_CFN_BUILT_IN_COPYSIGNF',
'gimple_simplify_CFN_BUILT_IN_COPYSIGN', 'gimple_simplify_49',
'gimple_simplify_38', 'gimple_simplify_260', 'gimple_simplify_136',
'gimple_simplify_125']
['gimple_simplify_CFN_BUILT_IN_LROUNDL', 'gimple_simplify_CFN_BUILT_IN_LROUND',
'gimple_simplify_CFN_BUILT_IN_LRINTL', 'gimple_simplify_CFN_BUILT_IN_LRINT',
'gimple_simplify_CFN_BUILT_IN_LLROUNDL',
'gimple_simplify_CFN_BUILT_IN_LLROUND', 'gimple_simplify_CFN_BUILT_IN_LLRINTL',
'gimple_simplify_CFN_BUILT_IN_LLRINT', 'gimple_simplify_CFN_BUILT_IN_LLFLOORL',
'gimple_simplify_CFN_BUILT_IN_LLFLOOR', 'gimple_simplify_CFN_BUILT_IN_LLCEILL',
'gimple_simplify_CFN_BUILT_IN_LLCEIL', 'gimple_simplify_CFN_BUILT_IN_LFLOORL',
'gimple_simplify_CFN_BUILT_IN_LFLOOR', 'gimple_simplify_CFN_BUILT_IN_LCEILL',
'gimple_simplify_CFN_BUILT_IN_LCEIL', 'gimple_simplify_CFN_BUILT_IN_IROUNDL',
'gimple_simplify_CFN_BUILT_IN_IROUND', 'gimple_simplify_CFN_BUILT_IN_IRINTL',
'gimple_simplify_CFN_BUILT_IN_IRINT', 'gimple_simplify_CFN_BUILT_IN_IFLOORL',
'gimple_simplify_CFN_BUILT_IN_IFLOOR', 'gimple_simplify_CFN_BUILT_IN_ICEILL',
'gimple_simplify_CFN_BUILT_IN_ICEIL', 'gimple_simplify_205',
'gimple_simplify_158']
['gimple_simplify_TRUNC_DIV_EXPR', 'gimple_simplify_ROUND_DIV_EXPR',
'gimple_simplify_MULT_EXPR', 'gimple_simplify_FLOOR_DIV_EXPR',
'gimple_simplify_EXACT_DIV_EXPR', 'gimple_simplify_CEIL_DIV_EXPR',
'gimple_simplify_92', 'gimple_simplify_72', 'gimple_simplify_35',
'gimple_simplify_294', 'gimple_simplify_273', 'gimple_simplify_27',
'gimple_simplify_264', 'gimple_simplify_262', 'gimple_simplify_26',
'gimple_simplify_243', 'gimple_simplify_240', 'gimple_simplify_222',
'gimple_simplify_20', 'gimple_simplify_192', 'gimple_simplify_189',
'gimple_simplify_181', 'gimple_simplify_18', 'gimple_simplify_155',
'gimple_simplify_145', 'gimple_simplify_141', 'gimple_simplify_132',
'gimple_simplify_129', 'gimple_simplify_128', 'gimple_simplify_111']
['gimple_simplify_MIN_EXPR', 'gimple_simplify_MAX_EXPR',
'gimple_simplify_CFN_FMIN', 'gimple_simplify_CFN_FMAX',
'gimple_simplify_CFN_BUILT_IN_FMINL', 'gimple_simplify_CFN_BUILT_IN_FMINF64X',
'gimple_simplify_CFN_BUILT_IN_FMINF64',
'gimple_simplify_CFN_BUILT_IN_FMINF32X',
'gimple_simplify_CFN_BUILT_IN_FMINF32', 'gimple_simplify_CFN_BUILT_IN_FMINF16',
'gimple_simplify_CFN_BUILT_IN_FMINF128X',
'gimple_simplify_CFN_BUILT_IN_FMINF128', 'gimple_simplify_CFN_BUILT_IN_FMINF',
'gimple_simplify_CFN_BUILT_IN_FMIN', 'gimple_simplify_CFN_BUILT_IN_FMAXL',
'gimple_simplify_CFN_BUILT_IN_FMAXF64X',
'gimple_simplify_CFN_BUILT_IN_FMAXF64',
'gimple_simplify_CFN_BUILT_IN_FMAXF32X',
'gimple_simplify_CFN_BUILT_IN_FMAXF32', 'gimple_simplify_CFN_BUILT_IN_FMAXF16',
'gimple_simplify_CFN_BUILT_IN_FMAXF128X',
'gimple_simplify_CFN_BUILT_IN_FMAXF128', 'gimple_simplify_CFN_BUILT_IN_FMAXF',
'gimple_simplify_CFN_BUILT_IN_FMAX', 'gimple_simplify_89',
'gimple_simplify_82', 'gimple_simplify_299', 'gimple_simplify_295',
'gimple_simplify_248', 'gimple_simplify_246', 'gimple_simplify_245',
'gimple_simplify_149', 'gimple_simplify_11']
['gimple_simplify_CFN_TRUNC', 'gimple_simplify_CFN_ROUND',
'gimple_simplify_CFN_RINT', 'gimple_simplify_CFN_NEARBYINT',
'gimple_simplify_CFN_FLOOR', 'gimple_simplify_CFN_CEIL',
'gimple_simplify_CFN_BUILT_IN_TRUNCL',
'gimple_simplify_CFN_BUILT_IN_TRUNCF64X',
'gimple_simplify_CFN_BUILT_IN_TRUNCF64',
'gimple_simplify_CFN_BUILT_IN_TRUNCF32X',
'gimple_simplify_CFN_BUILT_IN_TRUNCF32',
'gimple_simplify_CFN_BUILT_IN_TRUNCF16',
'gimple_simplify_CFN_BUILT_IN_TRUNCF128X',
'gimple_simplify_CFN_BUILT_IN_TRUNCF128',
'gimple_simplify_CFN_BUILT_IN_TRUNCF', 'gimple_simplify_CFN_BUILT_IN_TRUNC',
'gimple_simplify_CFN_BUILT_IN_ROUNDL',
'gimple_simplify_CFN_BUILT_IN_ROUNDF64X',
'gimple_simplify_CFN_BUILT_IN_ROUNDF64',
'gimple_simplify_CFN_BUILT_IN_ROUNDF32X',
'gimple_simplify_CFN_BUILT_IN_ROUNDF32',
'gimple_simplify_CFN_BUILT_IN_ROUNDF16',
'gimple_simplify_CFN_BUILT_IN_ROUNDF128X',
'gimple_simplify_CFN_BUILT_IN_ROUNDF128',
'gimple_simplify_CFN_BUILT_IN_ROUNDF', 'gimple_simplify_CFN_BUILT_IN_ROUND',
'gimple_simplify_CFN_BUILT_IN_RINTL', 'gimple_simplify_CFN_BUILT_IN_RINTF64X',
'gimple_simplify_CFN_BUILT_IN_RINTF64',
'gimple_simplify_CFN_BUILT_IN_RINTF32X',
'gimple_simplify_CFN_BUILT_IN_RINTF32', 'gimple_simplify_CFN_BUILT_IN_RINTF16',
'gimple_simplify_CFN_BUILT_IN_RINTF128X',
'gimple_simplify_CFN_BUILT_IN_RINTF128', 'gimple_simplify_CFN_BUILT_IN_RINTF',
'gimple_simplify_CFN_BUILT_IN_RINT', 'gimple_simplify_CFN_BUILT_IN_NEARBYINTL',
'gimple_simplify_CFN_BUILT_IN_NEARBYINTF64X',
'gimple_simplify_CFN_BUILT_IN_NEARBYINTF64',
'gimple_simplify_CFN_BUILT_IN_NEARBYINTF32X',
'gimple_simplify_CFN_BUILT_IN_NEARBYINTF32',
'gimple_simplify_CFN_BUILT_IN_NEARBYINTF16',
'gimple_simplify_CFN_BUILT_IN_NEARBYINTF128X',
'gimple_simplify_CFN_BUILT_IN_NEARBYINTF128',
'gimple_simplify_CFN_BUILT_IN_NEARBYINTF',
'gimple_simplify_CFN_BUILT_IN_NEARBYINT',
'gimple_simplify_CFN_BUILT_IN_FLOORL',
'gimple_simplify_CFN_BUILT_IN_FLOORF64X',
'gimple_simplify_CFN_BUILT_IN_FLOORF64',
'gimple_simplify_CFN_BUILT_IN_FLOORF32X',
'gimple_simplify_CFN_BUILT_IN_FLOORF32',
'gimple_simplify_CFN_BUILT_IN_FLOORF16',
'gimple_simplify_CFN_BUILT_IN_FLOORF128X',
'gimple_simplify_CFN_BUILT_IN_FLOORF128',
'gimple_simplify_CFN_BUILT_IN_FLOORF', 'gimple_simplify_CFN_BUILT_IN_FLOOR',
'gimple_simplify_CFN_BUILT_IN_CEILL', 'gimple_simplify_CFN_BUILT_IN_CEILF64X',
'gimple_simplify_CFN_BUILT_IN_CEILF64',
'gimple_simplify_CFN_BUILT_IN_CEILF32X',
'gimple_simplify_CFN_BUILT_IN_CEILF32', 'gimple_simplify_CFN_BUILT_IN_CEILF16',
'gimple_simplify_CFN_BUILT_IN_CEILF128X',
'gimple_simplify_CFN_BUILT_IN_CEILF128', 'gimple_simplify_CFN_BUILT_IN_CEILF',
'gimple_simplify_CFN_BUILT_IN_CEIL', 'gimple_simplify_297',
'gimple_simplify_25', 'gimple_simplify_201', 'gimple_simplify_177',
'gimple_simplify_113']
['gimple_simplify_UNORDERED_EXPR', 'gimple_simplify_UNLT_EXPR',
'gimple_simplify_UNLE_EXPR', 'gimple_simplify_UNGT_EXPR',
'gimple_simplify_UNGE_EXPR', 'gimple_simplify_UNEQ_EXPR',
'gimple_simplify_ORDERED_EXPR', 'gimple_simplify_NE_EXPR',
'gimple_simplify_LT_EXPR', 'gimple_simplify_LTGT_EXPR',
'gimple_simplify_LE_EXPR', 'gimple_simplify_GT_EXPR',
'gimple_simplify_GE_EXPR', 'gimple_simplify_EQ_EXPR', 'gimple_simplify_95',
'gimple_simplify_94', 'gimple_simplify_90', 'gimple_simplify_88',
'gimple_simplify_78', 'gimple_simplify_7', 'gimple_simplify_68',
'gimple_simplify_64', 'gimple_simplify_6', 'gimple_simplify_55',
'gimple_simplify_52', 'gimple_simplify_51', 'gimple_simplify_50',
'gimple_simplify_47', 'gimple_simplify_41', 'gimple_simplify_39',
'gimple_simplify_37', 'gimple_simplify_36', 'gimple_simplify_32',
'gimple_simplify_31', 'gimple_simplify_3', 'gimple_simplify_293',
'gimple_simplify_291', 'gimple_simplify_289', 'gimple_simplify_284',
'gimple_simplify_283', 'gimple_simplify_28', 'gimple_simplify_270',
'gimple_simplify_263', 'gimple_simplify_258', 'gimple_simplify_257',
'gimple_simplify_254', 'gimple_simplify_253', 'gimple_simplify_252',
'gimple_simplify_230', 'gimple_simplify_23', 'gimple_simplify_220',
'gimple_simplify_216', 'gimple_simplify_210', 'gimple_simplify_204',
'gimple_simplify_199', 'gimple_simplify_198', 'gimple_simplify_197',
'gimple_simplify_193', 'gimple_simplify_191', 'gimple_simplify_188',
'gimple_simplify_187', 'gimple_simplify_186', 'gimple_simplify_183',
'gimple_simplify_180', 'gimple_simplify_178', 'gimple_simplify_176',
'gimple_simplify_172', 'gimple_simplify_169', 'gimple_simplify_168',
'gimple_simplify_166', 'gimple_simplify_157', 'gimple_simplify_154',
'gimple_simplify_152', 'gimple_simplify_15', 'gimple_simplify_147',
'gimple_simplify_146', 'gimple_simplify_142', 'gimple_simplify_140',
'gimple_simplify_14', 'gimple_simplify_138', 'gimple_simplify_135',
'gimple_simplify_134', 'gimple_simplify_127', 'gimple_simplify_121',
'gimple_simplify_120', 'gimple_simplify_12', 'gimple_simplify_118',
'gimple_simplify_117', 'gimple_simplify_110', 'gimple_simplify_104',
'gimple_simplify_103', 'gimple_simplify_100', 'gimple_simplify_10',
'gimple_simplify_1']
['gimple_simplify_PLUS_EXPR', 'gimple_simplify_MINUS_EXPR',
'gimple_simplify_BIT_XOR_EXPR', 'gimple_simplify_BIT_IOR_EXPR',
'gimple_simplify_BIT_AND_EXPR', 'gimple_simplify_99', 'gimple_simplify_98',
'gimple_simplify_97', 'gimple_simplify_96', 'gimple_simplify_87',
'gimple_simplify_86', 'gimple_simplify_85', 'gimple_simplify_83',
'gimple_simplify_81', 'gimple_simplify_80', 'gimple_simplify_8',
'gimple_simplify_79', 'gimple_simplify_69', 'gimple_simplify_67',
'gimple_simplify_66', 'gimple_simplify_65', 'gimple_simplify_63',
'gimple_simplify_62', 'gimple_simplify_60', 'gimple_simplify_54',
'gimple_simplify_53', 'gimple_simplify_5', 'gimple_simplify_48',
'gimple_simplify_44', 'gimple_simplify_43', 'gimple_simplify_42',
'gimple_simplify_34', 'gimple_simplify_33', 'gimple_simplify_303',
'gimple_simplify_301', 'gimple_simplify_300', 'gimple_simplify_30',
'gimple_simplify_298', 'gimple_simplify_296', 'gimple_simplify_292',
'gimple_simplify_288', 'gimple_simplify_281', 'gimple_simplify_280',
'gimple_simplify_279', 'gimple_simplify_278', 'gimple_simplify_277',
'gimple_simplify_276', 'gimple_simplify_271', 'gimple_simplify_267',
'gimple_simplify_265', 'gimple_simplify_256', 'gimple_simplify_251',
'gimple_simplify_250', 'gimple_simplify_249', 'gimple_simplify_244',
'gimple_simplify_242', 'gimple_simplify_241', 'gimple_simplify_238',
'gimple_simplify_237', 'gimple_simplify_235', 'gimple_simplify_233',
'gimple_simplify_232', 'gimple_simplify_228', 'gimple_simplify_227',
'gimple_simplify_226', 'gimple_simplify_225', 'gimple_simplify_223',
'gimple_simplify_221', 'gimple_simplify_218', 'gimple_simplify_217',
'gimple_simplify_215', 'gimple_simplify_211', 'gimple_simplify_208',
'gimple_simplify_206', 'gimple_simplify_203', 'gimple_simplify_200',
'gimple_simplify_2', 'gimple_simplify_196', 'gimple_simplify_19',
'gimple_simplify_185', 'gimple_simplify_184', 'gimple_simplify_182',
'gimple_simplify_175', 'gimple_simplify_173', 'gimple_simplify_17',
'gimple_simplify_163', 'gimple_simplify_162', 'gimple_simplify_160',
'gimple_simplify_16', 'gimple_simplify_159', 'gimple_simplify_156',
'gimple_simplify_153', 'gimple_simplify_151', 'gimple_simplify_150',
'gimple_simplify_148', 'gimple_simplify_139', 'gimple_simplify_137',
'gimple_simplify_133', 'gimple_simplify_130', 'gimple_simplify_124',
'gimple_simplify_116', 'gimple_simplify_114', 'gimple_simplify_112',
'gimple_simplify_109', 'gimple_simplify_105', 'gimple_simplify_102']
SCC components size:
1
1
1
1
1
1
1
1
1
1
1
1
1
1
1
1
1
1
1
1
1
1
1
1
1
1
1
1
1
1
1
1
1
1
1
1
1
1
1
1
1
1
1
1
1
1
1
1
1
1
1
1
1
1
1
1
1
1
1
1
1
1
1
1
1
1
1
1
1
1
1
1
1
1
1
2
3
3
3
3
4
4
5
5
5
6
7
7
9
9
12
13
13
13
13
16
26
30
33
71
94
106
