Make gimple.h checks conditional with ENABLE_GIMPLE_CHECKING
Richard Guenther
rguenther@suse.de
Wed Jun 9 11:30:00 GMT 2010
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
More information about the Gcc-patches
mailing list