On Wed, May 2, 2012 at 3:28 AM, Michael Matz <m...@suse.de> wrote:
> Hi,
>
> this patch basically is the one that makes all interfaces that possibly
> change a gimple_seq take a pointer to one, this time _including_ the
> statement iterator.
>
> For that I opted to use the same idiom as our basic block edge iterators,
> namely via a wrapper macro that replaces the current gsi_start, and
> expands to "gsi_start_1 (&x)".
>
> This means that now even an writable iterator can be formed from an empty
> list, which is magically filled when things are added via that iterator.
> This is the reason why the first patch made sure that the gsi_start calls
> only receive lvalues. And this means also that the gimple_seq_alloc calls
> can be moved even more down to the low-level helpers.
>
> I add some XXX remarks with this patch, for which I have already another
> patch fixing them again. But it's not part of this series, so please bear
> with me.
>
> This should still be a functional no-op, as should be the whole 1-5
> sequence of patches. As per [0/6] regstrapped with the other five on
> x86_64-linux. Okay for trunk?
Ok.
Thanks,
Richard.
>
> Ciao,
> Michael.
> --------------------
> 2012-05-02 Michael Matz <m...@suse.de>
>
> * gimple.h (gimple_stmt_iterator <seq>): Make it be pointer to
> gimple_seq.
> (gimple_seq_set_last, gimple_seq_set_first): Take pointer to
> sequence, lazily allocate it.
> (bb_seq_addr): New function.
> (gsi_start_1): Rename from gsi_start, but take pointer to sequence.
> (gsi_start): Macro to wrap gsi_start_1 taking pointer of argument.
> (gsi_none): New function.
> (gsi_start_bb): Adjust.
> (gsi_last_1): Rename from gsi_last, but take pointer to sequence.
> (gsi_last): Macro to wrap gsi_last_1 taking pointer of argument.
> (gsi_last_bb): Adjust.
> (gsi_seq): Adjust.
> * tree-flow-inline.h (phi_nodes_ptr): New function.
>
> * gimple-iterator.c (gsi_insert_seq_nodes_before): Adjust to
> datastructure and interface change.
> (gsi_insert_seq_before_without_update): Ditto.
> (gsi_insert_seq_nodes_after): Ditto.
> (gsi_insert_seq_after_without_update): Ditto.
> (gsi_split_seq_after): Ditto, don't use gimple_seq_alloc.
> (gsi_split_seq_before): Ditto.
> (gsi_start_phis): Adjust.
> * tree-vect-loop.c (vect_determine_vectorization_factor): Use
> gsi_none.
> (vect_transform_loop): Ditto.
> * gimple.c (gimple_seq_add_stmt, gimple_seq_add_seq,
> gimple_seq_copy): Don't use gimple_seq_alloc.
> * gimplify.c (gimple_seq_add_stmt_without_update): Ditto.
> (gimplify_seq_add_seq): Ditto.
> * lto-streamer-in.c (make_new_block): Ditto.
> * tree-cfg.c (create_bb): Ditto.
> * tree-sra.c (initialize_parameter_reductions): Ditto.
>
> Index: gimple.h
> ===================================================================
> *** gimple.h.orig 2012-05-01 22:44:15.000000000 +0200
> --- gimple.h 2012-05-01 22:44:17.000000000 +0200
> *************** typedef struct
> *** 165,171 ****
> are necessary to handle edge cases such as when statement is
> added to an empty basic block or when the last statement of a
> block/sequence is removed. */
> ! gimple_seq seq;
> basic_block bb;
> } gimple_stmt_iterator;
>
> --- 165,171 ----
> are necessary to handle edge cases such as when statement is
> added to an empty basic block or when the last statement of a
> block/sequence is removed. */
> ! gimple_seq *seq;
> basic_block bb;
> } gimple_stmt_iterator;
>
> *************** gimple_seq_last_stmt (const_gimple_seq s
> *** 1070,1090 ****
> }
>
>
> ! /* Set the last node in GIMPLE sequence S to LAST. */
>
> static inline void
> ! gimple_seq_set_last (gimple_seq s, gimple_seq_node last)
> {
> ! s->last = last;
> }
>
>
> ! /* Set the first node in GIMPLE sequence S to FIRST. */
>
> static inline void
> ! gimple_seq_set_first (gimple_seq s, gimple_seq_node first)
> {
> ! s->first = first;
> }
>
>
> --- 1070,1094 ----
> }
>
>
> ! /* Set the last node in GIMPLE sequence *PS to LAST. */
>
> static inline void
> ! gimple_seq_set_last (gimple_seq *ps, gimple_seq_node last)
> {
> ! if (!*ps)
> ! *ps = gimple_seq_alloc ();
> ! (*ps)->last = last;
> }
>
>
> ! /* Set the first node in GIMPLE sequence *PS to FIRST. */
>
> static inline void
> ! gimple_seq_set_first (gimple_seq *ps, gimple_seq_node first)
> {
> ! if (!*ps)
> ! *ps = gimple_seq_alloc ();
> ! (*ps)->first = first;
> }
>
>
> *************** bb_seq (const_basic_block bb)
> *** 1125,1130 ****
> --- 1129,1139 ----
> return (!(bb->flags & BB_RTL) && bb->il.gimple) ? bb->il.gimple->seq :
> NULL;
> }
>
> + static inline gimple_seq *
> + bb_seq_addr (const_basic_block bb)
> + {
> + return (!(bb->flags & BB_RTL) && bb->il.gimple) ? &bb->il.gimple->seq :
> NULL;
> + }
>
> /* Sets the sequence of statements in BB to SEQ. */
>
> *************** is_gimple_reg_type (tree type)
> *** 4940,4956 ****
> /* Return a new iterator pointing to GIMPLE_SEQ's first statement. */
>
> static inline gimple_stmt_iterator
> ! gsi_start (gimple_seq seq)
> {
> gimple_stmt_iterator i;
>
> ! i.ptr = gimple_seq_first (seq);
> i.seq = seq;
> i.bb = (i.ptr && i.ptr->stmt) ? gimple_bb (i.ptr->stmt) : NULL;
>
> return i;
> }
>
>
> /* Return a new iterator pointing to the first statement in basic block BB.
> */
>
> --- 4949,4976 ----
> /* Return a new iterator pointing to GIMPLE_SEQ's first statement. */
>
> static inline gimple_stmt_iterator
> ! gsi_start_1 (gimple_seq *seq)
> {
> gimple_stmt_iterator i;
>
> ! i.ptr = gimple_seq_first (*seq);
> i.seq = seq;
> i.bb = (i.ptr && i.ptr->stmt) ? gimple_bb (i.ptr->stmt) : NULL;
>
> return i;
> }
>
> + #define gsi_start(x) gsi_start_1(&(x))
> +
> + static inline gimple_stmt_iterator
> + gsi_none (void)
> + {
> + gimple_stmt_iterator i;
> + i.ptr = NULL;
> + i.seq = NULL;
> + i.bb = NULL;
> + return i;
> + }
>
> /* Return a new iterator pointing to the first statement in basic block BB.
> */
>
> *************** static inline gimple_stmt_iterator
> *** 4958,4969 ****
> gsi_start_bb (basic_block bb)
> {
> gimple_stmt_iterator i;
> ! gimple_seq seq;
>
> ! seq = bb_seq (bb);
> ! i.ptr = gimple_seq_first (seq);
> ! i.seq = seq;
> ! i.bb = bb;
>
> return i;
> }
> --- 4978,5000 ----
> gsi_start_bb (basic_block bb)
> {
> gimple_stmt_iterator i;
> ! gimple_seq *seq;
>
> ! seq = bb_seq_addr (bb);
> ! if (!seq)
> ! /* XXX Only necessary because of ENTRY/EXIT block which don't have
> ! il.gimple */
> ! {
> ! i.ptr = NULL;
> ! i.seq = NULL;
> ! i.bb = NULL;
> ! }
> ! else
> ! {
> ! i.ptr = gimple_seq_first (*seq);
> ! i.seq = seq;
> ! i.bb = bb;
> ! }
>
> return i;
> }
> *************** gsi_start_bb (basic_block bb)
> *** 4972,4988 ****
> /* Return a new iterator initially pointing to GIMPLE_SEQ's last statement.
> */
>
> static inline gimple_stmt_iterator
> ! gsi_last (gimple_seq seq)
> {
> gimple_stmt_iterator i;
>
> ! i.ptr = gimple_seq_last (seq);
> i.seq = seq;
> i.bb = (i.ptr && i.ptr->stmt) ? gimple_bb (i.ptr->stmt) : NULL;
>
> return i;
> }
>
>
> /* Return a new iterator pointing to the last statement in basic block BB.
> */
>
> --- 5003,5020 ----
> /* Return a new iterator initially pointing to GIMPLE_SEQ's last statement.
> */
>
> static inline gimple_stmt_iterator
> ! gsi_last_1 (gimple_seq *seq)
> {
> gimple_stmt_iterator i;
>
> ! i.ptr = gimple_seq_last (*seq);
> i.seq = seq;
> i.bb = (i.ptr && i.ptr->stmt) ? gimple_bb (i.ptr->stmt) : NULL;
>
> return i;
> }
>
> + #define gsi_last(x) gsi_last_1(&(x))
>
> /* Return a new iterator pointing to the last statement in basic block BB.
> */
>
> *************** static inline gimple_stmt_iterator
> *** 4990,5001 ****
> gsi_last_bb (basic_block bb)
> {
> gimple_stmt_iterator i;
> ! gimple_seq seq;
>
> ! seq = bb_seq (bb);
> ! i.ptr = gimple_seq_last (seq);
> ! i.seq = seq;
> ! i.bb = bb;
>
> return i;
> }
> --- 5022,5044 ----
> gsi_last_bb (basic_block bb)
> {
> gimple_stmt_iterator i;
> ! gimple_seq *seq;
>
> ! seq = bb_seq_addr (bb);
> ! if (!seq)
> ! /* XXX Only necessary because of ENTRY/EXIT block which don't have
> ! il.gimple */
> ! {
> ! i.ptr = NULL;
> ! i.seq = NULL;
> ! i.bb = NULL;
> ! }
> ! else
> ! {
> ! i.ptr = gimple_seq_last (*seq);
> ! i.seq = seq;
> ! i.bb = bb;
> ! }
>
> return i;
> }
> *************** gsi_bb (gimple_stmt_iterator i)
> *** 5136,5142 ****
> static inline gimple_seq
> gsi_seq (gimple_stmt_iterator i)
> {
> ! return i.seq;
> }
>
>
> --- 5179,5185 ----
> static inline gimple_seq
> gsi_seq (gimple_stmt_iterator i)
> {
> ! return *i.seq;
> }
>
>
> Index: gimple-iterator.c
> ===================================================================
> *** gimple-iterator.c.orig 2012-05-01 22:44:06.000000000 +0200
> --- gimple-iterator.c 2012-05-01 22:44:17.000000000 +0200
> *************** gsi_insert_seq_nodes_before (gimple_stmt
> *** 129,135 ****
> }
> else
> {
> ! gimple_seq_node itlast = gimple_seq_last (i->seq);
>
> /* If CUR is NULL, we link at the end of the sequence (this case
> happens
> when gsi_after_labels is called for a basic block that contains only
> --- 129,135 ----
> }
> else
> {
> ! gimple_seq_node itlast = gimple_seq_last (*i->seq);
>
> /* If CUR is NULL, we link at the end of the sequence (this case
> happens
> when gsi_after_labels is called for a basic block that contains only
> *************** gsi_insert_seq_before_without_update (gi
> *** 178,190 ****
> return;
>
> /* Don't allow inserting a sequence into itself. */
> ! gcc_assert (seq != i->seq);
>
> first = gimple_seq_first (seq);
> last = gimple_seq_last (seq);
>
> ! gimple_seq_set_first (seq, NULL);
> ! gimple_seq_set_last (seq, NULL);
> gimple_seq_free (seq);
>
> /* Empty sequences need no work. */
> --- 178,190 ----
> return;
>
> /* Don't allow inserting a sequence into itself. */
> ! gcc_assert (seq != *i->seq);
>
> first = gimple_seq_first (seq);
> last = gimple_seq_last (seq);
>
> ! gimple_seq_set_first (&seq, NULL);
> ! gimple_seq_set_last (&seq, NULL);
> gimple_seq_free (seq);
>
> /* Empty sequences need no work. */
> *************** gsi_insert_seq_nodes_after (gimple_stmt_
> *** 248,254 ****
> }
> else
> {
> ! gcc_assert (!gimple_seq_last (i->seq));
> gimple_seq_set_first (i->seq, first);
> gimple_seq_set_last (i->seq, last);
> }
> --- 248,254 ----
> }
> else
> {
> ! gcc_assert (!gimple_seq_last (*i->seq));
> gimple_seq_set_first (i->seq, first);
> gimple_seq_set_last (i->seq, last);
> }
> *************** gsi_insert_seq_after_without_update (gim
> *** 289,301 ****
> return;
>
> /* Don't allow inserting a sequence into itself. */
> ! gcc_assert (seq != i->seq);
>
> first = gimple_seq_first (seq);
> last = gimple_seq_last (seq);
>
> ! gimple_seq_set_first (seq, NULL);
> ! gimple_seq_set_last (seq, NULL);
> gimple_seq_free (seq);
>
> /* Empty sequences need no work. */
> --- 289,301 ----
> return;
>
> /* Don't allow inserting a sequence into itself. */
> ! gcc_assert (seq != *i->seq);
>
> first = gimple_seq_first (seq);
> last = gimple_seq_last (seq);
>
> ! gimple_seq_set_first (&seq, NULL);
> ! gimple_seq_set_last (&seq, NULL);
> gimple_seq_free (seq);
>
> /* Empty sequences need no work. */
> *************** gimple_seq
> *** 329,335 ****
> gsi_split_seq_after (gimple_stmt_iterator i)
> {
> gimple_seq_node cur, next;
> ! gimple_seq old_seq, new_seq;
>
> cur = i.ptr;
>
> --- 329,335 ----
> gsi_split_seq_after (gimple_stmt_iterator i)
> {
> gimple_seq_node cur, next;
> ! gimple_seq *pold_seq, new_seq;
>
> cur = i.ptr;
>
> *************** gsi_split_seq_after (gimple_stmt_iterato
> *** 337,348 ****
> gcc_assert (cur && cur->next);
> next = cur->next;
>
> ! old_seq = i.seq;
> ! new_seq = gimple_seq_alloc ();
>
> ! gimple_seq_set_first (new_seq, next);
> ! gimple_seq_set_last (new_seq, gimple_seq_last (old_seq));
> ! gimple_seq_set_last (old_seq, cur);
> cur->next = NULL;
> next->prev = NULL;
>
> --- 337,348 ----
> gcc_assert (cur && cur->next);
> next = cur->next;
>
> ! pold_seq = i.seq;
> ! new_seq = NULL;
>
> ! gimple_seq_set_first (&new_seq, next);
> ! gimple_seq_set_last (&new_seq, gimple_seq_last (*pold_seq));
> ! gimple_seq_set_last (pold_seq, cur);
> cur->next = NULL;
> next->prev = NULL;
>
> *************** void
> *** 369,375 ****
> gsi_split_seq_before (gimple_stmt_iterator *i, gimple_seq *pnew_seq)
> {
> gimple_seq_node cur, prev;
> ! gimple_seq old_seq, new_seq;
>
> cur = i->ptr;
>
> --- 369,375 ----
> gsi_split_seq_before (gimple_stmt_iterator *i, gimple_seq *pnew_seq)
> {
> gimple_seq_node cur, prev;
> ! gimple_seq old_seq;
>
> cur = i->ptr;
>
> *************** gsi_split_seq_before (gimple_stmt_iterat
> *** 377,399 ****
> gcc_assert (cur);
> prev = cur->prev;
>
> ! old_seq = i->seq;
> ! new_seq = gimple_seq_alloc ();
> ! i->seq = new_seq;
>
> /* Set the limits on NEW_SEQ. */
> ! gimple_seq_set_first (new_seq, cur);
> ! gimple_seq_set_last (new_seq, gimple_seq_last (old_seq));
>
> /* Cut OLD_SEQ before I. */
> ! gimple_seq_set_last (old_seq, prev);
> cur->prev = NULL;
> if (prev)
> prev->next = NULL;
> else
> ! gimple_seq_set_first (old_seq, NULL);
> !
> ! *pnew_seq = new_seq;
> }
>
>
> --- 377,397 ----
> gcc_assert (cur);
> prev = cur->prev;
>
> ! old_seq = *i->seq;
> ! i->seq = pnew_seq;
> ! *pnew_seq = NULL;
>
> /* Set the limits on NEW_SEQ. */
> ! gimple_seq_set_first (pnew_seq, cur);
> ! gimple_seq_set_last (pnew_seq, gimple_seq_last (old_seq));
>
> /* Cut OLD_SEQ before I. */
> ! gimple_seq_set_last (&old_seq, prev);
> cur->prev = NULL;
> if (prev)
> prev->next = NULL;
> else
> ! gimple_seq_set_first (&old_seq, NULL);
> }
>
>
> *************** gsi_commit_one_edge_insert (edge e, basi
> *** 850,854 ****
> gimple_stmt_iterator
> gsi_start_phis (basic_block bb)
> {
> ! return gsi_start (phi_nodes (bb));
> }
> --- 848,854 ----
> gimple_stmt_iterator
> gsi_start_phis (basic_block bb)
> {
> ! gimple_seq *pseq = phi_nodes_ptr (bb);
> ! /* XXX check only necessary because ENTRY/EXIT blocks don't have
> il.gimple */
> ! return pseq ? gsi_start_1 (pseq) : gsi_none ();
> }
> Index: tree-flow-inline.h
> ===================================================================
> *** tree-flow-inline.h.orig 2012-05-01 22:39:06.000000000 +0200
> --- tree-flow-inline.h 2012-05-01 22:44:17.000000000 +0200
> *************** phi_nodes (const_basic_block bb)
> *** 511,516 ****
> --- 511,525 ----
> return bb->il.gimple->phi_nodes;
> }
>
> + static inline gimple_seq *
> + phi_nodes_ptr (const_basic_block bb)
> + {
> + gcc_checking_assert (!(bb->flags & BB_RTL));
> + if (!bb->il.gimple)
> + return NULL;
> + return &bb->il.gimple->phi_nodes;
> + }
> +
> /* Set PHI nodes of a basic block BB to SEQ. */
>
> static inline void
> Index: tree-vect-loop.c
> ===================================================================
> *** tree-vect-loop.c.orig 2012-05-01 22:39:06.000000000 +0200
> --- tree-vect-loop.c 2012-05-01 22:44:17.000000000 +0200
> *************** vect_determine_vectorization_factor (loo
> *** 183,189 ****
> HOST_WIDE_INT dummy;
> gimple stmt, pattern_stmt = NULL;
> gimple_seq pattern_def_seq = NULL;
> ! gimple_stmt_iterator pattern_def_si = gsi_start (NULL);
> bool analyze_pattern_stmt = false;
>
> if (vect_print_dump_info (REPORT_DETAILS))
> --- 183,189 ----
> HOST_WIDE_INT dummy;
> gimple stmt, pattern_stmt = NULL;
> gimple_seq pattern_def_seq = NULL;
> ! gimple_stmt_iterator pattern_def_si = gsi_none ();
> bool analyze_pattern_stmt = false;
>
> if (vect_print_dump_info (REPORT_DETAILS))
> *************** vect_determine_vectorization_factor (loo
> *** 336,342 ****
> }
> else
> {
> ! pattern_def_si = gsi_start (NULL);
> analyze_pattern_stmt = false;
> }
> }
> --- 336,342 ----
> }
> else
> {
> ! pattern_def_si = gsi_none ();
> analyze_pattern_stmt = false;
> }
> }
> *************** vect_transform_loop (loop_vec_info loop_
> *** 5231,5237 ****
> gimple_seq cond_expr_stmt_list = NULL;
> gimple stmt, pattern_stmt;
> gimple_seq pattern_def_seq = NULL;
> ! gimple_stmt_iterator pattern_def_si = gsi_start (NULL);
> bool transform_pattern_stmt = false;
>
> if (vect_print_dump_info (REPORT_DETAILS))
> --- 5231,5237 ----
> gimple_seq cond_expr_stmt_list = NULL;
> gimple stmt, pattern_stmt;
> gimple_seq pattern_def_seq = NULL;
> ! gimple_stmt_iterator pattern_def_si = gsi_none ();
> bool transform_pattern_stmt = false;
>
> if (vect_print_dump_info (REPORT_DETAILS))
> *************** vect_transform_loop (loop_vec_info loop_
> *** 5409,5415 ****
> }
> else
> {
> ! pattern_def_si = gsi_start (NULL);
> transform_pattern_stmt = false;
> }
> }
> --- 5409,5415 ----
> }
> else
> {
> ! pattern_def_si = gsi_none ();
> transform_pattern_stmt = false;
> }
> }
> Index: gimple.c
> ===================================================================
> *** gimple.c.orig 2012-05-01 22:43:34.000000000 +0200
> --- gimple.c 2012-05-01 22:44:17.000000000 +0200
> *************** void
> *** 1255,1267 ****
> gimple_seq_add_stmt (gimple_seq *seq_p, gimple gs)
> {
> gimple_stmt_iterator si;
> -
> if (gs == NULL)
> return;
>
> - if (*seq_p == NULL)
> - *seq_p = gimple_seq_alloc ();
> -
> si = gsi_last (*seq_p);
> gsi_insert_after (&si, gs, GSI_NEW_STMT);
> }
> --- 1255,1263 ----
> *************** void
> *** 1274,1286 ****
> gimple_seq_add_seq (gimple_seq *dst_p, gimple_seq src)
> {
> gimple_stmt_iterator si;
> -
> if (src == NULL)
> return;
>
> - if (*dst_p == NULL)
> - *dst_p = gimple_seq_alloc ();
> -
> si = gsi_last (*dst_p);
> gsi_insert_seq_after (&si, src, GSI_NEW_STMT);
> }
> --- 1270,1278 ----
> *************** gimple_seq
> *** 1324,1330 ****
> gimple_seq_copy (gimple_seq src)
> {
> gimple_stmt_iterator gsi;
> ! gimple_seq new_seq = gimple_seq_alloc ();
> gimple stmt;
>
> for (gsi = gsi_start (src); !gsi_end_p (gsi); gsi_next (&gsi))
> --- 1316,1322 ----
> gimple_seq_copy (gimple_seq src)
> {
> gimple_stmt_iterator gsi;
> ! gimple_seq new_seq = NULL;
> gimple stmt;
>
> for (gsi = gsi_start (src); !gsi_end_p (gsi); gsi_next (&gsi))
> Index: gimplify.c
> ===================================================================
> *** gimplify.c.orig 2012-05-01 22:44:02.000000000 +0200
> --- gimplify.c 2012-05-01 22:44:17.000000000 +0200
> *************** gimple_seq_add_stmt_without_update (gimp
> *** 169,179 ****
> if (gs == NULL)
> return;
>
> - if (*seq_p == NULL)
> - *seq_p = gimple_seq_alloc ();
> -
> si = gsi_last (*seq_p);
> -
> gsi_insert_after_without_update (&si, gs, GSI_NEW_STMT);
> }
>
> --- 169,175 ----
> *************** gimplify_seq_add_seq (gimple_seq *dst_p,
> *** 200,208 ****
> if (src == NULL)
> return;
>
> - if (*dst_p == NULL)
> - *dst_p = gimple_seq_alloc ();
> -
> si = gsi_last (*dst_p);
> gsi_insert_seq_after_without_update (&si, src, GSI_NEW_STMT);
> }
> --- 196,201 ----
> Index: lto-streamer-in.c
> ===================================================================
> *** lto-streamer-in.c.orig 2012-05-01 22:39:06.000000000 +0200
> --- lto-streamer-in.c 2012-05-01 22:44:17.000000000 +0200
> *************** make_new_block (struct function *fn, uns
> *** 602,608 ****
> bb->il.gimple = ggc_alloc_cleared_gimple_bb_info ();
> n_basic_blocks_for_function (fn)++;
> bb->flags = 0;
> ! set_bb_seq (bb, gimple_seq_alloc ());
> return bb;
> }
>
> --- 602,608 ----
> bb->il.gimple = ggc_alloc_cleared_gimple_bb_info ();
> n_basic_blocks_for_function (fn)++;
> bb->flags = 0;
> ! set_bb_seq (bb, NULL);
> return bb;
> }
>
> Index: tree-cfg.c
> ===================================================================
> *** tree-cfg.c.orig 2012-05-01 22:43:34.000000000 +0200
> --- tree-cfg.c 2012-05-01 22:44:17.000000000 +0200
> *************** create_bb (void *h, void *e, basic_block
> *** 439,445 ****
> bb->index = last_basic_block;
> bb->flags = BB_NEW;
> bb->il.gimple = ggc_alloc_cleared_gimple_bb_info ();
> ! set_bb_seq (bb, h ? (gimple_seq) h : gimple_seq_alloc ());
>
> /* Add the new block to the linked list of blocks. */
> link_block (bb, after);
> --- 439,445 ----
> bb->index = last_basic_block;
> bb->flags = BB_NEW;
> bb->il.gimple = ggc_alloc_cleared_gimple_bb_info ();
> ! set_bb_seq (bb, h ? (gimple_seq) h : NULL);
>
> /* Add the new block to the linked list of blocks. */
> link_block (bb, after);
> Index: tree-sra.c
> ===================================================================
> *** tree-sra.c.orig 2012-05-01 22:39:06.000000000 +0200
> --- tree-sra.c 2012-05-01 22:44:17.000000000 +0200
> *************** initialize_parameter_reductions (void)
> *** 3192,3197 ****
> --- 3192,3198 ----
> gimple_seq seq = NULL;
> tree parm;
>
> + gsi = gsi_start (seq);
> for (parm = DECL_ARGUMENTS (current_function_decl);
> parm;
> parm = DECL_CHAIN (parm))
> *************** initialize_parameter_reductions (void)
> *** 3205,3216 ****
> if (!access_vec)
> continue;
>
> - if (!seq)
> - {
> - seq = gimple_seq_alloc ();
> - gsi = gsi_start (seq);
> - }
> -
> for (access = VEC_index (access_p, access_vec, 0);
> access;
> access = access->next_grp)
> --- 3206,3211 ----
> *************** initialize_parameter_reductions (void)
> *** 3218,3223 ****
> --- 3213,3219 ----
> EXPR_LOCATION (parm));
> }
>
> + seq = gsi_seq (gsi);
> if (seq)
> gsi_insert_seq_on_edge_immediate (single_succ_edge (ENTRY_BLOCK_PTR),
> seq);
> }
