On Thu, Jul 9, 2015 at 2:20 PM, Michael Matz <[email protected]> wrote:
> Hi,
>
> while looking at gimple-match.c I got a minor stroke, so this patch makes
> genmatch generated (mostly) properly indented code. Sure, it could be
> done post-fact by an editor or something when one looks at the file, but
> all other generators also try to generate good looking code. No
> functional changes to the emitted code.
>
> Regstrapping on x86_64-linux in progress. Okay if that passes?
Ok.
Thanks,
Richard.
>
> Ciao,
> Michael.
>
> * genmatch.c (fprintf_indent): New function.
> (operand::gen_transform): Add indent parameter.
> (expr::gen_transform, c_expr::gen_transform,
> capture::gen_transform): Ditto and use fprintf_indent.
> (dt_node::gen, dt_node::gen_kids, dt_node::gen_kids_1): Ditto.
> (dt_operand::gen, dt_operand::gen_predicate,
> dt_operand::gen_match_op, dt_operand::gen_gimple_expr,
> dt_operand::gen_generic_expr, dt_simplify::gen): Ditto.
> (decision_tree::gen_gimple): Adjust calls and indent generated
> code.
> (decision_tree::gen_generic): Ditto.
> (write_predicate): Ditto.
>
> Index: gcc/genmatch.c
> ===================================================================
> --- gcc.orig/genmatch.c 2015-07-08 16:50:04.000000000 +0200
> +++ gcc/genmatch.c 2015-07-09 14:05:44.000000000 +0200
> @@ -126,6 +126,21 @@ warning_at (const cpp_token *tk, const c
> va_end (ap);
> }
>
> +/* Like fprintf, but print INDENT spaces at the beginning. */
> +
> +static void
> +#if GCC_VERSION >= 4001
> +__attribute__((format (printf, 3, 4)))
> +#endif
> +fprintf_indent (FILE *f, unsigned int indent, const char *format, ...)
> +{
> + va_list ap;
> + va_start (ap, format);
> + fprintf (f, "%*s", indent, "");
> + vfprintf (f, format, ap);
> + va_end (ap);
> +}
> +
> static void
> output_line_directive (FILE *f, source_location location,
> bool dumpfile = false)
> @@ -468,7 +483,7 @@ struct operand {
> enum op_type { OP_PREDICATE, OP_EXPR, OP_CAPTURE, OP_C_EXPR };
> operand (enum op_type type_) : type (type_) {}
> enum op_type type;
> - virtual void gen_transform (FILE *, const char *, bool, int,
> + virtual void gen_transform (FILE *, int, const char *, bool, int,
> const char *, capture_info *,
> dt_operand ** = 0,
> bool = true)
> @@ -503,7 +518,7 @@ struct expr : public operand
> bool is_commutative;
> /* Whether the expression is expected to be in GENERIC form. */
> bool is_generic;
> - virtual void gen_transform (FILE *f, const char *, bool, int,
> + virtual void gen_transform (FILE *f, int, const char *, bool, int,
> const char *, capture_info *,
> dt_operand ** = 0, bool = true);
> };
> @@ -534,7 +549,7 @@ struct c_expr : public operand
> unsigned nr_stmts;
> /* The identifier replacement vector. */
> vec<id_tab> ids;
> - virtual void gen_transform (FILE *f, const char *, bool, int,
> + virtual void gen_transform (FILE *f, int, const char *, bool, int,
> const char *, capture_info *,
> dt_operand ** = 0, bool = true);
> };
> @@ -549,7 +564,7 @@ struct capture : public operand
> unsigned where;
> /* The captured value. */
> operand *what;
> - virtual void gen_transform (FILE *f, const char *, bool, int,
> + virtual void gen_transform (FILE *f, int, const char *, bool, int,
> const char *, capture_info *,
> dt_operand ** = 0, bool = true);
> };
> @@ -1156,10 +1171,10 @@ struct dt_node
> dt_node *append_match_op (dt_operand *, dt_node *parent = 0, unsigned pos
> = 0);
> dt_node *append_simplify (simplify *, unsigned, dt_operand **);
>
> - virtual void gen (FILE *, bool) {}
> + virtual void gen (FILE *, int, bool) {}
>
> - void gen_kids (FILE *, bool);
> - void gen_kids_1 (FILE *, bool,
> + void gen_kids (FILE *, int, bool);
> + void gen_kids_1 (FILE *, int, bool,
> vec<dt_operand *>, vec<dt_operand *>, vec<dt_operand *>,
> vec<dt_operand *>, vec<dt_operand *>, vec<dt_node *>);
> };
> @@ -1178,12 +1193,12 @@ struct dt_operand : public dt_node
> : dt_node (type), op (op_), match_dop (match_dop_),
> parent (parent_), pos (pos_) {}
>
> - void gen (FILE *, bool);
> - unsigned gen_predicate (FILE *, const char *, bool);
> - unsigned gen_match_op (FILE *, const char *);
> + void gen (FILE *, int, bool);
> + unsigned gen_predicate (FILE *, int, const char *, bool);
> + unsigned gen_match_op (FILE *, int, const char *);
>
> - unsigned gen_gimple_expr (FILE *);
> - unsigned gen_generic_expr (FILE *, const char *);
> + unsigned gen_gimple_expr (FILE *, int);
> + unsigned gen_generic_expr (FILE *, int, const char *);
>
> char *get_name (char *);
> void gen_opname (char *, unsigned);
> @@ -1201,7 +1216,7 @@ struct dt_simplify : public dt_node
> : dt_node (DT_SIMPLIFY), s (s_), pattern_no (pattern_no_),
> indexes (indexes_) {}
>
> - void gen (FILE *f, bool);
> + void gen (FILE *f, int, bool);
> };
>
> template<>
> @@ -1726,8 +1741,8 @@ get_operand_type (id_base *op, const cha
> /* Generate transform code for an expression. */
>
> void
> -expr::gen_transform (FILE *f, const char *dest, bool gimple, int depth,
> - const char *in_type, capture_info *cinfo,
> +expr::gen_transform (FILE *f, int indent, const char *dest, bool gimple,
> + int depth, const char *in_type, capture_info *cinfo,
> dt_operand **indexes, bool)
> {
> bool conversion_p = is_conversion (operation);
> @@ -1771,18 +1786,20 @@ expr::gen_transform (FILE *f, const char
> if (!type)
> fatal ("two conversions in a row");
>
> - fprintf (f, "{\n");
> - fprintf (f, " tree ops%d[%u], res;\n", depth, ops.length ());
> + fprintf_indent (f, indent, "{\n");
> + indent += 2;
> + fprintf_indent (f, indent, "tree ops%d[%u], res;\n", depth, ops.length ());
> char op0type[64];
> snprintf (op0type, 64, "TREE_TYPE (ops%d[0])", depth);
> for (unsigned i = 0; i < ops.length (); ++i)
> {
> char dest[32];
> - snprintf (dest, 32, " ops%d[%u]", depth, i);
> + snprintf (dest, 32, "ops%d[%u]", depth, i);
> const char *optype
> = get_operand_type (operation, in_type, expr_type,
> i == 0 ? NULL : op0type);
> - ops[i]->gen_transform (f, dest, gimple, depth + 1, optype, cinfo,
> indexes,
> + ops[i]->gen_transform (f, indent, dest, gimple, depth + 1, optype,
> + cinfo, indexes,
> ((!(*operation == COND_EXPR)
> && !(*operation == VEC_COND_EXPR))
> || i != 0));
> @@ -1797,45 +1814,67 @@ expr::gen_transform (FILE *f, const char
> if (gimple)
> {
> if (*operation == CONVERT_EXPR)
> - fprintf (f, " if (%s != TREE_TYPE (ops%d[0])\n"
> - " && !useless_type_conversion_p (%s, TREE_TYPE
> (ops%d[0])))\n"
> - " {\n", type, depth, type, depth);
> + {
> + fprintf_indent (f, indent,
> + "if (%s != TREE_TYPE (ops%d[0])\n",
> + type, depth);
> + fprintf_indent (f, indent,
> + " && !useless_type_conversion_p (%s, TREE_TYPE
> (ops%d[0])))\n",
> + type, depth);
> + fprintf_indent (f, indent + 2, "{\n");
> + indent += 4;
> + }
> /* ??? Building a stmt can fail for various reasons here, seq being
> NULL or the stmt referencing SSA names occuring in abnormal PHIs.
> So if we fail here we should continue matching other patterns. */
> - fprintf (f, " code_helper tem_code = %s;\n"
> - " tree tem_ops[3] = { ", opr);
> + fprintf_indent (f, indent, "code_helper tem_code = %s;\n", opr);
> + fprintf_indent (f, indent, "tree tem_ops[3] = { ");
> for (unsigned i = 0; i < ops.length (); ++i)
> fprintf (f, "ops%d[%u]%s", depth, i,
> i == ops.length () - 1 ? " };\n" : ", ");
> - fprintf (f, " gimple_resimplify%d (seq, &tem_code, %s, tem_ops,
> valueize);\n",
> - ops.length (), type);
> - fprintf (f, " res = maybe_push_res_to_seq (tem_code, %s, tem_ops,
> seq);\n"
> - " if (!res) return false;\n", type);
> + fprintf_indent (f, indent,
> + "gimple_resimplify%d (seq, &tem_code, %s, tem_ops,
> valueize);\n",
> + ops.length (), type);
> + fprintf_indent (f, indent,
> + "res = maybe_push_res_to_seq (tem_code, %s, tem_ops,
> seq);\n",
> + type);
> + fprintf_indent (f, indent,
> + "if (!res) return false;\n");
> if (*operation == CONVERT_EXPR)
> - fprintf (f, " }\n"
> - " else\n"
> - " res = ops%d[0];\n", depth);
> + {
> + indent -= 4;
> + fprintf_indent (f, indent, " }\n");
> + fprintf_indent (f, indent, "else\n");
> + fprintf_indent (f, indent, " res = ops%d[0];\n", depth);
> + }
> }
> else
> {
> if (*operation == CONVERT_EXPR)
> - fprintf (f, " if (TREE_TYPE (ops%d[0]) != %s)\n", depth, type);
> + {
> + fprintf_indent (f, indent, "if (TREE_TYPE (ops%d[0]) != %s)\n",
> + depth, type);
> + indent += 2;
> + }
> if (operation->kind == id_base::CODE)
> - fprintf (f, " res = fold_build%d_loc (loc, %s, %s",
> - ops.length(), opr, type);
> + fprintf_indent (f, indent, "res = fold_build%d_loc (loc, %s, %s",
> + ops.length(), opr, type);
> else
> - fprintf (f, " res = build_call_expr_loc (loc, "
> - "builtin_decl_implicit (%s), %d", opr, ops.length());
> + fprintf_indent (f, indent, "res = build_call_expr_loc (loc, "
> + "builtin_decl_implicit (%s), %d", opr, ops.length());
> for (unsigned i = 0; i < ops.length (); ++i)
> fprintf (f, ", ops%d[%u]", depth, i);
> fprintf (f, ");\n");
> if (*operation == CONVERT_EXPR)
> - fprintf (f, " else\n"
> - " res = ops%d[0];\n", depth);
> + {
> + indent -= 2;
> + fprintf_indent (f, indent, "else\n");
> + fprintf_indent (f, indent, " res = ops%d[0];\n", depth);
> + }
> }
> - fprintf (f, "%s = res;\n", dest);
> - fprintf (f, "}\n");
> + fprintf_indent (f, indent, "%s = res;\n", dest);
> + indent -= 2;
> + fprintf_indent (f, indent, "}\n");
> }
>
> /* Generate code for a c_expr which is either the expression inside
> @@ -1843,12 +1882,12 @@ expr::gen_transform (FILE *f, const char
> result to be stored to DEST. */
>
> void
> -c_expr::gen_transform (FILE *f, const char *dest,
> +c_expr::gen_transform (FILE *f, int indent, const char *dest,
> bool, int, const char *, capture_info *,
> dt_operand **, bool)
> {
> if (dest && nr_stmts == 1)
> - fprintf (f, "%s = ", dest);
> + fprintf_indent (f, indent, "%s = ", dest);
>
> unsigned stmt_nr = 1;
> for (unsigned i = 0; i < code.length (); ++i)
> @@ -1902,10 +1941,9 @@ c_expr::gen_transform (FILE *f, const ch
> if (token->type == CPP_SEMICOLON)
> {
> stmt_nr++;
> + fputc ('\n', f);
> if (dest && stmt_nr == nr_stmts)
> - fprintf (f, "\n %s = ", dest);
> - else
> - fputc ('\n', f);
> + fprintf_indent (f, indent, "%s = ", dest);
> }
> }
> }
> @@ -1913,8 +1951,8 @@ c_expr::gen_transform (FILE *f, const ch
> /* Generate transform code for a capture. */
>
> void
> -capture::gen_transform (FILE *f, const char *dest, bool gimple, int depth,
> - const char *in_type, capture_info *cinfo,
> +capture::gen_transform (FILE *f, int indent, const char *dest, bool gimple,
> + int depth, const char *in_type, capture_info *cinfo,
> dt_operand **indexes, bool expand_compares)
> {
> if (what && is_a<expr *> (what))
> @@ -1923,11 +1961,12 @@ capture::gen_transform (FILE *f, const c
> {
> char buf[20];
> sprintf (buf, "captures[%u]", where);
> - what->gen_transform (f, buf, gimple, depth, in_type, cinfo, NULL);
> + what->gen_transform (f, indent, buf, gimple, depth, in_type,
> + cinfo, NULL);
> }
> }
>
> - fprintf (f, "%s = captures[%u];\n", dest, where);
> + fprintf_indent (f, indent, "%s = captures[%u];\n", dest, where);
>
> /* ??? Stupid tcc_comparison GENERIC trees in COND_EXPRs. Deal
> with substituting a capture of that.
> @@ -1935,13 +1974,16 @@ capture::gen_transform (FILE *f, const c
> to match. */
> if (gimple && expand_compares
> && cinfo->info[where].cond_expr_cond_p)
> - fprintf (f, "if (COMPARISON_CLASS_P (%s))\n"
> - " {\n"
> - " if (!seq) return false;\n"
> - " %s = gimple_build (seq, TREE_CODE (%s),"
> - " TREE_TYPE (%s), TREE_OPERAND (%s, 0),"
> - " TREE_OPERAND (%s, 1));\n"
> - " }\n", dest, dest, dest, dest, dest, dest);
> + {
> + fprintf_indent (f, indent, "if (COMPARISON_CLASS_P (%s))\n", dest);
> + fprintf_indent (f, indent, " {\n");
> + fprintf_indent (f, indent, " if (!seq) return false;\n");
> + fprintf_indent (f, indent, " %s = gimple_build (seq, TREE_CODE
> (%s),"
> + " TREE_TYPE (%s), TREE_OPERAND (%s, 0),"
> + " TREE_OPERAND (%s, 1));\n",
> + dest, dest, dest, dest, dest);
> + fprintf_indent (f, indent, " }\n");
> + }
> }
>
> /* Return the name of the operand representing the decision tree node.
> @@ -1976,7 +2018,7 @@ dt_operand::gen_opname (char *name, unsi
> a predicate. */
>
> unsigned
> -dt_operand::gen_predicate (FILE *f, const char *opname, bool gimple)
> +dt_operand::gen_predicate (FILE *f, int indent, const char *opname, bool
> gimple)
> {
> predicate *p = as_a <predicate *> (op);
>
> @@ -1985,13 +2027,14 @@ dt_operand::gen_predicate (FILE *f, cons
> /* If this is a predicate generated from a pattern mangle its
> name and pass on the valueize hook. */
> if (gimple)
> - fprintf (f, "if (gimple_%s (%s, valueize))\n", p->p->id, opname);
> + fprintf_indent (f, indent, "if (gimple_%s (%s, valueize))\n",
> + p->p->id, opname);
> else
> - fprintf (f, "if (tree_%s (%s))\n", p->p->id, opname);
> + fprintf_indent (f, indent, "if (tree_%s (%s))\n", p->p->id, opname);
> }
> else
> - fprintf (f, "if (%s (%s))\n", p->p->id, opname);
> - fprintf (f, "{\n");
> + fprintf_indent (f, indent, "if (%s (%s))\n", p->p->id, opname);
> + fprintf_indent (f, indent + 2, "{\n");
> return 1;
> }
>
> @@ -1999,20 +2042,20 @@ dt_operand::gen_predicate (FILE *f, cons
> a capture-match. */
>
> unsigned
> -dt_operand::gen_match_op (FILE *f, const char *opname)
> +dt_operand::gen_match_op (FILE *f, int indent, const char *opname)
> {
> char match_opname[20];
> match_dop->get_name (match_opname);
> - fprintf (f, "if (%s == %s || operand_equal_p (%s, %s, 0))\n",
> - opname, match_opname, opname, match_opname);
> - fprintf (f, "{\n");
> + fprintf_indent (f, indent, "if (%s == %s || operand_equal_p (%s, %s,
> 0))\n",
> + opname, match_opname, opname, match_opname);
> + fprintf_indent (f, indent + 2, "{\n");
> return 1;
> }
>
> /* Generate GIMPLE matching code for the decision tree operand. */
>
> unsigned
> -dt_operand::gen_gimple_expr (FILE *f)
> +dt_operand::gen_gimple_expr (FILE *f, int indent)
> {
> expr *e = static_cast<expr *> (op);
> id_base *id = e->operation;
> @@ -2032,25 +2075,37 @@ dt_operand::gen_gimple_expr (FILE *f)
> /* ??? If this is a memory operation we can't (and should not)
> match this. The only sensible operand types are
> SSA names and invariants. */
> - fprintf (f, "tree %s = TREE_OPERAND (gimple_assign_rhs1
> (def_stmt), %i);\n",
> - child_opname, i);
> - fprintf (f, "if ((TREE_CODE (%s) == SSA_NAME\n"
> - "|| is_gimple_min_invariant (%s))\n"
> - "&& (%s = do_valueize (valueize, %s)))\n"
> - "{\n", child_opname, child_opname, child_opname,
> - child_opname);
> + fprintf_indent (f, indent,
> + "tree %s = TREE_OPERAND (gimple_assign_rhs1
> (def_stmt), %i);\n",
> + child_opname, i);
> + fprintf_indent (f, indent,
> + "if ((TREE_CODE (%s) == SSA_NAME\n",
> + child_opname);
> + fprintf_indent (f, indent,
> + " || is_gimple_min_invariant (%s))\n",
> + child_opname);
> + fprintf_indent (f, indent,
> + " && (%s = do_valueize (valueize, %s)))\n",
> + child_opname, child_opname);
> + fprintf_indent (f, indent,
> + " {\n");
> + indent += 4;
> continue;
> }
> else
> - fprintf (f, "tree %s = gimple_assign_rhs%u (def_stmt);\n",
> - child_opname, i + 1);
> + fprintf_indent (f, indent,
> + "tree %s = gimple_assign_rhs%u (def_stmt);\n",
> + child_opname, i + 1);
> }
> else
> - fprintf (f, "tree %s = gimple_call_arg (def_stmt, %u);\n",
> - child_opname, i);
> - fprintf (f, "if ((%s = do_valueize (valueize, %s)))\n",
> - child_opname, child_opname);
> - fprintf (f, "{\n");
> + fprintf_indent (f, indent,
> + "tree %s = gimple_call_arg (def_stmt, %u);\n",
> + child_opname, i);
> + fprintf_indent (f, indent,
> + "if ((%s = do_valueize (valueize, %s)))\n",
> + child_opname, child_opname);
> + fprintf_indent (f, indent, " {\n");
> + indent += 4;
> }
> /* While the toplevel operands are canonicalized by the caller
> after valueizing operands of sub-expressions we have to
> @@ -2066,9 +2121,12 @@ dt_operand::gen_gimple_expr (FILE *f)
> char child_opname0[20], child_opname1[20];
> gen_opname (child_opname0, 0);
> gen_opname (child_opname1, 1);
> - fprintf (f, "if (tree_swap_operands_p (%s, %s, false))\n"
> - " std::swap (%s, %s);\n", child_opname0, child_opname1,
> - child_opname0, child_opname1);
> + fprintf_indent (f, indent,
> + "if (tree_swap_operands_p (%s, %s, false))\n",
> + child_opname0, child_opname1);
> + fprintf_indent (f, indent,
> + " std::swap (%s, %s);\n",
> + child_opname0, child_opname1);
> }
> }
>
> @@ -2078,7 +2136,7 @@ dt_operand::gen_gimple_expr (FILE *f)
> /* Generate GENERIC matching code for the decision tree operand. */
>
> unsigned
> -dt_operand::gen_generic_expr (FILE *f, const char *opname)
> +dt_operand::gen_generic_expr (FILE *f, int indent, const char *opname)
> {
> expr *e = static_cast<expr *> (op);
> unsigned n_ops = e->ops.length ();
> @@ -2089,11 +2147,11 @@ dt_operand::gen_generic_expr (FILE *f, c
> gen_opname (child_opname, i);
>
> if (e->operation->kind == id_base::CODE)
> - fprintf (f, "tree %s = TREE_OPERAND (%s, %u);\n",
> - child_opname, opname, i);
> + fprintf_indent (f, indent, "tree %s = TREE_OPERAND (%s, %u);\n",
> + child_opname, opname, i);
> else
> - fprintf (f, "tree %s = CALL_EXPR_ARG (%s, %u);\n",
> - child_opname, opname, i);
> + fprintf_indent (f, indent, "tree %s = CALL_EXPR_ARG (%s, %u);\n",
> + child_opname, opname, i);
> }
>
> return 0;
> @@ -2102,7 +2160,7 @@ dt_operand::gen_generic_expr (FILE *f, c
> /* Generate matching code for the children of the decision tree node. */
>
> void
> -dt_node::gen_kids (FILE *f, bool gimple)
> +dt_node::gen_kids (FILE *f, int indent, bool gimple)
> {
> auto_vec<dt_operand *> gimple_exprs;
> auto_vec<dt_operand *> generic_exprs;
> @@ -2150,10 +2208,10 @@ dt_node::gen_kids (FILE *f, bool gimple)
> {
> /* A DT_TRUE operand serves as a barrier - generate code now
> for what we have collected sofar. */
> - gen_kids_1 (f, gimple, gimple_exprs, generic_exprs,
> + gen_kids_1 (f, indent, gimple, gimple_exprs, generic_exprs,
> fns, generic_fns, preds, others);
> /* And output the true operand itself. */
> - kids[i]->gen (f, gimple);
> + kids[i]->gen (f, indent, gimple);
> gimple_exprs.truncate (0);
> generic_exprs.truncate (0);
> fns.truncate (0);
> @@ -2166,14 +2224,14 @@ dt_node::gen_kids (FILE *f, bool gimple)
> }
>
> /* Generate code for the remains. */
> - gen_kids_1 (f, gimple, gimple_exprs, generic_exprs,
> + gen_kids_1 (f, indent, gimple, gimple_exprs, generic_exprs,
> fns, generic_fns, preds, others);
> }
>
> /* Generate matching code for the children of the decision tree node. */
>
> void
> -dt_node::gen_kids_1 (FILE *f, bool gimple,
> +dt_node::gen_kids_1 (FILE *f, int indent, bool gimple,
> vec<dt_operand *> gimple_exprs,
> vec<dt_operand *> generic_exprs,
> vec<dt_operand *> fns,
> @@ -2200,67 +2258,88 @@ dt_node::gen_kids_1 (FILE *f, bool gimpl
> else
> generic_exprs[0]->get_name (kid_opname);
>
> - fprintf (f, "switch (TREE_CODE (%s))\n"
> - "{\n", kid_opname);
> + fprintf_indent (f, indent, "switch (TREE_CODE (%s))\n", kid_opname);
> + fprintf_indent (f, indent, " {\n");
> + indent += 4;
> }
>
> if (exprs_len || fns_len)
> {
> - fprintf (f, "case SSA_NAME:\n");
> - fprintf (f, "if (do_valueize (valueize, %s) != NULL_TREE)\n",
> kid_opname);
> - fprintf (f, "{\n");
> - fprintf (f, "gimple def_stmt = SSA_NAME_DEF_STMT (%s);\n", kid_opname);
> + fprintf_indent (f, indent,
> + "case SSA_NAME:\n");
> + fprintf_indent (f, indent,
> + " if (do_valueize (valueize, %s) != NULL_TREE)\n",
> + kid_opname);
> + fprintf_indent (f, indent,
> + " {\n");
> + fprintf_indent (f, indent,
> + " gimple def_stmt = SSA_NAME_DEF_STMT (%s);\n",
> + kid_opname);
>
> + indent += 6;
> if (exprs_len)
> {
> - fprintf (f, "if (is_gimple_assign (def_stmt))\n");
> - fprintf (f, "switch (gimple_assign_rhs_code (def_stmt))\n"
> - "{\n");
> + fprintf_indent (f, indent,
> + "if (is_gimple_assign (def_stmt))\n");
> + fprintf_indent (f, indent,
> + " switch (gimple_assign_rhs_code (def_stmt))\n");
> + indent += 4;
> + fprintf_indent (f, indent, "{\n");
> for (unsigned i = 0; i < exprs_len; ++i)
> {
> expr *e = as_a <expr *> (gimple_exprs[i]->op);
> id_base *op = e->operation;
> if (*op == CONVERT_EXPR || *op == NOP_EXPR)
> - fprintf (f, "CASE_CONVERT:\n");
> + fprintf_indent (f, indent, " CASE_CONVERT:\n");
> else
> - fprintf (f, "case %s:\n", op->id);
> - fprintf (f, "{\n");
> - gimple_exprs[i]->gen (f, true);
> - fprintf (f, "break;\n"
> - "}\n");
> + fprintf_indent (f, indent, " case %s:\n", op->id);
> + fprintf_indent (f, indent, " {\n");
> + gimple_exprs[i]->gen (f, indent + 6, true);
> + fprintf_indent (f, indent, " break;\n");
> + fprintf_indent (f, indent, " }\n");
> }
> - fprintf (f, "default:;\n"
> - "}\n");
> + fprintf_indent (f, indent, " default:;\n");
> + indent -= 4;
> + fprintf_indent (f, indent, "}\n");
> }
>
> if (fns_len)
> {
> if (exprs_len)
> - fprintf (f, "else ");
> + fprintf_indent (f, indent, "else ");
> + else
> + fprintf_indent (f, indent, " ");
>
> - fprintf (f, "if (gimple_call_builtin_p (def_stmt,
> BUILT_IN_NORMAL))\n"
> - "{\n"
> - "tree fndecl = gimple_call_fndecl (def_stmt);\n"
> - "switch (DECL_FUNCTION_CODE (fndecl))\n"
> - "{\n");
> + fprintf (f, "if (gimple_call_builtin_p (def_stmt,
> BUILT_IN_NORMAL))\n");
> + fprintf_indent (f, indent,
> + " {\n");
> + fprintf_indent (f, indent,
> + " tree fndecl = gimple_call_fndecl
> (def_stmt);\n");
> + fprintf_indent (f, indent,
> + " switch (DECL_FUNCTION_CODE (fndecl))\n");
> + fprintf_indent (f, indent,
> + " {\n");
> + indent += 8;
>
> for (unsigned i = 0; i < fns_len; ++i)
> {
> expr *e = as_a <expr *>(fns[i]->op);
> - fprintf (f, "case %s:\n"
> - "{\n", e->operation->id);
> - fns[i]->gen (f, true);
> - fprintf (f, "break;\n"
> - "}\n");
> + fprintf_indent (f, indent, "case %s:\n", e->operation->id);
> + fprintf_indent (f, indent, " {\n");
> + fns[i]->gen (f, indent + 4, true);
> + fprintf_indent (f, indent, " break;\n");
> + fprintf_indent (f, indent, " }\n");
> }
>
> - fprintf (f, "default:;\n"
> - "}\n"
> - "}\n");
> + fprintf_indent (f, indent, "default:;\n");
> + indent -= 8;
> + fprintf_indent (f, indent, " }\n");
> + fprintf_indent (f, indent, " }\n");
> }
>
> - fprintf (f, "}\n"
> - "break;\n");
> + indent -= 6;
> + fprintf_indent (f, indent, " }\n");
> + fprintf_indent (f, indent, " break;\n");
> }
>
> for (unsigned i = 0; i < generic_exprs.length (); ++i)
> @@ -2268,76 +2347,89 @@ dt_node::gen_kids_1 (FILE *f, bool gimpl
> expr *e = as_a <expr *>(generic_exprs[i]->op);
> id_base *op = e->operation;
> if (*op == CONVERT_EXPR || *op == NOP_EXPR)
> - fprintf (f, "CASE_CONVERT:\n");
> + fprintf_indent (f, indent, "CASE_CONVERT:\n");
> else
> - fprintf (f, "case %s:\n", op->id);
> - fprintf (f, "{\n");
> - generic_exprs[i]->gen (f, gimple);
> - fprintf (f, "break;\n"
> - "}\n");
> + fprintf_indent (f, indent, "case %s:\n", op->id);
> + fprintf_indent (f, indent, " {\n");
> + generic_exprs[i]->gen (f, indent + 4, gimple);
> + fprintf_indent (f, indent, " break;\n");
> + fprintf_indent (f, indent, " }\n");
> }
>
> if (gfns_len)
> {
> - fprintf (f, "case CALL_EXPR:\n"
> - "{\n"
> - "tree fndecl = get_callee_fndecl (%s);\n"
> - "if (fndecl && DECL_BUILT_IN_CLASS (fndecl) ==
> BUILT_IN_NORMAL)\n"
> - "switch (DECL_FUNCTION_CODE (fndecl))\n"
> - "{\n", kid_opname);
> + fprintf_indent (f, indent,
> + "case CALL_EXPR:\n");
> + fprintf_indent (f, indent,
> + " {\n");
> + fprintf_indent (f, indent,
> + " tree fndecl = get_callee_fndecl (%s);\n",
> + kid_opname);
> + fprintf_indent (f, indent,
> + " if (fndecl && DECL_BUILT_IN_CLASS (fndecl) ==
> BUILT_IN_NORMAL)\n");
> + fprintf_indent (f, indent,
> + " switch (DECL_FUNCTION_CODE (fndecl))\n");
> + fprintf_indent (f, indent,
> + " {\n");
> + indent += 10;
>
> for (unsigned j = 0; j < generic_fns.length (); ++j)
> {
> expr *e = as_a <expr *>(generic_fns[j]->op);
> gcc_assert (e->operation->kind == id_base::FN);
>
> - fprintf (f, "case %s:\n"
> - "{\n", e->operation->id);
> - generic_fns[j]->gen (f, false);
> - fprintf (f, "break;\n"
> - "}\n");
> + fprintf_indent (f, indent, "case %s:\n", e->operation->id);
> + fprintf_indent (f, indent, " {\n");
> + generic_fns[j]->gen (f, indent + 4, false);
> + fprintf_indent (f, indent, " break;\n");
> + fprintf_indent (f, indent, " }\n");
> }
>
> - fprintf (f, "default:;\n"
> - "}\n"
> - "break;\n"
> - "}\n");
> + indent -= 10;
> + fprintf_indent (f, indent, " default:;\n");
> + fprintf_indent (f, indent, " }\n");
> + fprintf_indent (f, indent, " break;\n");
> + fprintf_indent (f, indent, " }\n");
> }
>
> /* Close switch (TREE_CODE ()). */
> if (exprs_len || fns_len || gexprs_len || gfns_len)
> - fprintf (f, "default:;\n"
> - "}\n");
> + {
> + indent -= 4;
> + fprintf_indent (f, indent, " default:;\n");
> + fprintf_indent (f, indent, " }\n");
> + }
>
> for (unsigned i = 0; i < preds.length (); ++i)
> {
> expr *e = as_a <expr *> (preds[i]->op);
> predicate_id *p = as_a <predicate_id *> (e->operation);
> preds[i]->get_name (kid_opname);
> - fprintf (f, "tree %s_pops[%d];\n", kid_opname, p->nargs);
> - fprintf (f, "if (%s_%s (%s, %s_pops%s))\n",
> + fprintf_indent (f, indent, "tree %s_pops[%d];\n", kid_opname,
> p->nargs);
> + fprintf_indent (f, indent, "if (%s_%s (%s, %s_pops%s))\n",
> gimple ? "gimple" : "tree",
> p->id, kid_opname, kid_opname,
> gimple ? ", valueize" : "");
> - fprintf (f, "{\n");
> + fprintf_indent (f, indent, " {\n");
> for (int j = 0; j < p->nargs; ++j)
> {
> char child_opname[20];
> preds[i]->gen_opname (child_opname, j);
> - fprintf (f, "tree %s = %s_pops[%d];\n", child_opname, kid_opname,
> j);
> + fprintf_indent (f, indent + 4, "tree %s = %s_pops[%d];\n",
> + child_opname, kid_opname, j);
> }
> - preds[i]->gen_kids (f, gimple);
> + preds[i]->gen_kids (f, indent + 4, gimple);
> fprintf (f, "}\n");
> }
>
> for (unsigned i = 0; i < others.length (); ++i)
> - others[i]->gen (f, gimple);
> + others[i]->gen (f, indent, gimple);
> }
>
> /* Generate matching code for the decision tree operand. */
>
> void
> -dt_operand::gen (FILE *f, bool gimple)
> +dt_operand::gen (FILE *f, int indent, bool gimple)
> {
> char opname[20];
> get_name (opname);
> @@ -2348,14 +2440,14 @@ dt_operand::gen (FILE *f, bool gimple)
> switch (op->type)
> {
> case operand::OP_PREDICATE:
> - n_braces = gen_predicate (f, opname, gimple);
> + n_braces = gen_predicate (f, indent, opname, gimple);
> break;
>
> case operand::OP_EXPR:
> if (gimple)
> - n_braces = gen_gimple_expr (f);
> + n_braces = gen_gimple_expr (f, indent);
> else
> - n_braces = gen_generic_expr (f, opname);
> + n_braces = gen_generic_expr (f, indent, opname);
> break;
>
> default:
> @@ -2364,14 +2456,20 @@ dt_operand::gen (FILE *f, bool gimple)
> else if (type == DT_TRUE)
> ;
> else if (type == DT_MATCH)
> - n_braces = gen_match_op (f, opname);
> + n_braces = gen_match_op (f, indent, opname);
> else
> gcc_unreachable ();
>
> - gen_kids (f, gimple);
> + indent += 4 * n_braces;
> + gen_kids (f, indent, gimple);
>
> for (unsigned i = 0; i < n_braces; ++i)
> - fprintf (f, "}\n");
> + {
> + indent -= 4;
> + if (indent < 0)
> + indent = 0;
> + fprintf_indent (f, indent, " }\n");
> + }
> }
>
>
> @@ -2381,19 +2479,21 @@ dt_operand::gen (FILE *f, bool gimple)
> that is not part of the decision tree (simplify->match). */
>
> void
> -dt_simplify::gen (FILE *f, bool gimple)
> +dt_simplify::gen (FILE *f, int indent, bool gimple)
> {
> - fprintf (f, "{\n");
> + fprintf_indent (f, indent, "{\n");
> + indent += 2;
> output_line_directive (f, s->result_location);
> if (s->capture_max >= 0)
> - fprintf (f, "tree captures[%u] ATTRIBUTE_UNUSED = {};\n",
> - s->capture_max + 1);
> + fprintf_indent (f, indent, "tree captures[%u] ATTRIBUTE_UNUSED = {};\n",
> + s->capture_max + 1);
>
> for (int i = 0; i <= s->capture_max; ++i)
> if (indexes[i])
> {
> char opname[20];
> - fprintf (f, "captures[%u] = %s;\n", i, indexes[i]->get_name (opname));
> + fprintf_indent (f, indent, "captures[%u] = %s;\n",
> + i, indexes[i]->get_name (opname));
> }
>
> unsigned n_braces = 0;
> @@ -2404,18 +2504,19 @@ dt_simplify::gen (FILE *f, bool gimple)
> if_or_with &w = s->ifexpr_vec[i];
> if (w.is_with)
> {
> - fprintf (f, "{\n");
> + fprintf_indent (f, indent, "{\n");
> + indent += 4;
> output_line_directive (f, w.location);
> - w.cexpr->gen_transform (f, NULL, true, 1, "type", NULL);
> + w.cexpr->gen_transform (f, indent, NULL, true, 1, "type", NULL);
> n_braces++;
> }
> else
> {
> output_line_directive (f, w.location);
> - fprintf (f, "if (");
> + fprintf_indent (f, indent, "if (");
> if (i == s->ifexpr_vec.length () - 1
> || s->ifexpr_vec[i+1].is_with)
> - w.cexpr->gen_transform (f, NULL, true, 1, "type", NULL);
> + w.cexpr->gen_transform (f, indent, NULL, true, 1, "type",
> NULL);
> else
> {
> unsigned j = i;
> @@ -2425,10 +2526,10 @@ dt_simplify::gen (FILE *f, bool gimple)
> {
> fprintf (f, "\n");
> output_line_directive (f,
> s->ifexpr_vec[j].location);
> - fprintf (f, "&& ");
> + fprintf_indent (f, indent + 4, "&& ");
> }
> fprintf (f, "(");
> - s->ifexpr_vec[j].cexpr->gen_transform (f, NULL,
> + s->ifexpr_vec[j].cexpr->gen_transform (f, 0, NULL,
> true, 1, "type",
> NULL);
> fprintf (f, ")");
> @@ -2441,7 +2542,8 @@ dt_simplify::gen (FILE *f, bool gimple)
> fprintf (f, ")\n");
> }
> }
> - fprintf (f, "{\n");
> + fprintf_indent (f, indent + 2, "{\n");
> + indent += 4;
> n_braces++;
> }
>
> @@ -2456,15 +2558,18 @@ dt_simplify::gen (FILE *f, bool gimple)
> {
> for (unsigned i = 0; i < as_a <expr *> (s->match)->ops.length (); ++i)
> if (cinfo.force_no_side_effects & (1 << i))
> - fprintf (f, "if (TREE_SIDE_EFFECTS (op%d)) return NULL_TREE;\n", i);
> + fprintf_indent (f, indent,
> + "if (TREE_SIDE_EFFECTS (op%d)) return NULL_TREE;\n",
> + i);
> for (int i = 0; i <= s->capture_max; ++i)
> if (cinfo.info[i].cse_p)
> ;
> else if (cinfo.info[i].force_no_side_effects_p
> && (cinfo.info[i].toplevel_msk
> & cinfo.force_no_side_effects) == 0)
> - fprintf (f, "if (TREE_SIDE_EFFECTS (captures[%d])) "
> - "return NULL_TREE;\n", i);
> + fprintf_indent (f, indent,
> + "if (TREE_SIDE_EFFECTS (captures[%d])) "
> + "return NULL_TREE;\n", i);
> else if ((cinfo.info[i].toplevel_msk
> & cinfo.force_no_side_effects) != 0)
> /* Mark capture as having no side-effects if we had to verify
> @@ -2472,7 +2577,7 @@ dt_simplify::gen (FILE *f, bool gimple)
> cinfo.info[i].force_no_side_effects_p = true;
> }
>
> - fprintf (f, "if (dump_file && (dump_flags & TDF_DETAILS)) "
> + fprintf_indent (f, indent, "if (dump_file && (dump_flags & TDF_DETAILS)) "
> "fprintf (dump_file, \"Applying pattern ");
> output_line_directive (f, s->result_location, true);
> fprintf (f, ", %%s:%%d\\n\", __FILE__, __LINE__);\n");
> @@ -2481,7 +2586,7 @@ dt_simplify::gen (FILE *f, bool gimple)
> if (!result)
> {
> /* If there is no result then this is a predicate implementation. */
> - fprintf (f, "return true;\n");
> + fprintf_indent (f, indent, "return true;\n");
> }
> else if (gimple)
> {
> @@ -2495,18 +2600,17 @@ dt_simplify::gen (FILE *f, bool gimple)
> expr *e = as_a <expr *> (result);
> bool is_predicate = is_a <predicate_id *> (e->operation);
> if (!is_predicate)
> - fprintf (f, "*res_code = %s;\n",
> - *e->operation == CONVERT_EXPR
> - ? "NOP_EXPR" : e->operation->id);
> + fprintf_indent (f, indent, "*res_code = %s;\n",
> + *e->operation == CONVERT_EXPR
> + ? "NOP_EXPR" : e->operation->id);
> for (unsigned j = 0; j < e->ops.length (); ++j)
> {
> char dest[32];
> - snprintf (dest, 32, " res_ops[%d]", j);
> + snprintf (dest, 32, "res_ops[%d]", j);
> const char *optype
> = get_operand_type (e->operation,
> "type", e->expr_type,
> - j == 0
> - ? NULL : "TREE_TYPE (res_ops[0])");
> + j == 0 ? NULL : "TREE_TYPE (res_ops[0])");
> /* We need to expand GENERIC conditions we captured from
> COND_EXPRs. */
> bool expand_generic_cond_exprs_p
> @@ -2517,38 +2621,46 @@ dt_simplify::gen (FILE *f, bool gimple)
> && ((!(*e->operation == COND_EXPR)
> && !(*e->operation == VEC_COND_EXPR))
> || j != 0));
> - e->ops[j]->gen_transform (f, dest, true, 1, optype, &cinfo,
> + e->ops[j]->gen_transform (f, indent, dest, true, 1, optype,
> + &cinfo,
> indexes, expand_generic_cond_exprs_p);
> }
>
> /* Re-fold the toplevel result. It's basically an embedded
> gimple_build w/o actually building the stmt. */
> if (!is_predicate)
> - fprintf (f, "gimple_resimplify%d (seq, res_code, type, "
> - "res_ops, valueize);\n", e->ops.length ());
> + fprintf_indent (f, indent,
> + "gimple_resimplify%d (seq, res_code, type, "
> + "res_ops, valueize);\n", e->ops.length ());
> }
> else if (result->type == operand::OP_CAPTURE
> || result->type == operand::OP_C_EXPR)
> {
> - result->gen_transform (f, "res_ops[0]", true, 1, "type",
> + result->gen_transform (f, indent, "res_ops[0]", true, 1, "type",
> &cinfo, indexes, false);
> - fprintf (f, "*res_code = TREE_CODE (res_ops[0]);\n");
> + fprintf_indent (f, indent, "*res_code = TREE_CODE (res_ops[0]);\n");
> if (is_a <capture *> (result)
> && cinfo.info[as_a <capture *>
> (result)->where].cond_expr_cond_p)
> {
> /* ??? Stupid tcc_comparison GENERIC trees in COND_EXPRs. Deal
> with substituting a capture of that. */
> - fprintf (f, "if (COMPARISON_CLASS_P (res_ops[0]))\n"
> - " {\n"
> - " tree tem = res_ops[0];\n"
> - " res_ops[0] = TREE_OPERAND (tem, 0);\n"
> - " res_ops[1] = TREE_OPERAND (tem, 1);\n"
> - " }\n");
> + fprintf_indent (f, indent,
> + "if (COMPARISON_CLASS_P (res_ops[0]))\n");
> + fprintf_indent (f, indent,
> + " {\n");
> + fprintf_indent (f, indent,
> + " tree tem = res_ops[0];\n");
> + fprintf_indent (f, indent,
> + " res_ops[0] = TREE_OPERAND (tem, 0);\n");
> + fprintf_indent (f, indent,
> + " res_ops[1] = TREE_OPERAND (tem, 1);\n");
> + fprintf_indent (f, indent,
> + " }\n");
> }
> }
> else
> gcc_unreachable ();
> - fprintf (f, "return true;\n");
> + fprintf_indent (f, indent, "return true;\n");
> }
> else /* GENERIC */
> {
> @@ -2564,9 +2676,14 @@ dt_simplify::gen (FILE *f, bool gimple)
> {
> if (!cinfo.info[i].force_no_side_effects_p
> && cinfo.info[i].result_use_count > 1)
> - fprintf (f, " if (TREE_SIDE_EFFECTS (captures[%d]))\n"
> - " captures[%d] = save_expr (captures[%d]);\n",
> - i, i, i);
> + {
> + fprintf_indent (f, indent,
> + "if (TREE_SIDE_EFFECTS (captures[%d]))\n",
> + i);
> + fprintf_indent (f, indent,
> + " captures[%d] = save_expr
> (captures[%d]);\n",
> + i, i);
> + }
> }
> for (unsigned j = 0; j < e->ops.length (); ++j)
> {
> @@ -2575,38 +2692,41 @@ dt_simplify::gen (FILE *f, bool gimple)
> snprintf (dest, 32, "res_ops[%d]", j);
> else
> {
> - fprintf (f, " tree res_op%d;\n", j);
> - snprintf (dest, 32, " res_op%d", j);
> + fprintf_indent (f, indent, "tree res_op%d;\n", j);
> + snprintf (dest, 32, "res_op%d", j);
> }
> const char *optype
> = get_operand_type (e->operation,
> "type", e->expr_type,
> j == 0
> ? NULL : "TREE_TYPE (res_op0)");
> - e->ops[j]->gen_transform (f, dest, false, 1, optype,
> + e->ops[j]->gen_transform (f, indent, dest, false, 1, optype,
> &cinfo, indexes);
> }
> if (is_predicate)
> - fprintf (f, "return true;\n");
> + fprintf_indent (f, indent, "return true;\n");
> else
> {
> - fprintf (f, " tree res;\n");
> + fprintf_indent (f, indent, "tree res;\n");
> /* Re-fold the toplevel result. Use non_lvalue to
> build NON_LVALUE_EXPRs so they get properly
> ignored when in GIMPLE form. */
> if (*e->operation == NON_LVALUE_EXPR)
> - fprintf (f, " res = non_lvalue_loc (loc, res_op0);\n");
> + fprintf_indent (f, indent,
> + "res = non_lvalue_loc (loc, res_op0);\n");
> else
> {
> if (e->operation->kind == id_base::CODE)
> - fprintf (f, " res = fold_build%d_loc (loc, %s, type",
> - e->ops.length (),
> - *e->operation == CONVERT_EXPR
> - ? "NOP_EXPR" : e->operation->id);
> + fprintf_indent (f, indent,
> + "res = fold_build%d_loc (loc, %s, type",
> + e->ops.length (),
> + *e->operation == CONVERT_EXPR
> + ? "NOP_EXPR" : e->operation->id);
> else
> - fprintf (f, " res = build_call_expr_loc "
> - "(loc, builtin_decl_implicit (%s), %d",
> - e->operation->id, e->ops.length());
> + fprintf_indent (f, indent,
> + "res = build_call_expr_loc "
> + "(loc, builtin_decl_implicit (%s), %d",
> + e->operation->id, e->ops.length());
> for (unsigned j = 0; j < e->ops.length (); ++j)
> fprintf (f, ", res_op%d", j);
> fprintf (f, ");\n");
> @@ -2617,8 +2737,8 @@ dt_simplify::gen (FILE *f, bool gimple)
> || result->type == operand::OP_C_EXPR)
>
> {
> - fprintf (f, " tree res;\n");
> - s->result->gen_transform (f, " res", false, 1, "type",
> + fprintf_indent (f, indent, "tree res;\n");
> + s->result->gen_transform (f, indent, "res", false, 1, "type",
> &cinfo, indexes);
> }
> else
> @@ -2632,19 +2752,28 @@ dt_simplify::gen (FILE *f, bool gimple)
> if (!cinfo.info[i].force_no_side_effects_p
> && !cinfo.info[i].expr_p
> && cinfo.info[i].result_use_count == 0)
> - fprintf (f, " if (TREE_SIDE_EFFECTS (captures[%d]))\n"
> - " res = build2_loc (loc, COMPOUND_EXPR, type,"
> - " fold_ignored_result (captures[%d]), res);\n",
> - i, i);
> + {
> + fprintf_indent (f, indent,
> + "if (TREE_SIDE_EFFECTS (captures[%d]))\n",
> + i);
> + fprintf_indent (f, indent + 2,
> + "res = build2_loc (loc, COMPOUND_EXPR,
> type, "
> + "fold_ignored_result (captures[%d]),
> res);\n",
> + i);
> + }
> }
> - fprintf (f, " return res;\n");
> + fprintf_indent (f, indent, "return res;\n");
> }
> }
>
> for (unsigned i = 0; i < n_braces; ++i)
> - fprintf (f, "}\n");
> + {
> + fprintf_indent (f, indent - 2, "}\n");
> + indent -= 4;
> + }
>
> - fprintf (f, "}\n");
> + indent -= 2;
> + fprintf_indent (f, indent, "}\n");
> }
>
> /* Main entry to generate code for matching GIMPLE IL off the decision
> @@ -2664,8 +2793,8 @@ decision_tree::gen_gimple (FILE *f)
> fprintf (f, ")\n");
> fprintf (f, "{\n");
>
> - fprintf (f, "switch (code.get_rep())\n"
> - "{\n");
> + fprintf (f, " switch (code.get_rep())\n"
> + " {\n");
> for (unsigned i = 0; i < root->kids.length (); i++)
> {
> dt_operand *dop = static_cast<dt_operand *>(root->kids[i]);
> @@ -2675,20 +2804,20 @@ decision_tree::gen_gimple (FILE *f)
>
> if (*e->operation == CONVERT_EXPR
> || *e->operation == NOP_EXPR)
> - fprintf (f, "CASE_CONVERT:\n");
> + fprintf (f, " CASE_CONVERT:\n");
> else
> - fprintf (f, "case %s%s:\n",
> + fprintf (f, " case %s%s:\n",
> is_a <fn_id *> (e->operation) ? "-" : "",
> e->operation->id);
> - fprintf (f, "{\n");
> - dop->gen_kids (f, true);
> - fprintf (f, "break;\n");
> - fprintf (f, "}\n");
> + fprintf (f, " {\n");
> + dop->gen_kids (f, 10, true);
> + fprintf (f, " break;\n");
> + fprintf (f, " }\n");
> }
> - fprintf (f, "default:;\n"
> - "}\n");
> + fprintf (f, " default:;\n"
> + " }\n");
>
> - fprintf (f, "return false;\n");
> + fprintf (f, " return false;\n");
> fprintf (f, "}\n");
> }
> }
> @@ -2709,8 +2838,8 @@ decision_tree::gen_generic (FILE *f)
> fprintf (f, ")\n");
> fprintf (f, "{\n");
>
> - fprintf (f, "switch (code)\n"
> - "{\n");
> + fprintf (f, " switch (code)\n"
> + " {\n");
> for (unsigned i = 0; i < root->kids.length (); i++)
> {
> dt_operand *dop = static_cast<dt_operand *>(root->kids[i]);
> @@ -2725,18 +2854,18 @@ decision_tree::gen_generic (FILE *f)
>
> operator_id *op_id = static_cast <operator_id *> (e->operation);
> if (op_id->code == NOP_EXPR || op_id->code == CONVERT_EXPR)
> - fprintf (f, "CASE_CONVERT:\n");
> + fprintf (f, " CASE_CONVERT:\n");
> else
> - fprintf (f, "case %s:\n", e->operation->id);
> - fprintf (f, "{\n");
> - dop->gen_kids (f, false);
> - fprintf (f, "break;\n"
> - "}\n");
> + fprintf (f, " case %s:\n", e->operation->id);
> + fprintf (f, " {\n");
> + dop->gen_kids (f, 10, false);
> + fprintf (f, " break;\n"
> + " }\n");
> }
> - fprintf (f, "default:;\n"
> - "}\n");
> + fprintf (f, " default:;\n"
> + " }\n");
>
> - fprintf (f, "return NULL_TREE;\n");
> + fprintf (f, " return NULL_TREE;\n");
> fprintf (f, "}\n");
> }
> }
> @@ -2752,13 +2881,13 @@ write_predicate (FILE *f, predicate_id *
> p->nargs > 0 ? ", tree *res_ops" : "",
> gimple ? ", tree (*valueize)(tree)" : "");
> /* Conveniently make 'type' available. */
> - fprintf (f, "tree type = TREE_TYPE (t);\n");
> + fprintf_indent (f, 2, "tree type = TREE_TYPE (t);\n");
>
> if (!gimple)
> - fprintf (f, "if (TREE_SIDE_EFFECTS (t)) return false;\n");
> - dt.root->gen_kids (f, gimple);
> + fprintf_indent (f, 2, "if (TREE_SIDE_EFFECTS (t)) return false;\n");
> + dt.root->gen_kids (f, 2, gimple);
>
> - fprintf (f, "return false;\n"
> + fprintf_indent (f, 2, "return false;\n"
> "}\n");
> }
>
