+2010-06-09 Jan Hubicka <jh@suse.cz>
+
+ * 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.
+
2010-06-09 Jason Merrill <jason@redhat.com>
* Makefile.in (TAGS): Collect tags info from c-family.
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;
}
{
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;
}
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;
}
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;
}
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;
}
#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
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;
}
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);
}
root = &(SSA_NAME_IMM_USE_NODE (def));
#ifdef ENABLE_CHECKING
if (linknode->use)
- gcc_assert (*(linknode->use) == def);
+ gcc_checking_assert (*(linknode->use) == def);
#endif
link_imm_use_to_list (linknode, root);
}
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)
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;
{
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))
pointer arithmetic. */
phi = USE_STMT (use);
- gcc_assert (gimple_code (phi) == GIMPLE_PHI);
element = (struct phi_arg_d *)use;
root = gimple_phi_arg (phi, 0);
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);
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);
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);
{
/* 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
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);
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);
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);
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);
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);
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)
{
int part;
- gcc_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];
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];
}
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);
}
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];
}
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];
}
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]);
}
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);
}
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);
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)
+ && uid2 <= VEC_length (vec_void_p, stmt_vec_info_vec));
if (uid1 < uid2)
return stmt1;
{
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;
}