On Wed, Mar 13, 2019 at 3:58 AM Richard Biener <rguent...@suse.de> wrote:
>
>
> This makes an attempt at fixing the most annoying parts of the GIMPLE
> FE unit testing - the lack of proper CFG preservation and hoops you
> need to jump through to make the CFG and SSA builders happy.
>
> Due to this the __GIMPLE specifiers takes two new flags, "cfg"
> for GIMPLE-with-a-CFG and "ssa" for GIMPLE-with-a-CFG-and-SSA.
> When there is a CFG you need to start basic-block boundaries with
>
> __BB(index):
>
> where 'index' is the basic-block index. That implicitely defines
> a label __BBindex for use in goto stmts and friends (but doesn't
> actually add a GIMPLE_LABEL).
>
> The parsing code isn't defensive right now so you need to watch
> out to not use index 0 or 1 (entry and exit block) which are
> only implicitely present.
>
> As a proof of concept I added one BB annotation - loop_header(num)
> where "num" is the loop number. This means you can now also
> have loop structures preserved (to some extent - the loop tree is
> not explicitely represented nor are loop fathers, both are re-built
> via fixup).
>
> I've not yet adjusted -gimple dumping.
>
> I've adjusted all testcases I could find.
>
> The CFG build inside the frontend is a bit awkward (spread out...),
> likewise some functionality is asking for split-out.
>
> This is mainly a RFC for whether you think this is forward looking
> enough. Future enhancements would include EH and abnormal edges
> via stmt annotations:
Thanks very much for doing this. Do we have a centralized
wiki/document on the formal definition? It would be very helpful even
it's still evolving, otherwise we would need to dig into messages for
fragmented clues.
Thanks,
bin
>
> __BB(2):
> foo () goto __BB3 __EDGE_EH; // EH edge to BB3
>
> __BB(3):
> setjmp () goto __BB4 __EDGE_AB; // abnormal edge to BB4
>
> __BB(4):
> _1 = _5 / 0. __NOTHROW; // gimple_nothrow_p is true
> _3 = _2 / _4 goto __BB5 __EDGE_EH; // EH edge to BB5
>
> etc. extra edge flags:
>
> goto __BB5 __EDGE_EXECUTABLE;
>
> I guess now is the time for bike-shedding.
>
> Richard.
>
> 2019-03-12 Richard Biener <rguent...@suse.de>
>
> c/
> * c-tree.h (enum c_declspec_il): New.
> (struct c_declspecs): Merge gimple_p and rtl_p into declspec_il
> enum bitfield.
> * c-parser.c (c_parser_declaration_or_fndef): Adjust accordingly.
> Pass start pass and declspec_il to c_parser_parse_gimple_body.
> (c_parser_declspecs): Adjust.
> * gimple-parser.c: Include cfg.h, cfghooks.h, cfganal.h, tree-cfg.h,
> gimple-iterator.h, cfgloop.h, tree-phinodes.h, tree-into-ssa.h
> and bitmap.h.
> (struct gimple_parser_edge): New.
> (edges, current_bb): New globals.
> (c_parser_gimple_parse_bb_spec): New helper.
> (c_parser_parse_gimple_body): Get start pass and IL specification.
> Initialize SSA and CFG.
> (c_parser_gimple_compound_statement): Handle CFG build.
> (c_parser_gimple_statement): Change intermittend __PHI internal
> function arg.
> (c_parser_gimple_or_rtl_pass_list): Handle ssa, cfg flags.
> (c_parser_gimple_goto_stmt): Record edges to build.
> (c_parser_gimple_if_stmt): Likewise.
> * gimple-parser.h (c_parser_parse_gimple_body): Adjust.
> (c_parser_gimple_or_rtl_pass_list): Likewise.
>
> * gcc.dg/gimplefe-13.c: Adjust.
> ...
>
> Index: gcc/c/c-parser.c
> ===================================================================
> --- gcc/c/c-parser.c (revision 269604)
> +++ gcc/c/c-parser.c (working copy)
> @@ -2324,19 +2324,9 @@ c_parser_declaration_or_fndef (c_parser
> DECL_STRUCT_FUNCTION (current_function_decl)->function_start_locus
> = c_parser_peek_token (parser)->location;
>
> - /* If the definition was marked with __GIMPLE then parse the
> - function body as GIMPLE. */
> - if (specs->gimple_p)
> - {
> - cfun->pass_startwith = specs->gimple_or_rtl_pass;
> - bool saved = in_late_binary_op;
> - in_late_binary_op = true;
> - c_parser_parse_gimple_body (parser);
> - in_late_binary_op = saved;
> - }
> - /* Similarly, if it was marked with __RTL, use the RTL parser now,
> + /* If the definition was marked with __RTL, use the RTL parser now,
> consuming the function body. */
> - else if (specs->rtl_p)
> + if (specs->declspec_il == cdil_rtl)
> {
> c_parser_parse_rtl_body (parser, specs->gimple_or_rtl_pass);
>
> @@ -2350,6 +2340,16 @@ c_parser_declaration_or_fndef (c_parser
> finish_function ();
> return;
> }
> + /* If the definition was marked with __GIMPLE then parse the
> + function body as GIMPLE. */
> + else if (specs->declspec_il != cdil_none)
> + {
> + bool saved = in_late_binary_op;
> + in_late_binary_op = true;
> + c_parser_parse_gimple_body (parser, specs->gimple_or_rtl_pass,
> + specs->declspec_il);
> + in_late_binary_op = saved;
> + }
> else
> fnbody = c_parser_compound_statement (parser);
> tree fndecl = current_function_decl;
> @@ -2372,8 +2372,8 @@ c_parser_declaration_or_fndef (c_parser
> add_stmt (fnbody);
> finish_function ();
> }
> - /* Get rid of the empty stmt list for GIMPLE. */
> - if (specs->gimple_p)
> + /* Get rid of the empty stmt list for GIMPLE/RTL. */
> + if (specs->declspec_il != cdil_none)
> DECL_SAVED_TREE (fndecl) = NULL_TREE;
>
> break;
> @@ -2882,15 +2882,15 @@ c_parser_declspecs (c_parser *parser, st
> if (! flag_gimple)
> error_at (loc, "%<__GIMPLE%> only valid with %<-fgimple%>");
> c_parser_consume_token (parser);
> - specs->gimple_p = true;
> + specs->declspec_il = cdil_gimple;
> specs->locations[cdw_gimple] = loc;
> - specs->gimple_or_rtl_pass = c_parser_gimple_or_rtl_pass_list
> (parser);
> + c_parser_gimple_or_rtl_pass_list (parser, specs);
> break;
> case RID_RTL:
> c_parser_consume_token (parser);
> - specs->rtl_p = true;
> + specs->declspec_il = cdil_rtl;
> specs->locations[cdw_rtl] = loc;
> - specs->gimple_or_rtl_pass = c_parser_gimple_or_rtl_pass_list
> (parser);
> + c_parser_gimple_or_rtl_pass_list (parser, specs);
> break;
> default:
> goto out;
> Index: gcc/c/c-tree.h
> ===================================================================
> --- gcc/c/c-tree.h (revision 269604)
> +++ gcc/c/c-tree.h (working copy)
> @@ -288,6 +288,14 @@ enum c_declspec_word {
> enumerator. */
> };
>
> +enum c_declspec_il {
> + cdil_none,
> + cdil_gimple, /* __GIMPLE */
> + cdil_gimple_cfg, /* __GIMPLE(cfg) */
> + cdil_gimple_ssa, /* __GIMPLE(ssa) */
> + cdil_rtl /* __RTL */
> +};
> +
> /* A sequence of declaration specifiers in C. When a new declaration
> specifier is added, please update the enum c_declspec_word above
> accordingly. */
> @@ -326,6 +334,7 @@ struct c_declspecs {
> /* The kind of type specifier if one has been seen, ctsk_none
> otherwise. */
> ENUM_BITFIELD (c_typespec_kind) typespec_kind : 3;
> + ENUM_BITFIELD (c_declspec_il) declspec_il : 3;
> /* Whether any expressions in typeof specifiers may appear in
> constant expressions. */
> BOOL_BITFIELD expr_const_operands : 1;
> @@ -381,10 +390,6 @@ struct c_declspecs {
> /* Whether any alignment specifier (even with zero alignment) was
> specified. */
> BOOL_BITFIELD alignas_p : 1;
> - /* Whether any __GIMPLE specifier was specified. */
> - BOOL_BITFIELD gimple_p : 1;
> - /* Whether any __RTL specifier was specified. */
> - BOOL_BITFIELD rtl_p : 1;
> /* The address space that the declaration belongs to. */
> addr_space_t address_space;
> };
> Index: gcc/c/gimple-parser.c
> ===================================================================
> --- gcc/c/gimple-parser.c (revision 269604)
> +++ gcc/c/gimple-parser.c (working copy)
> @@ -54,6 +54,15 @@ along with GCC; see the file COPYING3.
> #include "gimple-ssa.h"
> #include "tree-dfa.h"
> #include "internal-fn.h"
> +#include "cfg.h"
> +#include "cfghooks.h"
> +#include "cfganal.h"
> +#include "tree-cfg.h"
> +#include "gimple-iterator.h"
> +#include "cfgloop.h"
> +#include "tree-phinodes.h"
> +#include "tree-into-ssa.h"
> +#include "bitmap.h"
>
>
> /* Gimple parsing functions. */
> @@ -75,11 +84,34 @@ static void c_finish_gimple_return (loca
> static tree c_parser_gimple_paren_condition (c_parser *);
> static void c_parser_gimple_expr_list (c_parser *, vec<tree> *);
>
> +struct gimple_parser_edge
> +{
> + gimple_parser_edge (int s, int d, int f) : src(s), dest(d), flags(f) {}
> + int src;
> + int dest;
> + int flags;
> +};
> +
> +static vec<gimple_parser_edge> edges = vNULL;
> +static basic_block current_bb;
> +
> +static bool
> +c_parser_gimple_parse_bb_spec (tree val, int *index)
> +{
> + if (strncmp (IDENTIFIER_POINTER (val), "__BB", 4) != 0)
> + return false;
> + for (const char *p = IDENTIFIER_POINTER (val) + 4; *p; ++p)
> + if (!ISDIGIT (*p))
> + return false;
> + *index = atoi (IDENTIFIER_POINTER (val) + 4);
> + return *index > 0;
> +}
>
> /* Parse the body of a function declaration marked with "__GIMPLE". */
>
> void
> -c_parser_parse_gimple_body (c_parser *parser)
> +c_parser_parse_gimple_body (c_parser *parser, char *gimple_pass,
> + enum c_declspec_il cdil)
> {
> gimple_seq seq = NULL;
> gimple_seq body = NULL;
> @@ -87,9 +119,34 @@ c_parser_parse_gimple_body (c_parser *pa
> push_scope ();
> location_t loc1 = c_parser_peek_token (parser)->location;
>
> + cfun->pass_startwith = gimple_pass;
> init_tree_ssa (cfun);
>
> - if (! c_parser_gimple_compound_statement (parser, &seq))
> + if (cdil == cdil_gimple)
> + /* While we have SSA names in the IL we do not have a CFG built yet
> + and PHIs are represented using a PHI internal function. We do
> + have lowered control flow and exception handling (well, we do not
> + have parser support for EH yet). But as we still have BINDs
> + we have to go through lowering again. */
> + cfun->curr_properties = PROP_gimple_any;
> + else
> + {
> + /* We have at least cdil_gimple_cfg. */
> + gimple_register_cfg_hooks ();
> + init_empty_tree_cfg ();
> + /* Initialize the bare loop structure - we are going to only
> + mark headers and leave the rest to fixup. */
> + set_loops_for_fn (cfun, ggc_cleared_alloc<struct loops> ());
> + init_loops_structure (cfun, loops_for_fn (cfun), 1);
> + loops_state_set (cfun,
> LOOPS_NEED_FIXUP|LOOPS_MAY_HAVE_MULTIPLE_LATCHES);
> + cfun->curr_properties
> + |= PROP_gimple_lcf | PROP_gimple_leh | PROP_cfg | PROP_loops;
> + if (cdil == cdil_gimple_ssa)
> + cfun->curr_properties |= PROP_ssa;
> + }
> +
> + if (! c_parser_gimple_compound_statement (parser, &seq)
> + && cdil == cdil_gimple)
> {
> gimple *ret = gimple_build_return (NULL);
> gimple_seq_add_stmt (&seq, ret);
> @@ -104,18 +161,90 @@ c_parser_parse_gimple_body (c_parser *pa
> BLOCK_CHAIN (block) = NULL_TREE;
> TREE_ASM_WRITTEN (block) = 1;
>
> - gbind *bind_stmt = gimple_build_bind (BIND_EXPR_VARS (stmt), NULL,
> - BIND_EXPR_BLOCK (stmt));
> - gimple_bind_set_body (bind_stmt, seq);
> - gimple_seq_add_stmt (&body, bind_stmt);
> - gimple_set_body (current_function_decl, body);
> -
> - /* While we have SSA names in the IL we do not have a CFG built yet
> - and PHIs are represented using a PHI internal function. We do
> - have lowered control flow and exception handling (well, we do not
> - have parser support for EH yet). But as we still have BINDs
> - we have to go through lowering again. */
> - cfun->curr_properties = PROP_gimple_any;
> + if (cdil == cdil_gimple)
> + {
> + gbind *bind_stmt = gimple_build_bind (BIND_EXPR_VARS (stmt), NULL,
> + BIND_EXPR_BLOCK (stmt));
> + gimple_bind_set_body (bind_stmt, seq);
> + gimple_seq_add_stmt (&body, bind_stmt);
> + gimple_set_body (current_function_decl, body);
> + }
> + else
> + {
> + /* Control-flow and binds are lowered, record local decls. */
> + for (tree var = BIND_EXPR_VARS (stmt); var; var = DECL_CHAIN (var))
> + if (VAR_P (var)
> + && !DECL_EXTERNAL (var))
> + add_local_decl (cfun, var);
> + /* We have a CFG. Build the edges. */
> + for (unsigned i = 0; i < edges.length (); ++i)
> + make_edge (BASIC_BLOCK_FOR_FN (cfun, edges[i].src),
> + BASIC_BLOCK_FOR_FN (cfun, edges[i].dest), edges[i].flags);
> + /* Add fallthru edges and edges for case labels.
> + Entry and exit block are already treated specially. */
> + basic_block bb;
> + FOR_EACH_BB_FN (bb, cfun)
> + if (EDGE_COUNT (bb->succs) == 0)
> + {
> + gimple *last = last_stmt (bb);
> + if (gswitch *sw = safe_dyn_cast <gswitch *> (last))
> + for (unsigned i = 0; i < gimple_switch_num_labels (sw); ++i)
> + {
> + basic_block label_bb = gimple_switch_label_bb (cfun, sw, i);
> + make_edge (bb, label_bb, 0);
> + }
> + else if (!last
> + || !is_gimple_call (last)
> + || !gimple_call_noreturn_p (last))
> + make_edge (bb, bb->next_bb, EDGE_FALLTHRU);
> + }
> + /* With SSA lower PHIs parsed as internal function calls and
> + update stmts. */
> + if (cdil == cdil_gimple_ssa)
> + {
> + init_ssa_operands (cfun);
> + FOR_EACH_BB_FN (bb, cfun)
> + {
> + bool phis = true;
> + for (gimple_stmt_iterator gsi = gsi_start_bb (bb);
> + !gsi_end_p (gsi);)
> + {
> + gimple *stmt = gsi_stmt (gsi);
> + if (phis && gimple_call_internal_p (stmt, IFN_PHI))
> + {
> + gphi *phi = create_phi_node (gimple_call_lhs (stmt),
> bb);
> + for (unsigned i = 0; i < gimple_call_num_args (stmt); i
> += 2)
> + {
> + int src_index;
> + if (c_parser_gimple_parse_bb_spec (gimple_call_arg
> (stmt, i),
> + &src_index))
> + {
> + edge e = find_edge (BASIC_BLOCK_FOR_FN (cfun,
> src_index),
> + bb);
> + if (e)
> + add_phi_arg (phi, gimple_call_arg (stmt, i +
> 1), e,
> + UNKNOWN_LOCATION);
> + }
> + }
> + gsi_remove (&gsi, false);
> + }
> + else
> + {
> + phis = false;
> + update_stmt (stmt);
> + gsi_next (&gsi);
> + }
> + }
> + }
> + /* No explicit virtual operands (yet). */
> + bitmap_obstack_initialize (NULL);
> + update_ssa (TODO_update_ssa_only_virtuals);
> + bitmap_obstack_release (NULL);
> + }
> + fix_loop_structure (NULL);
> + }
> + edges.release ();
> + current_bb = NULL;
>
> dump_function (TDI_gimple, current_function_decl);
> }
> @@ -197,6 +326,8 @@ c_parser_gimple_compound_statement (c_pa
> if (! c_parser_require (parser, CPP_SEMICOLON,
> "expected %<;%>"))
> return return_p;
> + if (cfun->curr_properties & PROP_cfg)
> + make_edge (current_bb, EXIT_BLOCK_PTR_FOR_FN (cfun), 0);
> break;
> default:
> goto expr_stmt;
> @@ -208,6 +339,134 @@ c_parser_gimple_compound_statement (c_pa
> c_parser_gimple_label (parser, seq);
> break;
> }
> + /* Basic block specification.
> + __BB (index, ...) */
> + if ((cfun->curr_properties & PROP_cfg)
> + && !strcmp (IDENTIFIER_POINTER
> + (c_parser_peek_token (parser)->value), "__BB"))
> + {
> + c_parser_consume_token (parser);
> + if (! c_parser_require (parser, CPP_OPEN_PAREN,
> + "expected %<(%>"))
> + return return_p;
> + if (c_parser_next_token_is_not (parser, CPP_NUMBER))
> + {
> + c_parser_error (parser, "expected block index");
> + return return_p;
> + }
> + tree tnum = c_parser_peek_token (parser)->value;
> + if (TREE_CODE (tnum) != INTEGER_CST)
> + {
> + c_parser_error (parser, "expected block index");
> + return return_p;
> + }
> + int index = TREE_INT_CST_LOW (tnum);
> + int is_loop_header_of = -1;
> + c_parser_consume_token (parser);
> + while (c_parser_next_token_is (parser, CPP_COMMA))
> + {
> + c_parser_consume_token (parser);
> + if (! c_parser_next_token_is (parser, CPP_NAME))
> + {
> + c_parser_error (parser, "expected block specifier");
> + return return_p;
> + }
> + /* loop_header (NUM) */
> + if (!strcmp (IDENTIFIER_POINTER
> + (c_parser_peek_token (parser)->value),
> + "loop_header"))
> + {
> + c_parser_consume_token (parser);
> + if (! c_parser_require (parser, CPP_OPEN_PAREN,
> "expected %<(%>"))
> + return return_p;
> + tree loop_num;
> + if (! c_parser_next_token_is (parser, CPP_NUMBER)
> + || TREE_CODE (loop_num
> + = c_parser_peek_token
> (parser)->value)
> + != INTEGER_CST)
> + {
> + c_parser_error (parser, "expected loop number");
> + return return_p;
> + }
> + c_parser_consume_token (parser);
> + is_loop_header_of = TREE_INT_CST_LOW (loop_num);
> + if (! c_parser_require (parser, CPP_CLOSE_PAREN,
> "expected %<)%>"))
> + return return_p;
> + }
> + else
> + {
> + c_parser_error (parser, "unknown block specifier");
> + return return_p;
> + }
> + }
> + if (! c_parser_require (parser, CPP_CLOSE_PAREN,
> + "expected %<)%>"))
> + return return_p;
> + if (! c_parser_require (parser, CPP_COLON,
> + "expected %<:%>"))
> + return return_p;
> +
> + /* Put stmts parsed in the current block. */
> + if (!gimple_seq_empty_p (*seq))
> + {
> + if (!current_bb)
> + c_parser_error (parser, "stmts without block");
> + else
> + {
> + gimple_stmt_iterator gsi = gsi_start_bb (current_bb);
> + gsi_insert_seq_after_without_update (&gsi, *seq,
> +
> GSI_CONTINUE_LINKING);
> + }
> + *seq = NULL;
> + }
> +
> + /* Build an empty block with specified index, linking them
> + in source order. */
> + basic_block bb = alloc_block ();
> + bb->index = index;
> + link_block (bb, (current_bb ? current_bb
> + : ENTRY_BLOCK_PTR_FOR_FN (cfun)));
> + if (basic_block_info_for_fn (cfun)->length () <= (size_t)index)
> + vec_safe_grow_cleared (basic_block_info_for_fn (cfun),
> + index + 1);
> + SET_BASIC_BLOCK_FOR_FN (cfun, index, bb);
> + if (last_basic_block_for_fn (cfun) <= index)
> + last_basic_block_for_fn (cfun) = index + 1;
> + n_basic_blocks_for_fn (cfun)++;
> + if (!current_bb)
> + make_edge (ENTRY_BLOCK_PTR_FOR_FN (cfun), bb, EDGE_FALLTHRU);
> +
> + /* We leave the proper setting to fixup. */
> + struct loop *loop_father = loops_for_fn (cfun)->tree_root;
> + /* If the new block is a loop header, allocate a loop
> + struct. Fixup will take care of proper placement within
> + the loop tree. */
> + if (is_loop_header_of != -1)
> + {
> + if (number_of_loops (cfun) > (unsigned)is_loop_header_of
> + && get_loop (cfun, is_loop_header_of) != NULL)
> + {
> + c_parser_error (parser, "duplicate loop header");
> + }
> + else
> + {
> + struct loop *loop = alloc_loop ();
> + loop->num = is_loop_header_of;
> + loop->header = bb;
> + vec_safe_grow_cleared (loops_for_fn (cfun)->larray,
> + is_loop_header_of + 1);
> + (*loops_for_fn (cfun)->larray)[is_loop_header_of] =
> loop;
> + flow_loop_tree_node_add (loops_for_fn (cfun)->tree_root,
> + loop);
> + }
> + loop_father = get_loop (cfun, is_loop_header_of);
> + }
> + bb->loop_father = loop_father;
> +
> + /* Stmts now go to the new block. */
> + current_bb = bb;
> + break;
> + }
> goto expr_stmt;
>
> case CPP_SEMICOLON:
> @@ -229,6 +488,22 @@ expr_stmt:
> }
> }
> c_parser_consume_token (parser);
> +
> + /* Put stmts parsed in the current block. */
> + if ((cfun->curr_properties & PROP_cfg)
> + && !gimple_seq_empty_p (*seq))
> + {
> + if (!current_bb)
> + c_parser_error (parser, "stmts without block");
> + else
> + {
> + gimple_stmt_iterator gsi = gsi_start_bb (current_bb);
> + gsi_insert_seq_after_without_update (&gsi, *seq,
> + GSI_CONTINUE_LINKING);
> + }
> + *seq = NULL;
> + }
> +
> return return_p;
> }
>
> @@ -373,8 +648,7 @@ c_parser_gimple_statement (c_parser *par
> if (c_parser_next_token_is (parser, CPP_NAME)
> && c_parser_peek_2nd_token (parser)->type == CPP_COLON)
> {
> - arg = lookup_label_for_goto (loc,
> - c_parser_peek_token
> (parser)->value);
> + arg = c_parser_peek_token (parser)->value;
> c_parser_consume_token (parser);
>
> if (c_parser_next_token_is (parser, CPP_COLON))
> @@ -1288,48 +1562,57 @@ c_parser_gimple_label (c_parser *parser,
> startwith("pass-name")
> */
>
> -char *
> -c_parser_gimple_or_rtl_pass_list (c_parser *parser)
> +void
> +c_parser_gimple_or_rtl_pass_list (c_parser *parser, c_declspecs *specs)
> {
> char *pass = NULL;
>
> /* Accept __GIMPLE/__RTL. */
> if (c_parser_next_token_is_not (parser, CPP_OPEN_PAREN))
> - return NULL;
> + return;
> c_parser_consume_token (parser);
>
> - if (c_parser_next_token_is (parser, CPP_NAME))
> + while (c_parser_next_token_is (parser, CPP_NAME))
> {
> const char *op = IDENTIFIER_POINTER (c_parser_peek_token
> (parser)->value);
> c_parser_consume_token (parser);
> if (! strcmp (op, "startwith"))
> {
> if (! c_parser_require (parser, CPP_OPEN_PAREN, "expected %<(%>"))
> - return NULL;
> + return;
> if (c_parser_next_token_is_not (parser, CPP_STRING))
> {
> error_at (c_parser_peek_token (parser)->location,
> "expected pass name");
> - return NULL;
> + return;
> }
> pass = xstrdup (TREE_STRING_POINTER
> (c_parser_peek_token (parser)->value));
> c_parser_consume_token (parser);
> - if (! c_parser_require (parser, CPP_CLOSE_PAREN, "expected %<)%>"))
> - return NULL;
> + if (! c_parser_require (parser, CPP_CLOSE_PAREN, "expected %<(%>"))
> + return;
> }
> + else if (specs->declspec_il != cdil_gimple)
> + /* Allow only one IL specifier and none on RTL. */
> + ;
> + else if (! strcmp (op, "cfg"))
> + specs->declspec_il = cdil_gimple_cfg;
> + else if (! strcmp (op, "ssa"))
> + specs->declspec_il = cdil_gimple_ssa;
> else
> {
> error_at (c_parser_peek_token (parser)->location,
> "invalid operation");
> - return NULL;
> + return;
> }
> + if (c_parser_next_token_is (parser, CPP_COMMA))
> + c_parser_consume_token (parser);
> }
>
> if (! c_parser_require (parser, CPP_CLOSE_PAREN, "expected %<)%>"))
> - return NULL;
> + return;
>
> - return pass;
> + specs->gimple_or_rtl_pass = pass;
> }
>
> /* Parse gimple local declaration.
> @@ -1433,9 +1716,18 @@ c_parser_gimple_declaration (c_parser *p
> static void
> c_parser_gimple_goto_stmt (location_t loc, tree label, gimple_seq *seq)
> {
> + if (cfun->curr_properties & PROP_cfg)
> + {
> + int dest_index;
> + if (c_parser_gimple_parse_bb_spec (label, &dest_index))
> + {
> + edges.safe_push (gimple_parser_edge (current_bb->index, dest_index,
> + EDGE_FALLTHRU));
> + return;
> + }
> + }
> tree decl = lookup_label_for_goto (loc, label);
> gimple_seq_add_stmt (seq, gimple_build_goto (decl));
> - return;
> }
>
> /* Parse a parenthesized condition.
> @@ -1464,7 +1756,7 @@ c_parser_gimple_paren_condition (c_parse
> static void
> c_parser_gimple_if_stmt (c_parser *parser, gimple_seq *seq)
> {
> - tree t_label, f_label, label;
> + tree t_label = NULL_TREE, f_label = NULL_TREE, label;
> location_t loc;
> c_parser_consume_token (parser);
> tree cond = c_parser_gimple_paren_condition (parser);
> @@ -1480,7 +1772,13 @@ c_parser_gimple_if_stmt (c_parser *parse
> }
> label = c_parser_peek_token (parser)->value;
> c_parser_consume_token (parser);
> - t_label = lookup_label_for_goto (loc, label);
> + int dest_index;
> + if ((cfun->curr_properties & PROP_cfg)
> + && c_parser_gimple_parse_bb_spec (label, &dest_index))
> + edges.safe_push (gimple_parser_edge (current_bb->index, dest_index,
> + EDGE_TRUE_VALUE));
> + else
> + t_label = lookup_label_for_goto (loc, label);
> if (! c_parser_require (parser, CPP_SEMICOLON, "expected %<;%>"))
> return;
> }
> @@ -1508,7 +1806,13 @@ c_parser_gimple_if_stmt (c_parser *parse
> return;
> }
> label = c_parser_peek_token (parser)->value;
> - f_label = lookup_label_for_goto (loc, label);
> + int dest_index;
> + if ((cfun->curr_properties & PROP_cfg)
> + && c_parser_gimple_parse_bb_spec (label, &dest_index))
> + edges.safe_push (gimple_parser_edge (current_bb->index, dest_index,
> + EDGE_FALSE_VALUE));
> + else
> + f_label = lookup_label_for_goto (loc, label);
> c_parser_consume_token (parser);
> if (! c_parser_require (parser, CPP_SEMICOLON, "expected %<;%>"))
> return;
> Index: gcc/c/gimple-parser.h
> ===================================================================
> --- gcc/c/gimple-parser.h (revision 269604)
> +++ gcc/c/gimple-parser.h (working copy)
> @@ -21,7 +21,8 @@ along with GCC; see the file COPYING3.
> #define GCC_GIMPLE_PARSER_H
>
> /* Gimple parsing functions. */
> -extern void c_parser_parse_gimple_body (c_parser *);
> -extern char *c_parser_gimple_or_rtl_pass_list (c_parser *);
> +extern void c_parser_parse_gimple_body (c_parser *, char *,
> + enum c_declspec_il);
> +extern void c_parser_gimple_or_rtl_pass_list (c_parser *, c_declspecs *);
>
> #endif
> Index: gcc/testsuite/gcc.dg/gimplefe-13.c
> ===================================================================
> --- gcc/testsuite/gcc.dg/gimplefe-13.c (revision 269604)
> +++ gcc/testsuite/gcc.dg/gimplefe-13.c (working copy)
> @@ -1,25 +1,25 @@
> /* { dg-do compile } */
> /* { dg-options "-O -fgimple" } */
>
> -void __GIMPLE (startwith ("dse2")) foo ()
> +void __GIMPLE (ssa,startwith ("dse2")) foo ()
> {
> int a;
>
> -bb_2:
> - if (a > 4)
> - goto bb_3;
> +__BB(2):
> + if (a_5(D) > 4)
> + goto __BB3;
> else
> - goto bb_4;
> + goto __BB4;
>
> -bb_3:
> +__BB(3):
> a_2 = 10;
> - goto bb_5;
> + goto __BB5;
>
> -bb_4:
> +__BB(4):
> a_3 = 20;
>
> -bb_5:
> - a_1 = __PHI (bb_3: a_2, bb_4: a_3);
> +__BB(5):
> + a_1 = __PHI (__BB3: a_2, __BB4: a_3);
> a_4 = a_1 + 4;
>
> return;
> Index: gcc/testsuite/gcc.dg/gimplefe-14.c
> ===================================================================
> --- gcc/testsuite/gcc.dg/gimplefe-14.c (revision 269604)
> +++ gcc/testsuite/gcc.dg/gimplefe-14.c (working copy)
> @@ -1,29 +1,32 @@
> /* { dg-do run } */
> /* { dg-options "-O -fgimple" } */
>
> -int __GIMPLE ()
> +int __GIMPLE (ssa)
> main (int argc, char * * argv)
> {
> int a;
>
> - bb_2:
> + __BB(2):
> /* Because of PR82114 we need to handle also 0 as base metal can have
> argc == 0. */
> switch (argc_2(D)) {default: L2; case 0: L0; case 1: L0; case 2: L1; }
>
> + __BB(3):
> L0:
> a_4 = 0;
> - goto bb_6;
> + goto __BB6;
>
> + __BB(4):
> L1:
> a_3 = 3;
> - goto bb_6;
> + goto __BB6;
>
> + __BB(5):
> L2:
> a_5 = -1;
>
> - bb_6:
> - a_1 = __PHI (L0: a_4, L1: a_3, L2: a_5);
> + __BB(6):
> + a_1 = __PHI (__BB3: a_4, __BB4: a_3, __BB5: a_5);
> return a_1;
>
> }
> Index: gcc/testsuite/gcc.dg/gimplefe-17.c
> ===================================================================
> --- gcc/testsuite/gcc.dg/gimplefe-17.c (revision 269604)
> +++ gcc/testsuite/gcc.dg/gimplefe-17.c (working copy)
> @@ -1,26 +1,29 @@
> /* { dg-do compile } */
> -/* { dg-options "-fgimple -fdump-tree-ssa" } */
> +/* { dg-options "-fgimple -fdump-tree-fixup_cfg2" } */
>
> int
> -__GIMPLE () *
> +__GIMPLE (ssa) *
> foo ()
> {
> int _1;
> int j;
> int *b;
> +
> +__BB(5):
> _1 = 1;
> -bb1:
> +
> +__BB(2):
> if (_1)
> - goto bb3;
> + goto __BB4;
> else
> - goto bb2;
> + goto __BB3;
>
> -bb2:
> +__BB(3):
> b_2 = (int *)0;
>
> -bb3:
> - b_4 = __PHI (bb1: b_3(D), bb2: b_2);
> +__BB(4):
> + b_4 = __PHI (__BB2: b_3(D), __BB3: b_2);
> return b_4;
> }
>
> -/* { dg-final { scan-tree-dump-not "_1_" "ssa" } } */
> +/* { dg-final { scan-tree-dump-not "_1_" "fixup_cfg2" } } */
> Index: gcc/testsuite/gcc.dg/gimplefe-18.c
> ===================================================================
> --- gcc/testsuite/gcc.dg/gimplefe-18.c (revision 269604)
> +++ gcc/testsuite/gcc.dg/gimplefe-18.c (working copy)
> @@ -2,23 +2,26 @@
> /* { dg-options "-fgimple" } */
>
> int
> -__GIMPLE () *
> +__GIMPLE (ssa) *
> foo ()
> {
> int _1;
> int j;
> int *b;
> +
> +__BB(2):
> _1 = 1;
> -bb1:
> +
> +__BB(3):
> if (_1)
> - goto bb3;
> + goto __BB5;
> else
> - goto bb2;
> + goto __BB4;
>
> -bb2:
> +__BB(4):
> b_2 = (int *)0;
>
> -bb3:
> - b_4 = __PHI (bb1: &j, bb2: b_2);
> +__BB(5):
> + b_4 = __PHI (__BB3: &j, __BB4: b_2);
> return b_4;
> }
> Index: gcc/testsuite/gcc.dg/gimplefe-7.c
> ===================================================================
> --- gcc/testsuite/gcc.dg/gimplefe-7.c (revision 269604)
> +++ gcc/testsuite/gcc.dg/gimplefe-7.c (working copy)
> @@ -1,25 +1,25 @@
> /* { dg-do compile } */
> /* { dg-options "-fgimple" } */
>
> -void __GIMPLE () foo ()
> +void __GIMPLE (ssa) foo ()
> {
> int a;
>
> -bb_2:
> - if (a > 4)
> - goto bb_3;
> +__BB(2):
> + if (a_5(D) > 4)
> + goto __BB3;
> else
> - goto bb_4;
> + goto __BB4;
>
> -bb_3:
> +__BB(3):
> a_2 = 10;
> - goto bb_5;
> + goto __BB5;
>
> -bb_4:
> +__BB(4):
> a_3 = 20;
>
> -bb_5:
> - a_1 = __PHI (bb_3: a_2, bb_4: a_3);
> +__BB(5):
> + a_1 = __PHI (__BB3: a_2, __BB4: a_3);
> a_4 = a_1 + 4;
>
> return;
> Index: gcc/testsuite/gcc.dg/torture/pr89595.c
> ===================================================================
> --- gcc/testsuite/gcc.dg/torture/pr89595.c (revision 269604)
> +++ gcc/testsuite/gcc.dg/torture/pr89595.c (working copy)
> @@ -1,34 +1,38 @@
> /* { dg-do run } */
> /* { dg-additional-options "-fgimple" } */
>
> +/* Go back to fix the testcase -- need SSA name on freelist...
> + (allocate all gaps & put them there?) */
> +
> int __attribute__((noipa))
> __GIMPLE(startwith("dom")) bar(int cond, int val)
> {
> int i;
>
> +__BB(3):
> if (0 != 0)
> - goto bb_6;
> + goto __BB6;
> else
> - goto bb_2;
> + goto __BB2;
>
> -bb_2:
> +__BB(2):
> if (cond_5(D) != 0)
> - goto bb_4;
> + goto __BB4;
> else
> - goto bb_5;
> + goto __BB5;
>
> -bb_4:
> +__BB(4):
> i_6 = val_2(D);
> i_1 = val_2(D) > 0 ? i_6 : 0;
>
> -bb_5:
> - i_3 = __PHI (bb_4: i_1, bb_2: 0);
> +__BB(5):
> + i_3 = __PHI (__BB4: i_1, __BB2: 0);
> return i_3;
>
> -bb_6:
> +__BB(6):
> i_4 = 1;
> i_9 = 2;
> - goto bb_2;
> + goto __BB2;
> }
>
> int main()
> Index: gcc/testsuite/gcc.dg/tree-ssa/cunroll-13.c
> ===================================================================
> --- gcc/testsuite/gcc.dg/tree-ssa/cunroll-13.c (revision 269604)
> +++ gcc/testsuite/gcc.dg/tree-ssa/cunroll-13.c (working copy)
> @@ -9,7 +9,7 @@ typedef int i32;
>
> struct a {i32 a[8];i32 b;};
>
> -void __GIMPLE (startwith("fix_loops"))
> +void __GIMPLE (ssa,startwith("fix_loops"))
> t (struct a * a)
> {
> i32 i;
> @@ -18,37 +18,37 @@ t (struct a * a)
> i32 _9;
> i32 _11;
>
> -bb_2:
> +__BB(2):
> _11 = a_6(D)->a[0];
> if (_11 != _Literal (i32) 0)
> - goto bb_6;
> + goto __BB6;
> else
> - goto bb_3;
> + goto __BB3;
>
> -bb_3:
> +__BB(3):
> return;
>
> -bb_4:
> +__BB(4):
> _1 = _2 + _Literal (i32) 1;
> a_6(D)->a[i_19] = _1;
> i_8 = i_19 + _Literal (i32) 1;
> if (i_8 <= _Literal (i32) 123455)
> - goto bb_5;
> + goto __BB5;
> else
> - goto bb_3;
> + goto __BB3;
>
> -bb_5:
> - i_19 = __PHI (bb_6: _Literal (i32) 1, bb_4: i_8);
> +__BB(5):
> + i_19 = __PHI (__BB6: _Literal (i32) 1, __BB4: i_8);
> _2 = a_6(D)->a[i_19];
> if (_2 != _Literal (i32) 0)
> - goto bb_4;
> + goto __BB4;
> else
> - goto bb_3;
> + goto __BB3;
>
> -bb_6:
> +__BB(6):
> _9 = _11 + _Literal (i32) 1;
> a_6(D)->a[0] = _9;
> - goto bb_5;
> + goto __BB5;
> }
>
> /* This testcase relies on the fact that we do not eliminate the redundant
> test
> Index: gcc/testsuite/gcc.dg/tree-ssa/ivopt_mult_1g.c
> ===================================================================
> --- gcc/testsuite/gcc.dg/tree-ssa/ivopt_mult_1g.c (revision 269604)
> +++ gcc/testsuite/gcc.dg/tree-ssa/ivopt_mult_1g.c (working copy)
> @@ -15,7 +15,7 @@ foo (long int * p, long int * p2, int N1
> long unsigned int _4;
> long int _5;
>
> - bb_2:
> + __BB(2):
> _1 = (long unsigned int) N1_10(D);
> _2 = _1 * 8ul;
> p_limit_12 = p_11(D) + _2;
> @@ -23,59 +23,59 @@ foo (long int * p, long int * p2, int N1
> _4 = _3 * 8ul;
> p_limit2_15 = p2_14(D) + _4;
> if (p_11(D) <= p_limit_12)
> - goto bb_3;
> + goto __BB3;
> else
> - goto bb_13;
> + goto __BB13;
>
> - bb_13:
> + __BB(13):
>
> - bb_9:
> - goto bb_6;
> + __BB(9):
> + goto __BB6;
>
> - bb_3:
> + __BB(3):
> p_20 = p_11(D) + 8ul;
> p2_23 = p2_14(D) + 8ul;
> if (p_limit2_15 < p2_23)
> - goto bb_14;
> + goto __BB14;
> else
> - goto bb_7;
> + goto __BB7;
>
> - bb_14:
> - goto bb_9;
> + __BB(14):
> + goto __BB9;
>
> - bb_7:
> - goto bb_5;
> + __BB(7):
> + goto __BB5;
>
> - bb_4:
> + __BB(4):
> p_16 = p_26 + 8ul;
> p2_17 = p2_27 + 8ul;
> if (p_limit2_15 < p2_17)
> - goto bb_11;
> + goto __BB11;
> else
> - goto bb_8;
> + goto __BB8;
>
> - bb_11:
> - goto bb_6;
> + __BB(11):
> + goto __BB6;
>
> - bb_8:
> + __BB(8):
> ;
>
> - bb_5:
> - s_24 = __PHI (bb_7: 0l, bb_8: s_19);
> - p_26 = __PHI (bb_7: p_20, bb_8: p_16);
> - p2_27 = __PHI (bb_7: p2_23, bb_8: p2_17);
> + __BB(5):
> + s_24 = __PHI (__BB7: 0l, __BB8: s_19);
> + p_26 = __PHI (__BB7: p_20, __BB8: p_16);
> + p2_27 = __PHI (__BB7: p2_23, __BB8: p2_17);
> _5 = __MEM <long int> (p_26);
> s_19 = _5 + s_24;
> if (p_limit_12 >= p_26)
> - goto bb_4;
> + goto __BB4;
> else
> - goto bb_12;
> + goto __BB12;
>
> - bb_12:
> + __BB(12):
> ;
>
> - bb_6:
> - s_25 = __PHI (bb_12: s_19, bb_11: s_19, bb_9: 0l);
> + __BB(6):
> + s_25 = __PHI (__BB12: s_19, __BB11: s_19, __BB9: 0l);
> return s_25;
> }
>
> Index: gcc/testsuite/gcc.dg/tree-ssa/ivopt_mult_2g.c
> ===================================================================
> --- gcc/testsuite/gcc.dg/tree-ssa/ivopt_mult_2g.c (revision 269604)
> +++ gcc/testsuite/gcc.dg/tree-ssa/ivopt_mult_2g.c (working copy)
> @@ -3,7 +3,7 @@
>
> /* Exit tests 'i < N1' and 'p2 > p_limit2' can be replaced, so
> * two ivs i and p2 can be eliminate. */
> -long int __GIMPLE (startwith("fix_loops"))
> +long int __GIMPLE (ssa,startwith("fix_loops"))
> foo (long int * p, long int * p2, int N1, int N2)
> {
> long int s;
> @@ -13,66 +13,66 @@ foo (long int * p, long int * p2, int N1
> long unsigned int _2;
> long int _3;
>
> - bb_2:
> + __BB(2):
> _1 = (long unsigned int) N2_9(D);
> _2 = _1 * 8ul;
> p_limit2_11 = p2_10(D) + _2;
> if (N1_13(D) > 0)
> - goto bb_3;
> + goto __BB3;
> else
> - goto bb_13;
> + goto __BB13;
>
> - bb_13:
> + __BB(13):
>
> - bb_9:
> - goto bb_6;
> + __BB(9):
> + goto __BB6;
>
> - bb_3:
> + __BB(3):
> p_22 = p_12(D) + 8ul;
> p2_23 = p2_10(D) + 8ul;
> if (p_limit2_11 < p2_23)
> - goto bb_14;
> + goto __BB14;
> else
> - goto bb_7;
> + goto __BB7;
>
> - bb_14:
> - goto bb_9;
> + __BB(14):
> + goto __BB9;
>
> - bb_7:
> - goto bb_5;
> + __BB(7):
> + goto __BB5;
>
> - bb_4:
> + __BB(4):
> p_14 = p_27 + 8ul;
> p2_15 = p2_28 + 8ul;
> i_16 = i_29 + 1;
> if (p_limit2_11 < p2_15)
> - goto bb_11;
> + goto __BB11;
> else
> - goto bb_8;
> + goto __BB8;
>
> - bb_11:
> - goto bb_6;
> + __BB(11):
> + goto __BB6;
>
> - bb_8:
> + __BB(8):
> ;
>
> - bb_5:
> - s_25 = __PHI (bb_7: 0l, bb_8: s_18);
> - p_27 = __PHI (bb_7: p_22, bb_8: p_14);
> - p2_28 = __PHI (bb_7: p2_23, bb_8: p2_15);
> - i_29 = __PHI (bb_7: 1, bb_8: i_16);
> + __BB(5):
> + s_25 = __PHI (__BB7: 0l, __BB8: s_18);
> + p_27 = __PHI (__BB7: p_22, __BB8: p_14);
> + p2_28 = __PHI (__BB7: p2_23, __BB8: p2_15);
> + i_29 = __PHI (__BB7: 1, __BB8: i_16);
> _3 = __MEM <long int> (p_27);
> s_18 = _3 + s_25;
> if (N1_13(D) > i_29)
> - goto bb_4;
> + goto __BB4;
> else
> - goto bb_12;
> + goto __BB12;
>
> - bb_12:
> + __BB(12):
> ;
>
> - bb_6:
> - s_26 = __PHI (bb_12: s_18, bb_11: s_18, bb_9: 0l);
> + __BB(6):
> + s_26 = __PHI (__BB12: s_18, __BB11: s_18, __BB9: 0l);
> return s_26;
> }
>
> Index: gcc/testsuite/gcc.dg/tree-ssa/scev-3.c
> ===================================================================
> --- gcc/testsuite/gcc.dg/tree-ssa/scev-3.c (revision 269604)
> +++ gcc/testsuite/gcc.dg/tree-ssa/scev-3.c (working copy)
> @@ -4,39 +4,39 @@
> int *a_p;
> int a[1000];
>
> -void __GIMPLE (startwith ("loop"))
> +void __GIMPLE (ssa,startwith ("loop"))
> f (int k)
> {
> int i;
> int * _1;
>
> -bb_2:
> +__BB(2):
> i_5 = k_4(D);
> if (i_5 <= 999)
> - goto bb_4;
> + goto __BB4;
> else
> - goto bb_3;
> + goto __BB3;
>
> -bb_3:
> +__BB(3):
> return;
>
> -bb_4:
> +__BB(4):
> ;
>
> -bb_5:
> - i_12 = __PHI (bb_6: i_9, bb_4: i_5);
> +__BB(5):
> + i_12 = __PHI (__BB6: i_9, __BB4: i_5);
> _1 = &a[i_12];
> a_p = _1;
> __MEM <int[1000]> ((int *)&a)[i_12] = 100;
> i_9 = i_5 + i_12;
> if (i_9 <= 999)
> - goto bb_6;
> + goto __BB6;
> else
> - goto bb_3;
> + goto __BB3;
>
> -bb_6:
> +__BB(6):
> ;
> - goto bb_5;
> + goto __BB5;
>
> }
>
> Index: gcc/testsuite/gcc.dg/tree-ssa/scev-4.c
> ===================================================================
> --- gcc/testsuite/gcc.dg/tree-ssa/scev-4.c (revision 269604)
> +++ gcc/testsuite/gcc.dg/tree-ssa/scev-4.c (working copy)
> @@ -9,39 +9,39 @@ typedef struct {
> int *a_p;
> S a[1000];
>
> -void __GIMPLE (startwith ("loop"))
> +void __GIMPLE (ssa, startwith ("loop"))
> f (int k)
> {
> int i;
> int * _1;
>
> -bb_2:
> +__BB(2):
> i_5 = k_4(D);
> if (i_5 <= 999)
> - goto bb_4;
> + goto __BB4;
> else
> - goto bb_3;
> + goto __BB3;
>
> -bb_3:
> +__BB(3):
> return;
>
> -bb_4:
> +__BB(4):
> ;
>
> -bb_5:
> - i_12 = __PHI (bb_6: i_9, bb_4: i_5);
> +__BB(5):
> + i_12 = __PHI (__BB6: i_9, __BB4: i_5);
> _1 = &a[i_12].y;
> a_p = _1;
> __MEM <S[1000]> ((int *)&a)[i_12].y = 100;
> i_9 = i_5 + i_12;
> if (i_9 <= 999)
> - goto bb_6;
> + goto __BB6;
> else
> - goto bb_3;
> + goto __BB3;
>
> -bb_6:
> +__BB(6):
> ;
> - goto bb_5;
> + goto __BB5;
>
> }
>
> Index: gcc/testsuite/gcc.dg/tree-ssa/scev-5.c
> ===================================================================
> --- gcc/testsuite/gcc.dg/tree-ssa/scev-5.c (revision 269604)
> +++ gcc/testsuite/gcc.dg/tree-ssa/scev-5.c (working copy)
> @@ -4,39 +4,39 @@
> int *a_p;
> int a[1000];
>
> -void __GIMPLE (startwith ("loop"))
> +void __GIMPLE (ssa,startwith ("loop"))
> f (int k)
> {
> long long int i;
> int * _1;
>
> -bb_2:
> +__BB(2):
> i_5 = (long long int) k_4(D);
> if (i_5 <= 999ll)
> - goto bb_4;
> + goto __BB4;
> else
> - goto bb_3;
> + goto __BB3;
>
> -bb_3:
> +__BB(3):
> return;
>
> -bb_4:
> +__BB(4):
> ;
>
> -bb_5:
> - i_12 = __PHI (bb_6: i_9, bb_4: i_5);
> +__BB(5):
> + i_12 = __PHI (__BB6: i_9, __BB4: i_5);
> _1 = &a[i_12];
> a_p = _1;
> __MEM <int[1000]> ((int *)&a)[i_12] = 100;
> i_9 = i_5 + i_12;
> if (i_9 <= 999ll)
> - goto bb_6;
> + goto __BB6;
> else
> - goto bb_3;
> + goto __BB3;
>
> -bb_6:
> +__BB(6):
> ;
> - goto bb_5;
> + goto __BB5;
>
> }
>
> Index: gcc/testsuite/gcc.dg/vect/vect-cond-arith-2.c
> ===================================================================
> --- gcc/testsuite/gcc.dg/vect/vect-cond-arith-2.c (revision 269604)
> +++ gcc/testsuite/gcc.dg/vect/vect-cond-arith-2.c (working copy)
> @@ -1,7 +1,7 @@
> /* { dg-do compile } */
> /* { dg-additional-options "-fgimple -fdump-tree-optimized -ffast-math" } */
>
> -double __GIMPLE (startwith("loop"))
> +double __GIMPLE (ssa, startwith("loop"))
> neg_xi (double *x)
> {
> int i;
> @@ -13,13 +13,13 @@ neg_xi (double *x)
> double res;
> unsigned int ivtmp;
>
> - bb_1:
> - goto bb_2;
> + __BB(5):
> + goto __BB2;
>
> - bb_2:
> - res_1 = __PHI (bb_1: 0.0, bb_3: res_2);
> - i_4 = __PHI (bb_1: 0, bb_3: i_5);
> - ivtmp_6 = __PHI (bb_1: 100U, bb_3: ivtmp_7);
> + __BB(2):
> + res_1 = __PHI (__BB5: 0.0, __BB3: res_2);
> + i_4 = __PHI (__BB5: 0, __BB3: i_5);
> + ivtmp_6 = __PHI (__BB5: 100U, __BB3: ivtmp_7);
> index = (long unsigned int) i_4;
> offset = index * 8UL;
> xi_ptr = x_8(D) + offset;
> @@ -29,15 +29,15 @@ neg_xi (double *x)
> i_5 = i_4 + 1;
> ivtmp_7 = ivtmp_6 - 1U;
> if (ivtmp_7 != 0U)
> - goto bb_3;
> + goto __BB3;
> else
> - goto bb_4;
> + goto __BB4;
>
> - bb_3:
> - goto bb_2;
> + __BB(3):
> + goto __BB2;
>
> - bb_4:
> - res_3 = __PHI (bb_2: res_2);
> + __BB(4):
> + res_3 = __PHI (__BB2: res_2);
> return res_3;
> }
>
> Index: gcc/testsuite/gcc.target/aarch64/sve/loop_add_6.c
> ===================================================================
> --- gcc/testsuite/gcc.target/aarch64/sve/loop_add_6.c (revision 269604)
> +++ gcc/testsuite/gcc.target/aarch64/sve/loop_add_6.c (working copy)
> @@ -1,7 +1,7 @@
> /* { dg-do compile } */
> /* { dg-options "-O2 -ftree-vectorize -fgimple -ffast-math" } */
>
> -double __GIMPLE (startwith("loop"))
> +double __GIMPLE (ssa, startwith("loop"))
> neg_xi (double *x)
> {
> int i;
> @@ -13,13 +13,13 @@ neg_xi (double *x)
> double res;
> unsigned int ivtmp;
>
> - bb_1:
> - goto bb_2;
> + __BB(5):
> + goto __BB2;
>
> - bb_2:
> - res_1 = __PHI (bb_1: 0.0, bb_3: res_2);
> - i_4 = __PHI (bb_1: 0, bb_3: i_5);
> - ivtmp_6 = __PHI (bb_1: 100U, bb_3: ivtmp_7);
> + __BB(2):
> + res_1 = __PHI (__BB5: 0.0, __BB3: res_2);
> + i_4 = __PHI (__BB5: 0, __BB3: i_5);
> + ivtmp_6 = __PHI (__BB5: 100U, __BB3: ivtmp_7);
> index = (long unsigned int) i_4;
> offset = index * 8UL;
> xi_ptr = x_8(D) + offset;
> @@ -29,15 +29,15 @@ neg_xi (double *x)
> i_5 = i_4 + 1;
> ivtmp_7 = ivtmp_6 - 1U;
> if (ivtmp_7 != 0U)
> - goto bb_3;
> + goto __BB3;
> else
> - goto bb_4;
> + goto __BB4;
>
> - bb_3:
> - goto bb_2;
> + __BB(3):
> + goto __BB2;
>
> - bb_4:
> - res_3 = __PHI (bb_2: res_2);
> + __BB(4):
> + res_3 = __PHI (__BB2: res_2);
> return res_3;
> }
>
