Patchwork Make gimple.h checks conditional with ENABLE_GIMPLE_CHECKING

login
register
mail settings
Submitter Jan Hubicka
Date June 9, 2010, 11:09 a.m.
Message ID <20100609110948.GC8913@kam.mff.cuni.cz>
Download mbox | patch
Permalink /patch/55081/
State New
Headers show

Comments

Jan Hubicka - June 9, 2010, 11:09 a.m.
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.
Richard Guenther - June 9, 2010, 11:13 a.m.
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;
>  }
>  
> 
>
Jakub Jelinek - June 9, 2010, 11:16 a.m.
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

Patch

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;
 }