On Wed, 13 Mar 2019, Bin.Cheng wrote: > 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.
Earlier this week I transformed the old https://gcc.gnu.org/wiki/GimpleFrontEnd page into one documenting the current state but this doesn't yet include any kind of documentation. I suppose special syntax documentation should go into our texinfo docs, I guess into a new section in the internals manual. Currently we only have documentation for the -fgimple switch. Note that I view -gimple dumping as the thing that should give you a clue about expected syntax. I hope to spend a little more time on the patch to make it ready for GCC9. Richard. > 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; > > } > > > > -- Richard Biener <rguent...@suse.de> SUSE LINUX GmbH, GF: Felix Imendoerffer, Jane Smithard, Graham Norton, HRB 21284 (AG Nuernberg)
