* Make gimple.h checks conditional with ENABLE_GIMPLE_CHECKING
@ 2010-06-08 23:13 Jan Hubicka
2010-06-09 6:13 ` Basile Starynkevitch
` (3 more replies)
0 siblings, 4 replies; 15+ messages in thread
From: Jan Hubicka @ 2010-06-08 23:13 UTC (permalink / raw)
To: gcc-patches, rguenther
Hi,
this patch conditionalize the sanity checks in gimple accessor functions.
I originally intended to go through my list of most frequent aborts remianing
in the code, but it seems now to me that it would cause just maintenance
problems since it would be difficult to decide what to check and what not.
The nature of the checks is very similar to the tree/rtl and gimple checking
so I think we should just handle them same way and put them all into
ENABLE_GIMPLE_CHECKING
Bootstrapped/regtested x86_64-linux. My build time test actually regressed
to 11m16s (it used to be 10m19s), but I am quite convinced it is due to
merge of df-improv branch
OK?
Honza
* gimple.h (set_bb_seq): Make check conditional with ENABLE_ChECKING.
(gimple_set_def_ops, gimple_set_use_ops,
gimple_set_vuse, gimple_set_vdef,
gimple_omp_subcode, gimple_omp_set_subcode, gimple_ops, gimple_op,
gimple_op_ptr, gimple_op_ptr, gimple_set_op, gimple_bind_set_block,
gimple_asm_input_op, gimple_asm_input_op_ptr, gimple_asm_set_input_op,
gimple_asm_output_op, gimple_asm_output_op_ptr,
gimple_asm_set_output_op, gimple_asm_clobber_op,
gimple_asm_set_clobber_op, gimple_asm_label_op,
gimple_asm_set_label_op, gimple_try_set_kind, gimple_try_catch_is_cleanup
gimple_try_set_catch_is_cleanup, gimple_phi_arg,
gimple_switch_num_labels, gimple_switch_set_index, gimple_switch_label,
gimple_switch_set_label, gimple_omp_for_index, gimple_omp_for_index_ptr,
gimple_omp_for_set_index, gimple_omp_for_initial, gimple_omp_for_initial_ptr,
gimple_omp_for_set_initial, gimple_omp_for_final, gimple_omp_for_final_ptr,
gimple_omp_for_set_final, gimple_omp_for_incr, gimple_omp_for_incr_ptr,
gimple_omp_for_set_incr, gimple_omp_for_set_cond, gimple_omp_for_cond): Make
checking conditional with ENABLE_GIMPLE_CHECKING.
(gimple_phi_set_arg): Likewise; replace memcpy by assignment.
Index: gimple.h
===================================================================
--- gimple.h (revision 160447)
+++ gimple.h (working copy)
@@ -244,7 +244,9 @@ bb_seq (const_basic_block bb)
static inline void
set_bb_seq (basic_block bb, gimple_seq seq)
{
+#ifdef ENABLE_CHECKING
gcc_assert (!(bb->flags & BB_RTL));
+#endif
bb->il.gimple->seq = seq;
}
@@ -1326,7 +1328,9 @@ gimple_def_ops (const_gimple g)
static inline void
gimple_set_def_ops (gimple g, struct def_optype_d *def)
{
+#ifdef ENABLE_GIMPLE_CHECKING
gcc_assert (gimple_has_ops (g));
+#endif
g->gsops.opbase.def_ops = def;
}
@@ -1347,7 +1351,9 @@ gimple_use_ops (const_gimple g)
static inline void
gimple_set_use_ops (gimple g, struct use_optype_d *use)
{
+#ifdef ENABLE_GIMPLE_CHECKING
gcc_assert (gimple_has_ops (g));
+#endif
g->gsops.opbase.use_ops = use;
}
@@ -1428,7 +1434,9 @@ gimple_vdef_ptr (gimple g)
static inline void
gimple_set_vuse (gimple g, tree vuse)
{
+#ifdef ENABLE_GIMPLE_CHECKING
gcc_assert (gimple_has_mem_ops (g));
+#endif
g->gsmembase.vuse = vuse;
}
@@ -1437,7 +1445,9 @@ gimple_set_vuse (gimple g, tree vuse)
static inline void
gimple_set_vdef (gimple g, tree vdef)
{
+#ifdef ENABLE_GIMPLE_CHECKING
gcc_assert (gimple_has_mem_ops (g));
+#endif
g->gsmembase.vdef = vdef;
}
@@ -1528,8 +1538,10 @@ gimple_references_memory_p (gimple stmt)
static inline unsigned
gimple_omp_subcode (const_gimple s)
{
+#ifdef ENABLE_GIMPLE_CHECKING
gcc_assert (gimple_code (s) >= GIMPLE_OMP_ATOMIC_LOAD
&& gimple_code (s) <= GIMPLE_OMP_SINGLE);
+#endif
return s->gsbase.subcode;
}
@@ -1540,7 +1552,9 @@ gimple_omp_set_subcode (gimple s, unsign
{
/* We only have 16 bits for the subcode. Assert that we are not
overflowing it. */
+#ifdef ENABLE_GIMPLE_CHECKING
gcc_assert (subcode < (1 << 16));
+#ENDif
s->gsbase.subcode = subcode;
}
@@ -1640,7 +1654,9 @@ gimple_ops (gimple gs)
of the structure. Note that those structures that do not
have an operand vector have a zero offset. */
off = gimple_ops_offset_[gimple_statement_structure (gs)];
+#ifdef ENABLE_GIMPLE_CHECKING
gcc_assert (off != 0);
+#endif
return (tree *) ((char *) gs + off);
}
@@ -1653,7 +1669,7 @@ gimple_op (const_gimple gs, unsigned i)
{
if (gimple_has_ops (gs))
{
-#ifdef ENABLE_CHECKING
+#ifdef ENABLE_GIMPLE_CHECKING
gcc_assert (i < gimple_num_ops (gs));
#endif
return gimple_ops (CONST_CAST_GIMPLE (gs))[i];
@@ -1669,7 +1685,7 @@ gimple_op_ptr (const_gimple gs, unsigned
{
if (gimple_has_ops (gs))
{
-#ifdef ENABLE_CHECKING
+#ifdef ENABLE_GIMPLE_CHECKING
gcc_assert (i < gimple_num_ops (gs));
#endif
return gimple_ops (CONST_CAST_GIMPLE (gs)) + i;
@@ -1683,7 +1699,9 @@ gimple_op_ptr (const_gimple gs, unsigned
static inline void
gimple_set_op (gimple gs, unsigned i, tree op)
{
+#ifdef ENABLE_GIMPLE_CHECKING
gcc_assert (gimple_has_ops (gs) && i < gimple_num_ops (gs));
+#endif
/* Note. It may be tempting to assert that OP matches
is_gimple_operand, but that would be wrong. Different tuples
@@ -2626,7 +2644,9 @@ static inline void
gimple_bind_set_block (gimple gs, tree block)
{
GIMPLE_CHECK (gs, GIMPLE_BIND);
+#ifdef ENABLE_GIMPLE_CHECKING
gcc_assert (block == NULL_TREE || TREE_CODE (block) == BLOCK);
+#endif
gs->gimple_bind.block = block;
}
@@ -2675,7 +2695,9 @@ static inline tree
gimple_asm_input_op (const_gimple gs, unsigned index)
{
GIMPLE_CHECK (gs, GIMPLE_ASM);
+#ifdef ENABLE_GIMPLE_CHECKING
gcc_assert (index <= gs->gimple_asm.ni);
+#endif
return gimple_op (gs, index);
}
@@ -2685,7 +2707,9 @@ static inline tree *
gimple_asm_input_op_ptr (const_gimple gs, unsigned index)
{
GIMPLE_CHECK (gs, GIMPLE_ASM);
+#ifdef ENABLE_GIMPLE_CHECKING
gcc_assert (index <= gs->gimple_asm.ni);
+#endif
return gimple_op_ptr (gs, index);
}
@@ -2696,8 +2720,10 @@ static inline void
gimple_asm_set_input_op (gimple gs, unsigned index, tree in_op)
{
GIMPLE_CHECK (gs, GIMPLE_ASM);
+#ifdef ENABLE_GIMPLE_CHECKING
gcc_assert (index <= gs->gimple_asm.ni);
gcc_assert (TREE_CODE (in_op) == TREE_LIST);
+#endif
gimple_set_op (gs, index, in_op);
}
@@ -2708,7 +2734,9 @@ static inline tree
gimple_asm_output_op (const_gimple gs, unsigned index)
{
GIMPLE_CHECK (gs, GIMPLE_ASM);
+#ifdef ENABLE_GIMPLE_CHECKING
gcc_assert (index <= gs->gimple_asm.no);
+#endif
return gimple_op (gs, index + gs->gimple_asm.ni);
}
@@ -2718,7 +2746,9 @@ static inline tree *
gimple_asm_output_op_ptr (const_gimple gs, unsigned index)
{
GIMPLE_CHECK (gs, GIMPLE_ASM);
+#ifdef ENABLE_GIMPLE_CHECKING
gcc_assert (index <= gs->gimple_asm.no);
+#endif
return gimple_op_ptr (gs, index + gs->gimple_asm.ni);
}
@@ -2729,8 +2759,10 @@ static inline void
gimple_asm_set_output_op (gimple gs, unsigned index, tree out_op)
{
GIMPLE_CHECK (gs, GIMPLE_ASM);
+#ifdef ENABLE_GIMPLE_CHECKING
gcc_assert (index <= gs->gimple_asm.no);
gcc_assert (TREE_CODE (out_op) == TREE_LIST);
+#endif
gimple_set_op (gs, index + gs->gimple_asm.ni, out_op);
}
@@ -2741,7 +2773,9 @@ static inline tree
gimple_asm_clobber_op (const_gimple gs, unsigned index)
{
GIMPLE_CHECK (gs, GIMPLE_ASM);
+#ifdef ENABLE_GIMPLE_CHECKING
gcc_assert (index <= gs->gimple_asm.nc);
+#endif
return gimple_op (gs, index + gs->gimple_asm.ni + gs->gimple_asm.no);
}
@@ -2752,8 +2786,10 @@ static inline void
gimple_asm_set_clobber_op (gimple gs, unsigned index, tree clobber_op)
{
GIMPLE_CHECK (gs, GIMPLE_ASM);
+#ifdef ENABLE_GIMPLE_CHECKING
gcc_assert (index <= gs->gimple_asm.nc);
gcc_assert (TREE_CODE (clobber_op) == TREE_LIST);
+#endif
gimple_set_op (gs, index + gs->gimple_asm.ni + gs->gimple_asm.no, clobber_op);
}
@@ -2763,7 +2799,9 @@ static inline tree
gimple_asm_label_op (const_gimple gs, unsigned index)
{
GIMPLE_CHECK (gs, GIMPLE_ASM);
+#ifdef ENABLE_GIMPLE_CHECKING
gcc_assert (index <= gs->gimple_asm.nl);
+#endif
return gimple_op (gs, index + gs->gimple_asm.ni + gs->gimple_asm.nc);
}
@@ -2773,8 +2811,10 @@ static inline void
gimple_asm_set_label_op (gimple gs, unsigned index, tree label_op)
{
GIMPLE_CHECK (gs, GIMPLE_ASM);
+#ifdef ENABLE_GIMPLE_CHECKING
gcc_assert (index <= gs->gimple_asm.nl);
gcc_assert (TREE_CODE (label_op) == TREE_LIST);
+#endif
gimple_set_op (gs, index + gs->gimple_asm.ni + gs->gimple_asm.nc, label_op);
}
@@ -2987,7 +3027,9 @@ static inline void
gimple_try_set_kind (gimple gs, enum gimple_try_flags kind)
{
GIMPLE_CHECK (gs, GIMPLE_TRY);
+#ifdef ENABLE_GIMPLE_CHECKING
gcc_assert (kind == GIMPLE_TRY_CATCH || kind == GIMPLE_TRY_FINALLY);
+#endif
if (gimple_try_kind (gs) != kind)
gs->gsbase.subcode = (unsigned int) kind;
}
@@ -2998,7 +3040,9 @@ gimple_try_set_kind (gimple gs, enum gim
static inline bool
gimple_try_catch_is_cleanup (const_gimple gs)
{
+#ifdef ENABLE_GIMPLE_CHECKING
gcc_assert (gimple_try_kind (gs) == GIMPLE_TRY_CATCH);
+#endif
return (gs->gsbase.subcode & GIMPLE_TRY_CATCH_IS_CLEANUP) != 0;
}
@@ -3029,7 +3073,9 @@ gimple_try_cleanup (gimple gs)
static inline void
gimple_try_set_catch_is_cleanup (gimple g, bool catch_is_cleanup)
{
+#ifdef ENABLE_GIMPLE_CHECKING
gcc_assert (gimple_try_kind (g) == GIMPLE_TRY_CATCH);
+#endif
if (catch_is_cleanup)
g->gsbase.subcode |= GIMPLE_TRY_CATCH_IS_CLEANUP;
else
@@ -3156,7 +3202,9 @@ static inline struct phi_arg_d *
gimple_phi_arg (gimple gs, unsigned index)
{
GIMPLE_CHECK (gs, GIMPLE_PHI);
+#ifdef ENABLE_GIMPLE_CHECKING
gcc_assert (index <= gs->gimple_phi.capacity);
+#endif
return &(gs->gimple_phi.args[index]);
}
@@ -3167,8 +3215,10 @@ static inline void
gimple_phi_set_arg (gimple gs, unsigned index, struct phi_arg_d * phiarg)
{
GIMPLE_CHECK (gs, GIMPLE_PHI);
+#ifdef ENABLE_GIMPLE_CHECKING
gcc_assert (index <= gs->gimple_phi.nargs);
- memcpy (gs->gimple_phi.args + index, phiarg, sizeof (struct phi_arg_d));
+#endif
+ gs->gimple_phi.args[index] = *phiarg;
}
/* Return the region number for GIMPLE_RESX GS. */
@@ -3215,7 +3265,9 @@ gimple_switch_num_labels (const_gimple g
unsigned num_ops;
GIMPLE_CHECK (gs, GIMPLE_SWITCH);
num_ops = gimple_num_ops (gs);
+#ifdef ENABLE_GIMPLE_CHECKING
gcc_assert (num_ops > 1);
+#endif
return num_ops - 1;
}
@@ -3256,7 +3308,9 @@ static inline void
gimple_switch_set_index (gimple gs, tree index)
{
GIMPLE_CHECK (gs, GIMPLE_SWITCH);
+#ifdef ENABLE_GIMPLE_CHECKING
gcc_assert (SSA_VAR_P (index) || CONSTANT_CLASS_P (index));
+#endif
gimple_set_op (gs, 0, index);
}
@@ -3268,7 +3322,9 @@ static inline tree
gimple_switch_label (const_gimple gs, unsigned index)
{
GIMPLE_CHECK (gs, GIMPLE_SWITCH);
+#ifdef ENABLE_GIMPLE_CHECKING
gcc_assert (gimple_num_ops (gs) > index + 1);
+#endif
return gimple_op (gs, index + 1);
}
@@ -3278,8 +3334,10 @@ static inline void
gimple_switch_set_label (gimple gs, unsigned index, tree label)
{
GIMPLE_CHECK (gs, GIMPLE_SWITCH);
+#ifdef ENABLE_GIMPLE_CHECKING
gcc_assert (gimple_num_ops (gs) > index + 1);
gcc_assert (label == NULL_TREE || TREE_CODE (label) == CASE_LABEL_EXPR);
+#endif
gimple_set_op (gs, index + 1, label);
}
@@ -3506,7 +3564,9 @@ static inline tree
gimple_omp_for_index (const_gimple gs, size_t i)
{
GIMPLE_CHECK (gs, GIMPLE_OMP_FOR);
+#ifdef ENABLE_GIMPLE_CHECKING
gcc_assert (i < gs->gimple_omp_for.collapse);
+#endif
return gs->gimple_omp_for.iter[i].index;
}
@@ -3517,7 +3577,9 @@ static inline tree *
gimple_omp_for_index_ptr (gimple gs, size_t i)
{
GIMPLE_CHECK (gs, GIMPLE_OMP_FOR);
+#ifdef ENABLE_GIMPLE_CHECKING
gcc_assert (i < gs->gimple_omp_for.collapse);
+#endif
return &gs->gimple_omp_for.iter[i].index;
}
@@ -3528,7 +3590,9 @@ static inline void
gimple_omp_for_set_index (gimple gs, size_t i, tree index)
{
GIMPLE_CHECK (gs, GIMPLE_OMP_FOR);
+#ifdef ENABLE_GIMPLE_CHECKING
gcc_assert (i < gs->gimple_omp_for.collapse);
+#endif
gs->gimple_omp_for.iter[i].index = index;
}
@@ -3539,7 +3603,9 @@ static inline tree
gimple_omp_for_initial (const_gimple gs, size_t i)
{
GIMPLE_CHECK (gs, GIMPLE_OMP_FOR);
+#ifdef ENABLE_GIMPLE_CHECKING
gcc_assert (i < gs->gimple_omp_for.collapse);
+#endif
return gs->gimple_omp_for.iter[i].initial;
}
@@ -3550,7 +3616,9 @@ static inline tree *
gimple_omp_for_initial_ptr (gimple gs, size_t i)
{
GIMPLE_CHECK (gs, GIMPLE_OMP_FOR);
+#ifdef ENABLE_GIMPLE_CHECKING
gcc_assert (i < gs->gimple_omp_for.collapse);
+#endif
return &gs->gimple_omp_for.iter[i].initial;
}
@@ -3561,7 +3629,9 @@ static inline void
gimple_omp_for_set_initial (gimple gs, size_t i, tree initial)
{
GIMPLE_CHECK (gs, GIMPLE_OMP_FOR);
+#ifdef ENABLE_GIMPLE_CHECKING
gcc_assert (i < gs->gimple_omp_for.collapse);
+#endif
gs->gimple_omp_for.iter[i].initial = initial;
}
@@ -3572,7 +3642,9 @@ static inline tree
gimple_omp_for_final (const_gimple gs, size_t i)
{
GIMPLE_CHECK (gs, GIMPLE_OMP_FOR);
+#ifdef ENABLE_GIMPLE_CHECKING
gcc_assert (i < gs->gimple_omp_for.collapse);
+#endif
return gs->gimple_omp_for.iter[i].final;
}
@@ -3583,7 +3655,9 @@ static inline tree *
gimple_omp_for_final_ptr (gimple gs, size_t i)
{
GIMPLE_CHECK (gs, GIMPLE_OMP_FOR);
+#ifdef ENABLE_GIMPLE_CHECKING
gcc_assert (i < gs->gimple_omp_for.collapse);
+#endif
return &gs->gimple_omp_for.iter[i].final;
}
@@ -3594,7 +3668,9 @@ static inline void
gimple_omp_for_set_final (gimple gs, size_t i, tree final)
{
GIMPLE_CHECK (gs, GIMPLE_OMP_FOR);
+#ifdef ENABLE_GIMPLE_CHECKING
gcc_assert (i < gs->gimple_omp_for.collapse);
+#endif
gs->gimple_omp_for.iter[i].final = final;
}
@@ -3605,7 +3681,9 @@ static inline tree
gimple_omp_for_incr (const_gimple gs, size_t i)
{
GIMPLE_CHECK (gs, GIMPLE_OMP_FOR);
+#ifdef ENABLE_GIMPLE_CHECKING
gcc_assert (i < gs->gimple_omp_for.collapse);
+#endif
return gs->gimple_omp_for.iter[i].incr;
}
@@ -3616,7 +3694,9 @@ static inline tree *
gimple_omp_for_incr_ptr (gimple gs, size_t i)
{
GIMPLE_CHECK (gs, GIMPLE_OMP_FOR);
+#ifdef ENABLE_GIMPLE_CHECKING
gcc_assert (i < gs->gimple_omp_for.collapse);
+#endif
return &gs->gimple_omp_for.iter[i].incr;
}
@@ -3627,7 +3707,9 @@ static inline void
gimple_omp_for_set_incr (gimple gs, size_t i, tree incr)
{
GIMPLE_CHECK (gs, GIMPLE_OMP_FOR);
+#ifdef ENABLE_GIMPLE_CHECKING
gcc_assert (i < gs->gimple_omp_for.collapse);
+#endif
gs->gimple_omp_for.iter[i].incr = incr;
}
@@ -4129,8 +4211,10 @@ static inline void
gimple_omp_for_set_cond (gimple gs, size_t i, enum tree_code cond)
{
GIMPLE_CHECK (gs, GIMPLE_OMP_FOR);
+#ifdef ENABLE_GIMPLE_CHECKING
gcc_assert (TREE_CODE_CLASS (cond) == tcc_comparison);
gcc_assert (i < gs->gimple_omp_for.collapse);
+#endif
gs->gimple_omp_for.iter[i].cond = cond;
}
@@ -4141,7 +4225,9 @@ static inline enum tree_code
gimple_omp_for_cond (const_gimple gs, size_t i)
{
GIMPLE_CHECK (gs, GIMPLE_OMP_FOR);
+#ifdef ENABLE_GIMPLE_CHECKING
gcc_assert (i < gs->gimple_omp_for.collapse);
+#endif
return gs->gimple_omp_for.iter[i].cond;
}
^ permalink raw reply [flat|nested] 15+ messages in thread
* Re: Make gimple.h checks conditional with ENABLE_GIMPLE_CHECKING
2010-06-08 23:13 Make gimple.h checks conditional with ENABLE_GIMPLE_CHECKING Jan Hubicka
@ 2010-06-09 6:13 ` Basile Starynkevitch
2010-06-09 8:37 ` Manuel López-Ibáñez
` (2 subsequent siblings)
3 siblings, 0 replies; 15+ messages in thread
From: Basile Starynkevitch @ 2010-06-09 6:13 UTC (permalink / raw)
To: Jan Hubicka; +Cc: gcc-patches, rguenther
On Wed, 2010-06-09 at 00:57 +0200, Jan Hubicka wrote:
>
> @@ -1326,7 +1328,9 @@ gimple_def_ops (const_gimple g)
> static inline void
> gimple_set_def_ops (gimple g, struct def_optype_d *def)
> {
> +#ifdef ENABLE_GIMPLE_CHECKING
> gcc_assert (gimple_has_ops (g));
> +#endif
> g->gsops.opbase.def_ops = def;
> }
>
Maybe it should be
gcc_assert (g && gimple_has_ops (g));
or perhaps the test that g is not null should go into gimple_has_ops at
least when ENABLE_GIMPLE_CHECKING?
Cheers
--
Basile STARYNKEVITCH http://starynkevitch.net/Basile/
email: basile<at>starynkevitch<dot>net mobile: +33 6 8501 2359
8, rue de la Faiencerie, 92340 Bourg La Reine, France
*** opinions {are only mines, sont seulement les miennes} ***
^ permalink raw reply [flat|nested] 15+ messages in thread
* Re: Make gimple.h checks conditional with ENABLE_GIMPLE_CHECKING
2010-06-08 23:13 Make gimple.h checks conditional with ENABLE_GIMPLE_CHECKING Jan Hubicka
2010-06-09 6:13 ` Basile Starynkevitch
@ 2010-06-09 8:37 ` Manuel López-Ibáñez
2010-06-09 9:31 ` Richard Guenther
2010-06-09 9:29 ` Richard Guenther
2010-06-09 10:05 ` Paolo Bonzini
3 siblings, 1 reply; 15+ messages in thread
From: Manuel López-Ibáñez @ 2010-06-09 8:37 UTC (permalink / raw)
To: Jan Hubicka; +Cc: gcc-patches, rguenther
On 9 June 2010 00:57, Jan Hubicka <hubicka@ucw.cz> wrote:
> {
> +#ifdef ENABLE_CHECKING
> gcc_assert (!(bb->flags & BB_RTL));
> +#endif
> bb->il.gimple->seq = seq;
> }
Can't we simply have enable_checking_assert or similar?
>
> @@ -1326,7 +1328,9 @@ gimple_def_ops (const_gimple g)
> static inline void
> gimple_set_def_ops (gimple g, struct def_optype_d *def)
> {
> +#ifdef ENABLE_GIMPLE_CHECKING
> gcc_assert (gimple_has_ops (g));
> +#endif
> g->gsops.opbase.def_ops = def;
> }
And here gcc_gimple_assert or gimple_checking_assert or something
like that, to not sprinkle the code with a lot of extra ifdef-endif.
Just a suggestion for future maintenance and easy readability.
Cheers,
Manuel.
^ permalink raw reply [flat|nested] 15+ messages in thread
* Re: Make gimple.h checks conditional with ENABLE_GIMPLE_CHECKING
2010-06-08 23:13 Make gimple.h checks conditional with ENABLE_GIMPLE_CHECKING Jan Hubicka
2010-06-09 6:13 ` Basile Starynkevitch
2010-06-09 8:37 ` Manuel López-Ibáñez
@ 2010-06-09 9:29 ` Richard Guenther
2010-06-09 9:47 ` Jakub Jelinek
2010-06-09 11:15 ` Jan Hubicka
2010-06-09 10:05 ` Paolo Bonzini
3 siblings, 2 replies; 15+ messages in thread
From: Richard Guenther @ 2010-06-09 9:29 UTC (permalink / raw)
To: Jan Hubicka; +Cc: gcc-patches
On Wed, 9 Jun 2010, Jan Hubicka wrote:
> Hi,
> this patch conditionalize the sanity checks in gimple accessor functions.
> I originally intended to go through my list of most frequent aborts remianing
> in the code, but it seems now to me that it would cause just maintenance
> problems since it would be difficult to decide what to check and what not.
>
> The nature of the checks is very similar to the tree/rtl and gimple checking
> so I think we should just handle them same way and put them all into
> ENABLE_GIMPLE_CHECKING
>
> Bootstrapped/regtested x86_64-linux. My build time test actually regressed
> to 11m16s (it used to be 10m19s), but I am quite convinced it is due to
> merge of df-improv branch
> OK?
Ok.
Thanks,
Richard.
> Honza
>
> * gimple.h (set_bb_seq): Make check conditional with ENABLE_ChECKING.
> (gimple_set_def_ops, gimple_set_use_ops,
> gimple_set_vuse, gimple_set_vdef,
> gimple_omp_subcode, gimple_omp_set_subcode, gimple_ops, gimple_op,
> gimple_op_ptr, gimple_op_ptr, gimple_set_op, gimple_bind_set_block,
> gimple_asm_input_op, gimple_asm_input_op_ptr, gimple_asm_set_input_op,
> gimple_asm_output_op, gimple_asm_output_op_ptr,
> gimple_asm_set_output_op, gimple_asm_clobber_op,
> gimple_asm_set_clobber_op, gimple_asm_label_op,
> gimple_asm_set_label_op, gimple_try_set_kind, gimple_try_catch_is_cleanup
> gimple_try_set_catch_is_cleanup, gimple_phi_arg,
> gimple_switch_num_labels, gimple_switch_set_index, gimple_switch_label,
> gimple_switch_set_label, gimple_omp_for_index, gimple_omp_for_index_ptr,
> gimple_omp_for_set_index, gimple_omp_for_initial, gimple_omp_for_initial_ptr,
> gimple_omp_for_set_initial, gimple_omp_for_final, gimple_omp_for_final_ptr,
> gimple_omp_for_set_final, gimple_omp_for_incr, gimple_omp_for_incr_ptr,
> gimple_omp_for_set_incr, gimple_omp_for_set_cond, gimple_omp_for_cond): Make
> checking conditional with ENABLE_GIMPLE_CHECKING.
> (gimple_phi_set_arg): Likewise; replace memcpy by assignment.
> Index: gimple.h
> ===================================================================
> --- gimple.h (revision 160447)
> +++ gimple.h (working copy)
> @@ -244,7 +244,9 @@ bb_seq (const_basic_block bb)
> static inline void
> set_bb_seq (basic_block bb, gimple_seq seq)
> {
> +#ifdef ENABLE_CHECKING
> gcc_assert (!(bb->flags & BB_RTL));
> +#endif
> bb->il.gimple->seq = seq;
> }
>
> @@ -1326,7 +1328,9 @@ gimple_def_ops (const_gimple g)
> static inline void
> gimple_set_def_ops (gimple g, struct def_optype_d *def)
> {
> +#ifdef ENABLE_GIMPLE_CHECKING
> gcc_assert (gimple_has_ops (g));
> +#endif
> g->gsops.opbase.def_ops = def;
> }
>
> @@ -1347,7 +1351,9 @@ gimple_use_ops (const_gimple g)
> static inline void
> gimple_set_use_ops (gimple g, struct use_optype_d *use)
> {
> +#ifdef ENABLE_GIMPLE_CHECKING
> gcc_assert (gimple_has_ops (g));
> +#endif
> g->gsops.opbase.use_ops = use;
> }
>
> @@ -1428,7 +1434,9 @@ gimple_vdef_ptr (gimple g)
> static inline void
> gimple_set_vuse (gimple g, tree vuse)
> {
> +#ifdef ENABLE_GIMPLE_CHECKING
> gcc_assert (gimple_has_mem_ops (g));
> +#endif
> g->gsmembase.vuse = vuse;
> }
>
> @@ -1437,7 +1445,9 @@ gimple_set_vuse (gimple g, tree vuse)
> static inline void
> gimple_set_vdef (gimple g, tree vdef)
> {
> +#ifdef ENABLE_GIMPLE_CHECKING
> gcc_assert (gimple_has_mem_ops (g));
> +#endif
> g->gsmembase.vdef = vdef;
> }
>
> @@ -1528,8 +1538,10 @@ gimple_references_memory_p (gimple stmt)
> static inline unsigned
> gimple_omp_subcode (const_gimple s)
> {
> +#ifdef ENABLE_GIMPLE_CHECKING
> gcc_assert (gimple_code (s) >= GIMPLE_OMP_ATOMIC_LOAD
> && gimple_code (s) <= GIMPLE_OMP_SINGLE);
> +#endif
> return s->gsbase.subcode;
> }
>
> @@ -1540,7 +1552,9 @@ gimple_omp_set_subcode (gimple s, unsign
> {
> /* We only have 16 bits for the subcode. Assert that we are not
> overflowing it. */
> +#ifdef ENABLE_GIMPLE_CHECKING
> gcc_assert (subcode < (1 << 16));
> +#ENDif
> s->gsbase.subcode = subcode;
> }
>
> @@ -1640,7 +1654,9 @@ gimple_ops (gimple gs)
> of the structure. Note that those structures that do not
> have an operand vector have a zero offset. */
> off = gimple_ops_offset_[gimple_statement_structure (gs)];
> +#ifdef ENABLE_GIMPLE_CHECKING
> gcc_assert (off != 0);
> +#endif
>
> return (tree *) ((char *) gs + off);
> }
> @@ -1653,7 +1669,7 @@ gimple_op (const_gimple gs, unsigned i)
> {
> if (gimple_has_ops (gs))
> {
> -#ifdef ENABLE_CHECKING
> +#ifdef ENABLE_GIMPLE_CHECKING
> gcc_assert (i < gimple_num_ops (gs));
> #endif
> return gimple_ops (CONST_CAST_GIMPLE (gs))[i];
> @@ -1669,7 +1685,7 @@ gimple_op_ptr (const_gimple gs, unsigned
> {
> if (gimple_has_ops (gs))
> {
> -#ifdef ENABLE_CHECKING
> +#ifdef ENABLE_GIMPLE_CHECKING
> gcc_assert (i < gimple_num_ops (gs));
> #endif
> return gimple_ops (CONST_CAST_GIMPLE (gs)) + i;
> @@ -1683,7 +1699,9 @@ gimple_op_ptr (const_gimple gs, unsigned
> static inline void
> gimple_set_op (gimple gs, unsigned i, tree op)
> {
> +#ifdef ENABLE_GIMPLE_CHECKING
> gcc_assert (gimple_has_ops (gs) && i < gimple_num_ops (gs));
> +#endif
>
> /* Note. It may be tempting to assert that OP matches
> is_gimple_operand, but that would be wrong. Different tuples
> @@ -2626,7 +2644,9 @@ static inline void
> gimple_bind_set_block (gimple gs, tree block)
> {
> GIMPLE_CHECK (gs, GIMPLE_BIND);
> +#ifdef ENABLE_GIMPLE_CHECKING
> gcc_assert (block == NULL_TREE || TREE_CODE (block) == BLOCK);
> +#endif
> gs->gimple_bind.block = block;
> }
>
> @@ -2675,7 +2695,9 @@ static inline tree
> gimple_asm_input_op (const_gimple gs, unsigned index)
> {
> GIMPLE_CHECK (gs, GIMPLE_ASM);
> +#ifdef ENABLE_GIMPLE_CHECKING
> gcc_assert (index <= gs->gimple_asm.ni);
> +#endif
> return gimple_op (gs, index);
> }
>
> @@ -2685,7 +2707,9 @@ static inline tree *
> gimple_asm_input_op_ptr (const_gimple gs, unsigned index)
> {
> GIMPLE_CHECK (gs, GIMPLE_ASM);
> +#ifdef ENABLE_GIMPLE_CHECKING
> gcc_assert (index <= gs->gimple_asm.ni);
> +#endif
> return gimple_op_ptr (gs, index);
> }
>
> @@ -2696,8 +2720,10 @@ static inline void
> gimple_asm_set_input_op (gimple gs, unsigned index, tree in_op)
> {
> GIMPLE_CHECK (gs, GIMPLE_ASM);
> +#ifdef ENABLE_GIMPLE_CHECKING
> gcc_assert (index <= gs->gimple_asm.ni);
> gcc_assert (TREE_CODE (in_op) == TREE_LIST);
> +#endif
> gimple_set_op (gs, index, in_op);
> }
>
> @@ -2708,7 +2734,9 @@ static inline tree
> gimple_asm_output_op (const_gimple gs, unsigned index)
> {
> GIMPLE_CHECK (gs, GIMPLE_ASM);
> +#ifdef ENABLE_GIMPLE_CHECKING
> gcc_assert (index <= gs->gimple_asm.no);
> +#endif
> return gimple_op (gs, index + gs->gimple_asm.ni);
> }
>
> @@ -2718,7 +2746,9 @@ static inline tree *
> gimple_asm_output_op_ptr (const_gimple gs, unsigned index)
> {
> GIMPLE_CHECK (gs, GIMPLE_ASM);
> +#ifdef ENABLE_GIMPLE_CHECKING
> gcc_assert (index <= gs->gimple_asm.no);
> +#endif
> return gimple_op_ptr (gs, index + gs->gimple_asm.ni);
> }
>
> @@ -2729,8 +2759,10 @@ static inline void
> gimple_asm_set_output_op (gimple gs, unsigned index, tree out_op)
> {
> GIMPLE_CHECK (gs, GIMPLE_ASM);
> +#ifdef ENABLE_GIMPLE_CHECKING
> gcc_assert (index <= gs->gimple_asm.no);
> gcc_assert (TREE_CODE (out_op) == TREE_LIST);
> +#endif
> gimple_set_op (gs, index + gs->gimple_asm.ni, out_op);
> }
>
> @@ -2741,7 +2773,9 @@ static inline tree
> gimple_asm_clobber_op (const_gimple gs, unsigned index)
> {
> GIMPLE_CHECK (gs, GIMPLE_ASM);
> +#ifdef ENABLE_GIMPLE_CHECKING
> gcc_assert (index <= gs->gimple_asm.nc);
> +#endif
> return gimple_op (gs, index + gs->gimple_asm.ni + gs->gimple_asm.no);
> }
>
> @@ -2752,8 +2786,10 @@ static inline void
> gimple_asm_set_clobber_op (gimple gs, unsigned index, tree clobber_op)
> {
> GIMPLE_CHECK (gs, GIMPLE_ASM);
> +#ifdef ENABLE_GIMPLE_CHECKING
> gcc_assert (index <= gs->gimple_asm.nc);
> gcc_assert (TREE_CODE (clobber_op) == TREE_LIST);
> +#endif
> gimple_set_op (gs, index + gs->gimple_asm.ni + gs->gimple_asm.no, clobber_op);
> }
>
> @@ -2763,7 +2799,9 @@ static inline tree
> gimple_asm_label_op (const_gimple gs, unsigned index)
> {
> GIMPLE_CHECK (gs, GIMPLE_ASM);
> +#ifdef ENABLE_GIMPLE_CHECKING
> gcc_assert (index <= gs->gimple_asm.nl);
> +#endif
> return gimple_op (gs, index + gs->gimple_asm.ni + gs->gimple_asm.nc);
> }
>
> @@ -2773,8 +2811,10 @@ static inline void
> gimple_asm_set_label_op (gimple gs, unsigned index, tree label_op)
> {
> GIMPLE_CHECK (gs, GIMPLE_ASM);
> +#ifdef ENABLE_GIMPLE_CHECKING
> gcc_assert (index <= gs->gimple_asm.nl);
> gcc_assert (TREE_CODE (label_op) == TREE_LIST);
> +#endif
> gimple_set_op (gs, index + gs->gimple_asm.ni + gs->gimple_asm.nc, label_op);
> }
>
> @@ -2987,7 +3027,9 @@ static inline void
> gimple_try_set_kind (gimple gs, enum gimple_try_flags kind)
> {
> GIMPLE_CHECK (gs, GIMPLE_TRY);
> +#ifdef ENABLE_GIMPLE_CHECKING
> gcc_assert (kind == GIMPLE_TRY_CATCH || kind == GIMPLE_TRY_FINALLY);
> +#endif
> if (gimple_try_kind (gs) != kind)
> gs->gsbase.subcode = (unsigned int) kind;
> }
> @@ -2998,7 +3040,9 @@ gimple_try_set_kind (gimple gs, enum gim
> static inline bool
> gimple_try_catch_is_cleanup (const_gimple gs)
> {
> +#ifdef ENABLE_GIMPLE_CHECKING
> gcc_assert (gimple_try_kind (gs) == GIMPLE_TRY_CATCH);
> +#endif
> return (gs->gsbase.subcode & GIMPLE_TRY_CATCH_IS_CLEANUP) != 0;
> }
>
> @@ -3029,7 +3073,9 @@ gimple_try_cleanup (gimple gs)
> static inline void
> gimple_try_set_catch_is_cleanup (gimple g, bool catch_is_cleanup)
> {
> +#ifdef ENABLE_GIMPLE_CHECKING
> gcc_assert (gimple_try_kind (g) == GIMPLE_TRY_CATCH);
> +#endif
> if (catch_is_cleanup)
> g->gsbase.subcode |= GIMPLE_TRY_CATCH_IS_CLEANUP;
> else
> @@ -3156,7 +3202,9 @@ static inline struct phi_arg_d *
> gimple_phi_arg (gimple gs, unsigned index)
> {
> GIMPLE_CHECK (gs, GIMPLE_PHI);
> +#ifdef ENABLE_GIMPLE_CHECKING
> gcc_assert (index <= gs->gimple_phi.capacity);
> +#endif
> return &(gs->gimple_phi.args[index]);
> }
>
> @@ -3167,8 +3215,10 @@ static inline void
> gimple_phi_set_arg (gimple gs, unsigned index, struct phi_arg_d * phiarg)
> {
> GIMPLE_CHECK (gs, GIMPLE_PHI);
> +#ifdef ENABLE_GIMPLE_CHECKING
> gcc_assert (index <= gs->gimple_phi.nargs);
> - memcpy (gs->gimple_phi.args + index, phiarg, sizeof (struct phi_arg_d));
> +#endif
> + gs->gimple_phi.args[index] = *phiarg;
> }
>
> /* Return the region number for GIMPLE_RESX GS. */
> @@ -3215,7 +3265,9 @@ gimple_switch_num_labels (const_gimple g
> unsigned num_ops;
> GIMPLE_CHECK (gs, GIMPLE_SWITCH);
> num_ops = gimple_num_ops (gs);
> +#ifdef ENABLE_GIMPLE_CHECKING
> gcc_assert (num_ops > 1);
> +#endif
> return num_ops - 1;
> }
>
> @@ -3256,7 +3308,9 @@ static inline void
> gimple_switch_set_index (gimple gs, tree index)
> {
> GIMPLE_CHECK (gs, GIMPLE_SWITCH);
> +#ifdef ENABLE_GIMPLE_CHECKING
> gcc_assert (SSA_VAR_P (index) || CONSTANT_CLASS_P (index));
> +#endif
> gimple_set_op (gs, 0, index);
> }
>
> @@ -3268,7 +3322,9 @@ static inline tree
> gimple_switch_label (const_gimple gs, unsigned index)
> {
> GIMPLE_CHECK (gs, GIMPLE_SWITCH);
> +#ifdef ENABLE_GIMPLE_CHECKING
> gcc_assert (gimple_num_ops (gs) > index + 1);
> +#endif
> return gimple_op (gs, index + 1);
> }
>
> @@ -3278,8 +3334,10 @@ static inline void
> gimple_switch_set_label (gimple gs, unsigned index, tree label)
> {
> GIMPLE_CHECK (gs, GIMPLE_SWITCH);
> +#ifdef ENABLE_GIMPLE_CHECKING
> gcc_assert (gimple_num_ops (gs) > index + 1);
> gcc_assert (label == NULL_TREE || TREE_CODE (label) == CASE_LABEL_EXPR);
> +#endif
> gimple_set_op (gs, index + 1, label);
> }
>
> @@ -3506,7 +3564,9 @@ static inline tree
> gimple_omp_for_index (const_gimple gs, size_t i)
> {
> GIMPLE_CHECK (gs, GIMPLE_OMP_FOR);
> +#ifdef ENABLE_GIMPLE_CHECKING
> gcc_assert (i < gs->gimple_omp_for.collapse);
> +#endif
> return gs->gimple_omp_for.iter[i].index;
> }
>
> @@ -3517,7 +3577,9 @@ static inline tree *
> gimple_omp_for_index_ptr (gimple gs, size_t i)
> {
> GIMPLE_CHECK (gs, GIMPLE_OMP_FOR);
> +#ifdef ENABLE_GIMPLE_CHECKING
> gcc_assert (i < gs->gimple_omp_for.collapse);
> +#endif
> return &gs->gimple_omp_for.iter[i].index;
> }
>
> @@ -3528,7 +3590,9 @@ static inline void
> gimple_omp_for_set_index (gimple gs, size_t i, tree index)
> {
> GIMPLE_CHECK (gs, GIMPLE_OMP_FOR);
> +#ifdef ENABLE_GIMPLE_CHECKING
> gcc_assert (i < gs->gimple_omp_for.collapse);
> +#endif
> gs->gimple_omp_for.iter[i].index = index;
> }
>
> @@ -3539,7 +3603,9 @@ static inline tree
> gimple_omp_for_initial (const_gimple gs, size_t i)
> {
> GIMPLE_CHECK (gs, GIMPLE_OMP_FOR);
> +#ifdef ENABLE_GIMPLE_CHECKING
> gcc_assert (i < gs->gimple_omp_for.collapse);
> +#endif
> return gs->gimple_omp_for.iter[i].initial;
> }
>
> @@ -3550,7 +3616,9 @@ static inline tree *
> gimple_omp_for_initial_ptr (gimple gs, size_t i)
> {
> GIMPLE_CHECK (gs, GIMPLE_OMP_FOR);
> +#ifdef ENABLE_GIMPLE_CHECKING
> gcc_assert (i < gs->gimple_omp_for.collapse);
> +#endif
> return &gs->gimple_omp_for.iter[i].initial;
> }
>
> @@ -3561,7 +3629,9 @@ static inline void
> gimple_omp_for_set_initial (gimple gs, size_t i, tree initial)
> {
> GIMPLE_CHECK (gs, GIMPLE_OMP_FOR);
> +#ifdef ENABLE_GIMPLE_CHECKING
> gcc_assert (i < gs->gimple_omp_for.collapse);
> +#endif
> gs->gimple_omp_for.iter[i].initial = initial;
> }
>
> @@ -3572,7 +3642,9 @@ static inline tree
> gimple_omp_for_final (const_gimple gs, size_t i)
> {
> GIMPLE_CHECK (gs, GIMPLE_OMP_FOR);
> +#ifdef ENABLE_GIMPLE_CHECKING
> gcc_assert (i < gs->gimple_omp_for.collapse);
> +#endif
> return gs->gimple_omp_for.iter[i].final;
> }
>
> @@ -3583,7 +3655,9 @@ static inline tree *
> gimple_omp_for_final_ptr (gimple gs, size_t i)
> {
> GIMPLE_CHECK (gs, GIMPLE_OMP_FOR);
> +#ifdef ENABLE_GIMPLE_CHECKING
> gcc_assert (i < gs->gimple_omp_for.collapse);
> +#endif
> return &gs->gimple_omp_for.iter[i].final;
> }
>
> @@ -3594,7 +3668,9 @@ static inline void
> gimple_omp_for_set_final (gimple gs, size_t i, tree final)
> {
> GIMPLE_CHECK (gs, GIMPLE_OMP_FOR);
> +#ifdef ENABLE_GIMPLE_CHECKING
> gcc_assert (i < gs->gimple_omp_for.collapse);
> +#endif
> gs->gimple_omp_for.iter[i].final = final;
> }
>
> @@ -3605,7 +3681,9 @@ static inline tree
> gimple_omp_for_incr (const_gimple gs, size_t i)
> {
> GIMPLE_CHECK (gs, GIMPLE_OMP_FOR);
> +#ifdef ENABLE_GIMPLE_CHECKING
> gcc_assert (i < gs->gimple_omp_for.collapse);
> +#endif
> return gs->gimple_omp_for.iter[i].incr;
> }
>
> @@ -3616,7 +3694,9 @@ static inline tree *
> gimple_omp_for_incr_ptr (gimple gs, size_t i)
> {
> GIMPLE_CHECK (gs, GIMPLE_OMP_FOR);
> +#ifdef ENABLE_GIMPLE_CHECKING
> gcc_assert (i < gs->gimple_omp_for.collapse);
> +#endif
> return &gs->gimple_omp_for.iter[i].incr;
> }
>
> @@ -3627,7 +3707,9 @@ static inline void
> gimple_omp_for_set_incr (gimple gs, size_t i, tree incr)
> {
> GIMPLE_CHECK (gs, GIMPLE_OMP_FOR);
> +#ifdef ENABLE_GIMPLE_CHECKING
> gcc_assert (i < gs->gimple_omp_for.collapse);
> +#endif
> gs->gimple_omp_for.iter[i].incr = incr;
> }
>
> @@ -4129,8 +4211,10 @@ static inline void
> gimple_omp_for_set_cond (gimple gs, size_t i, enum tree_code cond)
> {
> GIMPLE_CHECK (gs, GIMPLE_OMP_FOR);
> +#ifdef ENABLE_GIMPLE_CHECKING
> gcc_assert (TREE_CODE_CLASS (cond) == tcc_comparison);
> gcc_assert (i < gs->gimple_omp_for.collapse);
> +#endif
> gs->gimple_omp_for.iter[i].cond = cond;
> }
>
> @@ -4141,7 +4225,9 @@ static inline enum tree_code
> gimple_omp_for_cond (const_gimple gs, size_t i)
> {
> GIMPLE_CHECK (gs, GIMPLE_OMP_FOR);
> +#ifdef ENABLE_GIMPLE_CHECKING
> gcc_assert (i < gs->gimple_omp_for.collapse);
> +#endif
> return gs->gimple_omp_for.iter[i].cond;
> }
>
>
>
--
Richard Guenther <rguenther@suse.de>
Novell / SUSE Labs
SUSE LINUX Products GmbH - Nuernberg - AG Nuernberg - HRB 16746 - GF: Markus Rex
^ permalink raw reply [flat|nested] 15+ messages in thread
* Re: Make gimple.h checks conditional with ENABLE_GIMPLE_CHECKING
2010-06-09 8:37 ` Manuel López-Ibáñez
@ 2010-06-09 9:31 ` Richard Guenther
0 siblings, 0 replies; 15+ messages in thread
From: Richard Guenther @ 2010-06-09 9:31 UTC (permalink / raw)
To: Manuel López-Ibáñez; +Cc: Jan Hubicka, gcc-patches
[-- Attachment #1: Type: TEXT/PLAIN, Size: 884 bytes --]
On Wed, 9 Jun 2010, Manuel López-Ibáñez wrote:
> On 9 June 2010 00:57, Jan Hubicka <hubicka@ucw.cz> wrote:
> > Â {
> > +#ifdef ENABLE_CHECKING
> > Â gcc_assert (!(bb->flags & BB_RTL));
> > +#endif
> > Â bb->il.gimple->seq = seq;
> > Â }
>
> Can't we simply have enable_checking_assert or similar?
>
> >
> > @@ -1326,7 +1328,9 @@ gimple_def_ops (const_gimple g)
> > Â static inline void
> > Â gimple_set_def_ops (gimple g, struct def_optype_d *def)
> > Â {
> > +#ifdef ENABLE_GIMPLE_CHECKING
> > Â gcc_assert (gimple_has_ops (g));
> > +#endif
> > Â g->gsops.opbase.def_ops = def;
> > Â }
>
> And here gcc_gimple_assert or gimple_checking_assert or something
> like that, to not sprinkle the code with a lot of extra ifdef-endif.
>
> Just a suggestion for future maintenance and easy readability.
Good suggestion. Though maybe the extra noise is even useful ...
Richard.
^ permalink raw reply [flat|nested] 15+ messages in thread
* Re: Make gimple.h checks conditional with ENABLE_GIMPLE_CHECKING
2010-06-09 9:29 ` Richard Guenther
@ 2010-06-09 9:47 ` Jakub Jelinek
2010-06-09 11:15 ` Jan Hubicka
1 sibling, 0 replies; 15+ messages in thread
From: Jakub Jelinek @ 2010-06-09 9:47 UTC (permalink / raw)
To: Richard Guenther; +Cc: Jan Hubicka, gcc-patches
On Wed, Jun 09, 2010 at 11:22:59AM +0200, Richard Guenther wrote:
> Ok.
>
> Thanks,
> Richard.
>
> > Honza
> >
> > * gimple.h (set_bb_seq): Make check conditional with ENABLE_ChECKING.
s/ChECK/CHECK/.
And I have to agree with Manuel that it would be nice to introduce
gcc_checking_assert and gcc_gimple_checking_assert with
#ifdef ENABLE_CHECKING
#define gcc_checking_assert(EXPR) gcc_assert (EXPR)
#else
#define gcc_checking_assert(EXPR) ((void)(0 && (EXPR)))
#endif
and similar definitions to avoid too many #ifdefs all around.
> > (gimple_set_def_ops, gimple_set_use_ops,
> > gimple_set_vuse, gimple_set_vdef,
> > gimple_omp_subcode, gimple_omp_set_subcode, gimple_ops, gimple_op,
> > gimple_op_ptr, gimple_op_ptr, gimple_set_op, gimple_bind_set_block,
> > gimple_asm_input_op, gimple_asm_input_op_ptr, gimple_asm_set_input_op,
> > gimple_asm_output_op, gimple_asm_output_op_ptr,
> > gimple_asm_set_output_op, gimple_asm_clobber_op,
> > gimple_asm_set_clobber_op, gimple_asm_label_op,
> > gimple_asm_set_label_op, gimple_try_set_kind, gimple_try_catch_is_cleanup
> > gimple_try_set_catch_is_cleanup, gimple_phi_arg,
> > gimple_switch_num_labels, gimple_switch_set_index, gimple_switch_label,
> > gimple_switch_set_label, gimple_omp_for_index, gimple_omp_for_index_ptr,
> > gimple_omp_for_set_index, gimple_omp_for_initial, gimple_omp_for_initial_ptr,
> > gimple_omp_for_set_initial, gimple_omp_for_final, gimple_omp_for_final_ptr,
> > gimple_omp_for_set_final, gimple_omp_for_incr, gimple_omp_for_incr_ptr,
> > gimple_omp_for_set_incr, gimple_omp_for_set_cond, gimple_omp_for_cond): Make
> > checking conditional with ENABLE_GIMPLE_CHECKING.
> > (gimple_phi_set_arg): Likewise; replace memcpy by assignment.
Jakub
^ permalink raw reply [flat|nested] 15+ messages in thread
* Re: Make gimple.h checks conditional with ENABLE_GIMPLE_CHECKING
2010-06-08 23:13 Make gimple.h checks conditional with ENABLE_GIMPLE_CHECKING Jan Hubicka
` (2 preceding siblings ...)
2010-06-09 9:29 ` Richard Guenther
@ 2010-06-09 10:05 ` Paolo Bonzini
2010-06-09 10:05 ` Laurynas Biveinis
3 siblings, 1 reply; 15+ messages in thread
From: Paolo Bonzini @ 2010-06-09 10:05 UTC (permalink / raw)
To: Jan Hubicka; +Cc: gcc-patches, rguenther, Laurynas Biveinis
On 06/09/2010 12:57 AM, Jan Hubicka wrote:
> Hi,
> this patch conditionalize the sanity checks in gimple accessor functions.
> I originally intended to go through my list of most frequent aborts remianing
> in the code, but it seems now to me that it would cause just maintenance
> problems since it would be difficult to decide what to check and what not.
>
> The nature of the checks is very similar to the tree/rtl and gimple checking
> so I think we should just handle them same way and put them all into
> ENABLE_GIMPLE_CHECKING
>
> Bootstrapped/regtested x86_64-linux. My build time test actually regressed
> to 11m16s (it used to be 10m19s), but I am quite convinced it is due to
> merge of df-improv branch
> OK?
Laurynas, can you check? I understood the gc-improv branch was basically
just cleanup, instead Jan's numbers say we're regressing 10%?
Paolo
^ permalink raw reply [flat|nested] 15+ messages in thread
* Re: Make gimple.h checks conditional with ENABLE_GIMPLE_CHECKING
2010-06-09 10:05 ` Paolo Bonzini
@ 2010-06-09 10:05 ` Laurynas Biveinis
2010-06-09 10:12 ` Paolo Bonzini
0 siblings, 1 reply; 15+ messages in thread
From: Laurynas Biveinis @ 2010-06-09 10:05 UTC (permalink / raw)
To: Paolo Bonzini; +Cc: Jan Hubicka, gcc-patches, rguenther
2010/6/9 Paolo Bonzini <bonzini@gnu.org>:
> Laurynas, can you check? I understood the gc-improv branch was basically
> just cleanup, instead Jan's numbers say we're regressing 10%?
Is that bootstrap time?
Now gengtype does more work (still at the noise level of the bootstrap
time) and generated gtype-desc.h, which is included almost everywhere,
is much larger now, although I wouldn't have guessed about 10%
regression for optimizing compilation. I'll check.
--
Laurynas
^ permalink raw reply [flat|nested] 15+ messages in thread
* Re: Make gimple.h checks conditional with ENABLE_GIMPLE_CHECKING
2010-06-09 10:05 ` Laurynas Biveinis
@ 2010-06-09 10:12 ` Paolo Bonzini
2010-06-09 10:50 ` Jan Hubicka
0 siblings, 1 reply; 15+ messages in thread
From: Paolo Bonzini @ 2010-06-09 10:12 UTC (permalink / raw)
To: Laurynas Biveinis; +Cc: Jan Hubicka, gcc-patches, rguenther
On 06/09/2010 11:57 AM, Laurynas Biveinis wrote:
> 2010/6/9 Paolo Bonzini<bonzini@gnu.org>:
>> Laurynas, can you check? I understood the gc-improv branch was basically
>> just cleanup, instead Jan's numbers say we're regressing 10%?
>
> Is that bootstrap time?
I think it's WHOPR bootstrap time, but checking normal bootstrap (or
simply "make stage3-bubble") will be enough.
> Now gengtype does more work (still at the noise level of the bootstrap
> time) and generated gtype-desc.h, which is included almost everywhere,
> is much larger now, although I wouldn't have guessed about 10%
> regression for optimizing compilation. I'll check.
Yeah, it also seemed strange to me, but double checking cannot hurt.
Paolo
^ permalink raw reply [flat|nested] 15+ messages in thread
* Re: Make gimple.h checks conditional with ENABLE_GIMPLE_CHECKING
2010-06-09 10:12 ` Paolo Bonzini
@ 2010-06-09 10:50 ` Jan Hubicka
2010-06-09 11:14 ` Paolo Bonzini
0 siblings, 1 reply; 15+ messages in thread
From: Jan Hubicka @ 2010-06-09 10:50 UTC (permalink / raw)
To: Paolo Bonzini; +Cc: Laurynas Biveinis, Jan Hubicka, gcc-patches, rguenther
> On 06/09/2010 11:57 AM, Laurynas Biveinis wrote:
>> 2010/6/9 Paolo Bonzini<bonzini@gnu.org>:
>>> Laurynas, can you check? I understood the gc-improv branch was basically
>>> just cleanup, instead Jan's numbers say we're regressing 10%?
>>
>> Is that bootstrap time?
>
> I think it's WHOPR bootstrap time, but checking normal bootstrap (or
> simply "make stage3-bubble") will be enough.
It is time needed to build final cc1 binary from WHOPR bootstrap with -O3
-fwhole-program. I am basically trying to optimize this since it is easy to
profile (don't thake as long time as normal bootstrap and spends 100% percents
in compiler rahter than our buildsystem so the noise is pretty low) and is
relevant since GCC is quite good example of large mostly hand written program.
I started to look into this to verify that GCC IPA is behaving sane and
improving result but found many issues that IPA can't handle, but I can fix ;)
I am bit in dark what changed the build time, since distribution in profiles
seems same and the binary is about the same as one I saved at 5th.
It is still possible that the change imporoved compilation time, just caused
slowdown due to different inlining decisions or so. This seems to be supported
by SPEC benchmarking
http://gcc.opensuse.org/SPEC/CINT/sb-barbella.suse.de-ai-64/times.html we
definitly have some improvements over in last few days on build times of pretty
much all benchmarks, still bootstrap is getting slower. Lets see how things
change with next run after the branch merge.
Honza
>
>> Now gengtype does more work (still at the noise level of the bootstrap
>> time) and generated gtype-desc.h, which is included almost everywhere,
>> is much larger now, although I wouldn't have guessed about 10%
>> regression for optimizing compilation. I'll check.
>
> Yeah, it also seemed strange to me, but double checking cannot hurt.
>
> Paolo
^ permalink raw reply [flat|nested] 15+ messages in thread
* Re: Make gimple.h checks conditional with ENABLE_GIMPLE_CHECKING
2010-06-09 10:50 ` Jan Hubicka
@ 2010-06-09 11:14 ` Paolo Bonzini
2010-06-09 19:11 ` Jan Hubicka
0 siblings, 1 reply; 15+ messages in thread
From: Paolo Bonzini @ 2010-06-09 11:14 UTC (permalink / raw)
To: Jan Hubicka; +Cc: Laurynas Biveinis, gcc-patches, rguenther
On 06/09/2010 12:22 PM, Jan Hubicka wrote:
> It is still possible that the change imporoved compilation time, just caused
> slowdown due to different inlining decisions or so.
Yeah, if the compiler has more work to do that would slow down the
build. And it makes sense to have more inlining after your patch.
> This seems to be supported by SPEC benchmarking
> http://gcc.opensuse.org/SPEC/CINT/sb-barbella.suse.de-ai-64/times.html we
> definitly have some improvements over in last few days on build times of pretty
> much all benchmarks, still bootstrap is getting slower. Lets see how things
> change with next run after the branch merge.
Agreed.
paolo
^ permalink raw reply [flat|nested] 15+ messages in thread
* Re: Make gimple.h checks conditional with ENABLE_GIMPLE_CHECKING
2010-06-09 9:29 ` Richard Guenther
2010-06-09 9:47 ` Jakub Jelinek
@ 2010-06-09 11:15 ` Jan Hubicka
2010-06-09 11:25 ` Jakub Jelinek
2010-06-09 11:30 ` Richard Guenther
1 sibling, 2 replies; 15+ messages in thread
From: Jan Hubicka @ 2010-06-09 11:15 UTC (permalink / raw)
To: Richard Guenther; +Cc: Jan Hubicka, gcc-patches
Hi,
so here is updated patch. I removed first BB test as I want to introduce
gcc_checking_arrest in system.h later and intorduced gcc_gimple_checking_assert.
I am using same define as for gcc_assert when it is disabled that means that
all operands of gcc_gimple_checking_assert must be optimizable out when
unused. I hope it is case of all the checks here, at least at first glance.
Bootstrapping/regtesting x86_64-linux, OK?
Honza
* gimple.h (gcc_gimple_checking_assert): New macro.
(gimple_set_def_ops, gimple_set_use_ops,
gimple_set_vuse, gimple_set_vdef,
gimple_omp_subcode, gimple_omp_set_subcode, gimple_ops, gimple_op,
gimple_op_ptr, gimple_op_ptr, gimple_set_op, gimple_bind_set_block,
gimple_asm_input_op, gimple_asm_input_op_ptr, gimple_asm_set_input_op,
gimple_asm_output_op, gimple_asm_output_op_ptr,
gimple_asm_set_output_op, gimple_asm_clobber_op,
gimple_asm_set_clobber_op, gimple_asm_label_op,
gimple_asm_set_label_op, gimple_try_set_kind, gimple_try_catch_is_cleanup
gimple_try_set_catch_is_cleanup, gimple_phi_arg,
gimple_switch_num_labels, gimple_switch_set_index, gimple_switch_label,
gimple_switch_set_label, gimple_omp_for_index, gimple_omp_for_index_ptr,
gimple_omp_for_set_index, gimple_omp_for_initial, gimple_omp_for_initial_ptr,
gimple_omp_for_set_initial, gimple_omp_for_final, gimple_omp_for_final_ptr,
gimple_omp_for_set_final, gimple_omp_for_incr, gimple_omp_for_incr_ptr,
gimple_omp_for_set_incr, gimple_omp_for_set_cond, gimple_omp_for_cond): Make
checking conditional with ENABLE_GIMPLE_CHECKING.
(gimple_phi_set_arg): Likewise; replace memcpy by assignment.
Index: gimple.h
===================================================================
--- gimple.h (revision 160447)
+++ gimple.h (working copy)
@@ -51,6 +51,7 @@ extern const unsigned char gimple_rhs_cl
/* Error out if a gimple tuple is addressed incorrectly. */
#if defined ENABLE_GIMPLE_CHECKING
+#define gcc_gimple_checking_assert(EXPR) gcc_assert (EXPR)
extern void gimple_check_failed (const_gimple, const char *, int, \
const char *, enum gimple_code, \
enum tree_code) ATTRIBUTE_NORETURN;
@@ -63,6 +64,7 @@ extern void gimple_check_failed (const_g
(CODE), ERROR_MARK); \
} while (0)
#else /* not ENABLE_GIMPLE_CHECKING */
+#define gcc_gimple_checking_assert(EXPR) ((void)(0 && (EXPR)))
#define GIMPLE_CHECK(GS, CODE) (void)0
#endif
@@ -1085,7 +1087,7 @@ static inline enum gimple_statement_stru
gss_for_code (enum gimple_code code)
{
#ifdef ENABLE_CHECKING
- gcc_assert ((unsigned int)code < LAST_AND_UNUSED_GIMPLE_CODE);
+ gcc_gimple_checking_assert ((unsigned int)code < LAST_AND_UNUSED_GIMPLE_CODE);
#endif
return gss_for_code_[code];
}
@@ -1326,7 +1328,7 @@ gimple_def_ops (const_gimple g)
static inline void
gimple_set_def_ops (gimple g, struct def_optype_d *def)
{
- gcc_assert (gimple_has_ops (g));
+ gcc_gimple_checking_assert (gimple_has_ops (g));
g->gsops.opbase.def_ops = def;
}
@@ -1347,7 +1349,7 @@ gimple_use_ops (const_gimple g)
static inline void
gimple_set_use_ops (gimple g, struct use_optype_d *use)
{
- gcc_assert (gimple_has_ops (g));
+ gcc_gimple_checking_assert (gimple_has_ops (g));
g->gsops.opbase.use_ops = use;
}
@@ -1428,7 +1430,7 @@ gimple_vdef_ptr (gimple g)
static inline void
gimple_set_vuse (gimple g, tree vuse)
{
- gcc_assert (gimple_has_mem_ops (g));
+ gcc_gimple_checking_assert (gimple_has_mem_ops (g));
g->gsmembase.vuse = vuse;
}
@@ -1437,7 +1439,7 @@ gimple_set_vuse (gimple g, tree vuse)
static inline void
gimple_set_vdef (gimple g, tree vdef)
{
- gcc_assert (gimple_has_mem_ops (g));
+ gcc_gimple_checking_assert (gimple_has_mem_ops (g));
g->gsmembase.vdef = vdef;
}
@@ -1528,7 +1530,7 @@ gimple_references_memory_p (gimple stmt)
static inline unsigned
gimple_omp_subcode (const_gimple s)
{
- gcc_assert (gimple_code (s) >= GIMPLE_OMP_ATOMIC_LOAD
+ gcc_gimple_checking_assert (gimple_code (s) >= GIMPLE_OMP_ATOMIC_LOAD
&& gimple_code (s) <= GIMPLE_OMP_SINGLE);
return s->gsbase.subcode;
}
@@ -1540,7 +1542,7 @@ gimple_omp_set_subcode (gimple s, unsign
{
/* We only have 16 bits for the subcode. Assert that we are not
overflowing it. */
- gcc_assert (subcode < (1 << 16));
+ gcc_gimple_checking_assert (subcode < (1 << 16));
s->gsbase.subcode = subcode;
}
@@ -1640,7 +1642,7 @@ gimple_ops (gimple gs)
of the structure. Note that those structures that do not
have an operand vector have a zero offset. */
off = gimple_ops_offset_[gimple_statement_structure (gs)];
- gcc_assert (off != 0);
+ gcc_gimple_checking_assert (off != 0);
return (tree *) ((char *) gs + off);
}
@@ -1654,7 +1656,7 @@ gimple_op (const_gimple gs, unsigned i)
if (gimple_has_ops (gs))
{
#ifdef ENABLE_CHECKING
- gcc_assert (i < gimple_num_ops (gs));
+ gcc_gimple_checking_assert (i < gimple_num_ops (gs));
#endif
return gimple_ops (CONST_CAST_GIMPLE (gs))[i];
}
@@ -1670,7 +1672,7 @@ gimple_op_ptr (const_gimple gs, unsigned
if (gimple_has_ops (gs))
{
#ifdef ENABLE_CHECKING
- gcc_assert (i < gimple_num_ops (gs));
+ gcc_gimple_checking_assert (i < gimple_num_ops (gs));
#endif
return gimple_ops (CONST_CAST_GIMPLE (gs)) + i;
}
@@ -1683,7 +1685,7 @@ gimple_op_ptr (const_gimple gs, unsigned
static inline void
gimple_set_op (gimple gs, unsigned i, tree op)
{
- gcc_assert (gimple_has_ops (gs) && i < gimple_num_ops (gs));
+ gcc_gimple_checking_assert (gimple_has_ops (gs) && i < gimple_num_ops (gs));
/* Note. It may be tempting to assert that OP matches
is_gimple_operand, but that would be wrong. Different tuples
@@ -2626,7 +2628,7 @@ static inline void
gimple_bind_set_block (gimple gs, tree block)
{
GIMPLE_CHECK (gs, GIMPLE_BIND);
- gcc_assert (block == NULL_TREE || TREE_CODE (block) == BLOCK);
+ gcc_gimple_checking_assert (block == NULL_TREE || TREE_CODE (block) == BLOCK);
gs->gimple_bind.block = block;
}
@@ -2675,7 +2677,7 @@ static inline tree
gimple_asm_input_op (const_gimple gs, unsigned index)
{
GIMPLE_CHECK (gs, GIMPLE_ASM);
- gcc_assert (index <= gs->gimple_asm.ni);
+ gcc_gimple_checking_assert (index <= gs->gimple_asm.ni);
return gimple_op (gs, index);
}
@@ -2685,7 +2687,7 @@ static inline tree *
gimple_asm_input_op_ptr (const_gimple gs, unsigned index)
{
GIMPLE_CHECK (gs, GIMPLE_ASM);
- gcc_assert (index <= gs->gimple_asm.ni);
+ gcc_gimple_checking_assert (index <= gs->gimple_asm.ni);
return gimple_op_ptr (gs, index);
}
@@ -2696,8 +2698,8 @@ static inline void
gimple_asm_set_input_op (gimple gs, unsigned index, tree in_op)
{
GIMPLE_CHECK (gs, GIMPLE_ASM);
- gcc_assert (index <= gs->gimple_asm.ni);
- gcc_assert (TREE_CODE (in_op) == TREE_LIST);
+ gcc_gimple_checking_assert (index <= gs->gimple_asm.ni);
+ gcc_gimple_checking_assert (TREE_CODE (in_op) == TREE_LIST);
gimple_set_op (gs, index, in_op);
}
@@ -2708,7 +2710,7 @@ static inline tree
gimple_asm_output_op (const_gimple gs, unsigned index)
{
GIMPLE_CHECK (gs, GIMPLE_ASM);
- gcc_assert (index <= gs->gimple_asm.no);
+ gcc_gimple_checking_assert (index <= gs->gimple_asm.no);
return gimple_op (gs, index + gs->gimple_asm.ni);
}
@@ -2718,7 +2720,7 @@ static inline tree *
gimple_asm_output_op_ptr (const_gimple gs, unsigned index)
{
GIMPLE_CHECK (gs, GIMPLE_ASM);
- gcc_assert (index <= gs->gimple_asm.no);
+ gcc_gimple_checking_assert (index <= gs->gimple_asm.no);
return gimple_op_ptr (gs, index + gs->gimple_asm.ni);
}
@@ -2729,8 +2731,8 @@ static inline void
gimple_asm_set_output_op (gimple gs, unsigned index, tree out_op)
{
GIMPLE_CHECK (gs, GIMPLE_ASM);
- gcc_assert (index <= gs->gimple_asm.no);
- gcc_assert (TREE_CODE (out_op) == TREE_LIST);
+ gcc_gimple_checking_assert (index <= gs->gimple_asm.no);
+ gcc_gimple_checking_assert (TREE_CODE (out_op) == TREE_LIST);
gimple_set_op (gs, index + gs->gimple_asm.ni, out_op);
}
@@ -2741,7 +2743,7 @@ static inline tree
gimple_asm_clobber_op (const_gimple gs, unsigned index)
{
GIMPLE_CHECK (gs, GIMPLE_ASM);
- gcc_assert (index <= gs->gimple_asm.nc);
+ gcc_gimple_checking_assert (index <= gs->gimple_asm.nc);
return gimple_op (gs, index + gs->gimple_asm.ni + gs->gimple_asm.no);
}
@@ -2752,8 +2754,8 @@ static inline void
gimple_asm_set_clobber_op (gimple gs, unsigned index, tree clobber_op)
{
GIMPLE_CHECK (gs, GIMPLE_ASM);
- gcc_assert (index <= gs->gimple_asm.nc);
- gcc_assert (TREE_CODE (clobber_op) == TREE_LIST);
+ gcc_gimple_checking_assert (index <= gs->gimple_asm.nc);
+ gcc_gimple_checking_assert (TREE_CODE (clobber_op) == TREE_LIST);
gimple_set_op (gs, index + gs->gimple_asm.ni + gs->gimple_asm.no, clobber_op);
}
@@ -2763,7 +2765,7 @@ static inline tree
gimple_asm_label_op (const_gimple gs, unsigned index)
{
GIMPLE_CHECK (gs, GIMPLE_ASM);
- gcc_assert (index <= gs->gimple_asm.nl);
+ gcc_gimple_checking_assert (index <= gs->gimple_asm.nl);
return gimple_op (gs, index + gs->gimple_asm.ni + gs->gimple_asm.nc);
}
@@ -2773,8 +2775,8 @@ static inline void
gimple_asm_set_label_op (gimple gs, unsigned index, tree label_op)
{
GIMPLE_CHECK (gs, GIMPLE_ASM);
- gcc_assert (index <= gs->gimple_asm.nl);
- gcc_assert (TREE_CODE (label_op) == TREE_LIST);
+ gcc_gimple_checking_assert (index <= gs->gimple_asm.nl);
+ gcc_gimple_checking_assert (TREE_CODE (label_op) == TREE_LIST);
gimple_set_op (gs, index + gs->gimple_asm.ni + gs->gimple_asm.nc, label_op);
}
@@ -2987,7 +2989,7 @@ static inline void
gimple_try_set_kind (gimple gs, enum gimple_try_flags kind)
{
GIMPLE_CHECK (gs, GIMPLE_TRY);
- gcc_assert (kind == GIMPLE_TRY_CATCH || kind == GIMPLE_TRY_FINALLY);
+ gcc_gimple_checking_assert (kind == GIMPLE_TRY_CATCH || kind == GIMPLE_TRY_FINALLY);
if (gimple_try_kind (gs) != kind)
gs->gsbase.subcode = (unsigned int) kind;
}
@@ -2998,7 +3000,7 @@ gimple_try_set_kind (gimple gs, enum gim
static inline bool
gimple_try_catch_is_cleanup (const_gimple gs)
{
- gcc_assert (gimple_try_kind (gs) == GIMPLE_TRY_CATCH);
+ gcc_gimple_checking_assert (gimple_try_kind (gs) == GIMPLE_TRY_CATCH);
return (gs->gsbase.subcode & GIMPLE_TRY_CATCH_IS_CLEANUP) != 0;
}
@@ -3029,7 +3031,7 @@ gimple_try_cleanup (gimple gs)
static inline void
gimple_try_set_catch_is_cleanup (gimple g, bool catch_is_cleanup)
{
- gcc_assert (gimple_try_kind (g) == GIMPLE_TRY_CATCH);
+ gcc_gimple_checking_assert (gimple_try_kind (g) == GIMPLE_TRY_CATCH);
if (catch_is_cleanup)
g->gsbase.subcode |= GIMPLE_TRY_CATCH_IS_CLEANUP;
else
@@ -3156,7 +3158,7 @@ static inline struct phi_arg_d *
gimple_phi_arg (gimple gs, unsigned index)
{
GIMPLE_CHECK (gs, GIMPLE_PHI);
- gcc_assert (index <= gs->gimple_phi.capacity);
+ gcc_gimple_checking_assert (index <= gs->gimple_phi.capacity);
return &(gs->gimple_phi.args[index]);
}
@@ -3167,7 +3169,7 @@ static inline void
gimple_phi_set_arg (gimple gs, unsigned index, struct phi_arg_d * phiarg)
{
GIMPLE_CHECK (gs, GIMPLE_PHI);
- gcc_assert (index <= gs->gimple_phi.nargs);
+ gcc_gimple_checking_assert (index <= gs->gimple_phi.nargs);
memcpy (gs->gimple_phi.args + index, phiarg, sizeof (struct phi_arg_d));
}
@@ -3215,7 +3217,7 @@ gimple_switch_num_labels (const_gimple g
unsigned num_ops;
GIMPLE_CHECK (gs, GIMPLE_SWITCH);
num_ops = gimple_num_ops (gs);
- gcc_assert (num_ops > 1);
+ gcc_gimple_checking_assert (num_ops > 1);
return num_ops - 1;
}
@@ -3256,7 +3258,7 @@ static inline void
gimple_switch_set_index (gimple gs, tree index)
{
GIMPLE_CHECK (gs, GIMPLE_SWITCH);
- gcc_assert (SSA_VAR_P (index) || CONSTANT_CLASS_P (index));
+ gcc_gimple_checking_assert (SSA_VAR_P (index) || CONSTANT_CLASS_P (index));
gimple_set_op (gs, 0, index);
}
@@ -3268,7 +3270,7 @@ static inline tree
gimple_switch_label (const_gimple gs, unsigned index)
{
GIMPLE_CHECK (gs, GIMPLE_SWITCH);
- gcc_assert (gimple_num_ops (gs) > index + 1);
+ gcc_gimple_checking_assert (gimple_num_ops (gs) > index + 1);
return gimple_op (gs, index + 1);
}
@@ -3278,8 +3280,8 @@ static inline void
gimple_switch_set_label (gimple gs, unsigned index, tree label)
{
GIMPLE_CHECK (gs, GIMPLE_SWITCH);
- gcc_assert (gimple_num_ops (gs) > index + 1);
- gcc_assert (label == NULL_TREE || TREE_CODE (label) == CASE_LABEL_EXPR);
+ gcc_gimple_checking_assert (gimple_num_ops (gs) > index + 1);
+ gcc_gimple_checking_assert (label == NULL_TREE || TREE_CODE (label) == CASE_LABEL_EXPR);
gimple_set_op (gs, index + 1, label);
}
@@ -3325,7 +3327,7 @@ gimple_debug_bind_get_var (gimple dbg)
{
GIMPLE_CHECK (dbg, GIMPLE_DEBUG);
#ifdef ENABLE_CHECKING
- gcc_assert (gimple_debug_bind_p (dbg));
+ gcc_gimple_checking_assert (gimple_debug_bind_p (dbg));
#endif
return gimple_op (dbg, 0);
}
@@ -3338,7 +3340,7 @@ gimple_debug_bind_get_value (gimple dbg)
{
GIMPLE_CHECK (dbg, GIMPLE_DEBUG);
#ifdef ENABLE_CHECKING
- gcc_assert (gimple_debug_bind_p (dbg));
+ gcc_gimple_checking_assert (gimple_debug_bind_p (dbg));
#endif
return gimple_op (dbg, 1);
}
@@ -3351,7 +3353,7 @@ gimple_debug_bind_get_value_ptr (gimple
{
GIMPLE_CHECK (dbg, GIMPLE_DEBUG);
#ifdef ENABLE_CHECKING
- gcc_assert (gimple_debug_bind_p (dbg));
+ gcc_gimple_checking_assert (gimple_debug_bind_p (dbg));
#endif
return gimple_op_ptr (dbg, 1);
}
@@ -3363,7 +3365,7 @@ gimple_debug_bind_set_var (gimple dbg, t
{
GIMPLE_CHECK (dbg, GIMPLE_DEBUG);
#ifdef ENABLE_CHECKING
- gcc_assert (gimple_debug_bind_p (dbg));
+ gcc_gimple_checking_assert (gimple_debug_bind_p (dbg));
#endif
gimple_set_op (dbg, 0, var);
}
@@ -3376,7 +3378,7 @@ gimple_debug_bind_set_value (gimple dbg,
{
GIMPLE_CHECK (dbg, GIMPLE_DEBUG);
#ifdef ENABLE_CHECKING
- gcc_assert (gimple_debug_bind_p (dbg));
+ gcc_gimple_checking_assert (gimple_debug_bind_p (dbg));
#endif
gimple_set_op (dbg, 1, value);
}
@@ -3393,7 +3395,7 @@ gimple_debug_bind_reset_value (gimple db
{
GIMPLE_CHECK (dbg, GIMPLE_DEBUG);
#ifdef ENABLE_CHECKING
- gcc_assert (gimple_debug_bind_p (dbg));
+ gcc_gimple_checking_assert (gimple_debug_bind_p (dbg));
#endif
gimple_set_op (dbg, 1, GIMPLE_DEBUG_BIND_NOVALUE);
}
@@ -3406,7 +3408,7 @@ gimple_debug_bind_has_value_p (gimple db
{
GIMPLE_CHECK (dbg, GIMPLE_DEBUG);
#ifdef ENABLE_CHECKING
- gcc_assert (gimple_debug_bind_p (dbg));
+ gcc_gimple_checking_assert (gimple_debug_bind_p (dbg));
#endif
return gimple_op (dbg, 1) != GIMPLE_DEBUG_BIND_NOVALUE;
}
@@ -3506,7 +3508,7 @@ static inline tree
gimple_omp_for_index (const_gimple gs, size_t i)
{
GIMPLE_CHECK (gs, GIMPLE_OMP_FOR);
- gcc_assert (i < gs->gimple_omp_for.collapse);
+ gcc_gimple_checking_assert (i < gs->gimple_omp_for.collapse);
return gs->gimple_omp_for.iter[i].index;
}
@@ -3517,7 +3519,7 @@ static inline tree *
gimple_omp_for_index_ptr (gimple gs, size_t i)
{
GIMPLE_CHECK (gs, GIMPLE_OMP_FOR);
- gcc_assert (i < gs->gimple_omp_for.collapse);
+ gcc_gimple_checking_assert (i < gs->gimple_omp_for.collapse);
return &gs->gimple_omp_for.iter[i].index;
}
@@ -3528,7 +3530,7 @@ static inline void
gimple_omp_for_set_index (gimple gs, size_t i, tree index)
{
GIMPLE_CHECK (gs, GIMPLE_OMP_FOR);
- gcc_assert (i < gs->gimple_omp_for.collapse);
+ gcc_gimple_checking_assert (i < gs->gimple_omp_for.collapse);
gs->gimple_omp_for.iter[i].index = index;
}
@@ -3539,7 +3541,7 @@ static inline tree
gimple_omp_for_initial (const_gimple gs, size_t i)
{
GIMPLE_CHECK (gs, GIMPLE_OMP_FOR);
- gcc_assert (i < gs->gimple_omp_for.collapse);
+ gcc_gimple_checking_assert (i < gs->gimple_omp_for.collapse);
return gs->gimple_omp_for.iter[i].initial;
}
@@ -3550,7 +3552,7 @@ static inline tree *
gimple_omp_for_initial_ptr (gimple gs, size_t i)
{
GIMPLE_CHECK (gs, GIMPLE_OMP_FOR);
- gcc_assert (i < gs->gimple_omp_for.collapse);
+ gcc_gimple_checking_assert (i < gs->gimple_omp_for.collapse);
return &gs->gimple_omp_for.iter[i].initial;
}
@@ -3561,7 +3563,7 @@ static inline void
gimple_omp_for_set_initial (gimple gs, size_t i, tree initial)
{
GIMPLE_CHECK (gs, GIMPLE_OMP_FOR);
- gcc_assert (i < gs->gimple_omp_for.collapse);
+ gcc_gimple_checking_assert (i < gs->gimple_omp_for.collapse);
gs->gimple_omp_for.iter[i].initial = initial;
}
@@ -3572,7 +3574,7 @@ static inline tree
gimple_omp_for_final (const_gimple gs, size_t i)
{
GIMPLE_CHECK (gs, GIMPLE_OMP_FOR);
- gcc_assert (i < gs->gimple_omp_for.collapse);
+ gcc_gimple_checking_assert (i < gs->gimple_omp_for.collapse);
return gs->gimple_omp_for.iter[i].final;
}
@@ -3583,7 +3585,7 @@ static inline tree *
gimple_omp_for_final_ptr (gimple gs, size_t i)
{
GIMPLE_CHECK (gs, GIMPLE_OMP_FOR);
- gcc_assert (i < gs->gimple_omp_for.collapse);
+ gcc_gimple_checking_assert (i < gs->gimple_omp_for.collapse);
return &gs->gimple_omp_for.iter[i].final;
}
@@ -3594,7 +3596,7 @@ static inline void
gimple_omp_for_set_final (gimple gs, size_t i, tree final)
{
GIMPLE_CHECK (gs, GIMPLE_OMP_FOR);
- gcc_assert (i < gs->gimple_omp_for.collapse);
+ gcc_gimple_checking_assert (i < gs->gimple_omp_for.collapse);
gs->gimple_omp_for.iter[i].final = final;
}
@@ -3605,7 +3607,7 @@ static inline tree
gimple_omp_for_incr (const_gimple gs, size_t i)
{
GIMPLE_CHECK (gs, GIMPLE_OMP_FOR);
- gcc_assert (i < gs->gimple_omp_for.collapse);
+ gcc_gimple_checking_assert (i < gs->gimple_omp_for.collapse);
return gs->gimple_omp_for.iter[i].incr;
}
@@ -3616,7 +3618,7 @@ static inline tree *
gimple_omp_for_incr_ptr (gimple gs, size_t i)
{
GIMPLE_CHECK (gs, GIMPLE_OMP_FOR);
- gcc_assert (i < gs->gimple_omp_for.collapse);
+ gcc_gimple_checking_assert (i < gs->gimple_omp_for.collapse);
return &gs->gimple_omp_for.iter[i].incr;
}
@@ -3627,7 +3629,7 @@ static inline void
gimple_omp_for_set_incr (gimple gs, size_t i, tree incr)
{
GIMPLE_CHECK (gs, GIMPLE_OMP_FOR);
- gcc_assert (i < gs->gimple_omp_for.collapse);
+ gcc_gimple_checking_assert (i < gs->gimple_omp_for.collapse);
gs->gimple_omp_for.iter[i].incr = incr;
}
@@ -4129,8 +4131,8 @@ static inline void
gimple_omp_for_set_cond (gimple gs, size_t i, enum tree_code cond)
{
GIMPLE_CHECK (gs, GIMPLE_OMP_FOR);
- gcc_assert (TREE_CODE_CLASS (cond) == tcc_comparison);
- gcc_assert (i < gs->gimple_omp_for.collapse);
+ gcc_gimple_checking_assert (TREE_CODE_CLASS (cond) == tcc_comparison);
+ gcc_gimple_checking_assert (i < gs->gimple_omp_for.collapse);
gs->gimple_omp_for.iter[i].cond = cond;
}
@@ -4141,7 +4143,7 @@ static inline enum tree_code
gimple_omp_for_cond (const_gimple gs, size_t i)
{
GIMPLE_CHECK (gs, GIMPLE_OMP_FOR);
- gcc_assert (i < gs->gimple_omp_for.collapse);
+ gcc_gimple_checking_assert (i < gs->gimple_omp_for.collapse);
return gs->gimple_omp_for.iter[i].cond;
}
^ permalink raw reply [flat|nested] 15+ messages in thread
* Re: Make gimple.h checks conditional with ENABLE_GIMPLE_CHECKING
2010-06-09 11:15 ` Jan Hubicka
@ 2010-06-09 11:25 ` Jakub Jelinek
2010-06-09 11:30 ` Richard Guenther
1 sibling, 0 replies; 15+ messages in thread
From: Jakub Jelinek @ 2010-06-09 11:25 UTC (permalink / raw)
To: Jan Hubicka; +Cc: Richard Guenther, gcc-patches
On Wed, Jun 09, 2010 at 01:09:48PM +0200, Jan Hubicka wrote:
> @@ -1085,7 +1087,7 @@ static inline enum gimple_statement_stru
> gss_for_code (enum gimple_code code)
> {
> #ifdef ENABLE_CHECKING
> - gcc_assert ((unsigned int)code < LAST_AND_UNUSED_GIMPLE_CODE);
> + gcc_gimple_checking_assert ((unsigned int)code < LAST_AND_UNUSED_GIMPLE_CODE);
> #endif
Please also remove the #ifdef guards (several times in the patch).
Jakub
^ permalink raw reply [flat|nested] 15+ messages in thread
* Re: Make gimple.h checks conditional with ENABLE_GIMPLE_CHECKING
2010-06-09 11:15 ` Jan Hubicka
2010-06-09 11:25 ` Jakub Jelinek
@ 2010-06-09 11:30 ` Richard Guenther
1 sibling, 0 replies; 15+ messages in thread
From: Richard Guenther @ 2010-06-09 11:30 UTC (permalink / raw)
To: Jan Hubicka; +Cc: gcc-patches
On Wed, 9 Jun 2010, Jan Hubicka wrote:
> Hi,
> so here is updated patch. I removed first BB test as I want to introduce
> gcc_checking_arrest in system.h later and intorduced gcc_gimple_checking_assert.
> I am using same define as for gcc_assert when it is disabled that means that
> all operands of gcc_gimple_checking_assert must be optimizable out when
> unused. I hope it is case of all the checks here, at least at first glance.
>
> Bootstrapping/regtesting x86_64-linux, OK?
A little bit too mechanical ...
#ifdef ENABLE_CHECKING
- gcc_assert (gimple_debug_bind_p (dbg));
+ gcc_gimple_checking_assert (gimple_debug_bind_p (dbg));
#endif
the ENABLE_CHECKINGs can go now.
Also please watch long lines and merge
- gcc_assert (TREE_CODE_CLASS (cond) == tcc_comparison);
- gcc_assert (i < gs->gimple_omp_for.collapse);
+ gcc_gimple_checking_assert (TREE_CODE_CLASS (cond) == tcc_comparison);
+ gcc_gimple_checking_assert (i < gs->gimple_omp_for.collapse);
into one assert. Likewise
- gcc_assert (index <= gs->gimple_asm.ni);
- gcc_assert (TREE_CODE (in_op) == TREE_LIST);
+ gcc_gimple_checking_assert (index <= gs->gimple_asm.ni);
+ gcc_gimple_checking_assert (TREE_CODE (in_op) == TREE_LIST);
and other similar cases.
Ok with that changes.
Thanks,
Richard.
> Honza
>
> * gimple.h (gcc_gimple_checking_assert): New macro.
> (gimple_set_def_ops, gimple_set_use_ops,
> gimple_set_vuse, gimple_set_vdef,
> gimple_omp_subcode, gimple_omp_set_subcode, gimple_ops, gimple_op,
> gimple_op_ptr, gimple_op_ptr, gimple_set_op, gimple_bind_set_block,
> gimple_asm_input_op, gimple_asm_input_op_ptr, gimple_asm_set_input_op,
> gimple_asm_output_op, gimple_asm_output_op_ptr,
> gimple_asm_set_output_op, gimple_asm_clobber_op,
> gimple_asm_set_clobber_op, gimple_asm_label_op,
> gimple_asm_set_label_op, gimple_try_set_kind, gimple_try_catch_is_cleanup
> gimple_try_set_catch_is_cleanup, gimple_phi_arg,
> gimple_switch_num_labels, gimple_switch_set_index, gimple_switch_label,
> gimple_switch_set_label, gimple_omp_for_index, gimple_omp_for_index_ptr,
> gimple_omp_for_set_index, gimple_omp_for_initial, gimple_omp_for_initial_ptr,
> gimple_omp_for_set_initial, gimple_omp_for_final, gimple_omp_for_final_ptr,
> gimple_omp_for_set_final, gimple_omp_for_incr, gimple_omp_for_incr_ptr,
> gimple_omp_for_set_incr, gimple_omp_for_set_cond, gimple_omp_for_cond): Make
> checking conditional with ENABLE_GIMPLE_CHECKING.
> (gimple_phi_set_arg): Likewise; replace memcpy by assignment.
>
> Index: gimple.h
> ===================================================================
> --- gimple.h (revision 160447)
> +++ gimple.h (working copy)
> @@ -51,6 +51,7 @@ extern const unsigned char gimple_rhs_cl
>
> /* Error out if a gimple tuple is addressed incorrectly. */
> #if defined ENABLE_GIMPLE_CHECKING
> +#define gcc_gimple_checking_assert(EXPR) gcc_assert (EXPR)
> extern void gimple_check_failed (const_gimple, const char *, int, \
> const char *, enum gimple_code, \
> enum tree_code) ATTRIBUTE_NORETURN;
> @@ -63,6 +64,7 @@ extern void gimple_check_failed (const_g
> (CODE), ERROR_MARK); \
> } while (0)
> #else /* not ENABLE_GIMPLE_CHECKING */
> +#define gcc_gimple_checking_assert(EXPR) ((void)(0 && (EXPR)))
> #define GIMPLE_CHECK(GS, CODE) (void)0
> #endif
>
> @@ -1085,7 +1087,7 @@ static inline enum gimple_statement_stru
> gss_for_code (enum gimple_code code)
> {
> #ifdef ENABLE_CHECKING
> - gcc_assert ((unsigned int)code < LAST_AND_UNUSED_GIMPLE_CODE);
> + gcc_gimple_checking_assert ((unsigned int)code < LAST_AND_UNUSED_GIMPLE_CODE);
> #endif
> return gss_for_code_[code];
> }
> @@ -1326,7 +1328,7 @@ gimple_def_ops (const_gimple g)
> static inline void
> gimple_set_def_ops (gimple g, struct def_optype_d *def)
> {
> - gcc_assert (gimple_has_ops (g));
> + gcc_gimple_checking_assert (gimple_has_ops (g));
> g->gsops.opbase.def_ops = def;
> }
>
> @@ -1347,7 +1349,7 @@ gimple_use_ops (const_gimple g)
> static inline void
> gimple_set_use_ops (gimple g, struct use_optype_d *use)
> {
> - gcc_assert (gimple_has_ops (g));
> + gcc_gimple_checking_assert (gimple_has_ops (g));
> g->gsops.opbase.use_ops = use;
> }
>
> @@ -1428,7 +1430,7 @@ gimple_vdef_ptr (gimple g)
> static inline void
> gimple_set_vuse (gimple g, tree vuse)
> {
> - gcc_assert (gimple_has_mem_ops (g));
> + gcc_gimple_checking_assert (gimple_has_mem_ops (g));
> g->gsmembase.vuse = vuse;
> }
>
> @@ -1437,7 +1439,7 @@ gimple_set_vuse (gimple g, tree vuse)
> static inline void
> gimple_set_vdef (gimple g, tree vdef)
> {
> - gcc_assert (gimple_has_mem_ops (g));
> + gcc_gimple_checking_assert (gimple_has_mem_ops (g));
> g->gsmembase.vdef = vdef;
> }
>
> @@ -1528,7 +1530,7 @@ gimple_references_memory_p (gimple stmt)
> static inline unsigned
> gimple_omp_subcode (const_gimple s)
> {
> - gcc_assert (gimple_code (s) >= GIMPLE_OMP_ATOMIC_LOAD
> + gcc_gimple_checking_assert (gimple_code (s) >= GIMPLE_OMP_ATOMIC_LOAD
> && gimple_code (s) <= GIMPLE_OMP_SINGLE);
> return s->gsbase.subcode;
> }
> @@ -1540,7 +1542,7 @@ gimple_omp_set_subcode (gimple s, unsign
> {
> /* We only have 16 bits for the subcode. Assert that we are not
> overflowing it. */
> - gcc_assert (subcode < (1 << 16));
> + gcc_gimple_checking_assert (subcode < (1 << 16));
> s->gsbase.subcode = subcode;
> }
>
> @@ -1640,7 +1642,7 @@ gimple_ops (gimple gs)
> of the structure. Note that those structures that do not
> have an operand vector have a zero offset. */
> off = gimple_ops_offset_[gimple_statement_structure (gs)];
> - gcc_assert (off != 0);
> + gcc_gimple_checking_assert (off != 0);
>
> return (tree *) ((char *) gs + off);
> }
> @@ -1654,7 +1656,7 @@ gimple_op (const_gimple gs, unsigned i)
> if (gimple_has_ops (gs))
> {
> #ifdef ENABLE_CHECKING
> - gcc_assert (i < gimple_num_ops (gs));
> + gcc_gimple_checking_assert (i < gimple_num_ops (gs));
> #endif
> return gimple_ops (CONST_CAST_GIMPLE (gs))[i];
> }
> @@ -1670,7 +1672,7 @@ gimple_op_ptr (const_gimple gs, unsigned
> if (gimple_has_ops (gs))
> {
> #ifdef ENABLE_CHECKING
> - gcc_assert (i < gimple_num_ops (gs));
> + gcc_gimple_checking_assert (i < gimple_num_ops (gs));
> #endif
> return gimple_ops (CONST_CAST_GIMPLE (gs)) + i;
> }
> @@ -1683,7 +1685,7 @@ gimple_op_ptr (const_gimple gs, unsigned
> static inline void
> gimple_set_op (gimple gs, unsigned i, tree op)
> {
> - gcc_assert (gimple_has_ops (gs) && i < gimple_num_ops (gs));
> + gcc_gimple_checking_assert (gimple_has_ops (gs) && i < gimple_num_ops (gs));
>
> /* Note. It may be tempting to assert that OP matches
> is_gimple_operand, but that would be wrong. Different tuples
> @@ -2626,7 +2628,7 @@ static inline void
> gimple_bind_set_block (gimple gs, tree block)
> {
> GIMPLE_CHECK (gs, GIMPLE_BIND);
> - gcc_assert (block == NULL_TREE || TREE_CODE (block) == BLOCK);
> + gcc_gimple_checking_assert (block == NULL_TREE || TREE_CODE (block) == BLOCK);
> gs->gimple_bind.block = block;
> }
>
> @@ -2675,7 +2677,7 @@ static inline tree
> gimple_asm_input_op (const_gimple gs, unsigned index)
> {
> GIMPLE_CHECK (gs, GIMPLE_ASM);
> - gcc_assert (index <= gs->gimple_asm.ni);
> + gcc_gimple_checking_assert (index <= gs->gimple_asm.ni);
> return gimple_op (gs, index);
> }
>
> @@ -2685,7 +2687,7 @@ static inline tree *
> gimple_asm_input_op_ptr (const_gimple gs, unsigned index)
> {
> GIMPLE_CHECK (gs, GIMPLE_ASM);
> - gcc_assert (index <= gs->gimple_asm.ni);
> + gcc_gimple_checking_assert (index <= gs->gimple_asm.ni);
> return gimple_op_ptr (gs, index);
> }
>
> @@ -2696,8 +2698,8 @@ static inline void
> gimple_asm_set_input_op (gimple gs, unsigned index, tree in_op)
> {
> GIMPLE_CHECK (gs, GIMPLE_ASM);
> - gcc_assert (index <= gs->gimple_asm.ni);
> - gcc_assert (TREE_CODE (in_op) == TREE_LIST);
> + gcc_gimple_checking_assert (index <= gs->gimple_asm.ni);
> + gcc_gimple_checking_assert (TREE_CODE (in_op) == TREE_LIST);
> gimple_set_op (gs, index, in_op);
> }
>
> @@ -2708,7 +2710,7 @@ static inline tree
> gimple_asm_output_op (const_gimple gs, unsigned index)
> {
> GIMPLE_CHECK (gs, GIMPLE_ASM);
> - gcc_assert (index <= gs->gimple_asm.no);
> + gcc_gimple_checking_assert (index <= gs->gimple_asm.no);
> return gimple_op (gs, index + gs->gimple_asm.ni);
> }
>
> @@ -2718,7 +2720,7 @@ static inline tree *
> gimple_asm_output_op_ptr (const_gimple gs, unsigned index)
> {
> GIMPLE_CHECK (gs, GIMPLE_ASM);
> - gcc_assert (index <= gs->gimple_asm.no);
> + gcc_gimple_checking_assert (index <= gs->gimple_asm.no);
> return gimple_op_ptr (gs, index + gs->gimple_asm.ni);
> }
>
> @@ -2729,8 +2731,8 @@ static inline void
> gimple_asm_set_output_op (gimple gs, unsigned index, tree out_op)
> {
> GIMPLE_CHECK (gs, GIMPLE_ASM);
> - gcc_assert (index <= gs->gimple_asm.no);
> - gcc_assert (TREE_CODE (out_op) == TREE_LIST);
> + gcc_gimple_checking_assert (index <= gs->gimple_asm.no);
> + gcc_gimple_checking_assert (TREE_CODE (out_op) == TREE_LIST);
> gimple_set_op (gs, index + gs->gimple_asm.ni, out_op);
> }
>
> @@ -2741,7 +2743,7 @@ static inline tree
> gimple_asm_clobber_op (const_gimple gs, unsigned index)
> {
> GIMPLE_CHECK (gs, GIMPLE_ASM);
> - gcc_assert (index <= gs->gimple_asm.nc);
> + gcc_gimple_checking_assert (index <= gs->gimple_asm.nc);
> return gimple_op (gs, index + gs->gimple_asm.ni + gs->gimple_asm.no);
> }
>
> @@ -2752,8 +2754,8 @@ static inline void
> gimple_asm_set_clobber_op (gimple gs, unsigned index, tree clobber_op)
> {
> GIMPLE_CHECK (gs, GIMPLE_ASM);
> - gcc_assert (index <= gs->gimple_asm.nc);
> - gcc_assert (TREE_CODE (clobber_op) == TREE_LIST);
> + gcc_gimple_checking_assert (index <= gs->gimple_asm.nc);
> + gcc_gimple_checking_assert (TREE_CODE (clobber_op) == TREE_LIST);
> gimple_set_op (gs, index + gs->gimple_asm.ni + gs->gimple_asm.no, clobber_op);
> }
>
> @@ -2763,7 +2765,7 @@ static inline tree
> gimple_asm_label_op (const_gimple gs, unsigned index)
> {
> GIMPLE_CHECK (gs, GIMPLE_ASM);
> - gcc_assert (index <= gs->gimple_asm.nl);
> + gcc_gimple_checking_assert (index <= gs->gimple_asm.nl);
> return gimple_op (gs, index + gs->gimple_asm.ni + gs->gimple_asm.nc);
> }
>
> @@ -2773,8 +2775,8 @@ static inline void
> gimple_asm_set_label_op (gimple gs, unsigned index, tree label_op)
> {
> GIMPLE_CHECK (gs, GIMPLE_ASM);
> - gcc_assert (index <= gs->gimple_asm.nl);
> - gcc_assert (TREE_CODE (label_op) == TREE_LIST);
> + gcc_gimple_checking_assert (index <= gs->gimple_asm.nl);
> + gcc_gimple_checking_assert (TREE_CODE (label_op) == TREE_LIST);
> gimple_set_op (gs, index + gs->gimple_asm.ni + gs->gimple_asm.nc, label_op);
> }
>
> @@ -2987,7 +2989,7 @@ static inline void
> gimple_try_set_kind (gimple gs, enum gimple_try_flags kind)
> {
> GIMPLE_CHECK (gs, GIMPLE_TRY);
> - gcc_assert (kind == GIMPLE_TRY_CATCH || kind == GIMPLE_TRY_FINALLY);
> + gcc_gimple_checking_assert (kind == GIMPLE_TRY_CATCH || kind == GIMPLE_TRY_FINALLY);
> if (gimple_try_kind (gs) != kind)
> gs->gsbase.subcode = (unsigned int) kind;
> }
> @@ -2998,7 +3000,7 @@ gimple_try_set_kind (gimple gs, enum gim
> static inline bool
> gimple_try_catch_is_cleanup (const_gimple gs)
> {
> - gcc_assert (gimple_try_kind (gs) == GIMPLE_TRY_CATCH);
> + gcc_gimple_checking_assert (gimple_try_kind (gs) == GIMPLE_TRY_CATCH);
> return (gs->gsbase.subcode & GIMPLE_TRY_CATCH_IS_CLEANUP) != 0;
> }
>
> @@ -3029,7 +3031,7 @@ gimple_try_cleanup (gimple gs)
> static inline void
> gimple_try_set_catch_is_cleanup (gimple g, bool catch_is_cleanup)
> {
> - gcc_assert (gimple_try_kind (g) == GIMPLE_TRY_CATCH);
> + gcc_gimple_checking_assert (gimple_try_kind (g) == GIMPLE_TRY_CATCH);
> if (catch_is_cleanup)
> g->gsbase.subcode |= GIMPLE_TRY_CATCH_IS_CLEANUP;
> else
> @@ -3156,7 +3158,7 @@ static inline struct phi_arg_d *
> gimple_phi_arg (gimple gs, unsigned index)
> {
> GIMPLE_CHECK (gs, GIMPLE_PHI);
> - gcc_assert (index <= gs->gimple_phi.capacity);
> + gcc_gimple_checking_assert (index <= gs->gimple_phi.capacity);
> return &(gs->gimple_phi.args[index]);
> }
>
> @@ -3167,7 +3169,7 @@ static inline void
> gimple_phi_set_arg (gimple gs, unsigned index, struct phi_arg_d * phiarg)
> {
> GIMPLE_CHECK (gs, GIMPLE_PHI);
> - gcc_assert (index <= gs->gimple_phi.nargs);
> + gcc_gimple_checking_assert (index <= gs->gimple_phi.nargs);
> memcpy (gs->gimple_phi.args + index, phiarg, sizeof (struct phi_arg_d));
> }
>
> @@ -3215,7 +3217,7 @@ gimple_switch_num_labels (const_gimple g
> unsigned num_ops;
> GIMPLE_CHECK (gs, GIMPLE_SWITCH);
> num_ops = gimple_num_ops (gs);
> - gcc_assert (num_ops > 1);
> + gcc_gimple_checking_assert (num_ops > 1);
> return num_ops - 1;
> }
>
> @@ -3256,7 +3258,7 @@ static inline void
> gimple_switch_set_index (gimple gs, tree index)
> {
> GIMPLE_CHECK (gs, GIMPLE_SWITCH);
> - gcc_assert (SSA_VAR_P (index) || CONSTANT_CLASS_P (index));
> + gcc_gimple_checking_assert (SSA_VAR_P (index) || CONSTANT_CLASS_P (index));
> gimple_set_op (gs, 0, index);
> }
>
> @@ -3268,7 +3270,7 @@ static inline tree
> gimple_switch_label (const_gimple gs, unsigned index)
> {
> GIMPLE_CHECK (gs, GIMPLE_SWITCH);
> - gcc_assert (gimple_num_ops (gs) > index + 1);
> + gcc_gimple_checking_assert (gimple_num_ops (gs) > index + 1);
> return gimple_op (gs, index + 1);
> }
>
> @@ -3278,8 +3280,8 @@ static inline void
> gimple_switch_set_label (gimple gs, unsigned index, tree label)
> {
> GIMPLE_CHECK (gs, GIMPLE_SWITCH);
> - gcc_assert (gimple_num_ops (gs) > index + 1);
> - gcc_assert (label == NULL_TREE || TREE_CODE (label) == CASE_LABEL_EXPR);
> + gcc_gimple_checking_assert (gimple_num_ops (gs) > index + 1);
> + gcc_gimple_checking_assert (label == NULL_TREE || TREE_CODE (label) == CASE_LABEL_EXPR);
> gimple_set_op (gs, index + 1, label);
> }
>
> @@ -3325,7 +3327,7 @@ gimple_debug_bind_get_var (gimple dbg)
> {
> GIMPLE_CHECK (dbg, GIMPLE_DEBUG);
> #ifdef ENABLE_CHECKING
> - gcc_assert (gimple_debug_bind_p (dbg));
> + gcc_gimple_checking_assert (gimple_debug_bind_p (dbg));
> #endif
> return gimple_op (dbg, 0);
> }
> @@ -3338,7 +3340,7 @@ gimple_debug_bind_get_value (gimple dbg)
> {
> GIMPLE_CHECK (dbg, GIMPLE_DEBUG);
> #ifdef ENABLE_CHECKING
> - gcc_assert (gimple_debug_bind_p (dbg));
> + gcc_gimple_checking_assert (gimple_debug_bind_p (dbg));
> #endif
> return gimple_op (dbg, 1);
> }
> @@ -3351,7 +3353,7 @@ gimple_debug_bind_get_value_ptr (gimple
> {
> GIMPLE_CHECK (dbg, GIMPLE_DEBUG);
> #ifdef ENABLE_CHECKING
> - gcc_assert (gimple_debug_bind_p (dbg));
> + gcc_gimple_checking_assert (gimple_debug_bind_p (dbg));
> #endif
> return gimple_op_ptr (dbg, 1);
> }
> @@ -3363,7 +3365,7 @@ gimple_debug_bind_set_var (gimple dbg, t
> {
> GIMPLE_CHECK (dbg, GIMPLE_DEBUG);
> #ifdef ENABLE_CHECKING
> - gcc_assert (gimple_debug_bind_p (dbg));
> + gcc_gimple_checking_assert (gimple_debug_bind_p (dbg));
> #endif
> gimple_set_op (dbg, 0, var);
> }
> @@ -3376,7 +3378,7 @@ gimple_debug_bind_set_value (gimple dbg,
> {
> GIMPLE_CHECK (dbg, GIMPLE_DEBUG);
> #ifdef ENABLE_CHECKING
> - gcc_assert (gimple_debug_bind_p (dbg));
> + gcc_gimple_checking_assert (gimple_debug_bind_p (dbg));
> #endif
> gimple_set_op (dbg, 1, value);
> }
> @@ -3393,7 +3395,7 @@ gimple_debug_bind_reset_value (gimple db
> {
> GIMPLE_CHECK (dbg, GIMPLE_DEBUG);
> #ifdef ENABLE_CHECKING
> - gcc_assert (gimple_debug_bind_p (dbg));
> + gcc_gimple_checking_assert (gimple_debug_bind_p (dbg));
> #endif
> gimple_set_op (dbg, 1, GIMPLE_DEBUG_BIND_NOVALUE);
> }
> @@ -3406,7 +3408,7 @@ gimple_debug_bind_has_value_p (gimple db
> {
> GIMPLE_CHECK (dbg, GIMPLE_DEBUG);
> #ifdef ENABLE_CHECKING
> - gcc_assert (gimple_debug_bind_p (dbg));
> + gcc_gimple_checking_assert (gimple_debug_bind_p (dbg));
> #endif
> return gimple_op (dbg, 1) != GIMPLE_DEBUG_BIND_NOVALUE;
> }
> @@ -3506,7 +3508,7 @@ static inline tree
> gimple_omp_for_index (const_gimple gs, size_t i)
> {
> GIMPLE_CHECK (gs, GIMPLE_OMP_FOR);
> - gcc_assert (i < gs->gimple_omp_for.collapse);
> + gcc_gimple_checking_assert (i < gs->gimple_omp_for.collapse);
> return gs->gimple_omp_for.iter[i].index;
> }
>
> @@ -3517,7 +3519,7 @@ static inline tree *
> gimple_omp_for_index_ptr (gimple gs, size_t i)
> {
> GIMPLE_CHECK (gs, GIMPLE_OMP_FOR);
> - gcc_assert (i < gs->gimple_omp_for.collapse);
> + gcc_gimple_checking_assert (i < gs->gimple_omp_for.collapse);
> return &gs->gimple_omp_for.iter[i].index;
> }
>
> @@ -3528,7 +3530,7 @@ static inline void
> gimple_omp_for_set_index (gimple gs, size_t i, tree index)
> {
> GIMPLE_CHECK (gs, GIMPLE_OMP_FOR);
> - gcc_assert (i < gs->gimple_omp_for.collapse);
> + gcc_gimple_checking_assert (i < gs->gimple_omp_for.collapse);
> gs->gimple_omp_for.iter[i].index = index;
> }
>
> @@ -3539,7 +3541,7 @@ static inline tree
> gimple_omp_for_initial (const_gimple gs, size_t i)
> {
> GIMPLE_CHECK (gs, GIMPLE_OMP_FOR);
> - gcc_assert (i < gs->gimple_omp_for.collapse);
> + gcc_gimple_checking_assert (i < gs->gimple_omp_for.collapse);
> return gs->gimple_omp_for.iter[i].initial;
> }
>
> @@ -3550,7 +3552,7 @@ static inline tree *
> gimple_omp_for_initial_ptr (gimple gs, size_t i)
> {
> GIMPLE_CHECK (gs, GIMPLE_OMP_FOR);
> - gcc_assert (i < gs->gimple_omp_for.collapse);
> + gcc_gimple_checking_assert (i < gs->gimple_omp_for.collapse);
> return &gs->gimple_omp_for.iter[i].initial;
> }
>
> @@ -3561,7 +3563,7 @@ static inline void
> gimple_omp_for_set_initial (gimple gs, size_t i, tree initial)
> {
> GIMPLE_CHECK (gs, GIMPLE_OMP_FOR);
> - gcc_assert (i < gs->gimple_omp_for.collapse);
> + gcc_gimple_checking_assert (i < gs->gimple_omp_for.collapse);
> gs->gimple_omp_for.iter[i].initial = initial;
> }
>
> @@ -3572,7 +3574,7 @@ static inline tree
> gimple_omp_for_final (const_gimple gs, size_t i)
> {
> GIMPLE_CHECK (gs, GIMPLE_OMP_FOR);
> - gcc_assert (i < gs->gimple_omp_for.collapse);
> + gcc_gimple_checking_assert (i < gs->gimple_omp_for.collapse);
> return gs->gimple_omp_for.iter[i].final;
> }
>
> @@ -3583,7 +3585,7 @@ static inline tree *
> gimple_omp_for_final_ptr (gimple gs, size_t i)
> {
> GIMPLE_CHECK (gs, GIMPLE_OMP_FOR);
> - gcc_assert (i < gs->gimple_omp_for.collapse);
> + gcc_gimple_checking_assert (i < gs->gimple_omp_for.collapse);
> return &gs->gimple_omp_for.iter[i].final;
> }
>
> @@ -3594,7 +3596,7 @@ static inline void
> gimple_omp_for_set_final (gimple gs, size_t i, tree final)
> {
> GIMPLE_CHECK (gs, GIMPLE_OMP_FOR);
> - gcc_assert (i < gs->gimple_omp_for.collapse);
> + gcc_gimple_checking_assert (i < gs->gimple_omp_for.collapse);
> gs->gimple_omp_for.iter[i].final = final;
> }
>
> @@ -3605,7 +3607,7 @@ static inline tree
> gimple_omp_for_incr (const_gimple gs, size_t i)
> {
> GIMPLE_CHECK (gs, GIMPLE_OMP_FOR);
> - gcc_assert (i < gs->gimple_omp_for.collapse);
> + gcc_gimple_checking_assert (i < gs->gimple_omp_for.collapse);
> return gs->gimple_omp_for.iter[i].incr;
> }
>
> @@ -3616,7 +3618,7 @@ static inline tree *
> gimple_omp_for_incr_ptr (gimple gs, size_t i)
> {
> GIMPLE_CHECK (gs, GIMPLE_OMP_FOR);
> - gcc_assert (i < gs->gimple_omp_for.collapse);
> + gcc_gimple_checking_assert (i < gs->gimple_omp_for.collapse);
> return &gs->gimple_omp_for.iter[i].incr;
> }
>
> @@ -3627,7 +3629,7 @@ static inline void
> gimple_omp_for_set_incr (gimple gs, size_t i, tree incr)
> {
> GIMPLE_CHECK (gs, GIMPLE_OMP_FOR);
> - gcc_assert (i < gs->gimple_omp_for.collapse);
> + gcc_gimple_checking_assert (i < gs->gimple_omp_for.collapse);
> gs->gimple_omp_for.iter[i].incr = incr;
> }
>
> @@ -4129,8 +4131,8 @@ static inline void
> gimple_omp_for_set_cond (gimple gs, size_t i, enum tree_code cond)
> {
> GIMPLE_CHECK (gs, GIMPLE_OMP_FOR);
> - gcc_assert (TREE_CODE_CLASS (cond) == tcc_comparison);
> - gcc_assert (i < gs->gimple_omp_for.collapse);
> + gcc_gimple_checking_assert (TREE_CODE_CLASS (cond) == tcc_comparison);
> + gcc_gimple_checking_assert (i < gs->gimple_omp_for.collapse);
> gs->gimple_omp_for.iter[i].cond = cond;
> }
>
> @@ -4141,7 +4143,7 @@ static inline enum tree_code
> gimple_omp_for_cond (const_gimple gs, size_t i)
> {
> GIMPLE_CHECK (gs, GIMPLE_OMP_FOR);
> - gcc_assert (i < gs->gimple_omp_for.collapse);
> + gcc_gimple_checking_assert (i < gs->gimple_omp_for.collapse);
> return gs->gimple_omp_for.iter[i].cond;
> }
>
>
>
--
Richard Guenther <rguenther@suse.de>
Novell / SUSE Labs
SUSE LINUX Products GmbH - Nuernberg - AG Nuernberg - HRB 16746 - GF: Markus Rex
^ permalink raw reply [flat|nested] 15+ messages in thread
* Re: Make gimple.h checks conditional with ENABLE_GIMPLE_CHECKING
2010-06-09 11:14 ` Paolo Bonzini
@ 2010-06-09 19:11 ` Jan Hubicka
0 siblings, 0 replies; 15+ messages in thread
From: Jan Hubicka @ 2010-06-09 19:11 UTC (permalink / raw)
To: Paolo Bonzini; +Cc: Jan Hubicka, Laurynas Biveinis, gcc-patches, rguenther
> On 06/09/2010 12:22 PM, Jan Hubicka wrote:
>> It is still possible that the change imporoved compilation time, just caused
>> slowdown due to different inlining decisions or so.
>
> Yeah, if the compiler has more work to do that would slow down the
> build. And it makes sense to have more inlining after your patch.
>
> > This seems to be supported by SPEC benchmarking
>> http://gcc.opensuse.org/SPEC/CINT/sb-barbella.suse.de-ai-64/times.html we
>> definitly have some improvements over in last few days on build times of pretty
>> much all benchmarks, still bootstrap is getting slower. Lets see how things
>> change with next run after the branch merge.
>
> Agreed.
Today results seems to support the theory. There are some nice off-noise speedups
but bootstrap time is not improved (it seems worse than before).
Other possibility is that also removing the asserts makes gcc to optimize itself
harder (i.e. do more inlining and prove more functions pure)
Honza
>
> paolo
^ permalink raw reply [flat|nested] 15+ messages in thread
end of thread, other threads:[~2010-06-09 18:58 UTC | newest]
Thread overview: 15+ messages (download: mbox.gz / follow: Atom feed)
-- links below jump to the message on this page --
2010-06-08 23:13 Make gimple.h checks conditional with ENABLE_GIMPLE_CHECKING Jan Hubicka
2010-06-09 6:13 ` Basile Starynkevitch
2010-06-09 8:37 ` Manuel López-Ibáñez
2010-06-09 9:31 ` Richard Guenther
2010-06-09 9:29 ` Richard Guenther
2010-06-09 9:47 ` Jakub Jelinek
2010-06-09 11:15 ` Jan Hubicka
2010-06-09 11:25 ` Jakub Jelinek
2010-06-09 11:30 ` Richard Guenther
2010-06-09 10:05 ` Paolo Bonzini
2010-06-09 10:05 ` Laurynas Biveinis
2010-06-09 10:12 ` Paolo Bonzini
2010-06-09 10:50 ` Jan Hubicka
2010-06-09 11:14 ` Paolo Bonzini
2010-06-09 19:11 ` Jan Hubicka
This is a public inbox, see mirroring instructions
for how to clone and mirror all data and code used for this inbox;
as well as URLs for read-only IMAP folder(s) and NNTP newsgroup(s).