This is the mail archive of the
gcc-patches@gcc.gnu.org
mailing list for the GCC project.
[5/6] Fold prev/next into gimple
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?
Ciao,
Michael.
--------------------
2012-05-02 Michael Matz <matz@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);
}