| Message ID | 20100609110948.GC8913@kam.mff.cuni.cz |
|---|---|
| State | New |
| Headers | show |
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; > } > > >
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
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; }