Patchwork More of inlined assert checks

login
register
mail settings
Submitter Jan Hubicka
Date June 9, 2010, 2:58 p.m.
Message ID <20100609145838.GA24927@kam.mff.cuni.cz>
Download mbox | patch
Permalink /patch/55101/
State New
Headers show

Comments

Jan Hubicka - June 9, 2010, 2:58 p.m.
Hi,
this patch converts more of inlined asserts to checking asserts.  I lookted at
those headers that scored high in my analysis on number of surviving asserts in
.optimized dumps of WHOPR cc1 build and always went through the whole header
for consistency.

I also converted cgraph.h tests as they are very unlikely to ever trigger,
we do same checking at a time of inserting nodes to varpool.

Also in tree-ssa-live.h I merged sequence of asserts into single to save some
space in checking enabled compiler.

Bootstrapped/regtested x86_64-linux, OK?

	* cgraph.h (varpool_first_static_initializer,
	varpool_next_static_initializer): Make checking only when
	checking enabled.
	* tree-vectorizer.h (vinfo_for_stmt): Remove check.
	(set_vinfo_for_stmt, get_earlier_stmt, is_loop_header_bb_p): Change
	gcc_assert to gcc_checking_assert.
	* tree-flow-inline.h (gimple_vop, get_var_ann, relink_imm_use, phi_nodes
	set_phi_nodes, phi_arg_index_from_use, op_iter_next_use,
	op_iter_next_def, op_iter_next_tree, op_iter_init, op_iter_init_use,
	op_iter_init_phiuse, op_iter_init_phidef, array_ref_contains_indirect_ref,
	ref_contains_array_ref): Use gcc_checking_assert.
	* emit-rtl.h (set_first_insn, set_last_insn): Likewise.
	* tree-ssa-live.h (var_to_partition, var_to_partition_to_var,
	partition_is_global, live_on_entry, live_on_exit,
	live_merge_and_clear): Likewise.
	* system.h (gcc_checking_assert): New macro.
	* gimple.h (set_bb_seq): Use gcc_checking_assert.
Richard Guenther - June 9, 2010, 3:12 p.m.
On Wed, Jun 9, 2010 at 4:58 PM, Jan Hubicka <hubicka@ucw.cz> wrote:
> Hi,
> this patch converts more of inlined asserts to checking asserts.  I lookted at
> those headers that scored high in my analysis on number of surviving asserts in
> .optimized dumps of WHOPR cc1 build and always went through the whole header
> for consistency.
>
> I also converted cgraph.h tests as they are very unlikely to ever trigger,
> we do same checking at a time of inserting nodes to varpool.
>
> Also in tree-ssa-live.h I merged sequence of asserts into single to save some
> space in checking enabled compiler.
>
> Bootstrapped/regtested x86_64-linux, OK?

Ok with ...

>        * cgraph.h (varpool_first_static_initializer,
>        varpool_next_static_initializer): Make checking only when
>        checking enabled.
>        * tree-vectorizer.h (vinfo_for_stmt): Remove check.
>        (set_vinfo_for_stmt, get_earlier_stmt, is_loop_header_bb_p): Change
>        gcc_assert to gcc_checking_assert.
>        * tree-flow-inline.h (gimple_vop, get_var_ann, relink_imm_use, phi_nodes
>        set_phi_nodes, phi_arg_index_from_use, op_iter_next_use,
>        op_iter_next_def, op_iter_next_tree, op_iter_init, op_iter_init_use,
>        op_iter_init_phiuse, op_iter_init_phidef, array_ref_contains_indirect_ref,
>        ref_contains_array_ref): Use gcc_checking_assert.
>        * emit-rtl.h (set_first_insn, set_last_insn): Likewise.
>        * tree-ssa-live.h (var_to_partition, var_to_partition_to_var,
>        partition_is_global, live_on_entry, live_on_exit,
>        live_merge_and_clear): Likewise.
>        * system.h (gcc_checking_assert): New macro.
>        * gimple.h (set_bb_seq): Use gcc_checking_assert.
> Index: cgraph.h
> ===================================================================
> --- cgraph.h    (revision 160447)
> +++ cgraph.h    (working copy)
> @@ -724,7 +724,7 @@ varpool_first_static_initializer (void)
>   struct varpool_node *node;
>   for (node = varpool_nodes_queue; node; node = node->next_needed)
>     {
> -      gcc_assert (TREE_CODE (node->decl) == VAR_DECL);
> +      gcc_checking_assert (TREE_CODE (node->decl) == VAR_DECL);
>       if (DECL_INITIAL (node->decl))
>        return node;
>     }
> @@ -737,7 +737,7 @@ varpool_next_static_initializer (struct
>  {
>   for (node = node->next_needed; node; node = node->next_needed)
>     {
> -      gcc_assert (TREE_CODE (node->decl) == VAR_DECL);
> +      gcc_checking_assert (TREE_CODE (node->decl) == VAR_DECL);
>       if (DECL_INITIAL (node->decl))
>        return node;
>     }
> Index: tree-vectorizer.h
> ===================================================================
> --- tree-vectorizer.h   (revision 160447)
> +++ tree-vectorizer.h   (working copy)
> @@ -567,7 +567,6 @@ vinfo_for_stmt (gimple stmt)
>   if (uid == 0)
>     return NULL;
>
> -  gcc_assert (uid <= VEC_length (vec_void_p, stmt_vec_info_vec));
>   return (stmt_vec_info) VEC_index (vec_void_p, stmt_vec_info_vec, uid - 1);
>  }
>
> @@ -577,7 +576,7 @@ set_vinfo_for_stmt (gimple stmt, stmt_ve
>   unsigned int uid = gimple_uid (stmt);
>   if (uid == 0)
>     {
> -      gcc_assert (info);
> +      gcc_checking_assert (info);
>       uid = VEC_length (vec_void_p, stmt_vec_info_vec) + 1;
>       gimple_set_uid (stmt, uid);
>       VEC_safe_push (vec_void_p, heap, stmt_vec_info_vec, (vec_void_p) info);
> @@ -603,8 +602,8 @@ get_earlier_stmt (gimple stmt1, gimple s
>   if (uid1 == 0 || uid2 == 0)
>     return NULL;
>
> -  gcc_assert (uid1 <= VEC_length (vec_void_p, stmt_vec_info_vec));
> -  gcc_assert (uid2 <= VEC_length (vec_void_p, stmt_vec_info_vec));
> +  gcc_checking_assert (uid1 <= VEC_length (vec_void_p, stmt_vec_info_vec));
> +  gcc_checking_assert (uid2 <= VEC_length (vec_void_p, stmt_vec_info_vec));

Merge the two asserts.

>   if (uid1 < uid2)
>     return stmt1;
> @@ -632,7 +631,7 @@ is_loop_header_bb_p (basic_block bb)
>  {
>   if (bb == (bb->loop_father)->header)
>     return true;
> -  gcc_assert (EDGE_COUNT (bb->preds) == 1);
> +  gcc_checking_assert (EDGE_COUNT (bb->preds) == 1);
>   return false;
>  }
>
> Index: tree-flow-inline.h
> ===================================================================
> --- tree-flow-inline.h  (revision 160447)
> +++ tree-flow-inline.h  (working copy)
> @@ -48,7 +48,7 @@ gimple_referenced_vars (const struct fun
>  static inline tree
>  gimple_vop (const struct function *fun)
>  {
> -  gcc_assert (fun && fun->gimple_df);
> +  gcc_checking_assert (fun && fun->gimple_df);
>   return fun->gimple_df->vop;
>  }
>
> @@ -141,7 +141,7 @@ static inline var_ann_t
>  get_var_ann (tree var)
>  {
>   var_ann_t *p = DECL_VAR_ANN_PTR (var);
> -  gcc_assert (p);
> +  gcc_checking_assert (p);

Indeed - asserts checking for NULL followed by dereference should
always be checking asserts.

>   return *p ? *p : create_var_ann (var);
>  }
>
> @@ -254,7 +254,7 @@ static inline void
>  relink_imm_use (ssa_use_operand_t *node, ssa_use_operand_t *old)
>  {
>   /* The node one had better be in the same list.  */
> -  gcc_assert (*(old->use) == *(node->use));
> +  gcc_checking_assert (*(old->use) == *(node->use));
>   node->prev = old->prev;
>   node->next = old->next;
>   if (old->prev)
> @@ -507,7 +507,7 @@ gimple_phi_arg_has_location (gimple gs,
>  static inline gimple_seq
>  phi_nodes (const_basic_block bb)
>  {
> -  gcc_assert (!(bb->flags & BB_RTL));
> +  gcc_checking_assert (!(bb->flags & BB_RTL));
>   if (!bb->il.gimple)
>     return NULL;
>   return bb->il.gimple->phi_nodes;
> @@ -520,7 +520,7 @@ set_phi_nodes (basic_block bb, gimple_se
>  {
>   gimple_stmt_iterator i;
>
> -  gcc_assert (!(bb->flags & BB_RTL));
> +  gcc_checking_assert (!(bb->flags & BB_RTL));
>   bb->il.gimple->phi_nodes = seq;
>   if (seq)
>     for (i = gsi_start (seq); !gsi_end_p (i); gsi_next (&i))
> @@ -541,7 +541,7 @@ phi_arg_index_from_use (use_operand_p us
>      pointer arithmetic.  */
>
>   phi = USE_STMT (use);
> -  gcc_assert (gimple_code (phi) == GIMPLE_PHI);
> +  gcc_checking_assert (gimple_code (phi) == GIMPLE_PHI);

Remove it - the following gimple_phi_arg call will check it.

>   element = (struct phi_arg_d *)use;
>   root = gimple_phi_arg (phi, 0);
> @@ -641,9 +641,7 @@ static inline use_operand_p
>  op_iter_next_use (ssa_op_iter *ptr)
>  {
>   use_operand_p use_p;
> -#ifdef ENABLE_CHECKING
> -  gcc_assert (ptr->iter_type == ssa_op_iter_use);
> -#endif
> +  gcc_checking_assert (ptr->iter_type == ssa_op_iter_use);
>   if (ptr->uses)
>     {
>       use_p = USE_OP_PTR (ptr->uses);
> @@ -663,9 +661,7 @@ static inline def_operand_p
>  op_iter_next_def (ssa_op_iter *ptr)
>  {
>   def_operand_p def_p;
> -#ifdef ENABLE_CHECKING
> -  gcc_assert (ptr->iter_type == ssa_op_iter_def);
> -#endif
> +  gcc_checking_assert (ptr->iter_type == ssa_op_iter_def);
>   if (ptr->defs)
>     {
>       def_p = DEF_OP_PTR (ptr->defs);
> @@ -681,9 +677,7 @@ static inline tree
>  op_iter_next_tree (ssa_op_iter *ptr)
>  {
>   tree val;
> -#ifdef ENABLE_CHECKING
> -  gcc_assert (ptr->iter_type == ssa_op_iter_tree);
> -#endif
> +  gcc_checking_assert (ptr->iter_type == ssa_op_iter_tree);
>   if (ptr->uses)
>     {
>       val = USE_OP (ptr->uses);
> @@ -725,8 +719,8 @@ op_iter_init (ssa_op_iter *ptr, gimple s
>  {
>   /* We do not support iterating over virtual defs or uses without
>      iterating over defs or uses at the same time.  */
> -  gcc_assert ((!(flags & SSA_OP_VDEF) || (flags & SSA_OP_DEF))
> -             && (!(flags & SSA_OP_VUSE) || (flags & SSA_OP_USE)));
> +  gcc_checking_assert ((!(flags & SSA_OP_VDEF) || (flags & SSA_OP_DEF))
> +                      && (!(flags & SSA_OP_VUSE) || (flags & SSA_OP_USE)));
>   ptr->defs = (flags & (SSA_OP_DEF|SSA_OP_VDEF)) ? gimple_def_ops (stmt) : NULL;
>   if (!(flags & SSA_OP_VDEF)
>       && ptr->defs
> @@ -749,8 +743,8 @@ op_iter_init (ssa_op_iter *ptr, gimple s
>  static inline use_operand_p
>  op_iter_init_use (ssa_op_iter *ptr, gimple stmt, int flags)
>  {
> -  gcc_assert ((flags & SSA_OP_ALL_DEFS) == 0
> -             && (flags & SSA_OP_USE));
> +  gcc_checking_assert ((flags & SSA_OP_ALL_DEFS) == 0
> +                      && (flags & SSA_OP_USE));
>   op_iter_init (ptr, stmt, flags);
>   ptr->iter_type = ssa_op_iter_use;
>   return op_iter_next_use (ptr);
> @@ -761,8 +755,8 @@ op_iter_init_use (ssa_op_iter *ptr, gimp
>  static inline def_operand_p
>  op_iter_init_def (ssa_op_iter *ptr, gimple stmt, int flags)
>  {
> -  gcc_assert ((flags & SSA_OP_ALL_USES) == 0
> -             && (flags & SSA_OP_DEF));
> +  gcc_checking_assert ((flags & SSA_OP_ALL_USES) == 0
> +                      && (flags & SSA_OP_DEF));
>   op_iter_init (ptr, stmt, flags);
>   ptr->iter_type = ssa_op_iter_def;
>   return op_iter_next_def (ptr);
> @@ -897,7 +891,7 @@ op_iter_init_phiuse (ssa_op_iter *ptr, g
>   clear_and_done_ssa_iter (ptr);
>   ptr->done = false;
>
> -  gcc_assert ((flags & (SSA_OP_USE | SSA_OP_VIRTUAL_USES)) != 0);
> +  gcc_checking_assert ((flags & (SSA_OP_USE | SSA_OP_VIRTUAL_USES)) != 0);
>
>   comp = (is_gimple_reg (phi_def) ? SSA_OP_USE : SSA_OP_VIRTUAL_USES);
>
> @@ -926,7 +920,7 @@ op_iter_init_phidef (ssa_op_iter *ptr, g
>   clear_and_done_ssa_iter (ptr);
>   ptr->done = false;
>
> -  gcc_assert ((flags & (SSA_OP_DEF | SSA_OP_VIRTUAL_DEFS)) != 0);
> +  gcc_checking_assert ((flags & (SSA_OP_DEF | SSA_OP_VIRTUAL_DEFS)) != 0);
>
>   comp = (is_gimple_reg (phi_def) ? SSA_OP_DEF : SSA_OP_VIRTUAL_DEFS);
>
> @@ -1125,7 +1119,7 @@ unmodifiable_var_p (const_tree var)
>  static inline bool
>  array_ref_contains_indirect_ref (const_tree ref)
>  {
> -  gcc_assert (TREE_CODE (ref) == ARRAY_REF);
> +  gcc_checking_assert (TREE_CODE (ref) == ARRAY_REF);
>
>   do {
>     ref = TREE_OPERAND (ref, 0);
> @@ -1140,7 +1134,7 @@ array_ref_contains_indirect_ref (const_t
>  static inline bool
>  ref_contains_array_ref (const_tree ref)
>  {
> -  gcc_assert (handled_component_p (ref));
> +  gcc_checking_assert (handled_component_p (ref));
>
>   do {
>     if (TREE_CODE (ref) == ARRAY_REF)
> Index: emit-rtl.h
> ===================================================================
> --- emit-rtl.h  (revision 160447)
> +++ emit-rtl.h  (working copy)
> @@ -76,7 +76,7 @@ get_insns (void)
>  static inline void
>  set_first_insn (rtx insn)
>  {
> -  gcc_assert (!insn || !PREV_INSN (insn));
> +  gcc_checking_assert (!insn || !PREV_INSN (insn));
>   crtl->emit.x_first_insn = insn;
>  }
>
> @@ -93,7 +93,7 @@ get_last_insn (void)
>  static inline void
>  set_last_insn (rtx insn)
>  {
> -  gcc_assert (!insn || !NEXT_INSN (insn));
> +  gcc_checking_assert (!insn || !NEXT_INSN (insn));
>   crtl->emit.x_last_insn = insn;
>  }
>
> Index: tree-ssa-live.h
> ===================================================================
> --- tree-ssa-live.h     (revision 160447)
> +++ tree-ssa-live.h     (working copy)
> @@ -144,7 +144,7 @@ var_to_partition (var_map map, tree var)
>  {
>   int part;
>
> -  gcc_assert (TREE_CODE (var) == SSA_NAME);
> +  gcc_checking_assert (TREE_CODE (var) == SSA_NAME);

redudnant - SSA_NAME_VERSION cehcks this.  So remove it.

>   part = partition_find (map->var_partition, SSA_NAME_VERSION (var));
>   if (map->partition_to_view)
>     part = map->partition_to_view[part];
> @@ -172,8 +172,8 @@ var_to_partition_to_var (var_map map, tr
>  static inline int
>  basevar_index (var_map map, int partition)
>  {
> -  gcc_assert (partition >= 0
> -             && partition <= (int) num_var_partitions (map));
> +  gcc_checking_assert (partition >= 0
> +                      && partition <= (int) num_var_partitions (map));
>   return map->partition_to_base_index[partition];
>  }
>
> @@ -271,7 +271,7 @@ extern void dump_live_info (FILE *, tree
>  static inline int
>  partition_is_global (tree_live_info_p live, int p)
>  {
> -  gcc_assert (live->global);
> +  gcc_checking_assert (live->global);
>   return bitmap_bit_p (live->global, p);
>  }
>
> @@ -282,9 +282,9 @@ partition_is_global (tree_live_info_p li
>  static inline bitmap
>  live_on_entry (tree_live_info_p live, basic_block bb)
>  {
> -  gcc_assert (live->livein);
> -  gcc_assert (bb != ENTRY_BLOCK_PTR);
> -  gcc_assert (bb != EXIT_BLOCK_PTR);
> +  gcc_checking_assert (live->livein
> +                      && bb != ENTRY_BLOCK_PTR
> +                      && bb != EXIT_BLOCK_PTR);
>
>   return live->livein[bb->index];
>  }
> @@ -296,9 +296,9 @@ live_on_entry (tree_live_info_p live, ba
>  static inline bitmap
>  live_on_exit (tree_live_info_p live, basic_block bb)
>  {
> -  gcc_assert (live->liveout);
> -  gcc_assert (bb != ENTRY_BLOCK_PTR);
> -  gcc_assert (bb != EXIT_BLOCK_PTR);
> +  gcc_checking_assert (live->liveout
> +                      && bb != ENTRY_BLOCK_PTR
> +                      && bb != EXIT_BLOCK_PTR);
>   return live->liveout[bb->index];
>  }
> @@ -319,8 +319,7 @@ live_var_map (tree_live_info_p live)
>  static inline void
>  live_merge_and_clear (tree_live_info_p live, int p1, int p2)
>  {
> -  gcc_assert (live->livein[p1]);
> -  gcc_assert (live->livein[p2]);
> +  gcc_checking_assert (live->livein[p1] && live->livein[p2]);
>   bitmap_ior_into (live->livein[p1], live->livein[p2]);
>   bitmap_zero (live->livein[p2]);
>  }
> Index: system.h
> ===================================================================
> --- system.h    (revision 160447)
> +++ system.h    (working copy)
> @@ -601,6 +601,12 @@ extern void fancy_abort (const char *, i
>  #define gcc_assert(EXPR) ((void)(0 && (EXPR)))
>  #endif
>
> +#ifdef ENABLE_CHECKING
> +#define gcc_checking_assert(EXPR) gcc_assert (EXPR)
> +#else
> +#define gcc_checking_assert(EXPR) ((void)(0 && (EXPR)))
> +#endif
> +
>  /* Use gcc_unreachable() to mark unreachable locations (like an
>    unreachable default case of a switch.  Do not use gcc_assert(0).  */
>  #if (GCC_VERSION >= 4005) && !ENABLE_ASSERT_CHECKING
> Index: gimple.h
> ===================================================================
> --- gimple.h    (revision 160474)
> +++ gimple.h    (working copy)
> @@ -246,7 +246,7 @@ bb_seq (const_basic_block bb)
>  static inline void
>  set_bb_seq (basic_block bb, gimple_seq seq)
>  {
> -  gcc_assert (!(bb->flags & BB_RTL));
> +  gcc_checking_assert (!(bb->flags & BB_RTL));
>   bb->il.gimple->seq = seq;
>  }
>
>

Patch

Index: cgraph.h
===================================================================
--- cgraph.h	(revision 160447)
+++ cgraph.h	(working copy)
@@ -724,7 +724,7 @@  varpool_first_static_initializer (void)
   struct varpool_node *node;
   for (node = varpool_nodes_queue; node; node = node->next_needed)
     {
-      gcc_assert (TREE_CODE (node->decl) == VAR_DECL);
+      gcc_checking_assert (TREE_CODE (node->decl) == VAR_DECL);
       if (DECL_INITIAL (node->decl))
 	return node;
     }
@@ -737,7 +737,7 @@  varpool_next_static_initializer (struct 
 {
   for (node = node->next_needed; node; node = node->next_needed)
     {
-      gcc_assert (TREE_CODE (node->decl) == VAR_DECL);
+      gcc_checking_assert (TREE_CODE (node->decl) == VAR_DECL);
       if (DECL_INITIAL (node->decl))
 	return node;
     }
Index: tree-vectorizer.h
===================================================================
--- tree-vectorizer.h	(revision 160447)
+++ tree-vectorizer.h	(working copy)
@@ -567,7 +567,6 @@  vinfo_for_stmt (gimple stmt)
   if (uid == 0)
     return NULL;
 
-  gcc_assert (uid <= VEC_length (vec_void_p, stmt_vec_info_vec));
   return (stmt_vec_info) VEC_index (vec_void_p, stmt_vec_info_vec, uid - 1);
 }
 
@@ -577,7 +576,7 @@  set_vinfo_for_stmt (gimple stmt, stmt_ve
   unsigned int uid = gimple_uid (stmt);
   if (uid == 0)
     {
-      gcc_assert (info);
+      gcc_checking_assert (info);
       uid = VEC_length (vec_void_p, stmt_vec_info_vec) + 1;
       gimple_set_uid (stmt, uid);
       VEC_safe_push (vec_void_p, heap, stmt_vec_info_vec, (vec_void_p) info);
@@ -603,8 +602,8 @@  get_earlier_stmt (gimple stmt1, gimple s
   if (uid1 == 0 || uid2 == 0)
     return NULL;
 
-  gcc_assert (uid1 <= VEC_length (vec_void_p, stmt_vec_info_vec));
-  gcc_assert (uid2 <= VEC_length (vec_void_p, stmt_vec_info_vec));
+  gcc_checking_assert (uid1 <= VEC_length (vec_void_p, stmt_vec_info_vec));
+  gcc_checking_assert (uid2 <= VEC_length (vec_void_p, stmt_vec_info_vec));
 
   if (uid1 < uid2)
     return stmt1;
@@ -632,7 +631,7 @@  is_loop_header_bb_p (basic_block bb)
 {
   if (bb == (bb->loop_father)->header)
     return true;
-  gcc_assert (EDGE_COUNT (bb->preds) == 1);
+  gcc_checking_assert (EDGE_COUNT (bb->preds) == 1);
   return false;
 }
 
Index: tree-flow-inline.h
===================================================================
--- tree-flow-inline.h	(revision 160447)
+++ tree-flow-inline.h	(working copy)
@@ -48,7 +48,7 @@  gimple_referenced_vars (const struct fun
 static inline tree
 gimple_vop (const struct function *fun)
 {
-  gcc_assert (fun && fun->gimple_df);
+  gcc_checking_assert (fun && fun->gimple_df);
   return fun->gimple_df->vop;
 }
 
@@ -141,7 +141,7 @@  static inline var_ann_t
 get_var_ann (tree var)
 {
   var_ann_t *p = DECL_VAR_ANN_PTR (var);
-  gcc_assert (p);
+  gcc_checking_assert (p);
   return *p ? *p : create_var_ann (var);
 }
 
@@ -254,7 +254,7 @@  static inline void
 relink_imm_use (ssa_use_operand_t *node, ssa_use_operand_t *old)
 {
   /* The node one had better be in the same list.  */
-  gcc_assert (*(old->use) == *(node->use));
+  gcc_checking_assert (*(old->use) == *(node->use));
   node->prev = old->prev;
   node->next = old->next;
   if (old->prev)
@@ -507,7 +507,7 @@  gimple_phi_arg_has_location (gimple gs, 
 static inline gimple_seq
 phi_nodes (const_basic_block bb)
 {
-  gcc_assert (!(bb->flags & BB_RTL));
+  gcc_checking_assert (!(bb->flags & BB_RTL));
   if (!bb->il.gimple)
     return NULL;
   return bb->il.gimple->phi_nodes;
@@ -520,7 +520,7 @@  set_phi_nodes (basic_block bb, gimple_se
 {
   gimple_stmt_iterator i;
 
-  gcc_assert (!(bb->flags & BB_RTL));
+  gcc_checking_assert (!(bb->flags & BB_RTL));
   bb->il.gimple->phi_nodes = seq;
   if (seq)
     for (i = gsi_start (seq); !gsi_end_p (i); gsi_next (&i))
@@ -541,7 +541,7 @@  phi_arg_index_from_use (use_operand_p us
      pointer arithmetic.  */
 
   phi = USE_STMT (use);
-  gcc_assert (gimple_code (phi) == GIMPLE_PHI);
+  gcc_checking_assert (gimple_code (phi) == GIMPLE_PHI);
 
   element = (struct phi_arg_d *)use;
   root = gimple_phi_arg (phi, 0);
@@ -641,9 +641,7 @@  static inline use_operand_p
 op_iter_next_use (ssa_op_iter *ptr)
 {
   use_operand_p use_p;
-#ifdef ENABLE_CHECKING
-  gcc_assert (ptr->iter_type == ssa_op_iter_use);
-#endif
+  gcc_checking_assert (ptr->iter_type == ssa_op_iter_use);
   if (ptr->uses)
     {
       use_p = USE_OP_PTR (ptr->uses);
@@ -663,9 +661,7 @@  static inline def_operand_p
 op_iter_next_def (ssa_op_iter *ptr)
 {
   def_operand_p def_p;
-#ifdef ENABLE_CHECKING
-  gcc_assert (ptr->iter_type == ssa_op_iter_def);
-#endif
+  gcc_checking_assert (ptr->iter_type == ssa_op_iter_def);
   if (ptr->defs)
     {
       def_p = DEF_OP_PTR (ptr->defs);
@@ -681,9 +677,7 @@  static inline tree
 op_iter_next_tree (ssa_op_iter *ptr)
 {
   tree val;
-#ifdef ENABLE_CHECKING
-  gcc_assert (ptr->iter_type == ssa_op_iter_tree);
-#endif
+  gcc_checking_assert (ptr->iter_type == ssa_op_iter_tree);
   if (ptr->uses)
     {
       val = USE_OP (ptr->uses);
@@ -725,8 +719,8 @@  op_iter_init (ssa_op_iter *ptr, gimple s
 {
   /* We do not support iterating over virtual defs or uses without
      iterating over defs or uses at the same time.  */
-  gcc_assert ((!(flags & SSA_OP_VDEF) || (flags & SSA_OP_DEF))
-	      && (!(flags & SSA_OP_VUSE) || (flags & SSA_OP_USE)));
+  gcc_checking_assert ((!(flags & SSA_OP_VDEF) || (flags & SSA_OP_DEF))
+		       && (!(flags & SSA_OP_VUSE) || (flags & SSA_OP_USE)));
   ptr->defs = (flags & (SSA_OP_DEF|SSA_OP_VDEF)) ? gimple_def_ops (stmt) : NULL;
   if (!(flags & SSA_OP_VDEF)
       && ptr->defs
@@ -749,8 +743,8 @@  op_iter_init (ssa_op_iter *ptr, gimple s
 static inline use_operand_p
 op_iter_init_use (ssa_op_iter *ptr, gimple stmt, int flags)
 {
-  gcc_assert ((flags & SSA_OP_ALL_DEFS) == 0
-	      && (flags & SSA_OP_USE));
+  gcc_checking_assert ((flags & SSA_OP_ALL_DEFS) == 0
+		       && (flags & SSA_OP_USE));
   op_iter_init (ptr, stmt, flags);
   ptr->iter_type = ssa_op_iter_use;
   return op_iter_next_use (ptr);
@@ -761,8 +755,8 @@  op_iter_init_use (ssa_op_iter *ptr, gimp
 static inline def_operand_p
 op_iter_init_def (ssa_op_iter *ptr, gimple stmt, int flags)
 {
-  gcc_assert ((flags & SSA_OP_ALL_USES) == 0
-	      && (flags & SSA_OP_DEF));
+  gcc_checking_assert ((flags & SSA_OP_ALL_USES) == 0
+		       && (flags & SSA_OP_DEF));
   op_iter_init (ptr, stmt, flags);
   ptr->iter_type = ssa_op_iter_def;
   return op_iter_next_def (ptr);
@@ -897,7 +891,7 @@  op_iter_init_phiuse (ssa_op_iter *ptr, g
   clear_and_done_ssa_iter (ptr);
   ptr->done = false;
 
-  gcc_assert ((flags & (SSA_OP_USE | SSA_OP_VIRTUAL_USES)) != 0);
+  gcc_checking_assert ((flags & (SSA_OP_USE | SSA_OP_VIRTUAL_USES)) != 0);
 
   comp = (is_gimple_reg (phi_def) ? SSA_OP_USE : SSA_OP_VIRTUAL_USES);
 
@@ -926,7 +920,7 @@  op_iter_init_phidef (ssa_op_iter *ptr, g
   clear_and_done_ssa_iter (ptr);
   ptr->done = false;
 
-  gcc_assert ((flags & (SSA_OP_DEF | SSA_OP_VIRTUAL_DEFS)) != 0);
+  gcc_checking_assert ((flags & (SSA_OP_DEF | SSA_OP_VIRTUAL_DEFS)) != 0);
 
   comp = (is_gimple_reg (phi_def) ? SSA_OP_DEF : SSA_OP_VIRTUAL_DEFS);
 
@@ -1125,7 +1119,7 @@  unmodifiable_var_p (const_tree var)
 static inline bool
 array_ref_contains_indirect_ref (const_tree ref)
 {
-  gcc_assert (TREE_CODE (ref) == ARRAY_REF);
+  gcc_checking_assert (TREE_CODE (ref) == ARRAY_REF);
 
   do {
     ref = TREE_OPERAND (ref, 0);
@@ -1140,7 +1134,7 @@  array_ref_contains_indirect_ref (const_t
 static inline bool
 ref_contains_array_ref (const_tree ref)
 {
-  gcc_assert (handled_component_p (ref));
+  gcc_checking_assert (handled_component_p (ref));
 
   do {
     if (TREE_CODE (ref) == ARRAY_REF)
Index: emit-rtl.h
===================================================================
--- emit-rtl.h	(revision 160447)
+++ emit-rtl.h	(working copy)
@@ -76,7 +76,7 @@  get_insns (void)
 static inline void
 set_first_insn (rtx insn)
 {
-  gcc_assert (!insn || !PREV_INSN (insn));
+  gcc_checking_assert (!insn || !PREV_INSN (insn));
   crtl->emit.x_first_insn = insn;
 }
 
@@ -93,7 +93,7 @@  get_last_insn (void)
 static inline void
 set_last_insn (rtx insn)
 {
-  gcc_assert (!insn || !NEXT_INSN (insn));
+  gcc_checking_assert (!insn || !NEXT_INSN (insn));
   crtl->emit.x_last_insn = insn;
 }
 
Index: tree-ssa-live.h
===================================================================
--- tree-ssa-live.h	(revision 160447)
+++ tree-ssa-live.h	(working copy)
@@ -144,7 +144,7 @@  var_to_partition (var_map map, tree var)
 {
   int part;
 
-  gcc_assert (TREE_CODE (var) == SSA_NAME);
+  gcc_checking_assert (TREE_CODE (var) == SSA_NAME);
   part = partition_find (map->var_partition, SSA_NAME_VERSION (var));
   if (map->partition_to_view)
     part = map->partition_to_view[part];
@@ -172,8 +172,8 @@  var_to_partition_to_var (var_map map, tr
 static inline int
 basevar_index (var_map map, int partition)
 {
-  gcc_assert (partition >= 0
-	      && partition <= (int) num_var_partitions (map));
+  gcc_checking_assert (partition >= 0
+	      	       && partition <= (int) num_var_partitions (map));
   return map->partition_to_base_index[partition];
 }
 
@@ -271,7 +271,7 @@  extern void dump_live_info (FILE *, tree
 static inline int
 partition_is_global (tree_live_info_p live, int p)
 {
-  gcc_assert (live->global);
+  gcc_checking_assert (live->global);
   return bitmap_bit_p (live->global, p);
 }
 
@@ -282,9 +282,9 @@  partition_is_global (tree_live_info_p li
 static inline bitmap
 live_on_entry (tree_live_info_p live, basic_block bb)
 {
-  gcc_assert (live->livein);
-  gcc_assert (bb != ENTRY_BLOCK_PTR);
-  gcc_assert (bb != EXIT_BLOCK_PTR);
+  gcc_checking_assert (live->livein
+		       && bb != ENTRY_BLOCK_PTR
+		       && bb != EXIT_BLOCK_PTR);
 
   return live->livein[bb->index];
 }
@@ -296,9 +296,9 @@  live_on_entry (tree_live_info_p live, ba
 static inline bitmap
 live_on_exit (tree_live_info_p live, basic_block bb)
 {
-  gcc_assert (live->liveout);
-  gcc_assert (bb != ENTRY_BLOCK_PTR);
-  gcc_assert (bb != EXIT_BLOCK_PTR);
+  gcc_checking_assert (live->liveout
+		       && bb != ENTRY_BLOCK_PTR
+		       && bb != EXIT_BLOCK_PTR);
 
   return live->liveout[bb->index];
 }
@@ -319,8 +319,7 @@  live_var_map (tree_live_info_p live)
 static inline void
 live_merge_and_clear (tree_live_info_p live, int p1, int p2)
 {
-  gcc_assert (live->livein[p1]);
-  gcc_assert (live->livein[p2]);
+  gcc_checking_assert (live->livein[p1] && live->livein[p2]);
   bitmap_ior_into (live->livein[p1], live->livein[p2]);
   bitmap_zero (live->livein[p2]);
 }
Index: system.h
===================================================================
--- system.h	(revision 160447)
+++ system.h	(working copy)
@@ -601,6 +601,12 @@  extern void fancy_abort (const char *, i
 #define gcc_assert(EXPR) ((void)(0 && (EXPR)))
 #endif
 
+#ifdef ENABLE_CHECKING
+#define gcc_checking_assert(EXPR) gcc_assert (EXPR)
+#else
+#define gcc_checking_assert(EXPR) ((void)(0 && (EXPR)))
+#endif
+
 /* Use gcc_unreachable() to mark unreachable locations (like an
    unreachable default case of a switch.  Do not use gcc_assert(0).  */
 #if (GCC_VERSION >= 4005) && !ENABLE_ASSERT_CHECKING
Index: gimple.h
===================================================================
--- gimple.h	(revision 160474)
+++ gimple.h	(working copy)
@@ -246,7 +246,7 @@  bb_seq (const_basic_block bb)
 static inline void
 set_bb_seq (basic_block bb, gimple_seq seq)
 {
-  gcc_assert (!(bb->flags & BB_RTL));
+  gcc_checking_assert (!(bb->flags & BB_RTL));
   bb->il.gimple->seq = seq;
 }