More of inlined assert checks
Jan Hubicka
hubicka@ucw.cz
Wed Jun 9 15:07:00 GMT 2010
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.
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;
}
More information about the Gcc-patches
mailing list